- Doxygen'ed a bunch of comments.

diff --git a/ginac/add.cpp b/ginac/add.cpp
index 08d275a259fd6896aeaf659d422173b155d0e493..aa8ff64f2785d40ff64e739f2562b98367d44837 100644 (file)
--- a/ginac/add.cpp
+++ b/ginac/add.cpp
@@ -554,14 +554,14 @@ ex add::expand(unsigned options) const
 
 // protected
 
-unsigned add::precedence=40;
+unsigned add::precedence = 40;
 
 //////////
 // global constants
 //////////
 
 const add some_add;
-const type_info & typeid_add=typeid(some_add);
+const type_info & typeid_add = typeid(some_add);
 
 #ifndef NO_NAMESPACE_GINAC
 } // namespace GiNaC

diff --git a/ginac/basic.cpp b/ginac/basic.cpp
index 8eec72b1f9e4b7c6046c28056f0214baaf6eaab8..5c3c147faf57d039fe57e94c9be0e2f92112d7bb 100644 (file)
--- a/ginac/basic.cpp
+++ b/ginac/basic.cpp
@@ -80,14 +80,7 @@ const basic & basic::operator=(const basic & other)
 
 // protected
 
-#if 0
-void basic::copy(const basic & other)
-{
-    flags=other.flags & ~ status_flags::dynallocated;
-    hashvalue=other.hashvalue;
-    tinfo_key=other.tinfo_key;
-}
-#endif
+// none (all inlined)
 
 //////////
 // other constructors
@@ -254,32 +247,38 @@ bool basic::has(const ex & other) const
     return false;
 }
 
+/** Return degree of highest power in symbol s. */
 int basic::degree(const symbol & s) const
 {
     return 0;
 }
 
+/** Return degree of lowest power in symbol s. */
 int basic::ldegree(const symbol & s) const
 {
     return 0;
 }
 
+/** Return coefficient of degree n in symbol s. */
 ex basic::coeff(const symbol & s, int n) const
 {
     return n==0 ? *this : _ex0();
 }
 
+/** Sort expression in terms of powers of some symbol.
+ *  @param s symbol to sort in. */
 ex basic::collect(const symbol & s) const
 {
     ex x;
-    int ldeg=ldegree(s);
-    int deg=degree(s);
+    int ldeg = this->ldegree(s);
+    int deg = this->degree(s);
     for (int n=ldeg; n<=deg; n++) {
-        x += coeff(s,n)*power(s,n);
+        x += this->coeff(s,n)*power(s,n);
     }
     return x;
 }
 
+/* Perform automatic symbolic evaluations on expression. */
 ex basic::eval(int level) const
 {
     return this->hold();
@@ -291,6 +290,7 @@ ex basic::evalf(int level) const
     return *this;
 }
 
+/* Substitute a set of symbols. */
 ex basic::subs(const lst & ls, const lst & lr) const
 {
     return *this;
@@ -382,6 +382,8 @@ unsigned basic::calchash(void) const
     return v;
 }
 
+/** Expand expression, i.e. multiply it out and return the result as a new
+ *  expression. */
 ex basic::expand(unsigned options) const
 {
     return this->setflag(status_flags::expanded);
@@ -394,13 +396,13 @@ ex basic::expand(unsigned options) const
 
 // public
 
+/** Substitute symbols in expression and return the result as a new expression.
+ *  There are two valid types of replacement arguments: 1) a relational like
+ *  symbol==ex and 2) a list of relationals lst(symbol1==ex1,symbol2==ex2,...),
+ *  which is converted to subs(lst(symbol1,symbol2,...),lst(ex1,ex2,...)).
+ *  In addition, an object of class idx can be used instead of a symbol. */
 ex basic::subs(const ex & e) const
 {
-    // accept 2 types of replacement expressions:
-    //   - symbol==ex
-    //   - lst(symbol1==ex1,symbol2==ex2,...)
-    // convert to subs(lst(symbol1,symbol2,...),lst(ex1,ex2,...))
-    // additionally, idx can be used instead of symbol
     if (e.info(info_flags::relation_equal)) {
         return subs(lst(e));
     }
@@ -477,6 +479,7 @@ int basic::compare(const basic & other) const
     return cmpval;
 }
 
+/** Test for equality. */
 bool basic::is_equal(const basic & other) const
 {
     unsigned hash_this = gethash();
@@ -496,6 +499,8 @@ bool basic::is_equal(const basic & other) const
 
 // protected
 
+/** Stop further evaluation.
+ *  @see basic::eval */
 const basic & basic::hold(void) const
 {
     return setflag(status_flags::evaluated);
@@ -514,8 +519,8 @@ void basic::ensure_if_modifiable(void) const
 
 // protected
 
-unsigned basic::precedence=70;
-unsigned basic::delta_indent=4;
+unsigned basic::precedence = 70;
+unsigned basic::delta_indent = 4;
 
 //////////
 // global constants

diff --git a/ginac/matrix.cpp b/ginac/matrix.cpp
index 0c627919b6953bf2e5bc5bd307dbd1d2a8820090..e5a9459f979f05ec085b1eeadcf64bb4f04ffae8 100644 (file)
--- a/ginac/matrix.cpp
+++ b/ginac/matrix.cpp
@@ -463,9 +463,9 @@ ex matrix::determinant(void) const
         det = determinant_numeric();
     else
         if (normal_flag)
-            det = determinant_symbolic_minor().normal();
+            det = determinant_minor().normal();
         else
-            det = determinant_symbolic_minor();
+            det = determinant_minor(); // is already expanded!
     
     return det;
 }
@@ -825,7 +825,7 @@ ex matrix::determinant_numeric(void) const
  *  This routine is only called internally by matrix::determinant(). The
  *  algorithm is very bad for symbolic matrices since it returns expressions
  *  that are quite hard to expand. */
-/*ex matrix::determinant_symbolic_leverrier(const matrix & M)
+/*ex matrix::determinant_leverrier(const matrix & M)
  *{
  *    GINAC_ASSERT(M.rows()==M.cols());  // cannot happen, just in case...
  *    
@@ -854,8 +854,9 @@ ex matrix::determinant_numeric(void) const
  *  polynomials and also for matrices of dense univariate polynomials if the
  *  matrix' dimesion is larger than 7.
  *
+ *  @return the determinant as a new expression (in expanded form)
  *  @see matrix::determinant() */
-ex matrix::determinant_symbolic_minor(void) const
+ex matrix::determinant_minor(void) const
 {
     // for small matrices the algorithm does not make any sense:
     if (this->row==1)
@@ -886,9 +887,9 @@ ex matrix::determinant_symbolic_minor(void) const
     //     }
     //     // recurse down and care for sign:
     //     if (r1%2)
-    //         det -= m[r1*col] * minorM.determinant_symbolic_minor();
+    //         det -= m[r1*col] * minorM.determinant_minor();
     //     else
-    //         det += m[r1*col] * minorM.determinant_symbolic_minor();
+    //         det += m[r1*col] * minorM.determinant_minor();
     // }
     // return det.expand();
     // What happens is that while proceeding down many of the minors are
@@ -967,7 +968,7 @@ ex matrix::determinant_symbolic_minor(void) const
 
 /** Determinant built by application of the full permutation group.  This
  *  routine is only called internally by matrix::determinant(). */
-ex matrix::determinant_symbolic_perm(void) const
+ex matrix::determinant_perm(void) const
 {
     if (rows()==1)  // speed things up
         return m[0];

diff --git a/ginac/matrix.h b/ginac/matrix.h
index 8a70ada83decd37bbc32948c9b345b40285c4655..c0e35dcdaf5e7c59e648f694f6d3756cd5fb4f74 100644 (file)
--- a/ginac/matrix.h
+++ b/ginac/matrix.h
@@ -96,8 +96,8 @@ public:
     matrix old_solve(const matrix & v) const;  // FIXME: may be removed
 protected:
     ex determinant_numeric(void) const;
-    ex determinant_symbolic_minor(void) const;
-    ex determinant_symbolic_perm(void) const;
+    ex determinant_minor(void) const;
+    ex determinant_perm(void) const;
     int gauss_elimination(void);
     int fraction_free_elimination(void);
     int pivot(unsigned ro, bool symbolic=true);

diff --git a/ginac/mul.cpp b/ginac/mul.cpp
index efabd3bee765406c92872be93445b97b0c3b75f0..b0caa52ded7d0840381f3c4f17a63ee7a94d2c0d 100644 (file)
--- a/ginac/mul.cpp
+++ b/ginac/mul.cpp
@@ -798,7 +798,7 @@ epvector * mul::expandchildren(unsigned options) const
 
 // protected
 
-unsigned mul::precedence=50;
+unsigned mul::precedence = 50;
 
 
 //////////
@@ -806,7 +806,7 @@ unsigned mul::precedence=50;
 //////////
 
 const mul some_mul;
-const type_info & typeid_mul=typeid(some_mul);
+const type_info & typeid_mul = typeid(some_mul);
 
 #ifndef NO_NAMESPACE_GINAC
 } // namespace GiNaC

diff --git a/ginac/power.cpp b/ginac/power.cpp
index c8f65dc41b3eaafa013d7c3ae0baa5e7764e84c2..49ee5c598cce0827006c20d3e6ae269ec9325a65 100644 (file)
--- a/ginac/power.cpp
+++ b/ginac/power.cpp
@@ -597,10 +597,10 @@ ex power::expand(unsigned options) const
 // non-virtual functions in this class
 //////////
 
+/** expand a^n where a is an add and n is an integer.
+ *  @see power::expand */
 ex power::expand_add(const add & a, int n) const
 {
-    // expand a^n where a is an add and n is an integer
-    
     if (n==2)
         return expand_add_2(a);
     
@@ -692,10 +692,11 @@ ex power::expand_add(const add & a, int n) const
     return (new add(sum))->setflag(status_flags::dynallocated);
 }
 
+
+/** Special case of power::expand. Expands a^2 where a is an add.
+ *  @see power::expand_add */
 ex power::expand_add_2(const add & a) const
 {
-    // special case: expand a^2 where a is an add
-
     epvector sum;
     unsigned a_nops=a.nops();
     sum.reserve((a_nops*(a_nops+1))/2);
@@ -755,13 +756,12 @@ ex power::expand_add_2(const add & a) const
     return (new add(sum))->setflag(status_flags::dynallocated);
 }
 
+/** Expand m^n where m is a mul and n is and integer
+ *  @see power::expand */
 ex power::expand_mul(const mul & m, const numeric & n) const
 {
-    // expand m^n where m is a mul and n is and integer
-
-    if (n.is_equal(_num0())) {
+    if (n.is_equal(_num0()))
         return _ex1();
-    }
     
     epvector distrseq;
     distrseq.reserve(m.seq.size());
@@ -828,7 +828,7 @@ ex power::expand_noncommutative(const ex & basis, const numeric & exponent,
 
 // protected
 
-unsigned power::precedence=60;
+unsigned power::precedence = 60;
 
 //////////
 // global constants