X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Fsymbol.cpp;h=e7eb9c92317b5d53b55e333b9ec206e4ae4605a3;hp=2657900a99524f43901fa9617aa1d608b508fe20;hb=f5abf61d2cb1a1d1809d270a24fa098575b172c4;hpb=e5362a33f72613b324b3714524a8c2e5f7b7f46f diff --git a/ginac/symbol.cpp b/ginac/symbol.cpp index 2657900a..e7eb9c92 100644 --- a/ginac/symbol.cpp +++ b/ginac/symbol.cpp @@ -3,7 +3,7 @@ * Implementation of GiNaC's symbolic objects. */ /* - * GiNaC Copyright (C) 1999-2001 Johannes Gutenberg University Mainz, Germany + * GiNaC Copyright (C) 1999-2010 Johannes Gutenberg University Mainz, Germany * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -17,74 +17,47 @@ * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ -#include -#include - #include "symbol.h" #include "lst.h" -#include "idx.h" #include "archive.h" -#include "debugmsg.h" +#include "tostring.h" #include "utils.h" +#include "hash_seed.h" +#include "inifcns.h" + +#include +#include +#include -#ifndef NO_NAMESPACE_GINAC namespace GiNaC { -#endif // ndef NO_NAMESPACE_GINAC -GINAC_IMPLEMENT_REGISTERED_CLASS_NO_CTORS(symbol, basic) +GINAC_IMPLEMENT_REGISTERED_CLASS_OPT(symbol, basic, + print_func(&symbol::do_print). + print_func(&symbol::do_print_latex). + print_func(&symbol::do_print_tree). + print_func(&symbol::do_print_python_repr)) ////////// -// default constructor, destructor, copy constructor assignment operator and helpers +// default constructor ////////// -symbol::symbol() : inherited(TINFO_symbol) -{ - debugmsg("symbol default constructor", LOGLEVEL_CONSTRUCT); - serial = next_serial++; - name = autoname_prefix()+ToString(serial); - asexinfop = new assigned_ex_info; - setflag(status_flags::evaluated); -} +// symbol -symbol::~symbol() +symbol::symbol() : serial(next_serial++), name(""), TeX_name("") { - debugmsg("symbol destructor", LOGLEVEL_DESTRUCT); - destroy(0); + setflag(status_flags::evaluated | status_flags::expanded); } -symbol::symbol(const symbol & other) -{ - debugmsg("symbol copy constructor", LOGLEVEL_CONSTRUCT); - copy(other); -} +// realsymbol -void symbol::copy(const symbol & other) -{ - inherited::copy(other); - name = other.name; - serial = other.serial; - asexinfop = other.asexinfop; - ++asexinfop->refcount; -} +realsymbol::realsymbol() : symbol() { } -void symbol::destroy(bool call_parent) -{ - if (--asexinfop->refcount == 0) { - delete asexinfop; - } - if (call_parent) { - inherited::destroy(call_parent); - } -} +// possymbol -// how should the following be interpreted? -// symbol x; -// symbol y; -// x=y; -// probably as: x=ex(y); +possymbol::possymbol() : realsymbol() { } ////////// // other constructors @@ -92,170 +65,180 @@ void symbol::destroy(bool call_parent) // public -symbol::symbol(const std::string & initname) : inherited(TINFO_symbol) +// symbol + +symbol::symbol(const std::string & initname) : serial(next_serial++), + name(initname), TeX_name("") { - debugmsg("symbol constructor from string", LOGLEVEL_CONSTRUCT); - name = initname; - serial = next_serial++; - asexinfop = new assigned_ex_info; - setflag(status_flags::evaluated); + setflag(status_flags::evaluated | status_flags::expanded); } +symbol::symbol(const std::string & initname, const std::string & texname) : + serial(next_serial++), name(initname), TeX_name(texname) +{ + setflag(status_flags::evaluated | status_flags::expanded); +} + +// realsymbol + +realsymbol::realsymbol(const std::string & initname) : symbol(initname) { } + +realsymbol::realsymbol(const std::string & initname, const std::string & texname) + : symbol(initname, texname) { } + +// possymbol + +possymbol::possymbol(const std::string & initname) : realsymbol(initname) { } + +possymbol::possymbol(const std::string & initname, const std::string & texname) + : realsymbol(initname, texname) { } + ////////// // archiving ////////// -/** Construct object from archive_node. */ -symbol::symbol(const archive_node &n, const lst &sym_lst) : inherited(n, sym_lst) +/** Read object from archive_node. */ +void symbol::read_archive(const archive_node &n, lst &sym_lst) { - debugmsg("symbol constructor from archive_node", LOGLEVEL_CONSTRUCT); + inherited::read_archive(n, sym_lst); serial = next_serial++; - if (!(n.find_string("name", name))) - name = autoname_prefix() + ToString(serial); - asexinfop = new assigned_ex_info; - setflag(status_flags::evaluated); -} - -/** Unarchive the object. */ -ex symbol::unarchive(const archive_node &n, const lst &sym_lst) -{ - ex s = (new symbol(n, sym_lst))->setflag(status_flags::dynallocated); + std::string tmp_name; + n.find_string("name", tmp_name); // If symbol is in sym_lst, return the existing symbol - for (unsigned i=0; i(*it) && (ex_to(*it).name == tmp_name)) { + *this = ex_to(*it); + // XXX: This method is responsible for reading realsymbol + // and possymbol objects too. But + // basic::operator=(const basic& other) + // resets status_flags::evaluated if other and *this are + // of different types. Usually this is a good idea, but + // doing this for symbols is wrong (for one, nothing is + // going to set status_flags::evaluated, evaluation will + // loop forever). Therefore we need to restore flags. + setflag(status_flags::evaluated | status_flags::expanded); + return; + } } - return s; + name = tmp_name; + if (!n.find_string("TeXname", TeX_name)) + TeX_name = std::string(""); + setflag(status_flags::evaluated | status_flags::expanded); + + setflag(status_flags::dynallocated); + sym_lst.append(*this); } /** Archive the object. */ void symbol::archive(archive_node &n) const { inherited::archive(n); - n.add_string("name", name); + // XXX: we should not archive anonymous symbols. + if (!name.empty()) + n.add_string("name", name); + if (!TeX_name.empty()) + n.add_string("TeX_name", TeX_name); } ////////// -// functions overriding virtual functions from bases classes +// functions overriding virtual functions from base classes ////////// +/** Return default TeX name for symbol. This recognizes some greek letters. */ +static const std::string& get_default_TeX_name(const std::string& name); + // public -basic *symbol::duplicate() const +std::string symbol::get_name() const { - debugmsg("symbol duplicate", LOGLEVEL_DUPLICATE); - return new symbol(*this); + if (name.empty()) { + std::ostringstream s; + s << "symbol" << serial; + name = s.str(); + } + return name; } -void symbol::print(std::ostream & os, unsigned upper_precedence) const +// protected + +void symbol::do_print(const print_context & c, unsigned level) const { - debugmsg("symbol print",LOGLEVEL_PRINT); - os << name; + c.s << get_name(); } -void symbol::printraw(std::ostream & os) const +void symbol::do_print_latex(const print_latex & c, unsigned level) const { - debugmsg("symbol printraw",LOGLEVEL_PRINT); - os << "symbol(" << "name=" << name << ",serial=" << serial - << ",hash=" << hashvalue << ",flags=" << flags << ")"; + if (!TeX_name.empty()) + c.s << TeX_name; + else if (!name.empty()) + c.s << get_default_TeX_name(name); + else + c.s << "symbol" << serial; } -void symbol::printtree(std::ostream & os, unsigned indent) const +void symbol::do_print_tree(const print_tree & c, unsigned level) const { - debugmsg("symbol printtree",LOGLEVEL_PRINT); - os << std::string(indent,' ') << name << " (symbol): " - << "serial=" << serial - << ", hash=" << hashvalue - << " (0x" << std::hex << hashvalue << std::dec << ")" - << ", flags=" << flags << std::endl; + c.s << std::string(level, ' ') << name << " (" << class_name() << ")" << " @" << this + << ", serial=" << serial + << std::hex << ", hash=0x" << hashvalue << ", flags=0x" << flags << std::dec + << ", domain=" << get_domain() + << std::endl; } -void symbol::printcsrc(std::ostream & os, unsigned type, unsigned upper_precedence) const +void symbol::do_print_python_repr(const print_python_repr & c, unsigned level) const { - debugmsg("symbol print csrc", LOGLEVEL_PRINT); - os << name; + c.s << class_name() << "('"; + if (!name.empty()) + c.s << name; + else + c.s << "symbol" << serial; + if (!TeX_name.empty()) + c.s << "','" << TeX_name; + c.s << "')"; } bool symbol::info(unsigned inf) const { - if (inf==info_flags::symbol) return true; - if (inf==info_flags::polynomial || - inf==info_flags::integer_polynomial || - inf==info_flags::cinteger_polynomial || - inf==info_flags::rational_polynomial || - inf==info_flags::crational_polynomial || - inf==info_flags::rational_function) { - return true; - } else { - return inherited::info(inf); + switch (inf) { + case info_flags::symbol: + case info_flags::polynomial: + case info_flags::integer_polynomial: + case info_flags::cinteger_polynomial: + case info_flags::rational_polynomial: + case info_flags::crational_polynomial: + case info_flags::rational_function: + case info_flags::expanded: + return true; + case info_flags::real: + return get_domain() == domain::real || get_domain() == domain::positive; + case info_flags::positive: + case info_flags::nonnegative: + return get_domain() == domain::positive; + case info_flags::has_indices: + return false; } + return inherited::info(inf); } -ex symbol::expand(unsigned options) const -{ - return this->hold(); -} - -bool symbol::has(const ex & other) const -{ - if (is_equal(*other.bp)) return true; - return false; -} - -int symbol::degree(const symbol & s) const -{ - return compare_same_type(s)==0 ? 1 : 0; -} - -int symbol::ldegree(const symbol & s) const +ex symbol::conjugate() const { - return compare_same_type(s)==0 ? 1 : 0; + return conjugate_function(*this).hold(); } -ex symbol::coeff(const symbol & s, int n) const +ex symbol::real_part() const { - if (compare_same_type(s)==0) { - return n==1 ? _ex1() : _ex0(); - } else { - return n==0 ? *this : _ex0(); - } + return real_part_function(*this).hold(); } -ex symbol::eval(int level) const +ex symbol::imag_part() const { - if (level == -max_recursion_level) { - throw(std::runtime_error("max recursion level reached")); - } - - if (asexinfop->is_assigned) { - setflag(status_flags::evaluated); - if (level==1) { - return (asexinfop->assigned_expression); - } else { - return (asexinfop->assigned_expression).eval(level); - } - } else { - return this->hold(); - } + return imag_part_function(*this).hold(); } -ex symbol::subs(const lst & ls, const lst & lr) const +bool symbol::is_polynomial(const ex & var) const { - GINAC_ASSERT(ls.nops()==lr.nops()); -#ifdef DO_GINAC_ASSERT - for (unsigned i=0; i(other)); const symbol *o = static_cast(&other); if (serial==o->serial) return 0; return serial < o->serial ? -1 : 1; @@ -283,25 +265,15 @@ int symbol::compare_same_type(const basic & other) const bool symbol::is_equal_same_type(const basic & other) const { - GINAC_ASSERT(is_of_type(other,symbol)); + GINAC_ASSERT(is_a(other)); const symbol *o = static_cast(&other); return serial==o->serial; } -unsigned symbol::return_type(void) const +unsigned symbol::calchash() const { - return return_types::commutative; -} - -unsigned symbol::return_type_tinfo(void) const -{ - return tinfo_key; -} - -unsigned symbol::calchash(void) const -{ - // return golden_ratio_hash(tinfo()) ^ serial; - hashvalue=golden_ratio_hash(golden_ratio_hash(0x55555555U ^ serial)); + unsigned seed = make_hash_seed(typeid(*this)); + hashvalue = golden_ratio_hash(seed ^ serial); setflag(status_flags::hash_calculated); return hashvalue; } @@ -316,31 +288,65 @@ unsigned symbol::calchash(void) const // non-virtual functions in this class ////////// -// public - -void symbol::assign(const ex & value) -{ - asexinfop->is_assigned=1; - asexinfop->assigned_expression=value; - clearflag(status_flags::evaluated); -} - -void symbol::unassign(void) -{ - if (asexinfop->is_assigned) { - asexinfop->is_assigned=0; - asexinfop->assigned_expression=_ex0(); +/** Return default TeX name for symbol. This recognizes some greek letters. */ +static const std::string& get_default_TeX_name(const std::string& name) +{ + static std::map standard_names; + static bool names_initialized = false; + if (!names_initialized) { + standard_names["alpha"] = std::string("\\alpha"); + standard_names["beta"] = std::string("\\beta");; + standard_names["gamma"] = std::string("\\gamma");; + standard_names["delta"] = std::string("\\delta");; + standard_names["epsilon"] = std::string("\\epsilon"); + standard_names["varepsilon"] = std::string("\\varepsilon"); + standard_names["zeta"] = std::string("\\zeta"); + standard_names["eta" ] = std::string("\\eta" ); + standard_names["theta"] = std::string("\\theta"); + standard_names["vartheta"] = std::string("\\vartheta"); + standard_names["iota"] = std::string("\\iota"); + standard_names["kappa"] = std::string("\\kappa"); + standard_names["lambda"] = std::string("\\lambda"); + standard_names["mu"] = std::string("\\mu"); + standard_names["nu"] = std::string("\\nu"); + standard_names["xi"] = std::string("\\xi"); + standard_names["omicron"] = std::string("\\omicron"); + standard_names["pi"] = std::string("\\pi"); + standard_names["varpi"] = std::string("\\varpi"); + standard_names["rho"] = std::string("\\rho"); + standard_names["varrho"] = std::string("\\varrho"); + standard_names["sigma"] = std::string("\\sigma"); + standard_names["varsigma"] = std::string("\\varsigma"); + standard_names["tau"] = std::string("\\tau"); + standard_names["upsilon"] = std::string("\\upsilon"); + standard_names["phi"] = std::string("\\phi"); + standard_names["varphi"] = std::string("\\varphi"); + standard_names["chi"] = std::string("\\chi"); + standard_names["psi"] = std::string("\\psi"); + standard_names["omega"] = std::string("\\omega"); + standard_names["Gamma"] = std::string("\\Gamma"); + standard_names["Delta"] = std::string("\\Delta"); + standard_names["Theta"] = std::string("\\Theta"); + standard_names["Lambda"] = std::string("\\Lambda"); + standard_names["Xi"] = std::string("\\Xi"); + standard_names["Pi"] = std::string("\\Pi"); + standard_names["Sigma"] = std::string("\\Sigma"); + standard_names["Upsilon"] = std::string("\\Upsilon"); + standard_names["Phi"] = std::string("\\Phi"); + standard_names["Psi"] = std::string("\\Psi"); + standard_names["Omega"] = std::string("\\Omega"); + names_initialized = true; } - setflag(status_flags::evaluated); + std::map::const_iterator it = standard_names.find(name); + if (it != standard_names.end()) + return it->second; + else + return name; } -// private - -std::string & symbol::autoname_prefix(void) -{ - static std::string * s=new std::string("symbol"); - return *s; -} +GINAC_BIND_UNARCHIVER(symbol); +GINAC_BIND_UNARCHIVER(realsymbol); +GINAC_BIND_UNARCHIVER(possymbol); ////////// // static member variables @@ -348,19 +354,6 @@ std::string & symbol::autoname_prefix(void) // private -unsigned symbol::next_serial=0; - -// std::string const symbol::autoname_prefix="symbol"; - -////////// -// subclass assigned_ex_info -////////// - -/** Default ctor. Defaults to unassigned. */ -symbol::assigned_ex_info::assigned_ex_info(void) : is_assigned(0), refcount(1) -{ -} +unsigned symbol::next_serial = 0; -#ifndef NO_NAMESPACE_GINAC } // namespace GiNaC -#endif // ndef NO_NAMESPACE_GINAC