- GiNaC-devel - ginac.de

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

Another bug in clifford.cpp
by Chris Dams 05 Jan '06

05 Jan '06

Dear all, I found out that canonicalizing clifford objects was not functioning properly. This was because a dirac_slash was automatically getting zero as its metric. When canonicalizing clifford objects the anti-commutator of two objects that were ordered in the wrong way is necesary. However, if the metric is automatically set to zero, this anti-commutator is zero too. I fixed this in CVS. I do have two questions about the implementation (1) Why are the indices in dirac_gamma (and with my patch in dirac_slash) static? Does the dimension of them not matter? It now seems that the dimension as used in the metric is always equal to the dimension of the very first dirac_gamma/dirac_slash that is constructed. (2) Why does the metric have indices? In view of the implementation of get_metric the primary purpose of these indices seems to be to be replaced by other indices. If that is the case why are they present in the first place? Best, Chris

2 3

Bug in clifford::subs().
by Chris Dams 04 Jan '06

04 Jan '06

Dear all, I found out that if there is nothing to substitute for clifford::subs it does not return an expression that is trivially equal (in the sense of are_ex_trivially_equal) to the original one. Besides that there were a lot of overloaded clifford::subs methods of which the purpose is unclear to me. I removed these spurious methods and fixed the bug. The patch is in CVS. Best wishes, Chris

1 0

Improvements for algebraic substitutions.
by Chris Dams 03 Jan '06

03 Jan '06

Happy new year! I found out that if we do (notation simplified to be more readable but less compilable): (a^n*b^m*b^p).subs($0^$1*$0^$2==$0^($1+$2),subs_options::algebraic) nothing happens because a^n already matches a factor in the pattern and in that case no other matches are attempted. I fixed this. Also, I allowed algebraic substitution to match multiple times on different factors with the same pattern. E.g. the above .subs() can be used to simplify a^n*a^m*b^p*b^q -> a^(n+m)*b^(p+q) These changes are in CVS. Bye, Chris

1 0

Bugfixes in 1.3
by Chris Dams 16 Dec '05

16 Dec '05

Dear GiNaCers, I put the speed-up for simplify_indexed and the fix for the yestday-discovered bug for user-defined inner products in CVS. Best, Chris

1 0

Improvements for dummy index renaming.
by Chris Dams 16 Dec '05

16 Dec '05

Dear all, I found out that the function get_all_dummy_indices only really gets all dummy indices if the it acts on something that is expanded (i.e., it works fine when called form simplify_indexed). However, if it is called from the new index renaming code, it does not see dummy indices that occur in a factor that looks, for instance like (A.i*A.i+alpha). To make this work, I added a new function get_all_dummy_indices_safely which is more costly computatunally but is supposed to really get always all dummy indices. Other changes: (1) Removed power::get_free_indices(). It is a bad idea that and index inside a power could be contracted with something. Therefore it should not be considered a free index. Besides, now that all dummy indices are found, this would break algebraic substitutions when used for something like U.i.j*Uinv.j.k==delta.i.k. (2) As mentioned in the "Note:" of my previous mail, removed the try/catch block that was introduce there. Now we do not try to look up inner products of expressions with more than one index. (3) Please don't cast an expession to a lst with (lst)expression. This is undefined behaviour and at my place it does not work as intended. What was the purpose of ex_to<whatever> again? Best, Chris

1 0

Crash in simplify_indexed.
by Chris Dams 15 Dec '05

15 Dec '05

Dear all, I found out that if one tries to use simplify_indexed for a product that contains, say, T~a.mu*T~a~mu and the dimensions of the indices a and mu are incomparable, this throws an exception. This is because GiNaC tries to apply user defined scalar_products in order to contract factors. As the user may not even be using scalar_products, I think this is not a good idea. I solved this by wrapping the part of the code that does this in a try-catch block. A patch is in CVS. Note: The try/catch-approach is not very elegant IMO. An alternative solution might be to stop trying to use user-defined scalar_products in case of considering contraction of indexed objects with more than one index. Is anybody using such a feature anyway? Best, Chris

2 1

tinfo
by Jens Vollinga 30 Nov '05

30 Nov '05

Hi everybody, just an idea for a better(?) tinfo mechanism in ginac: if we added two static constants to every class like class SOMECLASS { public: const static char* tinfo_name; const static unsigned tinfo; // ... rest of class ... } const char* SOMECLASS::tinfo_name = "SOMECLASS"; const unsigned SOMECLASS::tinfo = (unsigned)SOMECLASS::idstring; it seems that we would get a tinfo mechanism for ginac without having to set the tinfo numbers by hand. But maybe I am mistaken. So I'd like to ask somebody who knows C++ better than me, if there might be some hidden pitfalls. Is the conversion a problem (what about 64bit machines)? Is it guaranteed that the address of the static string is unique to every class? Maybe some optimizer will break this? Does it only work with gcc on linux etc.? Regards, Jens

3 12

new function system
by Jens Vollinga 29 Nov '05

29 Nov '05

Hi, here now a small code example to make clear what I was taking about when I mentioned class-functions. A log10 function is declared as an example. The fclass (-> function) class basically installs some default printing and has some convenience ctors. I know there are some issues about the macros (fixed archiving defaults, naming, ...), some print stuff is missing in fclass, and there is no special code for log10 (series, ...) yet, but the main concept should become clear. Eval: - compatibility is severly broken (but maybe we should break it anyhow: why not rename tgamma to Gamma, beta to Beta, lgamma to logGamma?) + logic like if (is_a<function>(e)) { std::string name = ex_to<function>(e).get_name(); if (name == "H") { ... can be replaced by more efficient code + hierarchies like polylog->nielsen_polylog->multiple_polylog possible + function.pl is no longer needed + eval/evalf slightly faster (?) + non-ex arguments for ctors (and eval, ...) possible + extra methods/logic/data can be included in the function class (projects like nestedsums, xloops suffer from not being able to do this at the moment) + more OOP like (disputable, but we will never hear the often raised question 'why didn't you just define the functions as classes?' again + better (OOP-like) handling of look-up tables (as static data or maybe the function might become a singleton) - no nice separation of cln and GiNaC code possible + print-Methods can also be changed at runtime for functions - archiving slightly slower because of longer reg_info list Regards, Jens #include <iostream> #include <fstream> #include <stdexcept> #include <ginac/ginac.h> using namespace std; using namespace GiNaC; namespace GiNaC { /** Primary macro for inclusion in the declaration of each registered class. */ #define NEW_GINAC_DECLARE_REGISTERED_CLASS_NO_CTORS(classname, supername) \ public: \ typedef supername inherited; \ private: \ static GiNaC::registered_class_info reg_info; \ public: \ static GiNaC::registered_class_info &get_class_info_static() { return reg_info; } \ virtual const GiNaC::registered_class_info &get_class_info() const { return classname::get_class_info_static(); } \ virtual GiNaC::registered_class_info &get_class_info() { return classname::get_class_info_static(); } \ virtual const char *class_name() const { return classname::get_class_info_static().options.get_name(); } \ \ classname(const GiNaC::archive_node &n, GiNaC::lst &sym_lst) : inherited(n, sym_lst) {} ; \ static GiNaC::ex unarchive(const GiNaC::archive_node &n, GiNaC::lst &sym_lst) \ { return (new classname(n, sym_lst))->setflag(status_flags::dynallocated); }; \ class visitor { \ public: \ virtual void visit(const classname &) = 0; \ virtual ~visitor() {}; \ }; \ private: /** Macro for inclusion in the declaration of each registered class. * It declares some functions that are common to all classes derived * from 'basic' as well as all required stuff for the GiNaC class * registry (mainly needed for archiving). */ #define NEW_GINAC_DECLARE_REGISTERED_CLASS(classname, supername) \ NEW_GINAC_DECLARE_REGISTERED_CLASS_NO_CTORS(classname, supername) \ public: \ classname() { tinfo_key = TINFO_##classname; } \ virtual classname * duplicate() const { return new classname(*this); } \ \ virtual void accept(GiNaC::visitor & v) const \ { \ if (visitor *p = dynamic_cast<visitor *>(&v)) \ p->visit(*this); \ else \ inherited::accept(v); \ } \ private: //////////////////////////////////////////////////////////////////////////////// const unsigned TINFO_fclass = 0x47231232U; class fclass : public exprseq { NEW_GINAC_DECLARE_REGISTERED_CLASS(fclass, exprseq) public: fclass(unsigned ti, const ex& x1) : inherited(x1) { tinfo_key = ti; } fclass(unsigned ti, const ex& x1, const ex& x2) : inherited(x1,x2) { tinfo_key = ti; } fclass(unsigned ti, const ex& x1, const ex& x2, const ex& x3) : inherited(x1,x2,x3) { tinfo_key = ti; } protected: void fclass::do_print(const print_context &c, unsigned level) const { c.s << class_name(); inherited::do_print(c,level); } }; GINAC_IMPLEMENT_REGISTERED_CLASS_OPT(fclass, exprseq, print_func<print_context>(&fclass::do_print)) //////////////////////////////////////////////////////////////////////////////// const unsigned TINFO_log10 = 0x47321232U; class log10 : public fclass { NEW_GINAC_DECLARE_REGISTERED_CLASS(log10, fclass) public: log10(const ex& x) : inherited(TINFO_log10, x) {} log10(const ex& x, const ex& y) : inherited(TINFO_log10, x, y) {} }; GINAC_IMPLEMENT_REGISTERED_CLASS(log10, fclass) //////////////////////////////////////////////////////////////////////////////// } main() { try { symbol x("x"); ex d = x; ex r1 = log10(d) * log10(x) + x; cout << r1 << endl; cout << tree << r1 << endl; cout << dflt << log10(lst(x,x),lst(x)) << endl; } catch (const exception& e) { cout << e.what() << endl; } return 0; }

2 5