def __call__(self, a, b, z, **kwargs): """ Return symbolic hypergeometric function expression. INPUT: - ``a`` -- a list or tuple of parameters - ``b`` -- a list or tuple of parameters - ``z`` -- a number or symbolic expression EXAMPLES:: sage: hypergeometric([], [], 1) hypergeometric((), (), 1) sage: hypergeometric([], [1], 1) hypergeometric((), (1,), 1) sage: hypergeometric([2, 3], [1], 1) hypergeometric((2, 3), (1,), 1) sage: hypergeometric([], [], x) hypergeometric((), (), x) sage: hypergeometric([x], [], x^2) hypergeometric((x,), (), x^2) The only simplification that is done automatically is returning 1 if ``z`` is 0. For other simplifications use the ``simplify_hypergeometric`` method. """ return BuiltinFunction.__call__(self, SR._force_pyobject(a), SR._force_pyobject(b), z, **kwargs)
def __call__(self, function_pieces, **kwds): r""" Piecewise functions INPUT: - ``function_pieces`` -- a list of pairs consisting of a domain and a symbolic function. - ``var=x`` -- a symbolic variable or ``None`` (default). The real variable in which the function is piecewise in. OUTPUT: A piecewise-defined function. A ``ValueError`` will be raised if the domains of the pieces are not pairwise disjoint. EXAMPLES:: sage: my_abs = piecewise([((-1, 0), -x), ([0, 1], x)], var=x); my_abs piecewise(x|-->-x on (-1, 0), x|-->x on [0, 1]; x) sage: [ my_abs(i/5) for i in range(-4, 5)] [4/5, 3/5, 2/5, 1/5, 0, 1/5, 2/5, 3/5, 4/5] TESTS:: sage: piecewise([([-1, 0], -x), ([0, 1], x)], var=x) Traceback (most recent call last): ... ValueError: domains must be pairwise disjoint sage: step = piecewise([((-1, 0), -1), ([0, 0], 0), ((0, 1), 1)], var=x); step piecewise(x|-->-1 on (-1, 0), x|-->0 on {0}, x|-->1 on (0, 1); x) sage: step(-1/2), step(0), step(1/2) (-1, 0, 1) """ from types import FunctionType var = kwds.pop('var', None) parameters = [] domain_list = [] for piece in function_pieces: domain, function = piece if not isinstance(domain, RealSet): domain = RealSet(domain) if domain.is_empty(): continue if isinstance(function, FunctionType): if var is None: var = SR.var('x') if function.func_code.co_argcount == 0: function = function() else: function = function(var) function = SR(function) if var is None and len(function.variables()) > 0: var = function.variables()[0] parameters.append((domain, function)) domain_list.append(domain) if not RealSet.are_pairwise_disjoint(*domain_list): raise ValueError('domains must be pairwise disjoint') if var is None: var = self.default_variable() parameters = SR._force_pyobject(tuple(parameters), recursive=False) return BuiltinFunction.__call__(self, parameters, var, **kwds)
def __call__(self, *args, **kwds): """ EXAMPLES:: sage: max_symbolic(3,5,x) max(x, 5) sage: max_symbolic(3,5,x, hold=True) max(3, 5, x) sage: max_symbolic([3,5,x]) max(x, 5) :: sage: min_symbolic(3,5,x) min(x, 3) sage: min_symbolic(3,5,x, hold=True) min(3, 5, x) sage: min_symbolic([3,5,x]) min(x, 3) TESTS: We get an exception if no arguments are given:: sage: max_symbolic() Traceback (most recent call last): ... ValueError: number of arguments must be > 0 Check if we return None, when the builtin function would:: sage: max_symbolic([None]) is None True sage: max_symbolic([None, None]) is None True sage: min_symbolic([None]) is None True sage: min_symbolic([None, None]) is None True Check if a single argument which is not iterable works:: sage: max_symbolic(None) Traceback (most recent call last): ... TypeError: 'NoneType' object is not iterable sage: max_symbolic(5) Traceback (most recent call last): ... TypeError: 'sage.rings.integer.Integer' object is not iterable sage: max_symbolic(x) Traceback (most recent call last): ... TypeError: 'sage.symbolic.expression.Expression' object is not iterable sage: min_symbolic(5) Traceback (most recent call last): ... TypeError: 'sage.rings.integer.Integer' object is not iterable sage: min_symbolic(x) Traceback (most recent call last): ... TypeError: 'sage.symbolic.expression.Expression' object is not iterable """ if len(args) == 0: raise ValueError("number of arguments must be > 0") if len(args) == 1: try: args=(SR._force_pyobject(iter(args[0])),) except TypeError as e: raise e try: return BuiltinFunction.__call__(self, *args, **kwds) except ValueError as e: if e.args[0] == "return None": return None