// 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
// 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
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();
return *this;
}
+/* Substitute a set of symbols. */
ex basic::subs(const lst & ls, const lst & lr) const
{
return *this;
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);
// 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));
}
return cmpval;
}
+/** Test for equality. */
bool basic::is_equal(const basic & other) const
{
unsigned hash_this = gethash();
// protected
+/** Stop further evaluation.
+ * @see basic::eval */
const basic & basic::hold(void) const
{
return setflag(status_flags::evaluated);
// protected
-unsigned basic::precedence=70;
-unsigned basic::delta_indent=4;
+unsigned basic::precedence = 70;
+unsigned basic::delta_indent = 4;
//////////
// global constants
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;
}
* 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...
*
* 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)
// }
// // 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
/** 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];
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);
// protected
-unsigned mul::precedence=50;
+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
// 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);
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);
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());
// protected
-unsigned power::precedence=60;
+unsigned power::precedence = 60;
//////////
// global constants