This is used while pickling old symbolic functions that define a custom evalf method.
The protocol for numeric evaluation functions was changed to include a parent argument instead of prec. This function creates a wrapper around the old custom method, which extracts the precision information from the given parent, and passes it on to the old function.
EXAMPLES:
sage: from sage.symbolic.function_factory import deprecated_custom_evalf_wrapper as dcew
sage: def old_func(x, prec=0): print "x: %s, prec: %s"%(x,prec)
sage: new_func = dcew(old_func)
sage: new_func(5, parent=RR)
x: 5, prec: 53
sage: new_func(0r, parent=ComplexField(100))
x: 0, prec: 100
Given a method f return a new method which takes a single symbolic expression argument and appends operands of the given expression to the arguments of f.
EXAMPLES:
sage: def f(ex, x, y):
....: '''
....: Some documentation.
....: '''
....: return x + 2*y
....:
sage: f(None, x, 1)
x + 2
sage: from sage.symbolic.function_factory import eval_on_operands
sage: g = eval_on_operands(f)
sage: g(x + 1)
x + 2
sage: g.__doc__.strip()
'Some documentation.'
Create a formal symbolic function with the name s.
INPUT:
Note that custom methods must be instance methods, i.e., expect the instance of the symbolic function as the first argument.
EXAMPLES:
sage: var('a, b')
(a, b)
sage: f = function('cr', a)
sage: g = f.diff(a).integral(b)
sage: g
b*D[0](cr)(a)
sage: foo = function("foo", nargs=2)
sage: x,y,z = var("x y z")
sage: foo(x, y) + foo(y, z)^2
foo(y, z)^2 + foo(x, y)
In Sage 4.0, you need to use substitute_function() to replace all occurrences of a function with another:
sage: g.substitute_function(cr, cos)
-b*sin(a)
sage: g.substitute_function(cr, (sin(x) + cos(x)).function(x))
b*(cos(a) - sin(a))
In Sage 4.0, basic arithmetic with unevaluated functions is no longer supported:
sage: x = var('x')
sage: f = function('f')
sage: 2*f
Traceback (most recent call last):
...
TypeError: unsupported operand parent(s) for '*': 'Integer Ring' and '<class 'sage.symbolic.function_factory.NewSymbolicFunction'>'
You now need to evaluate the function in order to do the arithmetic:
sage: 2*f(x)
2*f(x)
We create a formal function of one variable, write down an expression that involves first and second derivatives, and extract off coefficients.
sage: r, kappa = var('r,kappa')
sage: psi = function('psi', nargs=1)(r); psi
psi(r)
sage: g = 1/r^2*(2*r*psi.derivative(r,1) + r^2*psi.derivative(r,2)); g
(r^2*D[0, 0](psi)(r) + 2*r*D[0](psi)(r))/r^2
sage: g.expand()
2*D[0](psi)(r)/r + D[0, 0](psi)(r)
sage: g.coefficient(psi.derivative(r,2))
1
sage: g.coefficient(psi.derivative(r,1))
2/r
Defining custom methods for automatic or numeric evaluation, derivation, conjugation, etc. is supported:
sage: def ev(self, x): return 2*x
sage: foo = function("foo", nargs=1, eval_func=ev)
sage: foo(x)
2*x
sage: foo = function("foo", nargs=1, eval_func=lambda self, x: 5)
sage: foo(x)
5
sage: def ef(self, x): pass
sage: bar = function("bar", nargs=1, eval_func=ef)
sage: bar(x)
bar(x)
sage: def evalf_f(self, x, parent=None, algorithm=None): return 6
sage: foo = function("foo", nargs=1, evalf_func=evalf_f)
sage: foo(x)
foo(x)
sage: foo(x).n()
6
sage: foo = function("foo", nargs=1, conjugate_func=ev)
sage: foo(x).conjugate()
2*x
sage: def deriv(self, *args,**kwds): print args, kwds; return args[kwds['diff_param']]^2
sage: foo = function("foo", nargs=2, derivative_func=deriv)
sage: foo(x,y).derivative(y)
(x, y) {'diff_param': 1}
y^2
sage: def pow(self, x, power_param=None): print x, power_param; return x*power_param
sage: foo = function("foo", nargs=1, power_func=pow)
sage: foo(y)^(x+y)
y x + y
(x + y)*y
sage: def expand(self, *args, **kwds): print args, kwds; return sum(args[0]^i for i in range(kwds['order']))
sage: foo = function("foo", nargs=1, series_func=expand)
sage: foo(y).series(y, 5)
(y,) {'var': y, 'options': 0, 'at': 0, 'order': 5}
y^4 + y^3 + y^2 + y + 1
sage: def my_print(self, *args): return "my args are: " + ', '.join(map(repr, args))
sage: foo = function('t', nargs=2, print_func=my_print)
sage: foo(x,y^z)
my args are: x, y^z
sage: latex(foo(x,y^z))
t\left(x, y^{z}\right)
sage: foo = function('t', nargs=2, print_latex_func=my_print)
sage: foo(x,y^z)
t(x, y^z)
sage: latex(foo(x,y^z))
my args are: x, y^z
sage: foo = function('t', nargs=2, latex_name='foo')
sage: latex(foo(x,y^z))
foo\left(x, y^{z}\right)
Chain rule:
sage: def print_args(self, *args, **kwds): print "args:",args; print "kwds:",kwds; return args[0]
sage: foo = function('t', nargs=2, tderivative_func=print_args)
sage: foo(x,x).derivative(x)
args: (x, x)
kwds: {'diff_param': x}
x
sage: foo = function('t', nargs=2, derivative_func=print_args)
sage: foo(x,x).derivative(x)
args: (x, x)
kwds: {'diff_param': 0}
args: (x, x)
kwds: {'diff_param': 1}
2*x
TESTS:
Make sure that trac ticket #15860 is fixed and whitespaces are removed:
sage: function('A, B')
(A, B)
sage: B
B
sage: C, D, E = function(' C D E')
sage: C(D(x))
C(D(x))
sage: E
E
Create a formal symbolic function. For an explanation of the arguments see the documentation for the method function().
EXAMPLES:
sage: from sage.symbolic.function_factory import function_factory
sage: f = function_factory('f', 2, '\\foo', {'mathematica':'Foo'})
sage: f(2,4)
f(2, 4)
sage: latex(f(1,2))
\foo\left(1, 2\right)
sage: f._mathematica_init_()
'Foo'
sage: def evalf_f(self, x, parent=None, algorithm=None): return x*.5r
sage: g = function_factory('g',1,evalf_func=evalf_f)
sage: g(2)
g(2)
sage: g(2).n()
1.00000000000000
This is returned by the __reduce__ method of symbolic functions to be called during unpickling to recreate the given function.
It calls function_factory() with the supplied arguments.
EXAMPLES:
sage: from sage.symbolic.function_factory import unpickle_function
sage: nf = unpickle_function('f', 2, '\\foo', {'mathematica':'Foo'}, True, [])
sage: nf
f
sage: nf(1,2)
f(1, 2)
sage: latex(nf(x,x))
\foo\left(x, x\right)
sage: nf._mathematica_init_()
'Foo'
sage: from sage.symbolic.function import pickle_wrapper
sage: def evalf_f(self, x, parent=None, algorithm=None): return 2r*x + 5r
sage: def conjugate_f(self, x): return x/2r
sage: nf = unpickle_function('g', 1, None, None, True, [None, pickle_wrapper(evalf_f), pickle_wrapper(conjugate_f)] + [None]*8)
sage: nf
g
sage: nf(2)
g(2)
sage: nf(2).n()
9.00000000000000
sage: nf(2).conjugate()
1