SymPy es un paquete Python de matemáticas simbólicas. Su objetivo es convertirse en un sistema de álgebra computarizado con todas las funciones manteniendo el código lo más básico posible para que sea comprensible y ampliable. El paquete está completamente escrito en lenguaje python. Las expresiones lógicas en sympy se expresan mediante funciones booleanas. El módulo sympy.basic.booleanarg de sympy contiene funciones booleanas.
Los operadores comunes de Python & (Y), | (O) y ~ (No) se pueden usar para crear expresiones booleanas. >> y también se puede utilizar para crear implicaciones. otras operaciones booleanas o puertas son NAND, NOR, XOR, etc.
Booleano Verdadero:
sympy.logic.boolalg.BooleanTrue
Boolean True en SymPy es un singleton al que se puede acceder con S.true, o importando directamente True o importando symplify desde el paquete sympy.
Python3
# import packages from sympy import true from sympy import S, sympify # prints True print(true) # prints True print(S.true) # prints true print(sympify(true))
Producción:
True True True
Falso booleano:
sympy.logic.boolalg.BooleanFalse
Boolean False en SymPy es un singleton al que se puede acceder con S.false, o importando directamente false o importando symplify desde el paquete sympy.
Python3
# import packages from sympy import false from sympy import S, sympify # prints False print(false) # prints False print(S.false) # prints False print(sympify(false))
Producción:
False False False
la negación de verdadero es falso, y la negación de falso es verdadero.
Python3
# import packages from sympy import false, true print(~true,~false)
Producción:
False True
booleano y:
sympy.logic.boolalg.Y
Analiza cada uno de sus argumentos en secuencia, devuelve verdadero si todos los argumentos son verdaderos. si al menos un argumento es falso, se devuelve falso.
- verdadero & verdadero = verdadero
- verdadero y falso = falso
- falso y verdadero = falso
- falso&falso = falso
Python3
# import packages from sympy.abc import x, y from sympy.logic.boolalg import And res = x & y print(res) # 1&y ==y print(And(x, y).subs(x, 1)) # 0&y ==0 or False print(And(x, y).subs(x, 0)) # True&False == False print(And(True, False)) # True & True == True print(And(True, True)) # False & False == False print(And(False, False)) # False & True == False print(And(False, True))
Salida :
x & y y False False True False False
booleano o:
sympy.logic.boolalg.Or
Si alguno de los argumentos es verdadero, se devuelve verdadero o falso.
- verdadero | verdadero = verdadero
- verdadero|falso = verdadero
- falso | verdadero = verdadero
- falso|falso = falso
Python3
# import packages from sympy.abc import x, y from sympy.logic.boolalg import Or res = x | y print(res) # 1&y == 1 or True print(Or(x, y).subs(x, 1)) # 0|y ==y print(Or(x, y).subs(x, 0)) # True | False == True print(Or(True, False)) # True | True == True print(Or(True, True)) # False | False == False print(Or(False, False)) # False | True == True print(Or(False, True))
Producción:
x | y True y True True False True
Booleano No:
sympy.logic.boolalg.Not(arg)
No representa la negación. Si la declaración es Falsa, este método devuelve Verdadero. Si la afirmación es verdadera, devuelve Falso.
Python3
# import packages from sympy.abc import x from sympy.logic.boolalg import Not # nor formula print(Not(x)) # ~True == True print(Not(True)) # ~False == False print(Not(False))
Producción:
~x False True
Booleano Ni:
sympy.logic.boolalg.Nor(*argumentos)
Nor es una conjunción de Not y Or. Ni = No+O. Examina cada argumento a su vez, devolviendo Falso si alguno de ellos es Verdadero y Verdadero si todos ellos son Falso. Si algún argumento es Verdadero, devuelve Falso. Si todos los argumentos son falsos, esta función devuelve verdadero.
Python3
# import packages from sympy.abc import x, y from sympy.logic.boolalg import Nor nor_formula = ~(x | y) print(nor_formula) print(Nor(x, y)) # ~( True | False) == False print(Nor(True, False)) # ~(True | True) == False print(Nor(True, True)) # ~(False | False) == True print(Nor(False, False)) # ~(False | True) == False print(Nor(False, True))
Producción:
~(x | y) ~(x | y) False False True False
Nand booleana:
sympy.logic.boolalg.Nand(*argumentos)
Nand es una conjunción de Not y. Ni = No+Y. Analiza cada una de sus entradas en sucesión, devolviendo True si alguna de ellas es False y False si todas ellas son True. Si alguna de las entradas es falsa, esta función devuelve verdadero. Si todos los argumentos son verdaderos, devuelve falso.
Python3
# import packages from sympy.abc import x, y from sympy.logic.boolalg import Nand # not + nand == nand nor_formula = ~(x & y) print(nor_formula) print(Nand(x, y)) # ~( True & False) == True print(Nand(True, False)) # ~(True & True) == False print(Nand(True, True)) # ~(False & False) == True print(Nand(False, False)) # ~(False & True) == True print(Nand(False, True))
Producción:
~(x & y) ~(x & y) True False True True
Xor booleano:
sympy.logic.boolalg.Xor(*argumentos)
Xor representa la función XOR lógico o O exclusivo. Si un número impar de argumentos es verdadero y los demás son falsos, esta función devuelve verdadero. Si un número par de argumentos es Verdadero y los demás son Falso, el resultado es Falso.
Python3
# import packages from sympy.abc import x, y from sympy.logic.boolalg import Xor xor_formula = x ^ y print(xor_formula) print(Xor(x, y)) # True ^ False == True print(Xor(True, False)) # True ^ True == False print(Xor(True, True)) # False ^ False == False print(Xor(False, False)) # False ^ True == True print(Xor(False, True))
Producción:
x ^ y x ^ y True False False True
Booleano implica:
sympy.logic.boolalg.Implica(*argumentos)
Implica se refiere a implicaciones lógicas. x implica que y es equivalente a !xv y. Acepta x e y como entradas booleanas. Si x es Verdadero e y es Falso, devuelve Falso. De lo contrario, se devuelve True.
Python3
from sympy.abc import x, y from sympy.logic.boolalg import Implies # !A v B == implies formula # returns false when A is true and B is # false, rest all cases returns True print(Implies(x, y)) # false print(Implies(True, False)) # true print(Implies(True, True)) # true print(Implies(False, False)) # true print(Implies(False, True)) print(x << y) print(x >> y)
Producción:
Implies(x, y) False True True True Implies(y, x) Implies(x, y)
Equivalente booleano
sympy.logic.boolalg.Equivalent(*args)
Se refiere a una relación de equivalencia. Si xey son verdaderos o falsos, Equivalente(x, y) es verdadero. Si todos los argumentos son lógicamente equivalentes, se devuelve True. De lo contrario, se devuelve False.
Python3
from sympy.abc import x, y, z from sympy.logic.boolalg import Equivalent, And, Or print(Equivalent(x, y, z)) # true != false so it returns false print(Equivalent(True, False)) # True == True so it returns true print(Equivalent(True, True)) # False == False so it returns true print(Equivalent(False, False)) # False !=True so it returns false print(Equivalent(False, True)) # true ==true == true so it returns true print(Equivalent(True, Or(True, False), And(True, True)))
Producción:
Equivalent(x, y, z) False True True False True
ITE booleano:
sympy.logic.boolalg.ITE(*argumentos)
ITE se refiere a la cláusula If then else. Si A es verdadero, ITE(x, y, z) evalúa y devuelve el resultado de y; de lo contrario, ITE(x, y, z) evalúa y devuelve el resultado de z. Todos los argumentos deben ser booleanos.
Python3
from sympy.abc import x, y, z from sympy.logic.boolalg import ITE, Nor, Nand, Xor, Or, And # ITE == if then else print(ITE(x, y, z)) # x is true so y is returned print(ITE(True, Or(True, False), And(True, True))) # x is false so z is returned print(ITE(Nor(True, False), Xor(True, False), Nand(True, True)))
Producción:
ITE(x, y, z) True False
Publicación traducida automáticamente
Artículo escrito por sarahjane3102 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA