* Implementation of GiNaC's initially known functions. */
/*
- * GiNaC Copyright (C) 1999-2003 Johannes Gutenberg University Mainz, Germany
+ * GiNaC Copyright (C) 1999-2005 Johannes Gutenberg University Mainz, Germany
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <vector>
namespace GiNaC {
+//////////
+// complex conjugate
+//////////
+
+static ex conjugate_evalf(const ex & arg)
+{
+ if (is_exactly_a<numeric>(arg)) {
+ return ex_to<numeric>(arg).conjugate();
+ }
+ return conjugate_function(arg).hold();
+}
+
+static ex conjugate_eval(const ex & arg)
+{
+ return arg.conjugate();
+}
+
+static void conjugate_print_latex(const ex & arg, const print_context & c)
+{
+ c.s << "\\bar{"; arg.print(c); c.s << "}";
+}
+
+static ex conjugate_conjugate(const ex & arg)
+{
+ return arg;
+}
+
+REGISTER_FUNCTION(conjugate_function, eval_func(conjugate_eval).
+ evalf_func(conjugate_evalf).
+ print_func<print_latex>(conjugate_print_latex).
+ conjugate_func(conjugate_conjugate).
+ set_name("conjugate","conjugate"));
+
//////////
// absolute value
//////////
c.s << "fabs("; arg.print(c); c.s << ")";
}
+static ex abs_conjugate(const ex & arg)
+{
+ return abs(arg);
+}
+
REGISTER_FUNCTION(abs, eval_func(abs_eval).
evalf_func(abs_evalf).
print_func<print_latex>(abs_print_latex).
print_func<print_csrc_float>(abs_print_csrc_float).
- print_func<print_csrc_double>(abs_print_csrc_float));
+ print_func<print_csrc_double>(abs_print_csrc_float).
+ conjugate_func(abs_conjugate));
//////////
return pseries(rel,seq);
}
+static ex csgn_conjugate(const ex& arg)
+{
+ return csgn(arg);
+}
+
REGISTER_FUNCTION(csgn, eval_func(csgn_eval).
evalf_func(csgn_evalf).
- series_func(csgn_series));
+ series_func(csgn_series).
+ conjugate_func(csgn_conjugate));
//////////
return pseries(rel,seq);
}
+static ex eta_conjugate(const ex & x, const ex & y)
+{
+ return -eta(x,y);
+}
+
REGISTER_FUNCTION(eta, eval_func(eta_eval).
evalf_func(eta_evalf).
series_func(eta_series).
latex_name("\\eta").
- set_symmetry(sy_symm(0, 1)));
+ set_symmetry(sy_symm(0, 1)).
+ conjugate_func(eta_conjugate));
//////////
ex ser;
// manually construct the primitive expansion
for (int i=1; i<order; ++i)
- ser += pow(s,i) / pow(numeric(i), _num2);
+ ser += pow(s,i) / pow(numeric(i), *_num2_p);
// substitute the argument's series expansion
ser = ser.subs(s==x.series(rel, order), subs_options::no_pattern);
// maybe that was terminating, so add a proper order term
return factorial(x).hold();
}
+static void factorial_print_dflt_latex(const ex & x, const print_context & c)
+{
+ if (is_exactly_a<symbol>(x) ||
+ is_exactly_a<constant>(x) ||
+ is_exactly_a<function>(x)) {
+ x.print(c); c.s << "!";
+ } else {
+ c.s << "("; x.print(c); c.s << ")!";
+ }
+}
+
+static ex factorial_conjugate(const ex & x)
+{
+ return factorial(x);
+}
+
REGISTER_FUNCTION(factorial, eval_func(factorial_eval).
- evalf_func(factorial_evalf));
+ evalf_func(factorial_evalf).
+ print_func<print_dflt>(factorial_print_dflt_latex).
+ print_func<print_latex>(factorial_print_dflt_latex).
+ conjugate_func(factorial_conjugate));
//////////
// binomial
return binomial(x, y).hold();
}
+static ex binomial_sym(const ex & x, const numeric & y)
+{
+ if (y.is_integer()) {
+ if (y.is_nonneg_integer()) {
+ const unsigned N = y.to_int();
+ if (N == 0) return _ex0;
+ if (N == 1) return x;
+ ex t = x.expand();
+ for (unsigned i = 2; i <= N; ++i)
+ t = (t * (x + i - y - 1)).expand() / i;
+ return t;
+ } else
+ return _ex0;
+ }
+
+ return binomial(x, y).hold();
+}
+
static ex binomial_eval(const ex & x, const ex &y)
{
- if (is_exactly_a<numeric>(x) && is_exactly_a<numeric>(y))
- return binomial(ex_to<numeric>(x), ex_to<numeric>(y));
- else
+ if (is_exactly_a<numeric>(y)) {
+ if (is_exactly_a<numeric>(x) && ex_to<numeric>(x).is_integer())
+ return binomial(ex_to<numeric>(x), ex_to<numeric>(y));
+ else
+ return binomial_sym(x, ex_to<numeric>(y));
+ } else
return binomial(x, y).hold();
}
+// At the moment the numeric evaluation of a binomail function always
+// gives a real number, but if this would be implemented using the gamma
+// function, also complex conjugation should be changed (or rather, deleted).
+static ex binomial_conjugate(const ex & x, const ex & y)
+{
+ return binomial(x,y);
+}
+
REGISTER_FUNCTION(binomial, eval_func(binomial_eval).
- evalf_func(binomial_evalf));
+ evalf_func(binomial_evalf).
+ conjugate_func(binomial_conjugate));
//////////
// Order term function (for truncated power series)
return pseries(r, new_seq);
}
+static ex Order_conjugate(const ex & x)
+{
+ return Order(x);
+}
+
// Differentiation is handled in function::derivative because of its special requirements
REGISTER_FUNCTION(Order, eval_func(Order_eval).
series_func(Order_series).
- latex_name("\\mathcal{O}"));
+ latex_name("\\mathcal{O}").
+ conjugate_func(Order_conjugate));
//////////
// Solve linear system
git://www.ginac.de / ginac.git / blobdiff