X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Fsymbol.cpp;h=2f8afc006700e698779b5bd4bb933d21138b1d10;hp=39f2335abcd1911c8e4460aaa1d16c0ba1989e8a;hb=979b2636e20e037573c7c178a2e99fba282ed711;hpb=3a63743e24046766b37c3d1bd38605542ee0a536 diff --git a/ginac/symbol.cpp b/ginac/symbol.cpp index 39f2335a..2f8afc00 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-2004 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 @@ -25,100 +25,118 @@ #include "symbol.h" #include "lst.h" -#include "print.h" #include "archive.h" #include "tostring.h" #include "utils.h" +#include "inifcns.h" 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 ctor, dtor, copy ctor, assignment operator and helpers +// default constructor ////////// -symbol::symbol() : inherited(TINFO_symbol), serial(next_serial++) +// symbol + +symbol::symbol() + : inherited(TINFO_symbol), asexinfop(new assigned_ex_info), serial(next_serial++), name(autoname_prefix() + ToString(serial)), TeX_name(name), ret_type(return_types::commutative), ret_type_tinfo(TINFO_symbol), domain(domain::complex) { - name = TeX_name = autoname_prefix()+ToString(serial); - asexinfop = new assigned_ex_info; setflag(status_flags::evaluated | status_flags::expanded); } -/** For use by copy ctor and assignment operator. */ -void symbol::copy(const symbol & other) -{ - inherited::copy(other); - name = other.name; - TeX_name = other.TeX_name; - serial = other.serial; - asexinfop = other.asexinfop; - ++asexinfop->refcount; -} +// realsymbol -void symbol::destroy(bool call_parent) +realsymbol::realsymbol() { - if (--asexinfop->refcount == 0) - delete asexinfop; - if (call_parent) - inherited::destroy(call_parent); + domain = domain::real; } ////////// -// other ctors +// other constructors ////////// // public -symbol::symbol(const symbol & other) +// symbol + +symbol::symbol(const std::string & initname, unsigned domain) + : inherited(TINFO_symbol), asexinfop(new assigned_ex_info), serial(next_serial++), name(initname), TeX_name(default_TeX_name()), ret_type(return_types::commutative), ret_type_tinfo(TINFO_symbol), domain(domain) { - copy(other); + setflag(status_flags::evaluated | status_flags::expanded); +} + +symbol::symbol(const std::string & initname, const std::string & texname, unsigned domain) + : inherited(TINFO_symbol), asexinfop(new assigned_ex_info), serial(next_serial++), name(initname), TeX_name(texname), ret_type(return_types::commutative), ret_type_tinfo(TINFO_symbol), domain(domain) +{ + setflag(status_flags::evaluated | status_flags::expanded); } -symbol::symbol(const std::string & initname) : inherited(TINFO_symbol) +symbol::symbol(const std::string & initname, unsigned rt, unsigned rtt, unsigned domain) + : inherited(TINFO_symbol), asexinfop(new assigned_ex_info), serial(next_serial++), name(initname), TeX_name(default_TeX_name()), ret_type(rt), ret_type_tinfo(rtt), domain(domain) { - name = initname; - TeX_name = default_TeX_name(); - serial = next_serial++; - asexinfop = new assigned_ex_info; setflag(status_flags::evaluated | status_flags::expanded); } -symbol::symbol(const std::string & initname, const std::string & texname) : inherited(TINFO_symbol) +symbol::symbol(const std::string & initname, const std::string & texname, unsigned rt, unsigned rtt, unsigned domain) + : inherited(TINFO_symbol), asexinfop(new assigned_ex_info), serial(next_serial++), name(initname), TeX_name(texname), ret_type(rt), ret_type_tinfo(rtt), domain(domain) { - name = initname; - TeX_name = texname; - serial = next_serial++; - asexinfop = new assigned_ex_info; setflag(status_flags::evaluated | status_flags::expanded); } +// realsymbol + +realsymbol::realsymbol(const std::string & initname, unsigned domain) + : symbol(initname, domain) { } + +realsymbol::realsymbol(const std::string & initname, const std::string & texname, unsigned domain) + : symbol(initname, texname, domain) { } + +realsymbol::realsymbol(const std::string & initname, unsigned rt, unsigned rtt, unsigned domain) + : symbol(initname, rt, rtt, domain) { } + +realsymbol::realsymbol(const std::string & initname, const std::string & texname, unsigned rt, unsigned rtt, unsigned domain) + : symbol(initname, texname, rt, rtt, domain) { } + ////////// // archiving ////////// /** Construct object from archive_node. */ -symbol::symbol(const archive_node &n, const lst &sym_lst) : inherited(n, sym_lst) +symbol::symbol(const archive_node &n, lst &sym_lst) + : inherited(n, sym_lst), asexinfop(new assigned_ex_info), serial(next_serial++) { - serial = next_serial++; - if (!(n.find_string("name", name))) + if (!n.find_string("name", name)) name = autoname_prefix() + ToString(serial); - if (!(n.find_string("TeXname", TeX_name))) + if (!n.find_string("TeXname", TeX_name)) TeX_name = default_TeX_name(); - asexinfop = new assigned_ex_info; - setflag(status_flags::evaluated); + if (!n.find_unsigned("domain", domain)) + domain = domain::complex; + if (!n.find_unsigned("return_type", ret_type)) + ret_type = return_types::commutative; + if (!n.find_unsigned("return_type_tinfo", ret_type_tinfo)) + ret_type_tinfo = TINFO_symbol; + setflag(status_flags::evaluated | status_flags::expanded); } /** Unarchive the object. */ -ex symbol::unarchive(const archive_node &n, const lst &sym_lst) +ex symbol::unarchive(const archive_node &n, lst &sym_lst) { ex s = (new symbol(n, sym_lst))->setflag(status_flags::dynallocated); - + // If symbol is in sym_lst, return the existing symbol - for (unsigned i=0; i(sym_lst.op(i)).name == ex_to(s).name)) - return sym_lst.op(i); + for (lst::const_iterator it = sym_lst.begin(); it != sym_lst.end(); ++it) { + if (is_a(*it) && (ex_to(*it).name == ex_to(s).name)) + return *it; } + + // Otherwise add new symbol to list and return it + sym_lst.append(s); return s; } @@ -129,6 +147,12 @@ void symbol::archive(archive_node &n) const n.add_string("name", name); if (TeX_name != default_TeX_name()) n.add_string("TeX_name", TeX_name); + if (domain != domain::complex) + n.add_unsigned("domain", domain); + if (ret_type != return_types::commutative) + n.add_unsigned("return_type", ret_type); + if (ret_type_tinfo != TINFO_symbol) + n.add_unsigned("return_type_tinfo", ret_type_tinfo); } ////////// @@ -137,61 +161,48 @@ void symbol::archive(archive_node &n) const // public -basic *symbol::duplicate() const +void symbol::do_print(const print_context & c, unsigned level) const { - return new symbol(*this); + c.s << name; } -void symbol::print(const print_context & c, unsigned level) const +void symbol::do_print_latex(const print_latex & c, unsigned level) const { - if (is_a(c)) { - - c.s << std::string(level, ' ') << name << " (" << class_name() << ")" - << ", serial=" << serial - << std::hex << ", hash=0x" << hashvalue << ", flags=0x" << flags << std::dec - << std::endl; - - } else if (is_a(c)) { - c.s << TeX_name; - } else if (is_a(c)) { - c.s << class_name() << "('" << name; - if (TeX_name != default_TeX_name()) - c.s << "','" << TeX_name; - c.s << "')"; - } else - c.s << name; + c.s << TeX_name; } -bool symbol::info(unsigned inf) const +void symbol::do_print_tree(const print_tree & c, unsigned level) 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); + c.s << std::string(level, ' ') << name << " (" << class_name() << ")" << " @" << this + << ", serial=" << serial + << std::hex << ", hash=0x" << hashvalue << ", flags=0x" << flags << std::dec + << ", domain=" << domain + << std::endl; } -int symbol::degree(const ex & s) const +void symbol::do_print_python_repr(const print_python_repr & c, unsigned level) const { - return is_equal(ex_to(s)) ? 1 : 0; -} - -int symbol::ldegree(const ex & s) const -{ - return is_equal(ex_to(s)) ? 1 : 0; + c.s << class_name() << "('" << name; + if (TeX_name != default_TeX_name()) + c.s << "','" << TeX_name; + c.s << "')"; } -ex symbol::coeff(const ex & s, int n) const +bool symbol::info(unsigned inf) const { - if (is_equal(ex_to(s))) - return n==1 ? _ex1 : _ex0; + 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; + if (inf == info_flags::real) + return domain == domain::real; else - return n==0 ? *this : _ex0; + return inherited::info(inf); } ex symbol::eval(int level) const @@ -210,6 +221,15 @@ ex symbol::eval(int level) const } } +ex symbol::conjugate() const +{ + if (this->domain == domain::complex) { + return GiNaC::conjugate_function(*this).hold(); + } else { + return *this; + } +} + // protected /** Implementation of ex::diff() for single differentiation of a symbol. @@ -239,12 +259,9 @@ bool symbol::is_equal_same_type(const basic & other) const return serial==o->serial; } -unsigned symbol::calchash(void) const +unsigned symbol::calchash() const { - // this is where the schoolbook method - // (golden_ratio_hash(tinfo()) ^ serial) - // is not good enough yet... - hashvalue = golden_ratio_hash(golden_ratio_hash(tinfo()) ^ serial); + hashvalue = golden_ratio_hash(tinfo() ^ serial); setflag(status_flags::hash_calculated); return hashvalue; } @@ -263,15 +280,15 @@ unsigned symbol::calchash(void) const void symbol::assign(const ex & value) { - asexinfop->is_assigned = 1; + asexinfop->is_assigned = true; asexinfop->assigned_expression = value; clearflag(status_flags::evaluated | status_flags::expanded); } -void symbol::unassign(void) +void symbol::unassign() { if (asexinfop->is_assigned) { - asexinfop->is_assigned = 0; + asexinfop->is_assigned = false; asexinfop->assigned_expression = _ex0; } setflag(status_flags::evaluated | status_flags::expanded); @@ -281,14 +298,14 @@ void symbol::unassign(void) /** Symbols not constructed with a string get one assigned using this * prefix and a number. */ -std::string & symbol::autoname_prefix(void) +std::string & symbol::autoname_prefix() { static std::string *s = new std::string("symbol"); return *s; } /** Return default TeX name for symbol. This recognizes some greek letters. */ -std::string symbol::default_TeX_name(void) const +std::string symbol::default_TeX_name() const { if (name=="alpha" || name=="beta" || name=="gamma" || name=="delta" || name=="epsilon" || name=="varepsilon" @@ -322,7 +339,7 @@ unsigned symbol::next_serial = 0; ////////// /** Default ctor. Defaults to unassigned. */ -symbol::assigned_ex_info::assigned_ex_info(void) : is_assigned(0), refcount(1) +symbol::assigned_ex_info::assigned_ex_info() throw() : is_assigned(false) { }