def radsimp(expr): """ Rationalize the denominator. Examples: ========= >>> from sympy import * >>> radsimp(1/(2+sqrt(2))) 1 - 1/2*2**(1/2) >>> x,y = map(Symbol, 'xy') >>> e = ( (2+2*sqrt(2))*x+(2+sqrt(8))*y )/( 2+sqrt(2) ) >>> radsimp(e) x*2**(1/2) + y*2**(1/2) """ n,d = fraction(expr) a,b,c = map(Wild, 'abc') r = d.match(a+b*Basic.sqrt(c)) if r is not None: a = r[a] if r[b] == 0: b,c = 0,0 else: b,c = r[b],r[c] syms = list(n.atoms(type=Basic.Symbol)) n = collect( (n*(a-b*Basic.sqrt(c))).expand(), syms ) d = a**2 - c*b**2 return n/d
def parse_term(expr): rat_expo, sym_expo = Rational(1), None sexpr, deriv = expr, None if isinstance(expr, Pow): if isinstance(expr.base, Derivative): sexpr, deriv = parse_derivative(expr.base) else: sexpr = expr.base if isinstance(expr.exp, Rational): rat_expo = expr.exp elif isinstance(expr.exp, Mul): coeff, tail = term.exp.as_coeff_terms() if isinstance(coeff, Rational): rat_expo, sym_expo = coeff, Basic.Mul(*tail) else: sym_expo = expr.exp else: sym_expo = expr.exp elif isinstance(expr, Basic.exp): if isinstance(expr[0], Rational): sexpr, rat_expo = Basic.exp(Rational(1)), expr[0] elif isinstance(expr[0], Mul): coeff, tail = expr[0].as_coeff_terms() if isinstance(coeff, Rational): sexpr, rat_expo = Basic.exp(Basic.Mul(*tail)), coeff elif isinstance(expr, Derivative): sexpr, deriv = parse_derivative(expr) return sexpr, rat_expo, sym_expo, deriv
def _eval_apply(self, z, a=S.One): z, a = map(Basic.sympify, (z, a)) if isinstance(a, Basic.Number): if isinstance(a, Basic.NaN): return S.NaN elif isinstance(a, Basic.Zero): return self(z) if isinstance(z, Basic.Number): if isinstance(z, Basic.NaN): return S.NaN elif isinstance(z, Basic.Infinity): return S.One elif isinstance(z, Basic.Zero): if a.is_negative: return S.Half - a - 1 else: return S.Half - a elif isinstance(z, Basic.One): return S.ComplexInfinity elif isinstance(z, Basic.Integer): if isinstance(a, Basic.Integer): if z.is_negative: zeta = (-1)**z * Basic.bernoulli(-z+1)/(-z+1) elif z.is_even: B, F = Basic.bernoulli(z), Basic.Factorial(z) zeta = 2**(z-1) * abs(B) * pi**z / F if a.is_negative: return zeta + Basic.harmonic(abs(a), z) else: return zeta - Basic.harmonic(a-1, z)
def _eval_apply(cls, arg): arg = Basic.sympify(arg) if isinstance(arg, Basic.Number): if isinstance(arg, Basic.NaN): return S.NaN elif isinstance(arg, Basic.Infinity): return S.Infinity elif isinstance(arg, Basic.Integer): if arg.is_positive: return Basic.Factorial(arg-1) else: return S.ComplexInfinity elif isinstance(arg, Basic.Rational): if arg.q == 2: n = abs(arg.p) / arg.q if arg.is_positive: k, coeff = n, S.One else: n = k = n + 1 if n & 1 == 0: coeff = S.One else: coeff = S.NegativeOne for i in range(3, 2*k, 2): coeff *= i if arg.is_positive: return coeff*Basic.sqrt(S.Pi) / 2**n else: return 2**n*Basic.sqrt(S.Pi) / coeff
def _eval_apply(cls, a, x): if isinstance(a, Basic.Number): if isinstance(a, Basic.One): return S.One - Basic.exp(-x) elif isinstance(a, Basic.Integer): b = a - 1 if b.is_positive: return b*cls(b, x) - x**b * Basic.exp(-x)
def __new__(cls, f, z, **assumptions): f = Basic.sympify(f) if not f.is_polynomial(z): return f obj = Basic.__new__(cls, **assumptions) obj._args = (f.as_polynomial(z), z) return obj
def separate(expr, deep=False): """Rewrite or separate a power of product to a product of powers but without any expanding, ie. rewriting products to summations. >>> from sympy import * >>> x, y, z = symbols('x', 'y', 'z') >>> separate((x*y)**2) x**2*y**2 >>> separate((x*(y*z)**3)**2) x**2*y**6*z**6 >>> separate((x*sin(x))**y + (x*cos(x))**y) x**y*cos(x)**y + x**y*sin(x)**y #>>> separate((exp(x)*exp(y))**x) #exp(x*y)*exp(x**2) Notice that summations are left un touched. If this is not the requested behaviour, apply 'expand' to input expression before: >>> separate(((x+y)*z)**2) z**2*(x + y)**2 >>> separate((x*y)**(1+z)) x**(1 + z)*y**(1 + z) """ expr = Basic.sympify(expr) if isinstance(expr, Basic.Pow): terms, expo = [], separate(expr.exp, deep) #print expr, terms, expo, expr.base if isinstance(expr.base, Mul): t = [ separate(Basic.Pow(t,expo), deep) for t in expr.base ] return Basic.Mul(*t) elif isinstance(expr.base, Basic.exp): if deep == True: return Basic.exp(separate(expr.base[0], deep)*expo) else: return Basic.exp(expr.base[0]*expo) else: return Basic.Pow(separate(expr.base, deep), expo) elif isinstance(expr, (Basic.Add, Basic.Mul)): return type(expr)(*[ separate(t, deep) for t in expr ]) elif isinstance(expr, Basic.Function) and deep: return expr.func(*[ separate(t) for t in expr]) else: return expr
def __new__(cls, e, z, z0, dir="+"): e = sympify(e) z = sympify(z) z0 = sympify(z0) obj = Basic.__new__(cls) obj._args = (e, z, z0, dir) return obj
def __new__(cls, *args): from sympy.matrices.immutable import ImmutableDenseMatrix args = map(sympify, args) mat = ImmutableDenseMatrix(*args) obj = Basic.__new__(cls, mat) return obj
def __new__(cls, radius=1, center=[0,0,0], direction=[0,0,1], closed=False, **kwargs): """ >>> from sympy import * >>> from symplus.strplus import init_mprinting >>> init_mprinting() >>> InfiniteCylinder() InfiniteCylinder(1, [0 0 0]', [0 0 1]', False) >>> InfiniteCylinder(2, [0,0,0], [0,1,1]) InfiniteCylinder(2, [0 0 0]', [0 -sqrt(2)/2 -sqrt(2)/2]', False) >>> InfiniteCylinder().contains((1,1,1)) False >>> InfiniteCylinder(2, [0,0,0], [0,1,1]).contains((1,1,1)) True """ normalization = kwargs.pop("normalization", True) radius = sympify(abs(radius)) direction = Mat(direction) if normalization: if norm(direction) == 0: raise ValueError direction = simplify(normalize(direction)) direction = max(direction, -direction, key=hash) center = Mat(center) if normalization: center = simplify(center - project(center, direction)) closed = sympify(bool(closed)) return Basic.__new__(cls, radius, center, direction, closed)
def __new__(cls, *args, **options): # (Try to) sympify args first newargs = [] for ec in args: pair = ExprCondPair(*ec) cond = pair.cond if cond == false: continue if not isinstance(cond, (bool, Relational, Boolean)): raise TypeError( "Cond %s is of type %s, but must be a Relational," " Boolean, or a built-in bool." % (cond, type(cond))) newargs.append(pair) if cond == True: break if options.pop('evaluate', True): r = cls.eval(*newargs) else: r = None if r is None: return Basic.__new__(cls, *newargs, **options) else: return r
def __new__(cls, *components): if components and not isinstance(components[0], Morphism): # Maybe the user has explicitly supplied a list of # morphisms. return CompositeMorphism.__new__(cls, *components[0]) normalised_components = Tuple() for current, following in zip(components, components[1:]): if not isinstance(current, Morphism) or \ not isinstance(following, Morphism): raise TypeError("All components must be morphisms.") if current.codomain != following.domain: raise ValueError("Uncomposable morphisms.") normalised_components = CompositeMorphism._add_morphism( normalised_components, current) # We haven't added the last morphism to the list of normalised # components. Add it now. normalised_components = CompositeMorphism._add_morphism( normalised_components, components[-1]) if not normalised_components: # If ``normalised_components`` is empty, only identities # were supplied. Since they all were composable, they are # all the same identities. return components[0] elif len(normalised_components) == 1: # No sense to construct a whole CompositeMorphism. return normalised_components[0] return Basic.__new__(cls, normalised_components)
def __new__(cls, name, objects=EmptySet(), commutative_diagrams=EmptySet()): if not name: raise ValueError("A Category cannot have an empty name.") new_category = Basic.__new__(cls, Symbol(name), Class(objects), FiniteSet(*commutative_diagrams)) return new_category
def __new__(cls, *args, **kw_args): """ The constructor for the Prufer object. Examples ======== >>> from sympy.combinatorics.prufer import Prufer A Prufer object can be constructed from a list of node connections and the number of nodes: >>> a = Prufer([[0, 1], [0, 2], [0, 3]], 4) >>> a.prufer_repr [0, 0] A Prufer object can be constructed from a Prufer sequence: >>> b = Prufer([1, 3]) >>> b.tree_repr [[2, 1], [1, 3], [3, 0]] """ ret_obj = Basic.__new__(cls, *args, **kw_args) if isinstance(args[0][0], list): ret_obj._tree_repr = args[0] ret_obj._nodes = args[1] else: ret_obj._prufer_repr = args[0] ret_obj._nodes = len(ret_obj._prufer_repr) + 2 return ret_obj
def __new__(cls, *args, **kw_args): """ Constructor for the Permutation object. Examples ======== >>> from sympy.combinatorics.permutations import Permutation >>> p = Permutation([0,1,2]) >>> p Permutation([0, 1, 2]) >>> q = Permutation([[0,1],[2]]) >>> q Permutation([[0, 1], [2]]) """ if not args or not is_sequence(args[0]) or len(args) > 1 or \ len(set(is_sequence(a) for a in args[0])) > 1: raise ValueError('Permutation argument must be a list of ints or a list of lists.') # 0, 1, ..., n-1 should all be present temp = [int(i) for i in flatten(args[0])] if set(range(len(temp))) != set(temp): raise ValueError("Integers 0 through %s must be present." % len(temp)) cform = aform = None if args[0] and is_sequence(args[0][0]): cform = [list(a) for a in args[0]] else: aform = list(args[0]) ret_obj = Basic.__new__(cls, (cform or aform), **kw_args) ret_obj._cyclic_form, ret_obj._array_form = cform, aform return ret_obj
def __new__(cls, arg, expr): if not isinstance(arg, Argument): raise TypeError("arg must be of type `Argument`") expr = _sympify(expr) if not isinstance(expr, (Expr, MatrixExpr)): raise TypeError("Unsupported expression type %s." % type(expr)) return Basic.__new__(cls, arg, expr)
def __new__(cls, mat): mat = _sympify(mat) if not mat.is_Matrix: raise TypeError("mat should be a matrix") if not mat.is_square: raise ShapeError("Inverse of non-square matrix %s" % mat) return Basic.__new__(cls, mat)
def __new__(cls, subset, superset): """ Default constructor. It takes the subset and its superset as its parameters. Examples: >>> from sympy.combinatorics.subsets import Subset >>> a = Subset(['c','d'], ['a','b','c','d']) >>> a.subset ['c', 'd'] >>> a.superset ['a', 'b', 'c', 'd'] >>> a.size 2 """ if len(subset) > len(superset): raise ValueError("Invalid arguments have been provided. The superset must be larger than the subset.") for elem in subset: if elem not in superset: raise ValueError("The superset provided is invalid as it does not contain the element %i" % elem) obj = Basic.__new__(cls) obj._subset = subset obj._superset = superset return obj
def __new__(cls, func, center=[0,0,0], direction=[0,0,1], **kwargs): center = Mat(center) direction = Mat(direction) if norm(direction) == 0: raise ValueError direction = normalize(direction) return Basic.__new__(cls, func, center, direction)
def __new__(cls, *args, **kwargs): check = kwargs.get('check', True) obj = Basic.__new__(cls, *args) if check: validate(*args) return obj
def __new__(cls, partition, integer=None): """ Generates a new IntegerPartition object from a list or dictionary. The partition can be given as a list of positive integers or a dictionary of (integer, multiplicity) items. If the partition is preceeded by an integer an error will be raised if the partition does not sum to that given integer. Examples ======== >>> from sympy.combinatorics.partitions import IntegerPartition >>> a = IntegerPartition([5, 4, 3, 1, 1]) >>> a IntegerPartition(14, (5, 4, 3, 1, 1)) >>> print a [5, 4, 3, 1, 1] >>> IntegerPartition({1:3, 2:1}) IntegerPartition(5, (2, 1, 1, 1)) If the value that the partion should sum to is given first, a check will be made to see n error will be raised if there is a discrepancy: >>> IntegerPartition(10, [5, 4, 3, 1]) Traceback (most recent call last): ... ValueError: The partition is not valid """ from sympy.ntheory.residue_ntheory import int_tested if integer is not None: integer, partition = partition, integer if isinstance(partition, (dict, Dict)): _ = [] for k, v in sorted(partition.items(), reverse=True): if not v: continue k, v = int_tested(k, v) _.extend([k]*v) partition = tuple(_) else: partition = tuple(sorted(int_tested(partition), reverse=True)) sum_ok = False if integer is None: integer = sum(partition) sum_ok = True else: integer = int_tested(integer) if not sum_ok and sum(partition) != integer: raise ValueError("Partition did not add to %s" % integer) if any(i < 1 for i in partition): raise ValueError("The summands must all be positive.") obj = Basic.__new__(cls, integer, partition) obj.partition = list(partition) obj.integer = integer return obj
def __new__(cls, *args, **kwargs): args = list(map(sympify, args)) check = kwargs.get('check', True) obj = Basic.__new__(cls, *args) if check: validate(*args) return obj
def _new(cls, *args, **kwargs): if len(args) == 1 and isinstance(args[0], ImmutableMatrix): return args[0] rows, cols, flat_list = cls._handle_creation_inputs(*args, **kwargs) rows = Integer(rows) cols = Integer(cols) mat = Tuple(*flat_list) return Basic.__new__(cls, rows, cols, mat)
def _eval_apply(cls, a, z): if isinstance(z, Basic.Number): if isinstance(z, Basic.NaN): return S.NaN elif isinstance(z, Basic.Infinity): return S.Zero elif isinstance(z, Basic.Zero): return gamma(a) if isinstance(a, Basic.Number): if isinstance(a, Basic.One): return Basic.exp(-z) elif isinstance(a, Basic.Integer): b = a - 1 if b.is_positive: return b*cls(b, z) + z**b * Basic.exp(-z)
def __new__(cls, f, *symbols, **assumptions): f = Basic.sympify(f) if isinstance(f, Basic.Number): if isinstance(f, Basic.NaN): return S.NaN elif isinstance(f, Basic.Zero): return S.Zero if not symbols: limits = f.atoms(Symbol) if not limits: return f else: limits = [] for V in symbols: if isinstance(V, Symbol): limits.append(V) continue elif isinstance(V, Equality): if isinstance(V.lhs, Symbol): if isinstance(V.rhs, Interval): limits.append((V.lhs, V.rhs.start, V.rhs.end)) else: limits.append((V.lhs, V.rhs)) continue elif isinstance(V, (tuple, list)): if len(V) == 1: if isinstance(V[0], Symbol): limits.append(V[0]) continue elif len(V) in (2, 3): if isinstance(V[0], Symbol): limits.append(tuple(V)) continue raise ValueError("Invalid summation variable or limits") obj = Basic.__new__(cls, **assumptions) obj._args = (f, tuple(limits)) return obj
def __new__(cls, *args, **kwargs): check = kwargs.get('check', True) args = map(sympify, args) obj = Basic.__new__(cls, *args) factor, matrices = obj.as_coeff_matrices() if check: validate(*matrices) return obj
def _new(cls, *args, **kwargs): # same as sympy version, only always creates new class # even if passed in a matrix from sympy.core import Basic, Integer rows, cols, flat_list = cls._handle_creation_inputs(*args, **kwargs) rows = Integer(rows) cols = Integer(cols) mat = Tuple(*flat_list) return Basic.__new__(cls, rows, cols, mat)
def __new__(cls, dtype, expr): if isinstance(dtype, str): dtype = datatype(dtype) elif not isinstance(dtype, DataType): raise TypeError("datatype must be an instance of DataType.") expr = _sympify(expr) if not isinstance(expr, (Expr, MatrixExpr)): raise TypeError("Unsupported expression type %s." % type(expr)) return Basic.__new__(cls, dtype, expr)
def __new__(cls, routine, args): if not isinstance(routine, Routine): raise TypeError("routine must be of type Routine") if len(routine.arguments) != len(args): raise ValueError("Incorrect number of arguments") for n, (a, p) in enumerate(zip(args, routine.arguments)): cls._validate_arg(a, p) args = Tuple(*args) return Basic.__new__(cls, routine, args)
def __new__(cls, mat, exp=S(-1)): # exp is there to make it consistent with # inverse.func(*inverse.args) == inverse mat = _sympify(mat) if not mat.is_Matrix: raise TypeError("mat should be a matrix") if not mat.is_square: raise ShapeError("Inverse of non-square matrix %s" % mat) return Basic.__new__(cls, mat, exp)
def __new__(cls, n, *args, **kw_args): """ Default constructor. It takes a single argument ``n`` which gives the dimension of the Gray code. The starting Gray code string (``start``) or the starting ``rank`` may also be given; the default is to start at rank = 0 ('0...0'). Examples ======== >>> from sympy.combinatorics.graycode import GrayCode >>> a = GrayCode(3) >>> a GrayCode(3) >>> a.n 3 >>> a = GrayCode(3, start='100') >>> a.current '100' >>> a = GrayCode(4, rank=4) >>> a.current '0110' >>> a.rank 4 """ if n < 1 or int(n) != n: raise ValueError( 'Gray code dimension must be a positive integer, not %i' % n) n = int(n) args = (n, ) + args obj = Basic.__new__(cls, *args) if 'start' in kw_args: obj._current = kw_args["start"] if len(obj._current) > n: raise ValueError( 'Gray code start has length %i but should not be greater than %i' % (len(obj._current), n)) elif 'rank' in kw_args: if int(kw_args["rank"]) != kw_args["rank"]: raise ValueError( 'Gray code rank must be a positive integer, not %i' % kw_args["rank"]) obj._rank = int(kw_args["rank"]) % obj.selections obj._current = obj.unrank(n, obj._rank) return obj
def __new__(cls, arguments, expr, check=False): # ... if expr.atoms(DomainIntegral, BoundaryIntegral): raise TypeError('') # ... # ... if check and not is_linear_form(expr, arguments): msg = '> Expression is not linear' raise UnconsistentLinearExpressionError(msg) # ... args = _sanitize_arguments(arguments, is_linear=True) return Basic.__new__(cls, args, expr)
def __new__(cls, *args, **options): # (Try to) sympify args first if options.pop('evaluate', True): args = cls._annotate(*args) r = cls.eval(*args, **options) else: r = None if r is None: return Basic.__new__(cls, *args, **options) else: return r
def _new(cls, *args, **kwargs): if len(args) == 1 and isinstance(args[0], ImmutableDenseMatrix): return args[0] if kwargs.get('copy', True) is False: if len(args) != 3: raise TypeError("'copy=False' requires a matrix be initialized as rows,cols,[list]") rows, cols, flat_list = args else: rows, cols, flat_list = cls._handle_creation_inputs(*args, **kwargs) flat_list = list(flat_list) # create a shallow copy rows = Integer(rows) cols = Integer(cols) if not isinstance(flat_list, Tuple): flat_list = Tuple(*flat_list) return Basic.__new__(cls, rows, cols, flat_list)
def __new__(cls, *args, **kwargs): if not args: return GenericZeroMatrix() # This must be removed aggressively in the constructor to avoid # TypeErrors from GenericZeroMatrix().shape args = filter(lambda i: GenericZeroMatrix() != i, args) args = list(map(sympify, args)) check = kwargs.get('check', False) obj = Basic.__new__(cls, *args) if check: if all(not isinstance(i, MatrixExpr) for i in args): return Add.fromiter(args) validate(*args) return obj
def __new__(cls, function, *symbols, **assumptions): if any(len(l) != 3 or None for l in symbols): raise ValueError('ArrayComprehension requires values lower and upper bound' ' for the expression') if not isLambda(function): raise ValueError('Data type not supported') arglist = cls._check_limits_validity(function, symbols) obj = Basic.__new__(cls, *arglist, **assumptions) obj._limits = obj._args obj._shape = cls._calculate_shape_from_limits(obj._limits) obj._rank = len(obj._shape) obj._loop_size = cls._calculate_loop_size(obj._shape) obj._lambda = function return obj
def __new__(cls, arg1, arg2): arg1, arg2 = _sympify((arg1, arg2)) if not arg1.is_Matrix: raise TypeError("Argument 1 of DotProduct is not a matrix") if not arg2.is_Matrix: raise TypeError("Argument 2 of DotProduct is not a matrix") if not (1 in arg1.shape): raise TypeError("Argument 1 of DotProduct is not a vector") if not (1 in arg2.shape): raise TypeError("Argument 2 of DotProduct is not a vector") if set(arg1.shape) != set(arg2.shape): raise TypeError("DotProduct arguments are not the same length") return Basic.__new__(cls, arg1, arg2)
def __new__(cls, name, dim=None): target = None if not isinstance(name, str): target = name name = name.name if not (target is None): if isinstance(target, ProductDomain): dim = target.dim obj = Basic.__new__(cls, name) obj._dim = dim obj._target = target return obj
def __new__(cls, *args, **options): # (Try to) sympify args first name = options.pop('name', None) if options.pop('evaluate', True): r = cls.eval(*args) else: r = None if r is None: obj = Basic.__new__(cls, *args, **options) obj._name = name return obj else: r._name = name return r
def test_issue_3001(): x = Symbol('x') y = Symbol('y') assert x**1.0 == x assert x == x**1.0 assert True != x**1.0 assert x**1.0 is not True assert x is not True assert x*y == (x*y)**1.0 assert (x**1.0)**1.0 == x assert (x**1.0)**2.0 == x**2 b = Basic() assert Pow(b, 1.0, evaluate=False) == b # if the following gets distributed as a Mul (x**1.0*y**1.0 then # __eq__ methods could be added to Symbol and Pow to detect the # power-of-1.0 case. assert ((x*y)**1.0).func is Pow
def __new__(cls, f, *symbols, **assumptions): f = sympify(f) if f.is_Number: if f is S.NaN: return S.NaN elif f is S.Zero: return S.Zero if not symbols: limits = f.atoms(Symbol) if not limits: return f else: limits = [] for V in symbols: if isinstance(V, Symbol): limits.append(V) continue elif isinstance(V, Equality): if isinstance(V.lhs, Symbol): if isinstance(V.rhs, Interval): limits.append((V.lhs, V.rhs.start, V.rhs.end)) else: limits.append((V.lhs, V.rhs)) continue elif isinstance(V, (tuple, list)): if len(V) == 1: if isinstance(V[0], Symbol): limits.append(V[0]) continue elif len(V) in (2, 3): if isinstance(V[0], Symbol): limits.append(tuple(map(sympify, V))) continue raise ValueError("Invalid summation variable or limits") obj = Basic.__new__(cls, **assumptions) obj._args = (f, tuple(limits)) return obj
def test_issue_6100_12942_4473(): x = Symbol("x") y = Symbol("y") assert x**1.0 != x assert x != x**1.0 assert True != x**1.0 assert x**1.0 is not True assert x is not True assert x * y != (x * y)**1.0 # Pow != Symbol assert (x**1.0)**1.0 != x assert (x**1.0)**2.0 != x**2 b = Basic() assert Pow(b, 1.0, evaluate=False) != b # if the following gets distributed as a Mul (x**1.0*y**1.0 then # __eq__ methods could be added to Symbol and Pow to detect the # power-of-1.0 case. assert ((x * y)**1.0).func is Pow
def __new__(cls, name, bnd_minus, bnd_plus, mapping=None, logical_domain=None): if not isinstance(name , str ): raise TypeError(name) if not isinstance(bnd_minus, Boundary): raise TypeError(bnd_minus) if not isinstance(bnd_plus , Boundary): raise TypeError(bnd_plus) if bnd_minus.dim != bnd_plus.dim: raise TypeError('Dimension mismatch: {} != {}'.format( bnd_minus.dim, bnd_plus.dim)) assert mapping is None and logical_domain is None or\ mapping is not None and logical_domain is not None assert bnd_minus.axis == bnd_plus.axis obj = Basic.__new__(cls, name, bnd_minus, bnd_plus) obj._mapping = mapping obj._logical_domain = logical_domain return obj
def _new_from_array_form(perm): """ factory function to produce a Permutation object from a list; the list is bound to the _array_form attribute, so it must not be modified; this method is meant for internal use only; the list a is supposed to be generated as a temporary value in a method, so p = _new_from_array_form(a) is the only object to hold a reference to a:: >>> from sympy.combinatorics.permutations import _new_from_array_form >>> a = [2,1,3,0] >>> p = _new_from_array_form(a) >>> p Permutation([2, 1, 3, 0]) """ p = Basic.__new__(Permutation, perm) p._array_form = perm return p
def __new__(cls, name, args, results): # name if isinstance(name, str): name = Symbol(name) elif not isinstance(name, Symbol): raise TypeError("name must be Symbol or string") # args if not iterable(args): raise TypeError("args must be an iterable") if not all(isinstance(a, Argument) for a in args): raise TypeError("All args must be of type Argument") args = Tuple(*args) # results if not iterable(results): raise TypeError("results must be an iterable") if not all(isinstance(i, RoutineResult) for i in results): raise TypeError("All results must be of type RoutineResult") results = Tuple(*results) return Basic.__new__(cls, name, args, results)
def __new__(cls, *args, **options): # (Try to) sympify args first newargs = [] for ec in args: pair = ExprCondPair(*ec) cond_type = type(pair.cond) if not (cond_type is bool or issubclass(cond_type, Relational) or \ issubclass(cond_type, Number) or issubclass(cond_type, Set)): raise TypeError, \ "Cond %s is of type %s, but must be a bool," \ " Relational, Number or Set" % (pair.cond, cond_type) newargs.append(pair) r = cls.eval(*newargs) if r is None: return Basic.__new__(cls, *newargs, **options) else: return r
def __new__(cls, name, domain, axis=None, ext=None, mapping=None, logical_domain=None): if axis is not None: assert isinstance(axis, int) if ext is not None: assert isinstance(ext, int) obj = Basic.__new__(cls, name, domain, axis, ext) obj._mapping = mapping obj._logical_domain = logical_domain return obj
def __new__(cls, function, *symbols, **assumptions): function = sympify(function) if function.is_Number: if function is S.NaN: return S.NaN elif function is S.Infinity: return S.Infinity elif function is S.NegativeInfinity: return S.NegativeInfinity if symbols: limits = [] for V in symbols: if isinstance(V, Symbol): limits.append((V, None)) continue elif isinstance(V, (tuple, list)): if len(V) == 3: if isinstance(V[0], Symbol): nlim = map(sympify, V[1:]) limits.append((V[0], tuple(nlim))) continue elif len(V) == 1 or (len(V) == 2 and V[1] is None): if isinstance(V[0], Symbol): limits.append((V[0], None)) continue raise ValueError("Invalid integration variable or limits: %s" % str(symbols)) else: # no symbols provided -- let's compute full antiderivative limits = [(symb, None) for symb in function.atoms(Symbol)] if not limits: return function obj = Basic.__new__(cls, **assumptions) obj._args = (function, tuple(limits)) return obj
def __new__(cls, name, domain, shape, kind): if not isinstance(domain, BasicDomain): raise TypeError('> Expecting a BasicDomain object for domain') obj = Basic.__new__(cls) obj._name = name obj._domain = domain obj._shape = shape # ... if kind is None: kind = 'undefined' if isinstance(kind, str): kind_str = kind.lower() assert (kind_str in ['h1', 'hcurl', 'hdiv', 'l2', 'undefined']) kind = dtype_space_registry[kind_str] elif not isinstance(kind, SpaceType): raise TypeError('Expecting kind to be of SpaceType') kind_str = kind.name obj._kind = kind # ... if not (kind_str == 'undefined'): obj._regularity = dtype_regularity_registry[kind_str] # ... # ... # TODO remove this if => bug in tensor form if isinstance(domain, Interval): is_broken = False else: is_broken = len(domain) > 1 obj._is_broken = is_broken # ... return obj
def __new__(cls, arg1, arg2): if not arg1.is_Matrix: raise TypeError("Input to Dot Product, %s, not a matrix" % str(arg1)) if not arg2.is_Matrix: raise TypeError("Input to Dot Product, %s, not a matrix" % str(arg2)) if not (1 in arg1.shape): raise TypeError("Input to Dot Product, %s, not a vector" % str(arg1)) if not (1 in arg2.shape): raise TypeError("Input to Dot Product, %s, not a vector" % str(arg1)) if arg1.shape != arg2.shape: raise TypeError( "Input to Dot Product, %s and %s, are not of same dimensions" % (str(arg1), str(arg2))) return Basic.__new__(cls, arg1, arg2)
def __new__(cls, *args, **kwargs): check = kwargs.get('check', True) if not args: return GenericIdentity() # This must be removed aggressively in the constructor to avoid # TypeErrors from GenericIdentity().shape args = filter(lambda i: GenericIdentity() != i, args) args = list(map(sympify, args)) obj = Basic.__new__(cls, *args) factor, matrices = obj.as_coeff_matrices() if check: validate(*matrices) if not matrices: # Should it be # # return Basic.__neq__(cls, factor, GenericIdentity()) ? return factor return obj
def __new__(cls, name, dim=None, dtype=None, mapping=None, logical_domain=None): target = None if not isinstance(name, str): target = name name = name.name if not( target is None ): dim = target.dim assert mapping is None and logical_domain is None or \ mapping is not None and logical_domain is not None obj = Basic.__new__(cls, name) obj._dim = dim obj._target = target obj._dtype = dtype obj._mapping = mapping obj._logical_domain = logical_domain return obj
def __new__(cls, *args, evaluate=False, check=False, _sympify=True): if not args: return cls.identity # This must be removed aggressively in the constructor to avoid # TypeErrors from GenericZeroMatrix().shape args = list(filter(lambda i: cls.identity != i, args)) if _sympify: args = list(map(sympify, args)) obj = Basic.__new__(cls, *args) if check: if not any(isinstance(i, MatrixExpr) for i in args): return Add.fromiter(args) validate(*args) if evaluate: obj = cls._evaluate(obj) return obj
def __new__(cls, *args, **kw_args): """ The constructor for the Prufer object. Examples: >>> from sympy.combinatorics.prufer import Prufer >>> a = Prufer([[0, 1], [0, 2], [0, 3]], 4) >>> a.prufer_repr [0, 0] >>> b = Prufer([1, 3]) >>> b.tree_repr [[2, 1], [1, 3], [3, 0]] """ ret_obj = Basic.__new__(cls, *args, **kw_args) if isinstance(args[0][0], list): ret_obj._tree_repr = args[0] ret_obj._nodes = args[1] else: ret_obj._prufer_repr = args[0] ret_obj._nodes = len(ret_obj._prufer_repr) + 2 return ret_obj
def __new__(cls, term, *symbols, **assumptions): term = sympify(term) if term.is_Number: if term is S.NaN: return S.NaN elif term is S.Infinity: return S.NaN elif term is S.NegativeInfinity: return S.NaN elif term is S.Zero: return S.Zero elif term is S.One: return S.One if len(symbols) == 1: symbol = symbols[0] if isinstance(symbol, C.Equality): k = symbol.lhs a = symbol.rhs.start n = symbol.rhs.end elif isinstance(symbol, (tuple, list)): k, a, n = symbol else: raise ValueError("Invalid arguments") k, a, n = map(sympify, (k, a, n)) if isinstance(a, C.Number) and isinstance(n, C.Number): return Mul( *[term.subs(k, i) for i in xrange(int(a), int(n) + 1)]) else: raise NotImplementedError obj = Basic.__new__(cls, **assumptions) obj._args = (term, k, a, n) return obj
def __new__(cls, expr, domain, eval=True): if eval: expr = Integral(expr, domain) obj = Basic.__new__(cls, expr, domain) # compute dim from fields if available ls = list(expr.atoms((ScalarField, VectorField))) if ls: F = ls[0] space = F.space else: tag = random_string( 3 ) space_name = 'space_{}'.format(tag) space = ScalarFunctionSpace(space_name, domain) # TODO vector case obj._ldim = domain.dim obj._space = space return obj
def is_shape_numeric(self): """ Test if the array is shape-numeric which means there is no symbolic dimension. Examples ======== >>> from sympy.tensor.array import ArrayComprehension >>> from sympy import symbols >>> i, j, k = symbols('i j k') >>> a = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, 3)) >>> a.is_shape_numeric True >>> b = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, k+3)) >>> b.is_shape_numeric False """ for _, inf, sup in self._limits: if Basic(inf, sup).atoms(Symbol): return False return True
def __new__(cls, *args, **options): # (Try to) sympify args first newargs = [] for ec in args: # ec could be a ExprCondPair or a tuple pair = ExprCondPair(*getattr(ec, 'args', ec)) cond = pair.cond if cond is false: continue newargs.append(pair) if cond is true: break if options.pop('evaluate', True): r = cls.eval(*newargs) else: r = None if r is None: return Basic.__new__(cls, *newargs, **options) else: return r
def is_numeric(self): """ Return True if the expanded array is numeric, which means that there is not symbolic dimension. Examples ======== >>> from sympy.tensor.array import ArrayComprehension >>> from sympy.abc import i, j, k >>> a = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, 3)) >>> a.is_numeric True >>> b = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, k+3)) >>> b.is_numeric False """ for var, inf, sup in self._limits: if Basic(inf, sup).atoms(Symbol): return False return True
def __new__(cls, *components): if components and not isinstance(components[0], Morphism): # Maybe the user has explicitly supplied a list of # morphisms. return CompositeMorphism.__new__(cls, *components[0]) normalised_components = Tuple() # TODO: Fix the unpythonicity. for i in xrange(len(components) - 1): current = components[i] following = components[i + 1] if not isinstance(current, Morphism) or \ not isinstance(following, Morphism): raise TypeError("All components must be morphisms.") if current.codomain != following.domain: raise ValueError("Uncomposable morphisms.") normalised_components = CompositeMorphism._add_morphism( normalised_components, current) # We haven't added the last morphism to the list of normalised # components. Add it now. normalised_components = CompositeMorphism._add_morphism( normalised_components, components[-1]) if not normalised_components: # If ``normalised_components`` is empty, only identities # were supplied. Since they all were composable, they are # all the same identities. return components[0] elif len(normalised_components) == 1: # No sense to construct a whole CompositeMorphism. return normalised_components[0] return Basic.__new__(cls, normalised_components)