# Evaluating a String in Sage#

sage.misc.sage_eval.sage_eval(source, locals=None, cmds='', preparse=True)[source]#

Obtain a Sage object from the input string by evaluating it using Sage. This means calling eval after preparsing and with globals equal to everything included in the scope of ```from sage.all import *```.).

INPUT:

• `source` – a string or object with a `_sage_` method

• `locals` – evaluate in namespace of `sage.all` plus the locals dictionary

• `cmds` – string; sequence of commands to be run before source is evaluated.

• `preparse` – (default: `True`) if True, preparse the string expression.

EXAMPLES: This example illustrates that preparsing is applied.

```sage: eval('2^3')
1
sage: sage_eval('2^3')
8
```
```>>> from sage.all import *
>>> eval('2^3')
1
>>> sage_eval('2^3')
8
```

However, preparsing can be turned off.

```sage: sage_eval('2^3', preparse=False)
1
```
```>>> from sage.all import *
>>> sage_eval('2^3', preparse=False)
1
```

Note that you can explicitly define variables and pass them as the second option:

```sage: x = PolynomialRing(RationalField(),"x").gen()
sage: sage_eval('x^2+1', locals={'x':x})
x^2 + 1
```
```>>> from sage.all import *
>>> x = PolynomialRing(RationalField(),"x").gen()
>>> sage_eval('x^2+1', locals={'x':x})
x^2 + 1
```

This example illustrates that evaluation occurs in the context of `from sage.all import *`. Even though `bernoulli` has been redefined in the local scope, when calling `sage_eval()` the default value meaning of `bernoulli()` is used. Likewise for `QQ` below.

```sage: bernoulli = lambda x : x^2
sage: bernoulli(6)
36
sage: eval('bernoulli(6)')
36
sage: sage_eval('bernoulli(6)')                                                 # needs sage.libs.flint
1/42
```
```>>> from sage.all import *
>>> bernoulli = lambda x : x**Integer(2)
>>> bernoulli(Integer(6))
36
>>> eval('bernoulli(6)')
36
>>> sage_eval('bernoulli(6)')                                                 # needs sage.libs.flint
1/42
```
```sage: QQ = lambda x : x^2
sage: QQ(2)
4
sage: sage_eval('QQ(2)')
2
sage: parent(sage_eval('QQ(2)'))
Rational Field
```
```>>> from sage.all import *
>>> QQ = lambda x : x**Integer(2)
>>> QQ(Integer(2))
4
>>> sage_eval('QQ(2)')
2
>>> parent(sage_eval('QQ(2)'))
Rational Field
```

This example illustrates setting a variable for use in evaluation.

```sage: x = 5
sage: eval('4//3 + x', {'x': 25})
26
sage: sage_eval('4/3 + x',  locals={'x': 25})
79/3
```
```>>> from sage.all import *
>>> x = Integer(5)
>>> eval('4//3 + x', {'x': Integer(25)})
26
>>> sage_eval('4/3 + x',  locals={'x': Integer(25)})
79/3
```

You can also specify a sequence of commands to be run before the expression is evaluated:

```sage: sage_eval('p', cmds='K.<x> = QQ[]\np = x^2 + 1')
x^2 + 1
```
```>>> from sage.all import *
>>> sage_eval('p', cmds='K.<x> = QQ[]\np = x^2 + 1')
x^2 + 1
```

If you give commands to execute and a dictionary of variables, then the dictionary will be modified by assignments in the commands:

```sage: vars = {}
sage: sage_eval('None', cmds='y = 3', locals=vars)
sage: vars['y'], parent(vars['y'])
(3, Integer Ring)
```
```>>> from sage.all import *
>>> vars = {}
>>> sage_eval('None', cmds='y = 3', locals=vars)
>>> vars['y'], parent(vars['y'])
(3, Integer Ring)
```

You can also specify the object to evaluate as a tuple. A 2-tuple is assumed to be a pair of a command sequence and an expression; a 3-tuple is assumed to be a triple of a command sequence, an expression, and a dictionary holding local variables. (In this case, the given dictionary will not be modified by assignments in the commands.)

```sage: sage_eval(('f(x) = x^2', 'f(3)'))                                         # needs sage.symbolic
9
sage: vars = {'rt2': sqrt(2.0)}
sage: sage_eval(('rt2 += 1', 'rt2', vars))
2.41421356237309
sage: vars['rt2']
1.41421356237310
```
```>>> from sage.all import *
>>> sage_eval(('f(x) = x^2', 'f(3)'))                                         # needs sage.symbolic
9
>>> vars = {'rt2': sqrt(RealNumber('2.0'))}
>>> sage_eval(('rt2 += 1', 'rt2', vars))
2.41421356237309
>>> vars['rt2']
1.41421356237310
```

This example illustrates how `sage_eval` can be useful when evaluating the output of other computer algebra systems.

```sage: # needs sage.libs.gap
sage: R.<x> = PolynomialRing(RationalField())
sage: gap.eval('R:=PolynomialRing(Rationals,["x"]);')
'Rationals[x]'
sage: ff = gap.eval('x:=IndeterminatesOfPolynomialRing(R);; f:=x^2+1;'); ff
'x^2+1'
sage: sage_eval(ff, locals={'x':x})
x^2 + 1
sage: eval(ff)
Traceback (most recent call last):
...
RuntimeError: Use ** for exponentiation, not '^', which means xor
in Python, and has the wrong precedence.
```
```>>> from sage.all import *
>>> # needs sage.libs.gap
>>> R = PolynomialRing(RationalField(), names=('x',)); (x,) = R._first_ngens(1)
>>> gap.eval('R:=PolynomialRing(Rationals,["x"]);')
'Rationals[x]'
>>> ff = gap.eval('x:=IndeterminatesOfPolynomialRing(R);; f:=x^2+1;'); ff
'x^2+1'
>>> sage_eval(ff, locals={'x':x})
x^2 + 1
>>> eval(ff)
Traceback (most recent call last):
...
RuntimeError: Use ** for exponentiation, not '^', which means xor
in Python, and has the wrong precedence.
```

Here you can see that `eval()` simply will not work but `sage_eval()` will.

sage.misc.sage_eval.sageobj(x, vars=None)[source]#

Return a native Sage object associated to `x`, if possible and implemented.

If the object has a `_sage_` method it is called and the value is returned. Otherwise, `str()` is called on the object, and all preparsing is applied and the resulting expression is evaluated in the context of `from sage.all import *`. To evaluate the expression with certain variables set, use the `vars` argument, which should be a dictionary.

EXAMPLES:

```sage: type(sageobj(gp('34/56')))                                                # needs sage.libs.pari
<class 'sage.rings.rational.Rational'>

sage: n = 5/2
sage: sageobj(n) is n
True
sage: k = sageobj('Z(8^3/1)', {'Z':ZZ}); k
512
sage: type(k)
<class 'sage.rings.integer.Integer'>
```
```>>> from sage.all import *
>>> type(sageobj(gp('34/56')))                                                # needs sage.libs.pari
<class 'sage.rings.rational.Rational'>

>>> n = Integer(5)/Integer(2)
>>> sageobj(n) is n
True
>>> k = sageobj('Z(8^3/1)', {'Z':ZZ}); k
512
>>> type(k)
<class 'sage.rings.integer.Integer'>
```

This illustrates interfaces:

```sage: # needs sage.libs.pari
sage: f = gp('2/3')
sage: type(f)
<class 'sage.interfaces.gp.GpElement'>
sage: f._sage_()
2/3
sage: type(f._sage_())
<class 'sage.rings.rational.Rational'>

sage: # needs sage.libs.gap
sage: a = gap(939393/2433)
sage: a._sage_()
313131/811
sage: type(a._sage_())
<class 'sage.rings.rational.Rational'>
```
```>>> from sage.all import *
>>> # needs sage.libs.pari
>>> f = gp('2/3')
>>> type(f)
<class 'sage.interfaces.gp.GpElement'>
>>> f._sage_()
2/3
>>> type(f._sage_())
<class 'sage.rings.rational.Rational'>

>>> # needs sage.libs.gap
>>> a = gap(Integer(939393)/Integer(2433))
>>> a._sage_()
313131/811
>>> type(a._sage_())
<class 'sage.rings.rational.Rational'>
```