cadabra::DisplaySympy Class Reference

Description

Class to display expressions in a format that Sympy can parse. Will throw an exception if a Cadabra Ex object cannot be understood by Sympy. Can also convert expressions back to Cadabra notation. This class contains the printing logic that you see in action when you call the __sympy__ method on an Ex object.

#include <DisplaySympy.hh>

Inheritance diagram for cadabra::DisplaySympy:

Public Member Functions
	DisplaySympy (const Kernel &, const Ex &)
void	import (Ex &)
	Rewrite the output of sympy back into a notation used by Cadabra. More...
std::string	preparse_import (const std::string &)
Public Member Functions inherited from cadabra::DisplayBase
	DisplayBase (const Kernel &, const Ex &)
void	output (std::ostream &)
void	output (std::ostream &, Ex::iterator)

Protected Member Functions
virtual bool	needs_brackets (Ex::iterator it) override
	Determine if a node needs extra brackets around it. More...

Private Member Functions
void	print_multiplier (std::ostream &, Ex::iterator)
	Output the expression to a sympy-readable form. More...
void	print_opening_bracket (std::ostream &, str_node::bracket_t)
void	print_closing_bracket (std::ostream &, str_node::bracket_t)
void	print_parent_rel (std::ostream &, str_node::parent_rel_t, bool first)
void	print_children (std::ostream &, Ex::iterator, int skip=0)
virtual void	dispatch (std::ostream &, Ex::iterator) override
	For every object encountered, dispatch will figure out the most appropriate way to convert it into a LaTeX expression. More...
void	print_productlike (std::ostream &, Ex::iterator, const std::string &inbetween)
	Printing members for various standard constructions, e.g. More...
void	print_sumlike (std::ostream &, Ex::iterator)
void	print_fraclike (std::ostream &, Ex::iterator)
void	print_commalike (std::ostream &, Ex::iterator)
void	print_arrowlike (std::ostream &, Ex::iterator)
void	print_powlike (std::ostream &, Ex::iterator)
void	print_intlike (std::ostream &, Ex::iterator)
void	print_equalitylike (std::ostream &, Ex::iterator)
void	print_components (std::ostream &, Ex::iterator)
void	print_partial (std::ostream &str, Ex::iterator it)
void	print_matrix (std::ostream &str, Ex::iterator it)
void	print_other (std::ostream &str, Ex::iterator it)
bool	children_have_brackets (Ex::iterator ch) const

Private Attributes
std::map< std::string, std::string >	symmap
	Map from Cadabra symbols to Sympy symbols. More...
std::multimap< std::string, std::string >	regex_map
std::map< nset_t::iterator, Ex, nset_it_less >	depsyms
	Map from symbols which have had dependencies added to an expression containing these dependencies. More...

Additional Inherited Members
Protected Attributes inherited from cadabra::DisplayBase
const Ex &	tree
const Kernel &	kernel

Constructor & Destructor Documentation

DisplaySympy()

DisplaySympy::DisplaySympy	(	const Kernel &	kernel,
		const Ex &	e
	)

Member Function Documentation

children_have_brackets()

bool DisplaySympy::children_have_brackets ( Ex::iterator  ch ) const

private

dispatch()

void DisplaySympy::dispatch ( std::ostream &  str, Ex::iterator  it  )

overrideprivatevirtual

For every object encountered, dispatch will figure out the most appropriate way to convert it into a LaTeX expression.

This may be done by simply looking at the object's name (e.g. \prod will print as a product) but may also involve looking up properties and deciding on the best course of action based on the attached properties.

Implements cadabra::DisplayBase.

import()

void DisplaySympy::import

(

Ex &

ex

)

Rewrite the output of sympy back into a notation used by Cadabra.

This in particular involves converting 'sin' and friends to \sin and so on, as well as converting all the greek symbols. Currently only acts node-by-node, does not do anything complicated with trees.

needs_brackets()

bool DisplaySympy::needs_brackets ( Ex::iterator  it )

overrideprotectedvirtual

Determine if a node needs extra brackets around it.

Uses context from the parent node if necessary. Has to be implemented in a derived class, because the answer depends on the printing method (e.g. (a+b)/c needs brackets when printed like this, but does not need brackets when printed as \frac{a+b}{c}).

Implements cadabra::DisplayBase.

preparse_import()

std::string DisplaySympy::preparse_import

(

const std::string &

in

)

print_arrowlike()

void DisplaySympy::print_arrowlike ( std::ostream &  str, Ex::iterator  it  )

private

print_children()

void DisplaySympy::print_children ( std::ostream &  str, Ex::iterator  it, int  skip = 0  )

private

print_closing_bracket()

void DisplaySympy::print_closing_bracket ( std::ostream &  str, str_node::bracket_t  br  )

private

print_commalike()

void DisplaySympy::print_commalike ( std::ostream &  str, Ex::iterator  it  )

private

print_components()

void DisplaySympy::print_components ( std::ostream &  str, Ex::iterator  it  )

private

print_equalitylike()

void DisplaySympy::print_equalitylike ( std::ostream &  str, Ex::iterator  it  )

private

print_fraclike()

void DisplaySympy::print_fraclike ( std::ostream &  str, Ex::iterator  it  )

private

print_intlike()

void DisplaySympy::print_intlike ( std::ostream &  str, Ex::iterator  it  )

private

print_matrix()

void DisplaySympy::print_matrix ( std::ostream &  str, Ex::iterator  it  )

private

print_multiplier()

void DisplaySympy::print_multiplier ( std::ostream &  str, Ex::iterator  it  )

private

Output the expression to a sympy-readable form.

For symbols which cannot be parsed by sympy, this can convert to an alternative, Such rewrites can then be undone by the 'import' member above.

print_opening_bracket()

void DisplaySympy::print_opening_bracket ( std::ostream &  str, str_node::bracket_t  br  )

private

print_other()

void DisplaySympy::print_other ( std::ostream &  str, Ex::iterator  it  )

private

print_parent_rel()

void DisplaySympy::print_parent_rel ( std::ostream &  str, str_node::parent_rel_t  pr, bool  first  )

private

print_partial()

void DisplaySympy::print_partial ( std::ostream &  str, Ex::iterator  it  )

private

print_powlike()

void DisplaySympy::print_powlike ( std::ostream &  str, Ex::iterator  it  )

private

print_productlike()

void DisplaySympy::print_productlike ( std::ostream &  str, Ex::iterator  it, const std::string &  inbetween  )

private

Printing members for various standard constructions, e.g.

print as a list, or as a decorated symbol with super/subscripts etc. The names reflect the structure of the output, not necessarily the meaning or name of the object that is being printed.

print_sumlike()

void DisplaySympy::print_sumlike ( std::ostream &  str, Ex::iterator  it  )

private

Member Data Documentation

depsyms

std::map<nset_t::iterator, Ex, nset_it_less> cadabra::DisplaySympy::depsyms

private

Map from symbols which have had dependencies added to an expression containing these dependencies.

regex_map

std::multimap<std::string, std::string> cadabra::DisplaySympy::regex_map

private

symmap

std::map<std::string, std::string> cadabra::DisplaySympy::symmap

private

Map from Cadabra symbols to Sympy symbols.

---

The documentation for this class was generated from the following files:

• core/DisplaySympy.hh
• core/DisplaySympy.cc