Parsing¶

Parsing Functions Reference¶

sympy.parsing.sympy_parser.parse_expr(s: str, local_dict: ~typing.Dict[str, ~typing.Any] | None = None, transformations: ~typing.Tuple[~typing.Callable[[~typing.List[~typing.Tuple[int, str]], ~typing.Dict[str, ~typing.Any], ~typing.Dict[str, ~typing.Any]], ~typing.List[~typing.Tuple[int, str]]], ...] | str = (<function lambda_notation>, <function auto_symbol>, <function repeated_decimals>, <function auto_number>, <function factorial_notation>), global_dict: ~typing.Dict[str, ~typing.Any] | None = None, evaluate=True)[source]¶

Converts the string s to a SymPy expression, in local_dict.

Parameters:

s : str

The string to parse.

local_dict : dict, optional

A dictionary of local variables to use when parsing.

global_dict : dict, optional

A dictionary of global variables. By default, this is initialized with from sympy import *; provide this parameter to override this behavior (for instance, to parse "Q & S").

transformations : tuple or str

A tuple of transformation functions used to modify the tokens of the parsed expression before evaluation. The default transformations convert numeric literals into their SymPy equivalents, convert undefined variables into SymPy symbols, and allow the use of standard mathematical factorial notation (e.g. x!). Selection via string is available (see below).

evaluate : bool, optional

When False, the order of the arguments will remain as they were in the string and automatic simplification that would normally occur is suppressed. (see examples)

Examples

>>> from sympy.parsing.sympy_parser import parse_expr
>>> parse_expr("1/2")
1/2
>>> type(_)
<class 'sympy.core.numbers.Half'>
>>> from sympy.parsing.sympy_parser import standard_transformations,\
... implicit_multiplication_application
>>> transformations = (standard_transformations +
...     (implicit_multiplication_application,))
>>> parse_expr("2x", transformations=transformations)
2*x

When evaluate=False, some automatic simplifications will not occur:

>>> parse_expr("2**3"), parse_expr("2**3", evaluate=False)
(8, 2**3)

In addition the order of the arguments will not be made canonical. This feature allows one to tell exactly how the expression was entered:

>>> a = parse_expr('1 + x', evaluate=False)
>>> b = parse_expr('x + 1', evaluate=False)
>>> a == b
False
>>> a.args
(1, x)
>>> b.args
(x, 1)

Note, however, that when these expressions are printed they will appear the same:

>>> assert str(a) == str(b)

As a convenience, transformations can be seen by printing transformations:

>>> from sympy.parsing.sympy_parser import transformations

>>> print(transformations)
lambda_notation
auto_symbol
repeated_decimals
auto_number
factorial_notation
implicit_multiplication_application
convert_xor
implicit_application
implicit_multiplication
convert_equals_signs
function_exponentiation
rationalize

The T object provides a way to select these transformations:

>>> from sympy.parsing.sympy_parser import T

If you print it, you will see the same list as shown above.

>>> str(T) == str(transformations)
True

Standard slicing will return a tuple of transformations:

>>> T[:5] == standard_transformations
True

So T can be used to specify the parsing transformations:

>>> parse_expr("2x", transformations=T[:5])
Traceback (most recent call last):
...
SyntaxError: invalid syntax
>>> parse_expr("2x", transformations=T[:6])
2*x
>>> parse_expr('.3', transformations=T[3, 11])
3/10
>>> parse_expr('.3x', transformations=T[:])
3*x/10

As a further convenience, strings ‘implicit’ and ‘all’ can be used to select 0-5 and all the transformations, respectively.

>>> parse_expr('.3x', transformations='all')
3*x/10

Parsing Transformations Reference¶

A transformation is a function that accepts the arguments tokens, local_dict, global_dict and returns a list of transformed tokens. They can be used by passing a list of functions to parse_expr() and are applied in the order given.

sympy.parsing.sympy_parser.standard_transformations: Tuple[Callable[[List[Tuple[int, str]], Dict[str, Any], Dict[str, Any]], List[Tuple[int, str]]], ...] = (<function lambda_notation>, <function auto_symbol>, <function repeated_decimals>, <function auto_number>, <function factorial_notation>)¶: Standard transformations for parse_expr(). Inserts calls to Symbol, Integer, and other SymPy datatypes and allows the use of standard factorial notation (e.g. x!).

sympy.parsing.sympy_parser.split_symbols( tokens: List[Tuple[int, str]], local_dict: Dict[str, Any], global_dict: Dict[str, Any], )[source]¶

Splits symbol names for implicit multiplication.

Intended to let expressions like xyz be parsed as x*y*z. Does not split Greek character names, so theta will not become t*h*e*t*a. Generally this should be used with implicit_multiplication.

sympy.parsing.sympy_parser.split_symbols_custom( predicate: Callable[[str], bool], )[source]¶

Creates a transformation that splits symbol names.

predicate should return True if the symbol name is to be split.

For instance, to retain the default behavior but avoid splitting certain symbol names, a predicate like this would work:

>>> from sympy.parsing.sympy_parser import (parse_expr, _token_splittable,
... standard_transformations, implicit_multiplication,
... split_symbols_custom)
>>> def can_split(symbol):
...     if symbol not in ('list', 'of', 'unsplittable', 'names'):
...             return _token_splittable(symbol)
...     return False
...
>>> transformation = split_symbols_custom(can_split)
>>> parse_expr('unsplittable', transformations=standard_transformations +
... (transformation, implicit_multiplication))
unsplittable

sympy.parsing.sympy_parser.implicit_multiplication( tokens: List[Tuple[int, str]], local_dict: Dict[str, Any], global_dict: Dict[str, Any], ) → List[Tuple[int, str]][source]¶

Makes the multiplication operator optional in most cases.

Use this before implicit_application(), otherwise expressions like sin 2x will be parsed as x * sin(2) rather than sin(2*x).

Examples

>>> from sympy.parsing.sympy_parser import (parse_expr,
... standard_transformations, implicit_multiplication)
>>> transformations = standard_transformations + (implicit_multiplication,)
>>> parse_expr('3 x y', transformations=transformations)
3*x*y

sympy.parsing.sympy_parser.implicit_application( tokens: List[Tuple[int, str]], local_dict: Dict[str, Any], global_dict: Dict[str, Any], ) → List[Tuple[int, str]][source]¶

Makes parentheses optional in some cases for function calls.

Use this after implicit_multiplication(), otherwise expressions like sin 2x will be parsed as x * sin(2) rather than sin(2*x).

Examples

>>> from sympy.parsing.sympy_parser import (parse_expr,
... standard_transformations, implicit_application)
>>> transformations = standard_transformations + (implicit_application,)
>>> parse_expr('cot z + csc z', transformations=transformations)
cot(z) + csc(z)

sympy.parsing.sympy_parser.function_exponentiation( tokens: List[Tuple[int, str]], local_dict: Dict[str, Any], global_dict: Dict[str, Any], )[source]¶

Allows functions to be exponentiated, e.g. cos**2(x).

Examples

>>> from sympy.parsing.sympy_parser import (parse_expr,
... standard_transformations, function_exponentiation)
>>> transformations = standard_transformations + (function_exponentiation,)
>>> parse_expr('sin**4(x)', transformations=transformations)
sin(x)**4

sympy.parsing.sympy_parser.implicit_multiplication_application( result: List[Tuple[int, str]], local_dict: Dict[str, Any], global_dict: Dict[str, Any], ) → List[Tuple[int, str]][source]¶

Allows a slightly relaxed syntax.

Parentheses for single-argument method calls are optional.
Multiplication is implicit.
Symbol names can be split (i.e. spaces are not needed between symbols).
Functions can be exponentiated.

Examples

>>> from sympy.parsing.sympy_parser import (parse_expr,
... standard_transformations, implicit_multiplication_application)
>>> parse_expr("10sin**2 x**2 + 3xyz + tan theta",
... transformations=(standard_transformations +
... (implicit_multiplication_application,)))
3*x*y*z + 10*sin(x**2)**2 + tan(theta)

sympy.parsing.sympy_parser.rationalize( tokens: List[Tuple[int, str]], local_dict: Dict[str, Any], global_dict: Dict[str, Any], )[source]¶: Converts floats into Rational. Run AFTER auto_number.

sympy.parsing.sympy_parser.convert_xor( tokens: List[Tuple[int, str]], local_dict: Dict[str, Any], global_dict: Dict[str, Any], )[source]¶: Treats XOR, ^, as exponentiation, **.

These are included in sympy.parsing.sympy_parser.standard_transformations and generally don’t need to be manually added by the user.

sympy.parsing.sympy_parser.lambda_notation( tokens: List[Tuple[int, str]], local_dict: Dict[str, Any], global_dict: Dict[str, Any], )[source]¶: Substitutes “lambda” with its SymPy equivalent Lambda(). However, the conversion does not take place if only “lambda” is passed because that is a syntax error.

sympy.parsing.sympy_parser.auto_symbol( tokens: List[Tuple[int, str]], local_dict: Dict[str, Any], global_dict: Dict[str, Any], )[source]¶: Inserts calls to Symbol/Function for undefined variables.

sympy.parsing.sympy_parser.repeated_decimals( tokens: List[Tuple[int, str]], local_dict: Dict[str, Any], global_dict: Dict[str, Any], )[source]¶

Allows 0.2[1] notation to represent the repeated decimal 0.2111… (19/90)

Run this before auto_number.

sympy.parsing.sympy_parser.auto_number( tokens: List[Tuple[int, str]], local_dict: Dict[str, Any], global_dict: Dict[str, Any], )[source]¶

Converts numeric literals to use SymPy equivalents.

Complex numbers use I, integer literals use Integer, and float literals use Float.

sympy.parsing.sympy_parser.factorial_notation( tokens: List[Tuple[int, str]], local_dict: Dict[str, Any], global_dict: Dict[str, Any], )[source]¶: Allows standard notation for factorial.

Experimental \(\mathrm{\LaTeX}\) Parsing¶

The current implementations are experimental. The behavior, parser backend(s) and API might change in the future. Unlike some of the other parsers, \(\mathrm{\LaTeX}\) is designed as a type-setting language, not a computer algebra system and so can contain typographical conventions that might be interpreted multiple ways.

\(\mathrm{\LaTeX}\) Parsing Functions Reference¶

sympy.parsing.latex.parse_latex(s, strict=False, backend='antlr')[source]¶

Converts the input LaTeX string s to a SymPy Expr.

Parameters:

s : str

The LaTeX string to parse. In Python source containing LaTeX, raw strings (denoted with r", like this one) are preferred, as LaTeX makes liberal use of the \ character, which would trigger escaping in normal Python strings.

backend : str, optional

Currently, there are two backends supported: ANTLR, and Lark. The default setting is to use the ANTLR backend, which can be changed to Lark if preferred.

Use backend="antlr" for the ANTLR-based parser, and backend="lark" for the Lark-based parser.

The backend option is case-sensitive, and must be in all lowercase.

strict : bool, optional

This option is only available with the ANTLR backend.

If True, raise an exception if the string cannot be parsed as valid LaTeX. If False, try to recover gracefully from common mistakes.

Examples

>>> from sympy.parsing.latex import parse_latex
>>> expr = parse_latex(r"\frac {1 + \sqrt {\a}} {\b}")
>>> expr
(sqrt(a) + 1)/b
>>> expr.evalf(4, subs=dict(a=5, b=2))
1.618
>>> func = parse_latex(r"\int_1^\alpha \dfrac{\mathrm{d}t}{t}", backend="lark")
>>> func.evalf(subs={"alpha": 2})
0.693147180559945

ANTLR Backend¶

The ANTLR-based \(\mathrm{\LaTeX}\) parser was ported from latex2sympy. While functional and its API should remain stable, the parsing behavior or backend may change in future releases.

ANTLR \(\mathrm{\LaTeX}\) Parser Caveats¶

In its current definition, the parser may fail to fully parse an expression, yet not throw a warning:

parse_latex(r'x -')

will simply find x. What is covered by this behavior will almost certainly change between releases, and become stricter, more relaxed, or some mix.

Lark Backend¶

The Lark-based LaTeX parser is newer, and is intended to eventually completely replace the ANTLR-based parser. It has most of the features that the ANTLR-based parser provides, with some extras.

Lark \(\mathrm{\LaTeX}\) Parser Features¶

One thing to note is that the Lark backend does not support ill-formed expressions, and it does not try to fix any sort of common mistakes that may have occured. For example, as mentioned in the earlier section, the ANTLR-based parser would simply find x if we run:

parse_latex(r'x -', backend='ANTLR')

However, running:

parse_latex(r'x -', backend='Lark')

will raise an lark.exceptions.UnexpectedEOF exception.

Apart from that, there are a couple of extra things that the Lark-based parser supports that the ANTLR-based parser does not. They are:

Detecting ambiguous expressions, and
Allowing user-customization of the \(\mathrm{\LaTeX}\) grammar at runtime.

Expressions like \(f(x)\) are technically ambiguous \(\mathrm{\LaTeX}\) expressions because the \(f\) might be a function or a variable name. Lark has the capability to point out these ambiguities and notify the user, or even return all possible interpretations.

The Lark-based parser exposes a number of internals which allow the user to customize the parser’s behavior. For example, the user can specify their own \(\mathrm{\LaTeX}\) grammar by passing the path to the grammar file to the LarkLaTeXParser while instantiating the parser.

The user can also specify their own custom transformer class to the \(LarkLaTeXParser\) class.

The two examples mentioned above can be found in the test_custom_latex.py file.

Lark \(\mathrm{\LaTeX}\) Parser Capabilities¶

In order to use the Lark-based LaTeX parser, it is important to know what it can and cannot do. As the parser is still experimental, it supports many things, but some features are still only partially implemented, or not available.

As such, we will list the types of expressions that it can parse, and then list some expression types of interest where it may fail.

Here is a list of the things which are supported:

Symbols which consist of one letter, e.g., a, b, x, etc. Greek symbols and symbols with subscripts are also supported. Numbers are also supported, as is \infty.
Symbols with multiple letters are supported, as long as they are wrapped in \mathit.
Expressions with \(+\), \(-\), \(*\), \(/\), and alternative operators like \cdot, \times, \div, etc. If two expressions are next to each other, like \(xy\) or \((\sin x)(\cos t)\), then it is treated as implicit multiplication.
Relations with \(<\), \(>\), \(\le\), \(\ge\), \(=\), and \(\ne\).
Commonly used functions like
- Square roots,
- factorials,
- complex conjugation (like \(\overline{z}\))
- \(\log\),
- \(\ln\),
- \(\exp\),
- absolute value (e.g., \(|x|\)). Note that \(||x||\) is parsed as Abs(Abs(x)).
- floor (e.g., \(\lfloor x \rfloor\)) and ceiling (e.g., \(\lceil x \rceil\)),
- \(\min\) and \(\max\).
All the trigonometric functions and their inverses trigonometric functions. Powers like \sin^4 are also supported. The power \(-1\) is interpreted as the inverse function (i.e., \sin^{-1} x is interpreted as \arcsin x).
Hyperbolic trigonometric functions (currently only \(\sinh\), \(\cosh\), and \(\tanh\)) and their inverses. As mentioned in the previous point, powers like \tanh^2 are also supported, and \(-1\) is interpreted as the inverse function (i.e., \tanh^{-1} x is interpreted as \arctanh x).
AppliedFunctions, like \(f(x, y, z)\).
All types of fractions (\frac, \tfrac, \dfrac, \nicefrac) and binomials (\binom, \tbinom, \dbinom) are supported.
Integrals, both definite and indefinite. When the integrand is a fraction, having the differential in the numerator is allowed. The differential is allowed to be d, \text{d}, or \mathrm{d}.
Derivatives in one variable. I.e., things like \(\dfrac{d}{dx} (\sin x)\). Higher order derivatives and partial derivatives are not supported yet.
Limits in one variable. E.g., \(\lim\limits_{t\to 3^{+}} \sin t\).
Sums and products with simple conditions. For example, \(\sum\limits_{k=0}^n k^2\) is allowed because the condition on \(k\) is simple. An expression like \(\sum\limits_{d \mid n} d^2\) is not allowed because the condition on \(d\) in the subscript is complicated. Expressions with the index variable specified in the superscript are also allowed. For example, \(\prod\limits_{k=0}^{k=n} k^2\) is parsed correctly.
Bra (e.g., \(| x \rangle\)), and Ket (e.g., \(\langle p |\)) notation. Parsing Inner (e.g., \(\langle x | y \rangle\)) and Outer Products (e.g., \(| y \rangle \langle x |\)) is also supported.

Here is a(n incomplete) list of things which are currently not supported, which may be added in the future:

Matrices. Stuff like \begin{env}...\end{env}, where env is any of matrix, bmatrix, pmatrix, smallmatrix, and array.
Matrix operations like matrix-matrix addition, scalar-matrix multiplication, matrix-matrix multiplication.
Higher order derivatives and partial derivatives.
Double and triple integrals.

Lark \(\mathrm{\LaTeX}\) Parser Functions¶

sympy.parsing.latex.parse_latex_lark(s: str)[source]¶

Experimental LaTeX parser using Lark.

This function is still under development and its API may change with the next releases of SymPy.

Lark \(\mathrm{\LaTeX}\) Parser Classes¶

class sympy.parsing.latex.lark.LarkLaTeXParser( print_debug_output=False, transform=True, grammar_file=None, transformer=None, )[source]¶

Class for converting input \(\mathrm{\LaTeX}\) strings into SymPy Expressions. It holds all the necessary internal data for doing so, and exposes hooks for customizing its behavior.

Parameters:

print_debug_output : bool, optional

If set to True, prints debug output to the logger. Defaults to False.

transform : bool, optional

If set to True, the class runs the Transformer class on the parse tree generated by running Lark.parse on the input string. Defaults to True.

Setting it to False can help with debugging the \(\mathrm{\LaTeX}\) grammar.

grammar_file : str, optional

The path to the grammar file that the parser should use. If set to None, it uses the default grammar, which is in grammar/latex.lark, relative to the sympy/parsing/latex/lark/ directory.

transformer : str, optional

The name of the Transformer class to use. If set to None, it uses the default transformer class, which is TransformToSymPyExpr().

class sympy.parsing.latex.lark.TransformToSymPyExpr[source]¶

Returns a SymPy expression that is generated by traversing the lark.Tree passed to the .transform() function.

Parameters:: visit_tokens : bool, optional

For information about what this option does, see here.

Note that the option must be set to True for the default parser to work.

Notes

This class is never supposed to be used directly.

In order to tweak the behavior of this class, it has to be subclassed and then after the required modifications are made, the name of the new class should be passed to the LarkLaTeXParser class by using the transformer argument in the constructor.

\(\mathrm{\LaTeX}\) Parsing Exceptions Reference¶

class sympy.parsing.latex.LaTeXParsingError[source]¶

SymPy Expression Reference¶

class sympy.parsing.sym_expr.SymPyExpression(source_code=None, mode=None)[source]¶

Class to store and handle SymPy expressions

This class will hold SymPy Expressions and handle the API for the conversion to and from different languages.

It works with the C and the Fortran Parser to generate SymPy expressions which are stored here and which can be converted to multiple language’s source code.

Notes

The module and its API are currently under development and experimental and can be changed during development.

The Fortran parser does not support numeric assignments, so all the variables have been Initialized to zero.

The module also depends on external dependencies:

LFortran which is required to use the Fortran parser
Clang which is required for the C parser

Examples

Example of parsing C code:

>>> from sympy.parsing.sym_expr import SymPyExpression
>>> src = '''
... int a,b;
... float c = 2, d =4;
... '''
>>> a = SymPyExpression(src, 'c')
>>> a.return_expr()
[Declaration(Variable(a, type=intc)),
Declaration(Variable(b, type=intc)),
Declaration(Variable(c, type=float32, value=2.0)),
Declaration(Variable(d, type=float32, value=4.0))]

An example of variable definition:

>>> from sympy.parsing.sym_expr import SymPyExpression
>>> src2 = '''
... integer :: a, b, c, d
... real :: p, q, r, s
... '''
>>> p = SymPyExpression()
>>> p.convert_to_expr(src2, 'f')
>>> p.convert_to_c()
['int a = 0', 'int b = 0', 'int c = 0', 'int d = 0', 'double p = 0.0', 'double q = 0.0', 'double r = 0.0', 'double s = 0.0']

An example of Assignment:

>>> from sympy.parsing.sym_expr import SymPyExpression
>>> src3 = '''
... integer :: a, b, c, d, e
... d = a + b - c
... e = b * d + c * e / a
... '''
>>> p = SymPyExpression(src3, 'f')
>>> p.convert_to_python()
['a = 0', 'b = 0', 'c = 0', 'd = 0', 'e = 0', 'd = a + b - c', 'e = b*d + c*e/a']

An example of function definition:

>>> from sympy.parsing.sym_expr import SymPyExpression
>>> src = '''
... integer function f(a,b)
... integer, intent(in) :: a, b
... integer :: r
... end function
... '''
>>> a = SymPyExpression(src, 'f')
>>> a.convert_to_python()
['def f(a, b):\n   f = 0\n    r = 0\n    return f']

convert_to_c()[source]¶

Returns a list with the c source code for the SymPy expressions

Examples

>>> from sympy.parsing.sym_expr import SymPyExpression
>>> src2 = '''
... integer :: a, b, c, d
... real :: p, q, r, s
... c = a/b
... d = c/a
... s = p/q
... r = q/p
... '''
>>> p = SymPyExpression()
>>> p.convert_to_expr(src2, 'f')
>>> p.convert_to_c()
['int a = 0', 'int b = 0', 'int c = 0', 'int d = 0', 'double p = 0.0', 'double q = 0.0', 'double r = 0.0', 'double s = 0.0', 'c = a/b;', 'd = c/a;', 's = p/q;', 'r = q/p;']

convert_to_expr(src_code, mode)[source]¶

Converts the given source code to SymPy Expressions

Examples

>>> from sympy.parsing.sym_expr import SymPyExpression
>>> src3 = '''
... integer function f(a,b) result(r)
... integer, intent(in) :: a, b
... integer :: x
... r = a + b -x
... end function
... '''
>>> p = SymPyExpression()
>>> p.convert_to_expr(src3, 'f')
>>> p.return_expr()
[FunctionDefinition(integer, name=f, parameters=(Variable(a), Variable(b)), body=CodeBlock(
Declaration(Variable(r, type=integer, value=0)),
Declaration(Variable(x, type=integer, value=0)),
Assignment(Variable(r), a + b - x),
Return(Variable(r))
))]

Attributes

src_code	(String) the source code or filename of the source code that is to be converted
mode: String	the mode to determine which parser is to be used according to the language of the source code f or F for Fortran c or C for C/C++

convert_to_fortran()[source]¶

Returns a list with the fortran source code for the SymPy expressions

Examples

>>> from sympy.parsing.sym_expr import SymPyExpression
>>> src2 = '''
... integer :: a, b, c, d
... real :: p, q, r, s
... c = a/b
... d = c/a
... s = p/q
... r = q/p
... '''
>>> p = SymPyExpression(src2, 'f')
>>> p.convert_to_fortran()
['      integer*4 a', '      integer*4 b', '      integer*4 c', '      integer*4 d', '      real*8 p', '      real*8 q', '      real*8 r', '      real*8 s', '      c = a/b', '      d = c/a', '      s = p/q', '      r = q/p']

convert_to_python()[source]¶

Returns a list with Python code for the SymPy expressions

Examples

>>> from sympy.parsing.sym_expr import SymPyExpression
>>> src2 = '''
... integer :: a, b, c, d
... real :: p, q, r, s
... c = a/b
... d = c/a
... s = p/q
... r = q/p
... '''
>>> p = SymPyExpression(src2, 'f')
>>> p.convert_to_python()
['a = 0', 'b = 0', 'c = 0', 'd = 0', 'p = 0.0', 'q = 0.0', 'r = 0.0', 's = 0.0', 'c = a/b', 'd = c/a', 's = p/q', 'r = q/p']

return_expr()[source]¶

Returns the expression list

Examples

>>> from sympy.parsing.sym_expr import SymPyExpression
>>> src3 = '''
... integer function f(a,b)
... integer, intent(in) :: a, b
... integer :: r
... r = a+b
... f = r
... end function
... '''
>>> p = SymPyExpression()
>>> p.convert_to_expr(src3, 'f')
>>> p.return_expr()
[FunctionDefinition(integer, name=f, parameters=(Variable(a), Variable(b)), body=CodeBlock(
Declaration(Variable(f, type=integer, value=0)),
Declaration(Variable(r, type=integer, value=0)),
Assignment(Variable(f), Variable(r)),
Return(Variable(f))
))]

Runtime Installation¶

The currently-packaged LaTeX parser backend is partially generated with ANTLR4, but to use the parser, you only need the antlr4 Python package available.

Depending on your package manager, you can install the right package with, for example, pip:

$ pip install antlr4-python3-runtime==4.11

or conda:

$ conda install -c conda-forge antlr-python-runtime==4.11

The C parser depends on clang and the Fortran parser depends on LFortran. You can install these packages using:

$ conda install -c conda-forge lfortran clang