some cleanups

diff --git a/ginac/add.cpp b/ginac/add.cpp
index c4e53360b1ed665dd9f7047bc7c63ba178697f1b..5a4c805d4373d952dd3aab0712734e1ec2f635d9 100644 (file)
--- a/ginac/add.cpp
+++ b/ginac/add.cpp
@@ -151,7 +151,7 @@ void add::print(const print_context & c, unsigned level) const
                        }
                
                        // Separator is "+", except if the following expression would have a leading minus sign
-                       it++;
+                       ++it;
                        if (it != itend && !(it->coeff.compare(_num0()) < 0 || (it->coeff.compare(_num1()) == 0 && is_exactly_a<numeric>(it->rest) && it->rest.compare(_num0()) < 0)))
                                c.s << "+";
                }
@@ -215,7 +215,7 @@ void add::print(const print_context & c, unsigned level) const
                                        c.s << '*';
                        }
                        it->rest.print(c, precedence());
-                       it++;
+                       ++it;
                }
 
                if (precedence() <= level) {

diff --git a/ginac/assertion.h b/ginac/assertion.h
index 536a18a45efd127c28ca1b486f238c0af91098bc..f9d9e533870d7c919fc5535de1bf3a924405b83f 100644 (file)
--- a/ginac/assertion.h
+++ b/ginac/assertion.h
@@ -23,10 +23,9 @@
 #ifndef __GINAC_ASSERTION_H__
 #define __GINAC_ASSERTION_H__
 
-#include <cassert>
-
 #if !defined(GINAC_ASSERT)
 #if defined(DO_GINAC_ASSERT)
+#include <cassert>
 /** Assertion macro for checking invariances. */
 #define GINAC_ASSERT(X) assert(X)
 #else

diff --git a/ginac/basic.cpp b/ginac/basic.cpp
index 8d60fcfcc0b708e7ea202a1f4257ee8fcb5e3ae3..f8839db976a87b9c456ded4c8521b761cb176c1e 100644 (file)
--- a/ginac/basic.cpp
+++ b/ginac/basic.cpp
@@ -311,7 +311,7 @@ ex basic::collect(const ex & s, bool distributed) const
                                // Increment counters
                                int n = num - 1;
                                while (true) {
-                                       si[n].cnt++;
+                                       ++si[n].cnt;
                                        if (si[n].cnt <= si[n].deg) {
                                                // Update coefficients
                                                ex c;

diff --git a/ginac/expairseq.cpp b/ginac/expairseq.cpp
index 1530564b04d31ff93b7d0fd21ca238f96ae6533e..a18927c26e69933a485f7ddaa2aca91e42acc0c7 100644 (file)
--- a/ginac/expairseq.cpp
+++ b/ginac/expairseq.cpp
@@ -234,7 +234,7 @@ void expairseq::print(const print_context & c, unsigned level) const
                                        c.s << *it-seq.begin() << " ";
                                        ++this_bin_fill;
                                }
-                               os << std::endl;
+                               c.s << std::endl;
                                cum_fill += this_bin_fill;
                                cum_fill_sq += this_bin_fill*this_bin_fill;
                        }
@@ -308,7 +308,7 @@ ex expairseq::map(map_function & f) const
        epvector::const_iterator cit = seq.begin(), last = seq.end();
        while (cit != last) {
                v->push_back(split_ex_to_pair(f(recombine_pair_to_ex(*cit))));
-               cit++;
+               ++cit;
        }
 
        return thisexpairseq(v, f(overall_coeff));
@@ -890,16 +890,15 @@ void expairseq::construct_from_expairseq_ex(const expairseq &s,
        
        // merge p into s.seq
        while (first!=last) {
-               int cmpval=(*first).rest.compare(p.rest);
+               int cmpval = (*first).rest.compare(p.rest);
                if (cmpval==0) {
                        // combine terms
-                       const numeric &newcoeff = ex_to<numeric>((*first).coeff).
+                       const numeric &newcoeff = ex_to<numeric>(first->coeff).
                                                   add(ex_to<numeric>(p.coeff));
                        if (!newcoeff.is_zero()) {
-                               seq.push_back(expair((*first).rest,newcoeff));
-                               if (expair_needs_further_processing(seq.end()-1)) {
+                               seq.push_back(expair(first->rest,newcoeff));
+                               if (expair_needs_further_processing(seq.end()-1))
                                        needs_further_processing = true;
-                               }
                        }
                        ++first;
                        p_pushed = true;
@@ -1023,7 +1022,7 @@ void expairseq::make_flat(const epvector &v)
        while (cit!=v.end()) {
                if (cit->rest.bp->tinfo()==this->tinfo()) {
                        ++nexpairseqs;
-                       noperands += ex_to<expairseq>((*cit).rest).seq.size();
+                       noperands += ex_to<expairseq>(cit->rest).seq.size();
                }
                ++cit;
        }
@@ -1036,13 +1035,13 @@ void expairseq::make_flat(const epvector &v)
        while (cit!=v.end()) {
                if (cit->rest.bp->tinfo()==this->tinfo() &&
                    this->can_make_flat(*cit)) {
-                       const expairseq &subseqref = ex_to<expairseq>((*cit).rest);
+                       const expairseq &subseqref = ex_to<expairseq>(cit->rest);
                        combine_overall_coeff(ex_to<numeric>(subseqref.overall_coeff),
-                                                           ex_to<numeric>((*cit).coeff));
+                                                           ex_to<numeric>(cit->coeff));
                        epvector::const_iterator cit_s = subseqref.seq.begin();
                        while (cit_s!=subseqref.seq.end()) {
-                               seq.push_back(expair((*cit_s).rest,
-                                                    ex_to<numeric>((*cit_s).coeff).mul_dyn(ex_to<numeric>((*cit).coeff))));
+                               seq.push_back(expair(cit_s->rest,
+                                                    ex_to<numeric>(cit_s->coeff).mul_dyn(ex_to<numeric>(cit->coeff))));
                                //seq.push_back(combine_pair_with_coeff_to_pair(*cit_s,
                                //                                              (*cit).coeff));
                                ++cit_s;
@@ -1080,14 +1079,14 @@ void expairseq::combine_same_terms_sorted_seq(void)
                // possible from then on the sequence has changed and must be compacted
                bool must_copy = false;
                while (itin2!=last) {
-                       if ((*itin1).rest.compare((*itin2).rest)==0) {
-                               (*itin1).coeff = ex_to<numeric>((*itin1).coeff).
-                                                add_dyn(ex_to<numeric>((*itin2).coeff));
+                       if ((*itin1).rest.compare(itin2->rest)==0) {
+                               (*itin1).coeff = ex_to<numeric>(itin1->coeff).
+                                                add_dyn(ex_to<numeric>(itin2->coeff));
                                if (expair_needs_further_processing(itin1))
                                        needs_further_processing = true;
                                must_copy = true;
                        } else {
-                               if (!ex_to<numeric>((*itin1).coeff).is_zero()) {
+                               if (!ex_to<numeric>(itin1->coeff).is_zero()) {
                                        if (must_copy)
                                                *itout = *itin1;
                                        ++itout;
@@ -1096,7 +1095,7 @@ void expairseq::combine_same_terms_sorted_seq(void)
                        }
                        ++itin2;
                }
-               if (!ex_to<numeric>((*itin1).coeff).is_zero()) {
+               if (!ex_to<numeric>(itin1->coeff).is_zero()) {
                        if (must_copy)
                                *itout = *itin1;
                        ++itout;
@@ -1192,14 +1191,13 @@ void expairseq::remove_hashtab_entry(epvector::const_iterator element)
                ++epplit;
        }
        if (!erased) {
-               printtree(cout,0);
-               cout << "tried to erase " << element-seq.begin() << std::endl;
-               cout << "size " << seq.end()-seq.begin() << std::endl;
+               std::cout << "tried to erase " << element-seq.begin() << std::endl;
+               std::cout << "size " << seq.end()-seq.begin() << std::endl;
 
-               unsigned hashindex = calc_hashindex((*element).rest);
+               unsigned hashindex = calc_hashindex(element->rest);
                epplist &eppl = hashtab[hashindex];
-               epplist::iterator epplit=eppl.begin();
-               bool erased=false;
+               epplist::iterator epplit = eppl.begin();
+               bool erased = false;
                while (epplit!=eppl.end()) {
                        if (*epplit == element) {
                                eppl.erase(epplit);
@@ -1234,10 +1232,10 @@ void expairseq::move_hashtab_entry(epvector::const_iterator oldpos,
        GINAC_ASSERT(epplit!=eppl.end());
 }
 
-void expairseq::sorted_insert(epplist &eppl, epp elem)
+void expairseq::sorted_insert(epplist &eppl, epvector::const_iterator elem)
 {
        epplist::const_iterator current = eppl.begin();
-       while ((current!=eppl.end())&&((*(*current)).is_less(*elem))) {
+       while ((current!=eppl.end()) && ((*current)->is_less(*elem))) {
                ++current;
        }
        eppl.insert(current,elem);
@@ -1248,21 +1246,21 @@ void expairseq::build_hashtab_and_combine(epvector::iterator &first_numeric,
                                           std::vector<bool> &touched,
                                           unsigned &number_of_zeroes)
 {
-       epp current=seq.begin();
+       epp current = seq.begin();
 
        while (current!=first_numeric) {
-               if (is_ex_exactly_of_type((*current).rest,numeric)) {
+               if (is_ex_exactly_of_type(current->rest,numeric)) {
                        --first_numeric;
                        iter_swap(current,first_numeric);
                } else {
                        // calculate hashindex
-                       unsigned currenthashindex = calc_hashindex((*current).rest);
+                       unsigned currenthashindex = calc_hashindex(current->rest);
 
                        // test if there is already a matching expair in the hashtab-list
                        epplist &eppl=hashtab[currenthashindex];
                        epplist::iterator epplit = eppl.begin();
                        while (epplit!=eppl.end()) {
-                               if ((*current).rest.is_equal((*(*epplit)).rest))
+                               if (current->rest.is_equal((*epplit)->rest))
                                        break;
                                ++epplit;
                        }
@@ -1272,8 +1270,8 @@ void expairseq::build_hashtab_and_combine(epvector::iterator &first_numeric,
                                ++current;
                        } else {
                                // epplit points to a matching expair, combine it with current
-                               (*(*epplit)).coeff = ex_to<numeric>((*(*epplit)).coeff).
-                                                    add_dyn(ex_to<numeric>((*current).coeff));
+                               (*epplit)->coeff = ex_to<numeric>((*epplit)->coeff).
+                                                  add_dyn(ex_to<numeric>(current->coeff));
                                
                                // move obsolete current expair to end by swapping with last_non_zero element
                                // if this was a numeric, it is swapped with the expair before first_numeric 
@@ -1283,7 +1281,7 @@ void expairseq::build_hashtab_and_combine(epvector::iterator &first_numeric,
                                --last_non_zero;
                                ++number_of_zeroes;
                                // test if combined term has coeff 0 and can be removed is done later
-                               touched[(*epplit)-seq.begin()]=true;
+                               touched[(*epplit)-seq.begin()] = true;
                        }
                }
        }
@@ -1312,8 +1310,9 @@ void expairseq::drop_coeff_0_terms(epvector::iterator &first_numeric,
                        if (current!=last_non_zero) {
                                iter_swap(current,last_non_zero);
                                --first_numeric;
-                               bool numeric_swapped=first_numeric!=last_non_zero;
-                               if (numeric_swapped) iter_swap(first_numeric,current);
+                               bool numeric_swapped = first_numeric!=last_non_zero;
+                               if (numeric_swapped)
+                                       iter_swap(first_numeric,current);
                                epvector::iterator changed_entry;
 
                                if (numeric_swapped)
@@ -1437,22 +1436,22 @@ bool expairseq::is_canonical() const
        epvector::const_iterator it = seq.begin(), itend = seq.end();
        epvector::const_iterator it_last = it;
        for (++it; it!=itend; it_last=it, ++it) {
-               if (!((*it_last).is_less(*it) || (*it_last).is_equal(*it))) {
-                       if (!is_ex_exactly_of_type((*it_last).rest,numeric) ||
-                               !is_ex_exactly_of_type((*it).rest,numeric)) {
+               if (!(it_last->is_less(*it) || it_last->is_equal(*it))) {
+                       if (!is_ex_exactly_of_type(it_last->rest,numeric) ||
+                               !is_ex_exactly_of_type(it->rest,numeric)) {
                                // double test makes it easier to set a breakpoint...
-                               if (!is_ex_exactly_of_type((*it_last).rest,numeric) ||
-                                       !is_ex_exactly_of_type((*it).rest,numeric)) {
+                               if (!is_ex_exactly_of_type(it_last->rest,numeric) ||
+                                       !is_ex_exactly_of_type(it->rest,numeric)) {
                                        printpair(std::clog, *it_last, 0);
                                        std::clog << ">";
                                        printpair(std::clog, *it, 0);
                                        std::clog << "\n";
                                        std::clog << "pair1:" << std::endl;
-                                       (*it_last).rest.print(print_tree(std::clog));
-                                       (*it_last).coeff.print(print_tree(std::clog));
+                                       it_last->rest.print(print_tree(std::clog));
+                                       it_last->coeff.print(print_tree(std::clog));
                                        std::clog << "pair2:" << std::endl;
-                                       (*it).rest.print(print_tree(std::clog));
-                                       (*it).coeff.print(print_tree(std::clog));
+                                       it->rest.print(print_tree(std::clog));
+                                       it->coeff.print(print_tree(std::clog));
                                        return 0;
                                }
                        }
@@ -1472,8 +1471,8 @@ epvector * expairseq::expandchildren(unsigned options) const
        epvector::const_iterator last = seq.end();
        epvector::const_iterator cit = seq.begin();
        while (cit!=last) {
-               const ex &expanded_ex = (*cit).rest.expand(options);
-               if (!are_ex_trivially_equal((*cit).rest,expanded_ex)) {
+               const ex &expanded_ex = cit->rest.expand(options);
+               if (!are_ex_trivially_equal(cit->rest,expanded_ex)) {
                        
                        // something changed, copy seq, eval and return it
                        epvector *s = new epvector;
@@ -1487,12 +1486,12 @@ epvector * expairseq::expandchildren(unsigned options) const
                        }
                        // copy first changed element
                        s->push_back(combine_ex_with_coeff_to_pair(expanded_ex,
-                                                                  (*cit2).coeff));
+                                                                  cit2->coeff));
                        ++cit2;
                        // copy rest
                        while (cit2!=last) {
-                               s->push_back(combine_ex_with_coeff_to_pair((*cit2).rest.expand(options),
-                                                                          (*cit2).coeff));
+                               s->push_back(combine_ex_with_coeff_to_pair(cit2->rest.expand(options),
+                                                                          cit2->coeff));
                                ++cit2;
                        }
                        return s;
@@ -1522,11 +1521,11 @@ epvector * expairseq::evalchildren(int level) const
                throw(std::runtime_error("max recursion level reached"));
        
        --level;
-       epvector::const_iterator last=seq.end();
-       epvector::const_iterator cit=seq.begin();
+       epvector::const_iterator last = seq.end();
+       epvector::const_iterator cit = seq.begin();
        while (cit!=last) {
-               const ex &evaled_ex = (*cit).rest.eval(level);
-               if (!are_ex_trivially_equal((*cit).rest,evaled_ex)) {
+               const ex &evaled_ex = cit->rest.eval(level);
+               if (!are_ex_trivially_equal(cit->rest,evaled_ex)) {
                        
                        // something changed, copy seq, eval and return it
                        epvector *s = new epvector;
@@ -1540,12 +1539,12 @@ epvector * expairseq::evalchildren(int level) const
                        }
                        // copy first changed element
                        s->push_back(combine_ex_with_coeff_to_pair(evaled_ex,
-                                                                  (*cit2).coeff));
+                                                                  cit2->coeff));
                        ++cit2;
                        // copy rest
                        while (cit2!=last) {
-                               s->push_back(combine_ex_with_coeff_to_pair((*cit2).rest.eval(level),
-                                                                          (*cit2).coeff));
+                               s->push_back(combine_ex_with_coeff_to_pair(cit2->rest.eval(level),
+                                                                          cit2->coeff));
                                ++cit2;
                        }
                        return s;
@@ -1570,7 +1569,7 @@ epvector * expairseq::subschildren(const lst &ls, const lst &lr, bool no_pattern
        // is a product or power. In this case we have to recombine the pairs
        // because the numeric coefficients may be part of the search pattern.
        bool complex_subs = false;
-       for (unsigned i=0; i<ls.nops(); i++)
+       for (unsigned i=0; i<ls.nops(); ++i)
                if (is_ex_exactly_of_type(ls.op(i), mul) || is_ex_exactly_of_type(ls.op(i), power)) {
                        complex_subs = true;
                        break;

diff --git a/ginac/expairseq.h b/ginac/expairseq.h
index 1b5e211ab2c2620640e717f16f12abe09e848987..8d083c1613459e7d5ab50e6183b4a83f75ab0822 100644 (file)
--- a/ginac/expairseq.h
+++ b/ginac/expairseq.h
@@ -147,7 +147,7 @@ protected:
        void remove_hashtab_entry(epvector::const_iterator element);
        void move_hashtab_entry(epvector::const_iterator oldpos,
                                epvector::iterator newpos);
-       void sorted_insert(epplist & eppl, epp elem);
+       void sorted_insert(epplist & eppl, epvector::const_iterator elem);
        void build_hashtab_and_combine(epvector::iterator & first_numeric,
                                       epvector::iterator & last_non_zero,
                                       vector<bool> & touched,

diff --git a/ginac/function.pl b/ginac/function.pl
index b9ee78710d643a54b28914a1a9e7c36c108c350b..565b0f91c4b9f98ac58874a19a3b659393689dfd 100755 (executable)
--- a/ginac/function.pl
+++ b/ginac/function.pl
@@ -34,25 +34,11 @@ sub generate {
        return generate_from_to($template,$seq_template1,$seq_template2,1,$maxargs);
 }
 
-$declare_function_macro = <<'END_OF_DECLARE_FUNCTION_1_AND_2P_MACRO';
-#define DECLARE_FUNCTION_1P(NAME) \
-extern const unsigned function_index_##NAME; \
-inline GiNaC::function NAME(const GiNaC::ex & p1) { \
-       return GiNaC::function(function_index_##NAME, p1); \
-}
-#define DECLARE_FUNCTION_2P(NAME) \
-extern const unsigned function_index_##NAME; \
-inline GiNaC::function NAME(const GiNaC::ex & p1, const GiNaC::ex & p2) { \
-       return GiNaC::function(function_index_##NAME, p1, p2); \
-}
-
-END_OF_DECLARE_FUNCTION_1_AND_2P_MACRO
-
-$declare_function_macro .= generate_from_to(
-       <<'END_OF_DECLARE_FUNCTION_MACRO','const GiNaC::ex & p${N}','p${N}',3,$maxargs);
+$declare_function_macro = generate_from_to(
+       <<'END_OF_DECLARE_FUNCTION_MACRO','const GiNaC::ex & p${N}','p${N}',1,$maxargs);
 #define DECLARE_FUNCTION_${N}P(NAME) \\
 extern const unsigned function_index_##NAME; \\
-inline GiNaC::function NAME(${SEQ1}) { \\
+inline const GiNaC::function NAME(${SEQ1}) { \\
        return GiNaC::function(function_index_##NAME, ${SEQ2}); \\
 }
 
@@ -199,7 +185,7 @@ $interface=<<END_OF_INTERFACE;
 #include <string>
 #include <vector>
 
-// CINT needs <algorithm> to work properly with <vector> 
+// CINT needs <algorithm> to work properly with <vector>
 #include <algorithm>
 
 #include "exprseq.h"
@@ -629,7 +615,7 @@ function::function(const archive_node &n, const lst &sym_lst) : inherited(n, sym
                                serial = ser;
                                return;
                        }
-                       i++; ser++;
+                       ++i; ++ser;
                }
                throw (std::runtime_error("unknown function '" + s + "' in archive"));
        } else
@@ -687,7 +673,7 @@ void function::print(const print_context & c, unsigned level) const
                exvector::const_iterator it = seq.begin(), itend = seq.end();
                while (it != itend) {
                        it->print(c);
-                       it++;
+                       ++it;
                        if (it != itend)
                                c.s << ",";
                }
@@ -788,11 +774,11 @@ ex function::evalf(int level) const
                throw(std::runtime_error("max recursion level reached"));
        else
                eseq.reserve(seq.size());
-       level--;
+       --level;
        exvector::const_iterator it = seq.begin(), itend = seq.end();
        while (it != itend) {
-               eseq.push_back((*it).evalf(level));
-               it++;
+               eseq.push_back(it->evalf(level));
+               ++it;
        }
        
        if (registered_functions()[serial].evalf_f==0) {
@@ -990,7 +976,7 @@ unsigned function::register_new(function_options const & opt)
        unsigned same_name = 0;
        for (unsigned i=0; i<registered_functions().size(); ++i) {
                if (registered_functions()[i].name==opt.name) {
-                       same_name++;
+                       ++same_name;
                }
        }
        if (same_name>=opt.functions_with_same_name) {
@@ -1021,8 +1007,8 @@ unsigned function::find_function(const std::string &name, unsigned nparams)
        while (i != end) {
                if (i->get_name() == name && i->get_nparams() == nparams)
                        return serial;
-               i++;
-               serial++;
+               ++i;
+               ++serial;
        }
        throw (std::runtime_error("no function '" + name + "' with " + ToString(nparams) + " parameters defined"));
 }

diff --git a/ginac/mul.cpp b/ginac/mul.cpp
index 3bc70b4450465d478762dcef2a0ca619fc7b4023..2cb358efbfda50ea736fc816511069854a77eccb 100644 (file)
--- a/ginac/mul.cpp
+++ b/ginac/mul.cpp
@@ -224,7 +224,7 @@ void mul::print(const print_context & c, unsigned level) const
                                first = false;
                        }
                        recombine_pair_to_ex(*it).print(c, precedence());
-                       it++;
+                       ++it;
                }
 
                if (precedence() <= level) {
@@ -351,7 +351,7 @@ ex mul::eval(int level) const
        while (i != end) {
                GINAC_ASSERT((!is_ex_exactly_of_type(i->rest, mul)) ||
                             (!(ex_to<numeric>(i->coeff).is_integer())));
-               GINAC_ASSERT(!(cit->is_canonical_numeric()));
+               GINAC_ASSERT(!(i->is_canonical_numeric()));
                if (is_ex_exactly_of_type(recombine_pair_to_ex(*i), numeric))
                    print(print_tree(std::cerr));
                GINAC_ASSERT(!is_ex_exactly_of_type(recombine_pair_to_ex(*i), numeric));

diff --git a/ginac/power.cpp b/ginac/power.cpp
index 1fe5063c222ab91adaee973323a481593d32a771..f911c491f1d8783ee3fb5b69cd28a357c05ea6aa 100644 (file)
--- a/ginac/power.cpp
+++ b/ginac/power.cpp
@@ -580,7 +580,7 @@ ex power::expand(unsigned options) const
                epvector::const_iterator cit = a.seq.begin();
                while (cit!=last) {
                        distrseq.push_back(power(expanded_basis, a.recombine_pair_to_ex(*cit)));
-                       cit++;
+                       ++cit;
                }
                
                // Make sure that e.g. (x+y)^(2+a) expands the (x+y)^2 factor
@@ -713,7 +713,7 @@ ex power::expand_add(const add & a, int n) const
                l = m-2;
                while ((l>=0)&&((++k[l])>upper_limit[l])) {
                        k[l] = 0;    
-                       l--;
+                       --l;
                }
                if (l<0) break;