Exemple #1
0
class Type_A_Interval_III(object):
    #generate interval of type: {x, y, ...} (Finite set) or a Singleton - must not result in an EmptySet()
    def __init__(self):
        self.set_str = ""
        self.val_lst = []
        self.interval = FiniteSet()
        
    def generate_interval(self):
        if randint(0, 1) == 0:
            #generate FiniteSet
            amount = randint(1, 5)
            for i in range(amount):
                if self.val_lst == []:
                    self.val_lst.append(randint(-15,15))
                else:
                    self.val_lst.append(randint(self.val_lst[i-1]-5, self.val_lst[i-1]+5))
        else:
            #generate Singleton
            self.val_lst.append(randint(-20, 20))
            
        for i in range(len(self.val_lst)):
            self.interval = self.interval.union(FiniteSet(self.val_lst[i]))
            
        self.set_str += '\{'+str(self.interval)+'\}'
# Set Operations  such as Union, Intresection and the cartesian product allow you to
# combine sets in certain methodical ways. These set operations are extremely useful in real world
# Problem solving situations when we have to consider multiple sets together.

from sympy import FiniteSet
s = FiniteSet(1, 2, 3)
t = FiniteSet(2, 4, 6)
#The result is the third set with all the distinct  members of the two sets
print(s.union(t))

# The intersection of two sets creates a new set from the elelments common to both sets
# For Example, the intersection of the sets {1,2} and {2,3} will result in a new set with the only common element 2.
s = FiniteSet(1, 2)
t = FiniteSet(2, 3)
print(s.intersect(t))

# Whereas the union operation finds memebers that are in one set or another,
# the intersection operation finds elements that are present in both.Both of these operations
# can also be applied to more than two sets. For Example- here's how you'd find the union of three sets

s = FiniteSet(1, 2, 3)
t = FiniteSet(2, 4, 6)
u = FiniteSet(3, 5, 7)

print(s.union(t).union(u))

# CARTESIAN PRODUCT
# The cartesian product of two sets creates a set that consist all the possible pairs made by taking
# an element from each set. For examples cartesian product of the sets {1,2} and {3,4} is {(1,3),(1,4),(2,3),(2,4)}
# In SymPy you can find the cartesian product of two sets by simply using the multiplication operator
p = s * t
Exemple #3
0
from sympy import FiniteSet

set_one = FiniteSet(1, 2, 3)
set_two = FiniteSet(1, 2, 3, 4)

union = set_one.union(set_two)
print("Union:")
print(union)

print()

intersection = set_one.intersection(set_two)
print("Intersection:")
print(intersection)

print()
from sympy import FiniteSet

t = FiniteSet(1, 2, 3)
s = FiniteSet(2, 4, 6)

t == s  #burası biraz saçma
t.union(s)  #t kümesi ile s kümesini birleştirir. (t U s)
t.intersect(s)  #t kümesi ile s kümesini ayirir t kesişim s demek

t**2  #burası biraz saçma


def probability(space, event):
    return len(event) / len(space)


def check_prime(number):  #asal sayilari bulur
    if number != 1:
        for factor in range(2, number):
            if number % factor == 0:
                return False
    else:
        return False
    return True


space = FiniteSet(*range(1, 21))
primes = []
for num in space:
    if check_prime(num):
        primes.append(num)
Exemple #5
0
from sympy import FiniteSet

O = FiniteSet('a', 'p', 'e', 's', 'o')
S = FiniteSet('h', 'o', 'c', 'a', 'b')
H = FiniteSet('h', 'b', 'd', 'm', 't')

U = O.union(H).union(S)

sh = S.union(H)

sh.complement(U)
Exemple #6
0
# Subconjunto y subconjunto propio
print('-' * 30)
A = FiniteSet(1, 2, 3)
B = FiniteSet(1, 2, 3, 4, 5)
print(A.is_subset(B))

# A == B. El test de subconjunto propio da falso
print('-' * 30)
B = FiniteSet(2, 1, 3)
print(A.is_proper_subset(B))

# Union de dos conjuntos
print('-' * 30)
A = FiniteSet(1, 2, 3)
B = FiniteSet(2, 4, 6)
print(A.union(B))

# Interseccion de dos conjuntos
print('-' * 30)
A = FiniteSet(1, 2)
B = FiniteSet(2, 3)
print(A.intersect(B))

# Diferencia entre conjuntos
print('-' * 30)
print(A - B)

# Calculando el producto cartesiano. Con el conjunto por
# defecto de python no podemos hacer esto con el operador *
print('-' * 30)
A = FiniteSet(1, 2)
Exemple #7
0
from sympy import FiniteSet
from fractions import Fraction

t = FiniteSet(1, 2, 3)
s = FiniteSet(2, 4, 6)

if t == s:
    print("True")
else:
    print("False")

print(t.union(s))
print(t.intersect(s))
print(t**2)


def probability(space, event):
    return len(event) / len(space)


def check_prime(number):
    if number != 1:
        for factor in range(2, number):
            if number % factor == 0:
                return False
    else:
        return False
    return True


space = FiniteSet(* range(1, 21))
Exemple #8
0
len(ps)

s = FiniteSet(1, 2, 3)
t = FiniteSet(1, 2, 3)

s.is_proper_subset(t)

t = FiniteSet(1, 2, 3, 4)

t.is_proper_subset(s)
s.is_proper_subset(t)

s = FiniteSet(1, 2, 3)
t = FiniteSet(2, 4, 6)
s.union(t)

s = FiniteSet(1, 2, 3)
t = FiniteSet(2, 4, 6)
s.intersect(t)

s = FiniteSet(1, 2, 3)
t = FiniteSet(2, 4, 6)
u = FiniteSet(3, 5, 7)

s.union(t).union(u)

s.intersect(t).intersect(u)

s = FiniteSet(1, 2)
t = FiniteSet(3, 4)
Exemple #9
0
from sympy import FiniteSet

six_sided = FiniteSet(1, 2, 3, 4, 5, 6)
roll_one = FiniteSet(2, 3, 5)
roll_two = FiniteSet(1, 3, 5)

event = roll_one.union(roll_two)
prob = len(event) / len(six_sided)
print(prob)
Exemple #10
0
prime1 = primes(1000)

event = primes(20)

len(event)/len(range(1,21))

import matplotlib.pyplot as plt
plt.plot(range(1,len(prime1)+1), prime1)


from sympy import FiniteSet
s = FiniteSet()
for i in range(1,7):
    s1 = FiniteSet(i)
    s = s.union(s1)
a = FiniteSet(2,3,5)
b = FiniteSet(1,3,5)
PrimeOrOdd = a.union(b)
PrimeAndOdd = a.intersect(b)
ProbPrimeOrOdd = len(PrimeOrOdd)/len(s)
ProbPrimeAndOdd = len(PrimeAndOdd)/len(s)


import random
random.randint(1,6)




Exemple #11
0
from sympy import FiniteSet
s = FiniteSet(1, 2, 3, 4, 5, 6)
a = FiniteSet(2, 3, 5)
b = FiniteSet(1, 3, 5)
e = a.union(b)
print(len(e)/len(s))

# from sympy import FiniteSet
# s = FiniteSet(1, 2, 3, 4, 5, 6)
# a = FiniteSet(2, 3, 5)
# b = FiniteSet(1, 3, 5)
# e = a.intersect(b)
# print(len(e)/len(s))
from sympy import FiniteSet
from fractions import Fraction

s = FiniteSet(1, 2, 3)
t = FiniteSet(2, 4, 6)
print("Union ", s.union(t))

s = FiniteSet(1, 2)
t = FiniteSet(2, 3)
print("intersect  ", s.intersect(t))

s = FiniteSet(1, 2)
t = FiniteSet(2, 3)
u = FiniteSet(3, 5, 7)
print("Union ", s.union(t).union(u))

s = FiniteSet(1, 2)
t = FiniteSet(2, 3)
p = s * t
print("Cartesian ", p)

for elem in p:
    print("Cartesian ", elem)

s = FiniteSet(1, 2)
p = s**3
print("carteisna ** ", p)

for elem in p:
    print("Cartesian ", elem)
Exemple #13
0
>>> t.is_proper_superset(s)
False

>>> t=FiniteSet(1,2,3,4)
>>> s.is_proper_subset(t)
True
>>> t.is_proper_superset(s)
True

         #Set Operations

               #Union and intersection

>>> s=FiniteSet(1,2,3)
>>> t=FiniteSet(2,4,6)
>>> s.union(t)
{1, 2, 3, 4, 6}

>>> s=FiniteSet(1,2)
>>> t=FiniteSet(2,3)
>>> s.intersect(t)
{2}

                    #We can make an union and intersection of more than 2 sets

>>> s=FiniteSet(1,2,3)
>>> t=FiniteSet(2,4,6)
>>> u=FiniteSet(3,5,7)
>>> s.union(t).union(u)
{1, 2, 3, 4, 5, 6, 7}
from sympy import FiniteSet, pi
# Unions & Intersections
s = FiniteSet(1, 2, 3)
t = FiniteSet(2, 4, 6)

union = s.union(t)
print(union)

intersection = s.intersect(t)
print(intersection)

### Cartesian Products
cartesianProduct = s * t
print(cartesianProduct)

for elem in cartesianProduct:
    print(elem)

# Raise set to the power (calculate triplets)
cartesianProductCubed = s ** 3
for elem in cartesianProductCubed:
    print(elem)




def time_period(length, g):
    T = 2*pi*(length/g)**0.5
    return T

L = FiniteSet(15, 18, 21, 22.5, 25)
Exemple #15
0
	
	event = FiniteSet( *primes )

	p = probability( space, event )
	
	print( 'Sample Space: {0}'.format( space ) )
	print( 'Event: {0}'.format( event ) )
	print( 'Probability of rolling a prime: {0:.5f}'.format( p ) )


# P( A | B )

s = FiniteSet( 1, 2, 3, 4, 5, 6 )
a = FiniteSet( 2, 3, 5 )
b = FiniteSet( 1, 3, 5 )

e = a.union( b )

probability( s, e )

# P( A & B )

s = FiniteSet( 1, 2, 3, 4, 5, 6 )
a = FiniteSet( 2, 3, 5 )
b = FiniteSet( 1, 3, 5 )

e = a.intersect( b )

probability( s, e )

Exemple #16
0
exlist = [2, 3, 4, 5, 2, 1, 4, 3, 5, 5]
print(lookup(my_histogram(exlist), 2))

known = {0: 0, 1: 1}


def fibo_rec(n):
    if n in known:
        return known[n]
    else:
        result = fibo_rec(n - 1) + fibo_rec(n - 2)
        known[n] = result
        return result


s = FiniteSet(1, 1.5, Fraction(1, 5), 1, 1.5, 7, 42)
t = FiniteSet(Fraction(1, 5), 1, 5, 1, 1, 91, 87)

for member in s:
    print(member)

if s == t:
    print("True")
else:
    print("False")

print(s.union(t))
print(s.intersect(t))
print(set(s**2))
'''
    Math -> Set Operations
'''

from sympy import FiniteSet

# Union
s = FiniteSet(1, 2, 3)
t = FiniteSet(2, 4, 6)
s.union(t)              # {1, 2, 3, 4, 6,}

# Union of three Sets
s = FiniteSet(1, 2, 3)
t = FiniteSet(2, 4, 6)
u = FiniteSet(3, 5, 7)
s.union(t).union(u)     # {1, 2, 3, 4, 5, 6, 7}

# Intersection
s = FiniteSet(1, 2)
t = FiniteSet(2, 3)
s.intersect(t)          # 2

# Intersection of three Sets
s.intersect(t).interset(u)      # EmpySet()

# Cartesian Product
s = FiniteSet(1, 2)
t = FiniteSet(3, 4)
p = s*t
p                       # {1, 2} x {3, 4}
for elem in p:
Exemple #18
0
from sympy import FiniteSet, pi
# Unions & Intersections
s = FiniteSet(1, 2, 3)
t = FiniteSet(2, 4, 6)

union = s.union(t)
print(union)

intersection = s.intersect(t)
print(intersection)

### Cartesian Products
cartesianProduct = s * t
print(cartesianProduct)

for elem in cartesianProduct:
    print(elem)

# Raise set to the power (calculate triplets)
cartesianProductCubed = s**3
for elem in cartesianProductCubed:
    print(elem)


def time_period(length, g):
    T = 2 * pi * (length / g)**0.5
    return T


L = FiniteSet(15, 18, 21, 22.5, 25)
g_values = FiniteSet(9.8, 9.78, 9.83)
Exemple #19
0
 def set_second_part(self, num, element):
     set_str = ""
     #set_type = choice(['finite_set', 'infinite_set', 'empty_set', 'powerset'])
     #self.set_type = choice(['empty_set', 'finite_set', 'infinite_set'])
     self.set_type = choice(['infinite_set', 'empty_set', 'finite_set'])
     uberset = ""
     x = 0
     y = 0
     temp_str = ''
     temp_set = None
     
     #generate set in formal notation: {x | x in R and ...}
     if num == 0:
         uberset = self.f_set_dict[element] if element != 'x' else self.f_set_dict[choice(list(self.f_set_dict.keys()))]
         set_str += ' \ | \ '+element+'\in'+uberset
         set_str += '\wedge \ '
         if self.set_type == 'finite_set':
             self.set_description[0] = 'finite_set'
             c = choice([0, 1, 2, 3])
             if c == 0:
                 temp_set = FiniteSet(1) if uberset == '\mathbb N_{> 0}' else FiniteSet(0, 1)
                 set_str += element+'^{2} = \ '+element
                 self.set_description[1] = '\{'+str(temp_set)+'\}'
                 self.set_description[2] = temp_set
             elif c == 1:
                 x = randint(0, 5) if element == 'n' else randint(-5, 0)
                 y = randint(5, 10) if element == 'n' else randint(0, 5)
                 fin_set = FiniteSet()
                 for i in range(x+1, y, 1):
                     fin_set = fin_set.union(FiniteSet(i))
                 if element == 'n' or element == 'z':
                     set_str += element+'\in \ ('+str(x)+', '+str(y)+')'
                     self.set_description[1] = '\{'+str(fin_set)+'\}'
                     self.set_description[2] = fin_set
                 else:
                     x = randint(1, 99)
                     set_str += element+'\subseteq \ \{'+str(x)+'\}'
                     self.set_description[1] = '\{\emptyset, '+str(x)+'\}'
                     self.set_description[2] = FiniteSet(EmptySet(), x)
             elif c == 2:
                 if choice([0, 1]) == 0:
                     x = randint(-5, -5)
                     y = randint(-5, 5)
                     set_str = '\{'+str(x)+', '+str(y)+'\}'
                     self.set_description[1] = '\{'+str(FiniteSet(x, y))+'\}'
                     self.set_description[2] = FiniteSet(x, y)
                 else:
                     x = choice([x for x in np.arange(0, 99) if sqrt(x).is_integer()])
                     set_str += '\sqrt{'+element+'} = '+str(int(sqrt(x)))
                    
                     self.set_description[1] = '\{'+str(x)+'\}'
                     self.set_description[2] = FiniteSet(x)
             elif c == 3:
                 element+'\\textless 2 \wedge'+element+'\in \mathbb{N}'                    
                 if uberset == '\mathbb N_{> 0}':
                     temp_set = FiniteSet(1)
                 elif uberset == '\mathbb{N}':
                     temp_set = FiniteSet(0, 1)
                 else:
                     temp_set = FiniteSet(0, 1)
                 set_str += element+'^{2} = \ '+element
                 self.set_description[1] = '\{'+str(temp_set)+'\}'
                 self.set_description[2] = temp_set
                     
         elif self.set_type == 'infinite_set':
             self.set_description[0] = 'infinite_set'
             if element == 'n':
                 if choice([0, 1]) == 0:
                     set_str += element+'> 0'
                     self.set_description[1] = '\mathbb N_{> 0}'
                     self.set_description[2] = 'NPOS'
                 else:
                     set_str += element+'\in \mathbb{Z}'
                     self.set_description[1] = '\mathbb{N}'
                     self.set_description[2] = 'N'
             elif element == 'z':
                 if choice([0, 1]) == 0:
                     set_str += element+'\geq 0'
                     self.set_description[1] = '\mathbb{N}'
                     self.set_description[2] = 'N'
                 else:
                     set_str += '0 > '+element
                     self.set_description[1] = 'ZNEG'
                     self.set_description[2] = '-Z'
             elif element == 'q':
                 if choice([0, 1]) == 0:
                     set_str += element+'\in \mathbb{Z}'
                     self.set_description[1] = '\mathbb{Z}'
                     self.set_description[2] = 'Z'
                 else:
                     set_str += element+' \in \mathbb{Q}'
                     self.set_description[1] = 'Q'
                     self.set_description[2] = QQ 
             elif element == 'r':
                 if choice([0, 1]) == 0:
                     set_str += element+'^{2} \in \mathbb{N}'
                     self.set_description[0] = 'finite_set'
                     self.set_description[1] = '\{'+str(FiniteSet(0, 1))+'\}'
                     self.set_description[2] = FiniteSet(0, 1)
                 else:
                     x = randint(-2, 0)
                     y = randint(x, 2)
                     set_str += element+'\in ('+str(x)+', '+str(y)+')'
                     temp_set = Interval(x, y, True, True)
                     if isinstance(temp_set, FiniteSet):
                         self.set_description[0] = 'empty_set'
                         self.set_description[2] = EmptySet()
                     else:
                         self.set_description[2] = Interval(x, y, True, True) 
                         self.set_description[1] = str(self.set_description[2])        
             else:
                 if choice([0, 1]) == 0:
                     set_str += element+'\in \mathcal{P}('+uberset+') \wedge '+element+'^{2} = '+element
                     if uberset == '\mathbb N_{> 0}':
                         self.set_description[1] = '\{'
                         self.set_description[2] = FiniteSet()
                         self.set_description[0] = 'finite_set'
                 else:
                     set_str += element+'\leq 0'
                     self.set_description[1] = '\mathbb{Z} \setminus \mathbb{N}'
                     self.set_description[2] = 'ZNEG'
             
         elif self.set_type == 'empty_set':
             self.set_description[0] = 'empty_set'
             c = choice([0, 1])
             if c == 0:
                 set_str += element+'\in \mathcal{P}('+self.f_set_dict[choice(list(self.f_set_dict.keys()))]+')'
             elif c == 1:
                 set_str += '\emptyset \in \ '+uberset
             self.set_description[1] = '\emptyset'
             self.set_description[2] = EmptySet()
         else:
             self.description[0] = 'empty_set'
             self.set_description[1] = '\emptyset'
             self.set_description[2] = EmptySet()
     """elif num == 1:
         if self.set_type == 'finite_set':
             self.set_description[0] = 'finite_set'
             if element == '\{x\}':
                 if choice([0, 1]) == 0:
                     set_str += ' \ | \ x \in \mathbb{N} \wedgde x \leq 0'
                     self.set_description[1] = '\{1\}'
                     self.set_description[2] = FiniteSet(0)
                 else:
                     set_str += ' \ | \ x \in \mathbb{Z} \wedge \mathcal{P}(\{x\}) = \{\emptyset, \{-1\}, \{1\}, \{-1, 1\}\}'
                     self.set_description[1] = '\{\-1, 1}'
                     self.set_description[2] = FiniteSet(-1, 1)
             elif element == '\{x+1\}':
                 x = randint(-10, 10)
                 set_str += ' \ | \ x \in \mathbb{Z} \wedge x = '+str(x)
                 self.set_description[1] = '\{'+str(x+1)+'\}'
                 self.set_description[2] = FiniteSet(x+1)
             elif element == '\lvert x \\rvert':
                 set_str += ' \ | \ x \in \mathbb{Z} \wedge x \leq \pi'
                 self.set_description[1] = '\{0, 1, 2, 3\}'
                 self.set_description[2] = FiniteSet(0, 1, 2, 3)
             elif element == '-x':
                 if choice([0, 1]) == 0:
                     set_str += ' \ | \ x \in \mathbb{R} \wedge x^{2} = 2'
                     self.set_description[1] = '-\sqrt{2}, \sqrt{2}'
                     self.set_description[2] = 'sqrt1'
                 else:
                     set_str += ' \ | \ x \in \mathbb{R} \wedge x^{2} = 2 \wedge x \leq 0'
                     self.set_description[1] = '\sqrt{2}'
                     self.set_description[2] = 'sqrt2'
             elif element == '2x':
                 x = randint(0, 50)
                 set_str += ' \ | \ x \in \mathbb{Q} \wedge \\frac{x}{2} = '+str(x)
                 self.set_description[1] = '\{'+str(x*2)+'\}'
                 self.set_description[2] = FiniteSet(x*2)
             else:
                 self.set_description[1] = FiniteSet(0, 0, 0)
         elif self.set_type == 'infinite_set':
             self.set_description[0] = 'infinite_set'
             if element == '\{x\}' or element == '\{x+1\}':
                 temp_str = choice(['\mathbb{N}', '\mathbb{Z}'])
                 set_str += ' \ | \ x \in'+temp_str
                 self.set_description[1] = 'setofsets'
                 self.set_description[2] = 'POW'
             elif element == '\lvert x \\rvert':
                 set_str += ' \ | \ x \in \mathbb{Z}'
                 self.set_description[1] = '\mathbb{N}'
                 self.set_description[2] = 'N'
             elif element == '-x':
                 set_str += ' \ | \ x \in \mathbb{Z}'
                 self.set_description[1] = '\mathbb{Z}'
                 self.set_description[2] = 'Z'
             elif element == '2x':
                 temp_str = choice(['\mathbb{N}', '\mathbb{Z}', '\mathbb{Q}', '\mathbb{R}'])
                 set_str += ' \ | \ x \in'+temp_str
                 self.set_description[1] = ('MOD2')
             else:
                 temp_str = choice(['\mathbb{N}', '\mathbb{Z}', '\mathbb{Q}', '\mathbb{R}'])
                 set_str += ' \ | x \in '+temp_str
                 self.set_description[1] = 'x^{2}'
         elif self.set_type == 'empty_set':
             self.set_description[0] = 'empty_set'
             if element == '\{x\}':
                 if choice([0, 1]) == 0:
                     set_str += ' \ | \ \{x\} \in \mathcal{P}(\mathbb{N}) \setminus \mathcal{P}(\mathbb{Z})'
                 else:
                     set_str += ' \in \mathbb{N}'
             elif element == '\{x+1\}':
                 set_str += ' \ | \ x \in  \mathbb{N} \wedge \ x \leq -2'
             elif element == '\lvert x \\rvert':
                 set_str += ' \ | \ x \in \mathbb{N} \setminus \mathbb{Z}'
             elif element == '-x':
                 set_str += ' \ | \ x \in \mathbb N_{> 0}'
             elif element == 'x+1':
                 if choice([0, 1]) == 0:
                     set_str += ' \ | \ x \in  \mathbb{N} \wedge \ x \leq -2'
                 else:
                     set_str += '\ | | x \subseteq \{\pi\}'
             else:
                 set_str += ' \ | \ x \in \mathbb{Z} \wedge x = \sqrt{2}'
             self.set_description[1] = '\emptyset'
             self.set_description[2] = EmptySet()
         else:
             pass"""      
     self.final_set_string += set_str
#The power set is the set of all possible subsets
tenthset = FiniteSet(20, 55, 41, 98)
print(tenthset.powerset()) #print {EmptySet(), {20}, {41}, ..., {20, 55, 98}, {41, 55, 98}, {20, 41, 55, 98}}

seventhset = FiniteSet(999, 439, 20984)
eigthset = FiniteSet(999, 69, 48)
ninthset = FiniteSet(999, 69)
print(seventhset.is_proper_subset(eigthset)) #print False
print(eigthset.is_proper_subset(seventhset)) #print False
print(ninthset.is_proper_subset(eigthset)) #print True
print(ninthset.is_proper_superset(eigthset)) #print False
print(eigthset.is_proper_superset(ninthset)) #print True

tenthset = FiniteSet(1, 2, 3)
eleventhset = FiniteSet(2, 4, 6)
print(tenthset.union(eleventhset)) #print {1, 2, 3, 4, 6}
print(tenthset.intersect(eleventhset)) #print {2}
#we can apply union and intersect to more than two sets.
tenthset = FiniteSet(1, 2, 3)
eleventhset = FiniteSet(2, 4, 6)
twelthset = FiniteSet(3, 5, 7)
print(tenthset.union(eleventhset).union(twelthset)) #print {1, 2, 3, 4, 5, 6, 7}
print(tenthset.intersect(eleventhset).intersect(twelthset)) #print EmptySet()
#The cartesian product creates a set that consists of all possible pairs made by taking an element from each set.
print(tenthset*eleventhset) #print {1, 2, 3} x {2, 4, 6}
tentheleventh = tenthset*eleventhset
for eachtentheleventh in tentheleventh:
	print(eachtentheleventh)
'''
(1, 2)
(1, 4)
#ElifCelik Programlama Lab 3. Hafta Cuma
#Zar için olasilik hesabi
from sympy import FiniteSet

t = FiniteSet(1, 2, 3)
s = FiniteSet(2, 4, 6)

t == s
t.union(s)
t.intersect(s)

t**2


#probability calculation
def probability(space, event):
    return len(event) / len(space)


#is it prime number
def check_prime(number):
    if number != 1:
        for factor in range(2, number):
            if number % factor == 0:
                return False
    else:
        return False
    return True


space = FiniteSet(*range(1, 21))
Conjunto y operaciones con conjuntos usando la libreria SYMPY
"""

# Utilizando FiniteSet de sympy
from sympy import FiniteSet
C = FiniteSet(1, 2, 3)

# Subconjunto y subconjunto propio
A = FiniteSet(1,2,3)
B = FiniteSet(1,2,3,4,5)
A.subset(B)

# Union de dos conjuntos
A = FiniteSet(1, 2, 3)
B = FiniteSet(2, 4, 6)
A.union(B)


# Interseccion de dos conjuntos
A = FiniteSet(1, 2) 
B = FiniteSet(2, 3) 
A.intersect(B)


# Diferencia entre conjuntos
print A - B


# Calculando el producto cartesiano. 
A = FiniteSet(1, 2)
B = FiniteSet(3, 4)