- GiNaC-devel - ginac.de

csgn patch
by Vladimir Kisil 14 Mar '06

14 Mar '06

Dear all, Here is the full patch for the power property of csgn() function. Its effect can be seen in the following ginsh output: > csgn(x)^3; csgn(x) > csgn(x)^5; csgn(x) > csgn(x)^2; csgn(x)^2 > csgn(x)^(2/5); csgn(x)^(2/5) > csgn(x)^(6/2); csgn(x) > csgn(x)^(-2); csgn(x)^(-2) > csgn(x)^(-3); csgn(x)^(-3) > csgn(x)^(-3/3); csgn(x)^(-1) > csgn(x)^(-3/2); csgn(x)^(-3/2) Best wishes, Vladimir -- Vladimir V. Kisil email: kisilv(a)maths.leeds.ac.uk -- www: http://maths.leeds.ac.uk/~kisilv/ Index: ginac/inifcns.cpp =================================================================== RCS file: /home/cvs/GiNaC/ginac/inifcns.cpp,v retrieving revision 1.87 diff -u -r1.87 inifcns.cpp --- ginac/inifcns.cpp 13 Mar 2006 14:21:47 -0000 1.87 +++ ginac/inifcns.cpp 13 Mar 2006 15:56:20 -0000 @@ -252,10 +252,23 @@ return csgn(arg); } +static ex csgn_power(const ex & arg, const ex & exp) +{ + if (is_a<numeric>(exp) && exp.info(info_flags::positive) && ex_to<numeric>(exp).is_integer()) { + if (ex_to<numeric>(exp).is_odd()) + return csgn(arg); + else + return power(csgn(arg), _ex2).hold(); + } else + return power(csgn(arg), exp).hold(); +} + + REGISTER_FUNCTION(csgn, eval_func(csgn_eval). evalf_func(csgn_evalf). series_func(csgn_series). - conjugate_func(csgn_conjugate)); + conjugate_func(csgn_conjugate). + power_func(csgn_power)); //////////

2 1

New in GiNaC: step function
by Chris Dams 13 Mar '06

13 Mar '06

Dear all, I added the step function to GiNaCs repertoire of built-in functions. It is the real function step(x)=1 for x>0 and step(x)=0 for x<0. Considering the fact that numerical evaluation may yield a small imaginary part due to rounding errors, a possible imaginary part of a numerical argument is ignored. Furthermore step(0)=1/2. This, however, should not be taken too seriously as there is also the automatic evaluation step(x)^2 -> step(x). In the sense of distributions it does not matter what the value of step(0) is. Best, Chris

3 11

Symbols do not necessarily commute
by Chris Dams 23 Feb '06

23 Feb '06

Dear all, I removed the wrong statement that symbols always commute in GiNaC from the tutorial. Best, Chris

1 0

Improvement for epsilon tensors.
by Chris Dams 22 Feb '06

22 Feb '06

Dear GiNaCers, I modified the functions that construct epsilon_tensors in tensor.cpp. They now test whether their arguments are wildcards. In that case these tensors remain unevaluated. The problem is that if one tries to use .find(epsilon_tensor(idx(wild(0),2),idx(wild(1),2))) this may get "simplified" into -epsilon_tensor(idx(wild(1),2),idx(wild(0),2)) thereby obstructing the find method. This change is in the same patch as I applied to CVS in order to revive the return_type_tinfo system. Best, Chris

1 0

return_type_tinfo is alive again.
by Chris Dams 22 Feb '06

22 Feb '06

Dear all, I revived the return_type_tinfo-system again. Functions and symbols can take a tinfo_t argument. The idea is that user-defined return_type_tinfos are made by doing something like tinfo_static_t my_rtt_static; tinfo_t my_rtt = &my_rtt_static; After that, my_rtt can be used to label kinds of noncummativity. I implemented the representation labels of clifford and color objects by making an array of tinfo_static_t objects of size 256. My only concern is that archiving/unarchiving may not go completely right, but I do not know that as I did not yet try it. At least some code of myself that used this system works again and does so with minimal changes. Best, Chris

1 0

Forgot something.
by Chris Dams 21 Feb '06

21 Feb '06

Dear GiNaCers, I was silly enough to (among other files) modify function.cpp to make the new tinfo-system work on AMD64. This should, of course, have been function.pl. A patch is in CVS. Best, Chris

1 0

New return_type_tinfo-system seems broken.
by Chris Dams 15 Feb '06

15 Feb '06

Dear all, While looking at some of my code that no longer compiles under the new tinfo() system I started wondering about the new system for return_type_tinfo(). As this system always was always more or less separated from the rest of the type system there is as such no reason to remove it along with the revision of the tinfo() system. In fact, this has serious disadvantages: Why do all non-commutative symbols automatically get the same return_type_tinfo-value? What if A and B represent matrices in the same space and C is a matrix in a different space? Should A*C*B not get simplified to (A*B)*C then? Same question for functions. Why is it no longer possible to define your own function with the same return_type_tinfo as, say, Dirac matrices of a particular representation label? The fact that in ncmul::eval it is necessary to check for Dirac/color objects indicates bad design. Although the tinfo()-system has, arguably, been improved the return_type_tinfo-system has been demolished. What about the following replacement? Make return_type_tinfo return something of type tinfo_t. In that case the user can generate his own objects tinfo_t as he pleases and e.g. dirac_gamma could take an argument of type tinfo_t instead of a representation label. Does anyone feel like implementing this or shall I do it? Best, Chris

2 2

new function class
by Jens Vollinga 15 Feb '06

15 Feb '06

Hi, here is a short example code to demonstrate the changes I plan to make to GiNaC's function system (like discussed in November on this list). - every function is now a C++ class derived from class function (here still called newfunction to avoid name clashes). - the 14 functions already present in the standard C library have a special naming convention (here _ginac is appended to the class name) and supporting C functions for creation. - the definition of the functions is rather long, but will be made more comfortable with the help of new macros like GINAC_DECLARE_FUNCTION ... (not included here yet). Comments? Regards, Jens #include <iostream> #include <fstream> #include <stdexcept> #include <cmath> #include <ginac/ginac.h> namespace GiNaC { //////////////////////////////////////////////////////////////////////////////// class newfunction : public exprseq { GINAC_DECLARE_REGISTERED_CLASS_NO_CTORS(newfunction, exprseq) virtual newfunction* duplicate() const { return new newfunction(*this); } virtual void accept(GiNaC::visitor& v) const { if (visitor* p = dynamic_cast<visitor*>(&v)) { p->visit(*this); } else { inherited::accept(v); } } protected: virtual int compare_same_type(const basic& other) const { return exprseq::compare_same_type(other); } virtual bool is_equal_same_type(const basic& other) const { return exprseq::compare_same_type(other); } public: virtual void print(const print_context& c, unsigned level = 0) const; public: newfunction(tinfo_t ti) { tinfo_key = ti; } newfunction(tinfo_t ti, const ex& x1) : inherited(x1) { tinfo_key = ti; } newfunction(tinfo_t ti, const ex& x1, const ex& x2) : inherited(x1, x2) { tinfo_key = ti; } newfunction(tinfo_t ti, const ex& x1, const ex& x2, const ex& x3) : inherited(x1, x2, x3) { tinfo_key = ti; } // ... }; GINAC_IMPLEMENT_REGISTERED_CLASS(newfunction, exprseq) newfunction::newfunction(const GiNaC::archive_node& n, GiNaC::lst& sym_lst) : inherited(n, sym_lst) { } void newfunction::archive(GiNaC::archive_node& n) const { inherited::archive(n); } GiNaC::ex newfunction::unarchive(const GiNaC::archive_node& n, GiNaC::lst& sym_lst) { return (new newfunction(n, sym_lst))->setflag(status_flags::dynallocated); } void newfunction::print(const print_context& c, unsigned level) const { const std::vector<print_functor>& pdt = get_class_info().options.get_print_dispatch_table(); unsigned id = c.get_class_info().options.get_id(); if (id >= pdt.size() || !(pdt[id].is_valid())) { if (is_a<print_tree>(c)) { c.s << std::string(level, ' ') << class_name() << " @" << this << std::hex << ", hash=0x" << hashvalue << ", flags=0x" << flags << std::dec << ", nops=" << nops() << std::endl; unsigned delta_indent = static_cast<const print_tree&>(c).delta_indent; for (size_t i=0; i<seq.size(); ++i) { seq[i].print(c, level + delta_indent); } c.s << std::string(level + delta_indent, ' ') << "=====" << std::endl; } else if (is_a<print_latex>(c)) { c.s << "\\mbox{" << class_name() << "}"; inherited::do_print(c,level); } else { c.s << class_name(); inherited::do_print(c,level); } } else { pdt[id](*this, c, level); } } //////////////////////////////////////////////////////////////////////////////// class polylog : public newfunction { // a new GINAC_DECLARE_FUNCTION macro will replace this GINAC_DECLARE_REGISTERED_CLASS_NO_CTORS(polylog, newfunction) // will be part of GINAC_DECLARE_FUNCTION macro virtual polylog* duplicate() const { return new polylog(*this); } // will be part of GINAC_DECLARE_FUNCTION macro virtual void accept(GiNaC::visitor& v) const { if (visitor* p = dynamic_cast<visitor*>(&v)) { p->visit(*this); } else { inherited::accept(v); } } public: polylog(const ex& x1, const ex& x2) : inherited(&polylog::tinfo_static, x1, x2) { } protected: void do_print_latex(const print_context& c, unsigned level) const; public: virtual ex eval(int level = 0) const; }; GINAC_IMPLEMENT_REGISTERED_CLASS_OPT(polylog, exprseq, print_func<print_latex>(&polylog::do_print_latex)) // will be part of GINAC_IMPLEMENT_FUNCTION macro polylog::polylog(const GiNaC::archive_node& n, GiNaC::lst& sym_lst) : inherited(n, sym_lst) { } // will be part of GINAC_IMPLEMENT_FUNCTION macro void polylog::archive(GiNaC::archive_node& n) const { inherited::archive(n); } // will be part of GINAC_IMPLEMENT_FUNCTION macro GiNaC::ex polylog::unarchive(const GiNaC::archive_node& n, GiNaC::lst& sym_lst) { return (new polylog(n, sym_lst))->setflag(status_flags::dynallocated); } void polylog::do_print_latex(const print_context& c, unsigned level) const { c.s << "\\mbox{Li}"; inherited::do_print(c,level); } ex polylog::eval(int level) const { if (op(0).is_equal(1)) { return zeta(op(1)); } else { return this->hold(); } } //////////////////////////////////////////////////////////////////////////////// class log10_ginac : public newfunction { GINAC_DECLARE_REGISTERED_CLASS_NO_CTORS(log10_ginac, newfunction) virtual log10_ginac* duplicate() const { return new log10_ginac(*this); } virtual void accept(GiNaC::visitor& v) const { if (visitor* p = dynamic_cast<visitor*>(&v)) { p->visit(*this); } else { inherited::accept(v); } } public: log10_ginac(const ex& x) : inherited(&log10_ginac::tinfo_static, x) { } protected: void do_print(const print_context& c, unsigned level) const; void do_print_latex(const print_context& c, unsigned level) const; public: virtual ex eval(int level = 0) const; }; GINAC_IMPLEMENT_REGISTERED_CLASS_OPT(log10_ginac, newfunction, print_func<print_dflt>(&log10_ginac::do_print). print_func<print_latex>(&log10_ginac::do_print_latex)) log10_ginac::log10_ginac(const GiNaC::archive_node& n, GiNaC::lst& sym_lst) : inherited(n, sym_lst) { } void log10_ginac::archive(GiNaC::archive_node& n) const { inherited::archive(n); } GiNaC::ex log10_ginac::unarchive(const GiNaC::archive_node& n, GiNaC::lst& sym_lst) { return (new log10_ginac(n, sym_lst))->setflag(status_flags::dynallocated); } void log10_ginac::do_print(const print_context& c, unsigned level) const { std::string classname(class_name()); c.s << classname.erase(classname.find("_ginac",0),6); inherited::do_print(c,level); } void log10_ginac::do_print_latex(const print_context& c, unsigned level) const { c.s << "\\log"; inherited::do_print(c,level); } ex log10_ginac::eval(int level) const { if (op(0).is_equal(0)) { return 666; } else { return this->hold(); } } template<typename T1> const GiNaC::log10_ginac log10(const T1& x) { return log10_ginac(x); } const GiNaC::log10_ginac log10(double x) { return log10_ginac(x); } const GiNaC::log10_ginac log10(float x) { return log10_ginac(x); } //////////////////////////////////////////////////////////////////////////////// } // namespace GiNaC //using namespace std; using namespace GiNaC; int main() { try { symbol x("x"); ex r1 = polylog(x,3) + polylog(1,3) + 6*GiNaC::log10(3.0f) - log10(x); std::cout << dflt << r1 << std::endl; std::cout << tree << r1 << std::endl; std::cout << latex << r1 << std::endl; } catch (const std::exception& e) { std::cout << e.what() << std::endl; } return 0; }

2 6

Fixed problem on 64-bit machines and introduced has_options::algebraic.
by Chris Dams 14 Feb '06

14 Feb '06

Dear all, I found out that the new tinfo() system does not compile on AMD 64-bit machines because integers are still 32 bit on them. This makes the cast from void* to unsigned illegal. I solved this problem. I also introduced an extra optional argument for .has() that can be used to pass a has_option. I defined has_options::algebraic. This is analogous to subs_options::algebraic. For example (x*y*z).has(x*y,has_options::algebraic) will return true. I also included some checks for correct behavior of this feature in the check directory and documented it in the tutorial. Best, Chris

1 0

Index dimensions.
by Chris Dams 11 Jan '06

11 Jan '06

Dear all, I have modified the function minimal_dim in idx.cpp so that non-numerical dimensions do not have to be symbols. For instance minimal_dim(4,4-2*delta) will return 4. Generally a numeric dimension will always be considered smaller than a non-numeric dimension. This makes sense in the context of dimensional regularization. Best wishes, Chris

2 2