You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
177 lines
7.1 KiB
177 lines
7.1 KiB
import pycarl
|
|
|
|
|
|
def convert_integer(integer):
|
|
"""
|
|
Convert integer to cln.
|
|
:param integer: integer.
|
|
:return: cln interger.
|
|
"""
|
|
if isinstance(integer, pycarl.cln.Integer):
|
|
return integer
|
|
elif isinstance(integer, pycarl.gmp.Integer):
|
|
return pycarl.cln.Integer(integer)
|
|
elif isinstance(integer, int):
|
|
return pycarl.cln.Integer(integer)
|
|
else:
|
|
raise TypeError("Integer of type {} cannot be convert to cln".format(type(integer)))
|
|
|
|
|
|
def convert_rational(rational):
|
|
"""
|
|
Convert rational number to cln.
|
|
:param rational: rational number.
|
|
:return: cln rational.
|
|
"""
|
|
if isinstance(rational, pycarl.cln.Rational):
|
|
return rational
|
|
elif isinstance(rational, pycarl.gmp.Rational):
|
|
return pycarl.cln.Rational(rational)
|
|
elif isinstance(rational, float):
|
|
return pycarl.cln.Rational(rational)
|
|
else:
|
|
raise TypeError("Rational of type {} cannot be convert to cln".format(type(rational)))
|
|
|
|
|
|
def convert_term(term):
|
|
"""
|
|
Convert term to cln.
|
|
:param term: term.
|
|
:return: cln term.
|
|
"""
|
|
if isinstance(term, pycarl.cln.Term):
|
|
return term
|
|
elif isinstance(term, pycarl.gmp.Term):
|
|
coeff = convert_rational(term.coeff)
|
|
return pycarl.cln.Term(coeff, term.monomial)
|
|
else:
|
|
raise TypeError("Term of type {} cannot be convert to cln".format(type(term)))
|
|
|
|
|
|
def convert_polynomial(polynomial):
|
|
"""
|
|
Convert polynomial to cln.
|
|
:param polynomial: polynomial.
|
|
:return: cln polynomial.
|
|
"""
|
|
if isinstance(polynomial, pycarl.cln.Polynomial):
|
|
return polynomial
|
|
elif isinstance(polynomial, pycarl.gmp.Polynomial):
|
|
terms = []
|
|
for term in polynomial:
|
|
terms.append(convert_term(term))
|
|
return pycarl.cln.Polynomial(terms)
|
|
else:
|
|
raise TypeError("Polynomial of type {} cannot be convert to cln".format(type(polynomial)))
|
|
|
|
|
|
def convert_rational_function(ratfunc):
|
|
"""
|
|
Convert rational function to cln.
|
|
:param ratfunc: rational function.
|
|
:return: cln rational function.
|
|
"""
|
|
if isinstance(ratfunc, pycarl.cln.RationalFunction):
|
|
return ratfunc
|
|
elif isinstance(ratfunc, pycarl.gmp.RationalFunction):
|
|
numerator = convert_polynomial(ratfunc.numerator)
|
|
denominator = convert_polynomial(ratfunc.denominator)
|
|
return pycarl.cln.RationalFunction(numerator, denominator)
|
|
else:
|
|
raise TypeError("Rational function of type {} cannot be convert to cln".format(type(ratfunc)))
|
|
|
|
|
|
def convert_factorized_polynomial(polynomial):
|
|
"""
|
|
Convert factorized polynomial to cln.
|
|
:param polynomial: factorized polynomial.
|
|
:return: cln factorized polynomial.
|
|
"""
|
|
if isinstance(polynomial, pycarl.cln.FactorizedPolynomial):
|
|
return polynomial
|
|
elif isinstance(polynomial, pycarl.gmp.FactorizedPolynomial):
|
|
coefficient = convert_rational(polynomial.coefficient)
|
|
converted = pycarl.cln.FactorizedPolynomial(coefficient)
|
|
for (factor, exponent) in polynomial.factorization():
|
|
pol = convert_polynomial(factor.polynomial())
|
|
factorized = pycarl.cln.create_factorized_polynomial(pol)
|
|
converted *= factorized ** exponent
|
|
return converted
|
|
else:
|
|
raise TypeError("Factorized polynomial of type {} cannot be convert to cln".format(type(polynomial)))
|
|
|
|
|
|
def convert_factorized_rational_function(ratfunc):
|
|
"""
|
|
Convert factorized rational function to cln.
|
|
:param ratfunc: factorized rational function.
|
|
:return: cln factorized rational function.
|
|
"""
|
|
if isinstance(ratfunc, pycarl.cln.FactorizedRationalFunction):
|
|
return ratfunc
|
|
elif isinstance(ratfunc, pycarl.gmp.FactorizedRationalFunction):
|
|
numerator = convert_factorized_polynomial(ratfunc.numerator)
|
|
denominator = convert_factorized_polynomial(ratfunc.denominator)
|
|
return pycarl.cln.FactorizedRationalFunction(numerator, denominator)
|
|
else:
|
|
raise TypeError("Factorized rational function of type {} cannot be convert to cln".format(type(ratfunc)))
|
|
|
|
|
|
def convert_constraint(constraint):
|
|
"""
|
|
Convert constraint to cln.
|
|
:param constraint: constraint.
|
|
:return: cln constraint.
|
|
"""
|
|
if isinstance(constraint, pycarl.cln.formula.Constraint):
|
|
return constraint
|
|
elif isinstance(constraint, pycarl.gmp.formula.Constraint):
|
|
lhs = convert_polynomial(constraint.lhs)
|
|
return pycarl.cln.formula.Constraint(lhs, constraint.relation)
|
|
else:
|
|
raise TypeError("Constraint of type {} cannot be convert to cln".format(type(constraint)))
|
|
|
|
def convert_formula(formula):
|
|
if isinstance(formula, pycarl.cln.formula.Formula):
|
|
return formula
|
|
elif isinstance(formula, pycarl.gmp.formula.Formula):
|
|
if formula.type == pycarl.formula.FormulaType.TRUE:
|
|
return pycarl.cln.formula.Formula(pycarl.cln.formula.Constraint(True))
|
|
if formula.type == pycarl.formula.FormulaType.FALSE:
|
|
return pycarl.cln.formula.Formula(pycarl.cln.formula.Constraint(False))
|
|
if formula.type == pycarl.formula.FormulaType.CONSTRAINT:
|
|
return convert_constraint(formula.get_constraint())
|
|
if isinstance(formula, pycarl.gmp.formula.Formula):
|
|
csubformulae = [pycarl.cln.formula.Formula(convert(subf)) for subf in formula.get_subformulas()]
|
|
return pycarl.cln.formula.Formula(formula.type, csubformulae)
|
|
else:
|
|
raise TypeError("Formula of type {} cannot be convert to gmp".format(type(formula)))
|
|
|
|
|
|
def convert(data):
|
|
"""
|
|
Convert arbitrary data type to cln.
|
|
:param data: data structure.
|
|
:return: cln data structure.
|
|
"""
|
|
if isinstance(data, pycarl.cln.Integer) or isinstance(data, pycarl.gmp.Integer) or isinstance(data, int):
|
|
return convert_integer(data)
|
|
elif isinstance(data, pycarl.cln.Rational) or isinstance(data, pycarl.gmp.Rational) or isinstance(data, float):
|
|
return convert_rational(data)
|
|
elif isinstance(data, pycarl.cln.Term) or isinstance(data, pycarl.gmp.Term):
|
|
return convert_term(data)
|
|
elif isinstance(data, pycarl.cln.Polynomial) or isinstance(data, pycarl.gmp.Polynomial):
|
|
return convert_polynomial(data)
|
|
elif isinstance(data, pycarl.cln.RationalFunction) or isinstance(data, pycarl.gmp.RationalFunction):
|
|
return convert_rational_function(data)
|
|
elif isinstance(data, pycarl.cln.FactorizedPolynomial) or isinstance(data, pycarl.gmp.FactorizedPolynomial):
|
|
return convert_factorized_polynomial(data)
|
|
elif isinstance(data, pycarl.cln.FactorizedRationalFunction) or isinstance(data,
|
|
pycarl.gmp.FactorizedRationalFunction):
|
|
return convert_factorized_rational_function(data)
|
|
elif isinstance(data, pycarl.cln.formula.Constraint) or isinstance(data, pycarl.gmp.formula.Constraint):
|
|
return convert_constraint(data)
|
|
elif isinstance(data, pycarl.cln.formula.formula.Formula) or isinstance(data, pycarl.gmp.formula.Formula):
|
|
return convert_formula(data)
|
|
else:
|
|
raise TypeError("Unknown type {} for conversion to cln".format(type(data)))
|