Callable Symbolic Expressions

EXAMPLES:

When you do arithmetic with:

Sage

sage: f(x, y, z) = sin(x+y+z)
sage: g(x, y) = y + 2*x
sage: f + g
(x, y, z) |--> 2*x + y + sin(x + y + z)

Python

>>> from sage.all import *
>>> __tmp__=var("x,y,z"); f = symbolic_expression(sin(x+y+z)).function(x,y,z)
>>> __tmp__=var("x,y"); g = symbolic_expression(y + Integer(2)*x).function(x,y)
>>> f + g
(x, y, z) |--> 2*x + y + sin(x + y + z)

Sage Live

f(x, y, z) = sin(x+y+z)
g(x, y) = y + 2*x
f + g

Sage

sage: f(x, y, z) = sin(x+y+z)
sage: g(w, t) = cos(w - t)
sage: f + g
(t, w, x, y, z) |--> cos(-t + w) + sin(x + y + z)

Python

>>> from sage.all import *
>>> __tmp__=var("x,y,z"); f = symbolic_expression(sin(x+y+z)).function(x,y,z)
>>> __tmp__=var("w,t"); g = symbolic_expression(cos(w - t)).function(w,t)
>>> f + g
(t, w, x, y, z) |--> cos(-t + w) + sin(x + y + z)

Sage Live

f(x, y, z) = sin(x+y+z)
g(w, t) = cos(w - t)
f + g

Sage

sage: f(x, y, t) = y*(x^2-t)
sage: g(x, y, w) = x + y - cos(w)
sage: f*g
(x, y, t, w) |--> (x^2 - t)*(x + y - cos(w))*y

Python

>>> from sage.all import *
>>> __tmp__=var("x,y,t"); f = symbolic_expression(y*(x**Integer(2)-t)).function(x,y,t)
>>> __tmp__=var("x,y,w"); g = symbolic_expression(x + y - cos(w)).function(x,y,w)
>>> f*g
(x, y, t, w) |--> (x^2 - t)*(x + y - cos(w))*y

Sage Live

f(x, y, t) = y*(x^2-t)
g(x, y, w) = x + y - cos(w)
f*g

Sage

sage: f(x,y, t) = x+y
sage: g(x, y, w) = w + t
sage: f + g
(x, y, t, w) |--> t + w + x + y

Python

>>> from sage.all import *
>>> __tmp__=var("x,y,t"); f = symbolic_expression(x+y).function(x,y,t)
>>> __tmp__=var("x,y,w"); g = symbolic_expression(w + t).function(x,y,w)
>>> f + g
(x, y, t, w) |--> t + w + x + y

Sage Live

f(x,y, t) = x+y
g(x, y, w) = w + t
f + g

class sage.symbolic.callable.CallableSymbolicExpressionFunctor(arguments)

Bases: ConstructionFunctor

A functor which produces a CallableSymbolicExpressionRing from the SymbolicRing.

EXAMPLES:

Sage

sage: from sage.symbolic.callable import CallableSymbolicExpressionFunctor
sage: x,y = var('x,y')
sage: f = CallableSymbolicExpressionFunctor((x,y)); f
CallableSymbolicExpressionFunctor(x, y)
sage: f(SR)
Callable function ring with arguments (x, y)

sage: loads(dumps(f))
CallableSymbolicExpressionFunctor(x, y)

Python

>>> from sage.all import *
>>> from sage.symbolic.callable import CallableSymbolicExpressionFunctor
>>> x,y = var('x,y')
>>> f = CallableSymbolicExpressionFunctor((x,y)); f
CallableSymbolicExpressionFunctor(x, y)
>>> f(SR)
Callable function ring with arguments (x, y)

>>> loads(dumps(f))
CallableSymbolicExpressionFunctor(x, y)

Sage Live

from sage.symbolic.callable import CallableSymbolicExpressionFunctor
x,y = var('x,y')
f = CallableSymbolicExpressionFunctor((x,y)); f
f(SR)
loads(dumps(f))

arguments()

EXAMPLES:

Sage

sage: from sage.symbolic.callable import CallableSymbolicExpressionFunctor
sage: x,y = var('x,y')
sage: a = CallableSymbolicExpressionFunctor((x,y))
sage: a.arguments()
(x, y)

Python

>>> from sage.all import *
>>> from sage.symbolic.callable import CallableSymbolicExpressionFunctor
>>> x,y = var('x,y')
>>> a = CallableSymbolicExpressionFunctor((x,y))
>>> a.arguments()
(x, y)

Sage Live

from sage.symbolic.callable import CallableSymbolicExpressionFunctor
x,y = var('x,y')
a = CallableSymbolicExpressionFunctor((x,y))
a.arguments()

merge(other)

EXAMPLES:

Sage

sage: from sage.symbolic.callable import CallableSymbolicExpressionFunctor
sage: x,y = var('x,y')
sage: a = CallableSymbolicExpressionFunctor((x,))
sage: b = CallableSymbolicExpressionFunctor((y,))
sage: a.merge(b)
CallableSymbolicExpressionFunctor(x, y)

Python

>>> from sage.all import *
>>> from sage.symbolic.callable import CallableSymbolicExpressionFunctor
>>> x,y = var('x,y')
>>> a = CallableSymbolicExpressionFunctor((x,))
>>> b = CallableSymbolicExpressionFunctor((y,))
>>> a.merge(b)
CallableSymbolicExpressionFunctor(x, y)

Sage Live

from sage.symbolic.callable import CallableSymbolicExpressionFunctor
x,y = var('x,y')
a = CallableSymbolicExpressionFunctor((x,))
b = CallableSymbolicExpressionFunctor((y,))
a.merge(b)

unify_arguments(x)

Take the variable list from another CallableSymbolicExpression object and compare it with the current CallableSymbolicExpression object’s variable list, combining them according to the following rules:

Let a be self’s variable list, let b be y’s variable list.

1. If a == b, then the variable lists are identical, so return that variable list.

2. If a \(\neq\) b, then check if the first \(n\) items in a are the first \(n\) items in b, or vice versa. If so, return a list with these \(n\) items, followed by the remaining items in a and b sorted together in alphabetical order.

Note

When used for arithmetic between CallableSymbolicExpression’s, these rules ensure that the set of CallableSymbolicExpression’s will have certain properties. In particular, it ensures that the set is a commutative ring, i.e., the order of the input variables is the same no matter in which order arithmetic is done.

INPUT:

• x – a CallableSymbolicExpression

OUTPUT: a tuple of variables

EXAMPLES:

Sage

sage: from sage.symbolic.callable import CallableSymbolicExpressionFunctor
sage: x,y = var('x,y')
sage: a = CallableSymbolicExpressionFunctor((x,))
sage: b = CallableSymbolicExpressionFunctor((y,))
sage: a.unify_arguments(b)
(x, y)

Python

>>> from sage.all import *
>>> from sage.symbolic.callable import CallableSymbolicExpressionFunctor
>>> x,y = var('x,y')
>>> a = CallableSymbolicExpressionFunctor((x,))
>>> b = CallableSymbolicExpressionFunctor((y,))
>>> a.unify_arguments(b)
(x, y)

Sage Live

from sage.symbolic.callable import CallableSymbolicExpressionFunctor
x,y = var('x,y')
a = CallableSymbolicExpressionFunctor((x,))
b = CallableSymbolicExpressionFunctor((y,))
a.unify_arguments(b)

AUTHORS:

• Bobby Moretti: thanks to William Stein for the rules

class sage.symbolic.callable.CallableSymbolicExpressionRingFactory

Bases: UniqueFactory

create_key(args, check=True)

EXAMPLES:

Sage

sage: x,y = var('x,y')
sage: CallableSymbolicExpressionRing.create_key((x,y))
(x, y)

Python

>>> from sage.all import *
>>> x,y = var('x,y')
>>> CallableSymbolicExpressionRing.create_key((x,y))
(x, y)

Sage Live

x,y = var('x,y')
CallableSymbolicExpressionRing.create_key((x,y))

create_object(version, key, **extra_args)

Return a CallableSymbolicExpressionRing given a version and a key.

EXAMPLES:

Sage

sage: x,y = var('x,y')
sage: CallableSymbolicExpressionRing.create_object(0, (x, y))
Callable function ring with arguments (x, y)

Python

>>> from sage.all import *
>>> x,y = var('x,y')
>>> CallableSymbolicExpressionRing.create_object(Integer(0), (x, y))
Callable function ring with arguments (x, y)

Sage Live

x,y = var('x,y')
CallableSymbolicExpressionRing.create_object(0, (x, y))

class sage.symbolic.callable.CallableSymbolicExpressionRing_class(arguments)

Bases: SymbolicRing, CallableSymbolicExpressionRing

EXAMPLES:

We verify that coercion works in the case where x is not an instance of SymbolicExpression, but its parent is still the SymbolicRing:

Sage

sage: f(x) = 1
sage: f*e
x |--> e

Python

>>> from sage.all import *
>>> __tmp__=var("x"); f = symbolic_expression(Integer(1)).function(x)
>>> f*e
x |--> e

Sage Live

f(x) = 1
f*e

args()

Return the arguments of self.

The order that the variables appear in self.arguments() is the order that is used in evaluating the elements of self.

EXAMPLES:

Sage

sage: x,y = var('x,y')
sage: f(x,y) = 2*x+y
sage: f.parent().arguments()
(x, y)
sage: f(y,x) = 2*x+y
sage: f.parent().arguments()
(y, x)

Python

>>> from sage.all import *
>>> x,y = var('x,y')
>>> __tmp__=var("x,y"); f = symbolic_expression(Integer(2)*x+y).function(x,y)
>>> f.parent().arguments()
(x, y)
>>> __tmp__=var("y,x"); f = symbolic_expression(Integer(2)*x+y).function(y,x)
>>> f.parent().arguments()
(y, x)

Sage Live

x,y = var('x,y')
f(x,y) = 2*x+y
f.parent().arguments()
f(y,x) = 2*x+y
f.parent().arguments()

arguments()

Return the arguments of self.

The order that the variables appear in self.arguments() is the order that is used in evaluating the elements of self.

EXAMPLES:

Sage

sage: x,y = var('x,y')
sage: f(x,y) = 2*x+y
sage: f.parent().arguments()
(x, y)
sage: f(y,x) = 2*x+y
sage: f.parent().arguments()
(y, x)

Python

>>> from sage.all import *
>>> x,y = var('x,y')
>>> __tmp__=var("x,y"); f = symbolic_expression(Integer(2)*x+y).function(x,y)
>>> f.parent().arguments()
(x, y)
>>> __tmp__=var("y,x"); f = symbolic_expression(Integer(2)*x+y).function(y,x)
>>> f.parent().arguments()
(y, x)

Sage Live

x,y = var('x,y')
f(x,y) = 2*x+y
f.parent().arguments()
f(y,x) = 2*x+y
f.parent().arguments()

construction()

EXAMPLES:

Sage

sage: f(x,y) = x^2 + y
sage: f.parent().construction()
(CallableSymbolicExpressionFunctor(x, y), Symbolic Ring)

Python

>>> from sage.all import *
>>> __tmp__=var("x,y"); f = symbolic_expression(x**Integer(2) + y).function(x,y)
>>> f.parent().construction()
(CallableSymbolicExpressionFunctor(x, y), Symbolic Ring)

Sage Live

f(x,y) = x^2 + y
f.parent().construction()

Make live