- GiNaC-list - ginac.de

substitute for step ( wild ( ) ) function derivative
by jros 17 Sep '09

17 Sep '09

Hello, If I derive step I obtain D[0](step). I want to substitute for D[0](step)--> 0 to get a particular behavior. What should I do? (e.subs(D[0](step)(wild()) == 0) can't be understand diff(step(wild()),wild()) neither. Any clues. By the way I'm assuming that the step function is the Heaviside function ( step(x)=0 if x<0; 1 otherwise I'm assuming a real argument) . Thank you in advance. Javier

2 3

Ordering and pattern matching
by Chris Kelly 01 Sep '09

01 Sep '09

Dear all, I am new to GiNaC and am currently trying to get to grips with the clifford algebra classes. I am trying to perform the simple substitution: A_mu gamma_mu B_nu gamma_nu = A_mu A_nu delta_mu,nu (Euclidean space). The problem i am having is that the pattern match is not consistent over repeated use of the executable: sometimes the pattern will match, at other times it will not. It looks to me that this is related to the ordering of the expressions. Here is some example code: ------------------------------ ----------------------------------------------------------------------------------------------------- #include<iostream> #include<vector> #include<sstream> #include<ginac/ginac.h> using namespace std; using namespace GiNaC; //Aim is to identify A_mu gamma_mu B_nu gamma_nu == A_mu B_nu delta_mu,nu int main(){ ex metric = unit_matrix(4); idx i(symbol("i"),4) , j(symbol("j"),4); ex al_i = clifford_unit(i,metric); //Use generalised clifford gamma matrices for euclidean space ex al_j = clifford_unit(j,metric); //Create generic 'slashed' symbols with euclidean metric ex s1 = indexed(symbol("A"),i)*al_i; ex s2 = indexed(symbol("B"),j)*al_j; //Form the product ex prod = s1*s2; cout << s1*s2 << endl; //Attempt to match to patterns idx w1(wild(1),4), w2(wild(2),4); indexed in2_w1 = indexed(wild(2),w1); indexed in3_w2 = indexed(wild(3),w2); ex al_w1 = clifford_unit(w1,metric); ex al_w2 = clifford_unit(w2,metric); ex spat2_w1 = in2_w1*al_w1; ex spat3_w2 = in3_w2*al_w2; ex mpat = spat2_w1 * spat3_w2; cout << "MATCHING TO PATTERN: " << mpat << endl; cout << prod.match(mpat) << endl; ex mpat2 = in2_w1 * in3_w2 * al_w1 * al_w2; cout << "MATCHING TO PATTERN: " << mpat2 << endl; cout << prod.match(mpat2) << endl; ex mpat3 = in3_w2 * in2_w1 * al_w1 * al_w2; cout << "MATCHING TO PATTERN: " << mpat3 << endl; cout << prod.match(mpat3) << endl; return 0; } ----------------------------------------------------------- The output of this example is as follows: B.j*(e.i*e.j)*A.i <----- matching this against pattern MATCHING TO PATTERN: (e.($1)*e.($2))*$3.($2)*$2.($1) 0 MATCHING TO PATTERN: (e.($1)*e.($2))*$3.($2)*$2.($1) 0 MATCHING TO PATTERN: (e.($1)*e.($2))*$3.($2)*$2.($1) 0 So the expressions seem to all be reordered consistently, but in a different ordering to the object to which we wish to match. If i then add more code, reproducing the above code for the first pattern but using different wildcard indices: ----------------------------------------------------------- //Create new indices, perhaps hash ordering will be correct for these? idx w4(wild(4),4), w5(wild(5),4); indexed in2_w4 = indexed(wild(2),w4); indexed in3_w5 = indexed(wild(3),w5); ex al_w4 = clifford_unit(w4,metric); ex al_w5 = clifford_unit(w5,metric); ex spat2_w4 = in2_w4*al_w4; ex spat3_w5 = in3_w5*al_w5; ex mpat4 = spat2_w4 * spat3_w5; cout << "MATCHING TO PATTERN: " << mpat4 << endl; cout << prod.match(mpat4) << endl; ---------------------------------------------------------- The output sometimes (but not always) matches: First run: (object to match output as B.j*(e.i*e.j)*A.i ) MATCHING TO PATTERN: $2.($4)*(e.($4)*e.($5))*$3.($5) 0 Second run: (object to match output as (e.i*e.j)*B.j*A.i ) MATCHING TO PATTERN: (e.($4)*e.($5))*$3.($5)*$2.($4) 1 Third run: (object to match output as B.j*(e.i*e.j)*A.i ) <---- notice this is the same as the first run MATCHING TO PATTERN: (e.($4)*e.($5))*$3.($5)*$2.($4) 1 So for some reason the pattern matching is ordering dependent in a way that cannot be controlled. Strangely even if the pattern matches for a given run, the substitution code ------------------------------------------------- //Pattern sometimes matches, try a substitution for identity ex ident = in2_w4 * in3_w5 * delta_tensor(w4,w5); cout << "SUBSTITUTION RESULT:" << prod.subs(mpat4==ident) << endl; cout << "SUBSTITUTION RESULT (ALGEBRAIC):" << prod.subs(mpat4==ident,subs_options::algebraic) << endl; -------------------------------------------------- always seems to fail (or is ignored?) Second run: (object to match output as (e.i*e.j)*B.j*A.i ) SUBSTITUTION RESULT:(e.i*e.j)*B.j*A.i SUBSTITUTION RESULT (ALGEBRAIC):(e.i*e.j)*B.j*A.i Third run: (object to match output as B.j*(e.i*e.j)*A.i ) SUBSTITUTION RESULT:B.j*(e.i*e.j)*A.i SUBSTITUTION RESULT (ALGEBRAIC):B.j*(e.i*e.j)*A.i Does anyone know how to solve these issues? Thanks, Chris K

2 3

Ordering and pattern matching
by Chris Kelly 26 Aug '09

26 Aug '09

Dear all, I am new to GiNaC and am currently trying to get to grips with the clifford algebra classes. I am trying to perform the simple substitution: A_mu gamma_mu B_nu gamma_nu = A_mu A_nu delta_mu,nu (Euclidean space). The problem i am having is that the pattern match is not consistent over repeated use of the executable: sometimes the pattern will match, at other times it will not. It looks to me that this is related to the ordering of the expressions. Here is some example code: ----------------------------------------------------------------------------------------------------------------------------------- #include<iostream> #include<vector> #include<sstream> #include<ginac/ginac.h> using namespace std; using namespace GiNaC; //Aim is to identify A_mu gamma_mu B_nu gamma_nu == A_mu B_nu delta_mu,nu int main(){ ex metric = unit_matrix(4); idx i(symbol("i"),4) , j(symbol("j"),4); ex al_i = clifford_unit(i,metric); //Use generalised clifford gamma matrices for euclidean space ex al_j = clifford_unit(j,metric); //Create generic 'slashed' symbols with euclidean metric ex s1 = indexed(symbol("A"),i)*al_i; ex s2 = indexed(symbol("B"),j)*al_j; //Form the product ex prod = s1*s2; cout << s1*s2 << endl; //Attempt to match to patterns idx w1(wild(1),4), w2(wild(2),4); indexed in2_w1 = indexed(wild(2),w1); indexed in3_w2 = indexed(wild(3),w2); ex al_w1 = clifford_unit(w1,metric); ex al_w2 = clifford_unit(w2,metric); ex spat2_w1 = in2_w1*al_w1; ex spat3_w2 = in3_w2*al_w2; ex mpat = spat2_w1 * spat3_w2; cout << "MATCHING TO PATTERN: " << mpat << endl; cout << prod.match(mpat) << endl; ex mpat2 = in2_w1 * in3_w2 * al_w1 * al_w2; cout << "MATCHING TO PATTERN: " << mpat2 << endl; cout << prod.match(mpat2) << endl; ex mpat3 = in3_w2 * in2_w1 * al_w1 * al_w2; cout << "MATCHING TO PATTERN: " << mpat3 << endl; cout << prod.match(mpat3) << endl; return 0; } ----------------------------------------------------------- The output of this example is as follows: B.j*(e.i*e.j)*A.i <----- matching this against pattern MATCHING TO PATTERN: (e.($1)*e.($2))*$3.($2)*$2.($1) 0 MATCHING TO PATTERN: (e.($1)*e.($2))*$3.($2)*$2.($1) 0 MATCHING TO PATTERN: (e.($1)*e.($2))*$3.($2)*$2.($1) 0 So the expressions seem to all be reordered consistently, but in a different ordering to the object to which we wish to match. If i then add more code, reproducing the above code for the first pattern but using different wildcard indices: ----------------------------------------------------------- //Create new indices, perhaps hash ordering will be correct for these? idx w4(wild(4),4), w5(wild(5),4); indexed in2_w4 = indexed(wild(2),w4); indexed in3_w5 = indexed(wild(3),w5); ex al_w4 = clifford_unit(w4,metric); ex al_w5 = clifford_unit(w5,metric); ex spat2_w4 = in2_w4*al_w4; ex spat3_w5 = in3_w5*al_w5; ex mpat4 = spat2_w4 * spat3_w5; cout << "MATCHING TO PATTERN: " << mpat4 << endl; cout << prod.match(mpat4) << endl; ---------------------------------------------------------- The output sometimes (but not always) matches: First run: (object to match output as B.j*(e.i*e.j)*A.i ) MATCHING TO PATTERN: $2.($4)*(e.($4)*e.($5))*$3.($5) 0 Second run: (object to match output as (e.i*e.j)*B.j*A.i ) MATCHING TO PATTERN: (e.($4)*e.($5))*$3.($5)*$2.($4) 1 Third run: (object to match output as B.j*(e.i*e.j)*A.i ) <---- notice this is the same as the first run MATCHING TO PATTERN: (e.($4)*e.($5))*$3.($5)*$2.($4) 1 So for some reason the pattern matching is ordering dependent in a way that cannot be controlled. Strangely even if the pattern matches for a given run, the substitution code ------------------------------------------------- //Pattern sometimes matches, try a substitution for identity ex ident = in2_w4 * in3_w5 * delta_tensor(w4,w5); cout << "SUBSTITUTION RESULT:" << prod.subs(mpat4==ident) << endl; cout << "SUBSTITUTION RESULT (ALGEBRAIC):" << prod.subs(mpat4==ident,subs_options::algebraic) << endl; -------------------------------------------------- always seems to fail (or is ignored?) Second run: (object to match output as (e.i*e.j)*B.j*A.i ) SUBSTITUTION RESULT:(e.i*e.j)*B.j*A.i SUBSTITUTION RESULT (ALGEBRAIC):(e.i*e.j)*B.j*A.i Third run: (object to match output as B.j*(e.i*e.j)*A.i ) SUBSTITUTION RESULT:B.j*(e.i*e.j)*A.i SUBSTITUTION RESULT (ALGEBRAIC):B.j*(e.i*e.j)*A.i Does anyone know how to solve these issues? Thanks, Chris K

2 2

Ordering of expressions
by Luigi Capozza 12 Aug '09

12 Aug '09

Dear people, I have the following issue with the canonicalization of expressions. If I run many times the same program without changing anything, I get the output for the same expression ordered in different ways. As far as I understand, that seems to depend on the hash value that is assigned to each symbol, which happens to be different every time I run the program. Here is an example (example.cxx): ------------------------------------------ #include <iostream> #include "ginac/ginac.h" using namespace std; using namespace GiNaC; int main() { symbol x("x"),y("y"),z("z"); ex Ex1 = 2*(x + y); ex Ex2 = z*(x + y); cout<<x.gethash()<<endl <<y.gethash()<<endl <<z.gethash()<<endl; cout<<Ex1<<endl <<Ex2<<endl; return 0; } ------------------------------------------ And here is the output I get (I am running on Ubuntu 8.04.1 with the GCC 4.2.4 compiler): -------------------------------------------------- =>g++ -lginac example.cxx -o example =>example 2178355982 851138097 3818887508 2*y+2*x (y+x)*z =>example 3784401678 2457183793 1129965908 2*y+2*x (y+x)*z =>example 2632340238 1305122353 4272871764 2*y+2*x (y+x)*z =>example 3711329038 2384111153 1056893268 2*y+2*x z*(y+x) => ... -------------------------------------------------- With more complicated expressions also the run time can vary from execution to execution up to a factor of 2 or more. Is this normal or am I doing something wrong? I saw that the hash value is calculated in a fairly sophisticated manner but is it eventually possible to set it by hand? Thanks in advance. Regards, Luigi

4 9

Release GiNaC 1.5.3
by Jens Vollinga 30 Jul '09

30 Jul '09

Hi everybody, GiNaC 1.5.3 is out and available. The changes are: * The parser now understands user-defined functions by default. The parsed identifier names can now contain underscores. As always, this release can be downloaded from http://www.ginac.de/Download.html Best wishes, Jens

1 0

(no subject)
by Michael Hoffmann 30 Jul '09

30 Jul '09

Hello, i'm using Ubuntu 9.04 with g++. I installed Ginac with Synaptik (.deb Packeges), I also installed cln pakeges. But it doesn't works! :) Here is the bug message: g++ -o simple_function simple_function.o -lginac simple_function.o: In function `__static_initialization_and_destruction_0': /usr/local/include/ginac/archive.h:174: undefined reference to `GiNaC::unarchive_table_t::unarchive_table_t()' /usr/local/include/ginac/archive.h:174: undefined reference to `GiNaC::unarchive_table_t::~unarchive_table_t()' simple_function.o: In function `__static_initialization_and_destruction_0': /usr/local/include/ginac/lst.h:45: undefined reference to `GiNaC::lst_unarchiver::lst_unarchiver()' /usr/local/include/ginac/lst.h:45: undefined reference to `GiNaC::lst_unarchiver::~lst_unarchiver()' simple_function.o: In function `__static_initialization_and_destruction_0': /usr/local/include/ginac/constant.h:80: undefined reference to `GiNaC::constant_unarchiver::constant_unarchiver()' /usr/local/include/ginac/constant.h:80: undefined reference to `GiNaC::constant_unarchiver::~constant_unarchiver()' simple_function.o: In function `__static_initialization_and_destruction_0': /usr/local/include/ginac/fail.h:44: undefined reference to `GiNaC::fail_unarchiver::fail_unarchiver()' /usr/local/include/ginac/fail.h:44: undefined reference to `GiNaC::fail_unarchiver::~fail_unarchiver()' simple_function.o: In function `__static_initialization_and_destruction_0': /usr/local/include/ginac/integral.h:82: undefined reference to `GiNaC::integral_unarchiver::integral_unarchiver()' /usr/local/include/ginac/integral.h:82: undefined reference to `GiNaC::integral_unarchiver::~integral_unarchiver()' simple_function.o: In function `__static_initialization_and_destruction_0': /usr/local/include/ginac/matrix.h:178: undefined reference to `GiNaC::matrix_unarchiver::matrix_unarchiver()' /usr/local/include/ginac/matrix.h:178: undefined reference to `GiNaC::matrix_unarchiver::~matrix_unarchiver()' simple_function.o: In function `__static_initialization_and_destruction_0': /usr/local/include/ginac/numeric.h:206: undefined reference to `GiNaC::numeric_unarchiver::numeric_unarchiver()' /usr/local/include/ginac/numeric.h:206: undefined reference to `GiNaC::numeric_unarchiver::~numeric_unarchiver()' simple_function.o: In function `__static_initialization_and_destruction_0': ... i don't understand what he needs, cause i have the same system (Ubuntu 9.04) and the same installation of Ginac at work and it works. I already tried to uninstall and to install new one more time - nothing changes! Please HELP!!!

2 1

a function without any arguments with GiNaC?
by Michael Hoffmann 27 Jul '09

27 Jul '09

Hallo, how can I make a function without any arguments with GiNaC? I just need a function returned a symbolic matrix. It's the same matrix every time. How I have to declare such a function? minimal example: #include <stdio.h> #include <stdlib.h> #include <iostream> #include <math.h> #include <ginac/ginac.h> using namespace std; using namespace GiNaC; REGISTER_FUNCTION (symbolic_matrix, dummy()); { symbol a("a"), b("b"), c("c"); GiNaC::matrix D(2,2), E(2,2); D = a, b, 0, c; E = sin(a), cos(b), -sin(c), cos(a); GiNaC::ex h = D.mul(E) ; return h; } Thank you very match, Michael Hoffmann P.S. : sorry for my english!

2 1

Indefinite integration support
by Jorge Cardona 16 Jul '09

16 Jul '09

Hi, I recently wrote a code that will let define a entity that represents a indefinite integral, i called iintegral, basically i took the integral class, and remove the integration range, then i add to the function.pl extra code to define a new option on function, called iintegral_func, with that is possible to define the indefinite integral of a function when we define the function itself. I want to know if you like that idea and if you have some extra comment on this part. Look a definition of a function on inifcns_trans : static ex log_iinteg(const ex & x, unsigned iinteg_param) { GINAC_ASSERT(iinteg_param==0); // int {log(x)} -> x * (log (x) - 1) return x * (log (x) - _ex1); } .... REGISTER_FUNCTION(log, eval_func(log_eval). evalf_func(log_evalf). derivative_func(log_deriv). iintegral_func(log_iinteg). series_func(log_series). real_part_func(log_real_part). imag_part_func(log_imag_part). latex_name("\\ln")); ... Right now i call the iintegral constructor with 2 arguments, the integrand expression and the integration variable (the integration variable remains after the indefinite integral, is not as dummy as in the definite integral), and this iintegral instance remains until the eval_integ is called, which in a future (near future i hope) will have a better algorithm to integrate the expression, but right now just have the code that integrate a polynomial expression and a code that check if the expression is a functions, and if that function has an integral defined it also check if the argument is equal to the integration variable, and then call that function, if any of this don't match it return the iintegral object. I want to know what do you think about that way, or if you have some extra ideas, basically i want to implement the integration algorithm, but don't want to have some code that wont be added to GiNaC, so, please let me know your comments. Code on function::iintegral : ex function::iintegral(const symbol & s) const { GINAC_ASSERT(serial<registered_functions().size()); const function_options &opt = registered_functions()[serial]; // No iintegral defined? Then return abstract iintegral object if (opt.iintegral_f == NULL) return GiNaC::iintegral(s,this->eval()); size_t iinteg_param = -1; size_t num = seq.size(); for (size_t i=0; i<num; i++) { ex a = s; ex b = seq[i]; if(a.is_equal(b)) { iinteg_param = i; break; } } current_serial = serial; if (opt.iintegral_use_exvector_args) return ((iintegral_funcp_exvector)(opt.iintegral_f))(seq, iinteg_param); if(iinteg_param < 0) throw(std::logic_error("Composed functions on integral.")); switch (opt.nparams) { // the following lines have been generated for max. 14 parameters case 1: return ((iintegral_funcp_1)(opt.iintegral_f))(seq[1-1],iinteg_param); case 2: return ((iintegral_funcp_2)(opt.iintegral_f))(seq[1-1], seq[2-1],iinteg_param); case 3: return ((iintegral_funcp_3)(opt.iintegral_f))(seq[1-1], seq[2-1], seq[3-1],iinteg_param); case 4: return ((iintegral_funcp_4)(opt.iintegral_f))(seq[1-1], seq[2-1], seq[3-1], seq[4-1],iinteg_param); ...(Go with more arguments) Code on iintegral::eval_integ(): ex iintegral::eval_integ() const { if (!(flags & status_flags::expanded)) return this->expand().eval_integ(); if (f==x) return x*x/2; if (is_a<power>(f) && f.op(0)==x) { if (f.op(1)==-1) return log(x); if (!f.op(1).has(x)) { ex primit = power(x,f.op(1)+1)/(f.op(1)+1); return primit; } } if (is_a<function>(f)) { function fun = ex_to<function>(f); // TODO: Change the signature. return fun.iintegral(ex_to<symbol>(x)); } return *this; } There is a patch at: http://wiki.scilab.org/Gsoc2009Symbolic?action=AttachFile&do=get&target=Ext… This is a little code test: #include "ginac/ginac.h" using namespace std; using namespace GiNaC; int main() { symbol x("x"); ex f,g,h; f = 2*x; cout << f << endl; g = iintegral(x,f); cout << g << endl; h = g.eval_integ(); cout << h << endl; f = 2*sin(x) + exp(x) + log(x); cout << f << endl; g = iintegral(x,f); cout << g << endl; h = g.eval_integ(); cout << h << endl; } That returns: jcardona@terminus:~/stuff/personal/symbolic/spikes/Integrals$ ./test 2*x iintegral(x,2*x) x^2 exp(x)+log(x)+2*sin(x) iintegral(x,exp(x)+log(x)+2*sin(x)) exp(x)-2*cos(x)+(-1+log(x))*x Bye. -- Jorge Eduardo Cardona jorgeecardona(a)gmail.com jorgeecardona.blogspot.com ------------------------------------------------ Linux registered user #391186 Registered machine #291871 ------------------------------------------------

2 1

Release GiNaC 1.5.2
by Jens Vollinga 11 Jul '09

11 Jul '09

Hi everybody, GiNaC 1.5.2 is out and available. The changes are: * Fixed documentation of return_type_info(). * Fixed cstdio include issue. * GiNaC now requires at least version 1.2.2 of cln. As always, this release can be downloaded from http://www.ginac.de/Download.html Best wishes, Jens _______________________________________________ GiNaC-list mailing list GiNaC-list(a)ginac.de https://www.cebix.net/mailman/listinfo/ginac-list

1 0

legendre and chebyshev polynomials
by Jorge Cardona 10 Jul '09

10 Jul '09

Hi, i'm working in three classes to generate the legendre polynomial, and the chebyshev of first and second kind, in chebyshev i define the derivative in terms of chebyshev polynomials, but it get messy when is expanded because the polynomials at numerator and denominator are not factorized, and then the expression is complex that it should. What do you think is better, to let the derivatives of the polynomials in terms on the same polynomials, and expaned as like the users, or always expand at the derivative and return the polynomial expanded at the derivative (as in the legendre polynomial)? This is the code: / Chebyshev polynomial of first kind class chebyshev_1 : public basic { GINAC_DECLARE_REGISTERED_CLASS(chebyshev_1, basic) public: // Constructor of chebyshev of first kind chebyshev_1(numeric n, symbol x); ex derivative(const symbol & s) const; ex expand(unsigned options) const; protected: void do_print(const print_context & c, unsigned level = 0) const; private: numeric n; symbol x; }; // Chebyshev polynomial of second kind class chebyshev_2 : public basic { GINAC_DECLARE_REGISTERED_CLASS(chebyshev_2, basic) public: // Constructor of chebyshev of first kind chebyshev_2(numeric n, symbol x); ex derivative(const symbol & s) const; ex expand(unsigned options) const; protected: void do_print(const print_context & c, unsigned level = 0) const; private: numeric n; symbol x; }; // Legendre polynomial class legendre : public basic { GINAC_DECLARE_REGISTERED_CLASS(legendre, basic) public: // Constructor of chebyshev of first kind legendre(numeric n, symbol x); ex derivative(const symbol & s) const; ex expand(unsigned options) const; protected: void do_print(const print_context & c, unsigned level = 0) const; private: numeric n; symbol x; }; /*************************************************************** * Chebyshev polynomial of first kind ****************************************************************/ GINAC_IMPLEMENT_REGISTERED_CLASS_OPT(chebyshev_1, basic, print_func<print_context>(&chebyshev_1::do_print)) // Default constructor chebyshev_1::chebyshev_1() {} // Print the function void chebyshev_1::do_print(const print_context & c, unsigned level) const { c.s << "Tn(" << n << "," << x << ")"; } int chebyshev_1::compare_same_type(const basic & other) const { const chebyshev_1 &o = static_cast<const chebyshev_1 &>(other); if (x.is_equal(o.x) and (n == o.n)) return 0; return 1; } ex chebyshev_1::expand(unsigned options) const { if (n == 0) return 1; if (n == 1) return x; exvector e; numeric m = n / 2; if (n.is_odd()) m = (n-1)/2; e.reserve(m.to_long()); ex tmp = pow(2 * x,n) / 2; e.push_back(tmp); for(numeric i = 1; i <= m; i++) { tmp *= -(n - 2*i + 2) * (n - 2*i + 1); tmp /= (4 * i * pow(x,2) * (n-i)); e.push_back(tmp); } return add(e); } ex chebyshev_1::derivative(const symbol & s) const { if(s.is_equal(x) and (n!=0)) return n * chebyshev_2(n-1,x); return 0; } chebyshev_1::chebyshev_1(numeric n, symbol x) : n(n), x(x){} /*************************************************************** * Chebyshev polynomial of second kind ****************************************************************/ GINAC_IMPLEMENT_REGISTERED_CLASS_OPT(chebyshev_2, basic, print_func<print_context>(&chebyshev_2::do_print)) // Default constructor chebyshev_2::chebyshev_2() {} // Print the function void chebyshev_2::do_print(const print_context & c, unsigned level) const { c.s << "Un(" << n << "," << x << ")"; } int chebyshev_2::compare_same_type(const basic & other) const { const chebyshev_2 &o = static_cast<const chebyshev_2 &>(other); if (x.is_equal(o.x) and (n == o.n)) return 0; return 1; } ex chebyshev_2::expand(unsigned options) const { if (n == 0) return 1; if (n == 1) return 2*x; exvector e; numeric m = n / 2; if (n.is_odd()) m = (n-1)/2; e.reserve(m.to_long()); ex tmp = pow(2 * x,n); e.push_back(tmp); for(numeric i = 1; i <= m; i++) { tmp *= -(n - 2*i + 2) * (n - 2*i + 1); tmp /= (4 * i * pow(x,2) * (n - i + 1)); e.push_back(tmp); } return add(e); } ex chebyshev_2::derivative(const symbol & s) const { if(s.is_equal(x) and (n!=0)) return ((n+1) * chebyshev_1(n+1,x) - x * chebyshev_2(n,x)) / (pow(x,2) - 1); return 0; } chebyshev_2::chebyshev_2(numeric n, symbol x) : n(n), x(x){} /*************************************************************** * Legendre polynomial ****************************************************************/ GINAC_IMPLEMENT_REGISTERED_CLASS_OPT(legendre, basic, print_func<print_context>(&legendre::do_print)) // Default constructor legendre::legendre() {} // Print the function void legendre::do_print(const print_context & c, unsigned level) const { c.s << "Pn(" << n << "," << x << ")"; } int legendre::compare_same_type(const basic & other) const { const legendre &o = static_cast<const legendre &>(other); if (x.is_equal(o.x) and (n == o.n)) return 0; return 1; } ex legendre::expand(unsigned options) const { if (n == 0) return 1; if (n == 1) return x; exvector e; numeric m = n / 2; if (n.is_odd()) m = (n-1)/2; e.reserve(m.to_long()); ex tmp = factorial(2*n) * pow(x,n) /(pow(2,n) * pow(factorial(n),2)); e.push_back(tmp); for(numeric i = 1; i <= m; i++) { tmp *= -(n - 2 * i + 1) * (n - 2 * i + 2); tmp /= (4 * n -4 * i + 2) * i * pow(x,2); e.push_back(tmp); } return add(e); } ex legendre::derivative(const symbol & s) const { return (this->expand(0)).diff(s); //if(s.is_equal(x) and (n!=0)) // return ((n+1) * chebyshev_1(n+1,x) - x * legendre(n,x)) / (pow(x,2) - 1); //return 0; } legendre::legendre(numeric n, symbol x) : n(n), x(x){} -- Jorge Eduardo Cardona jorgeecardona(a)gmail.com jorgeecardona.blogspot.com ------------------------------------------------ Linux registered user #391186 Registered machine #291871 ------------------------------------------------

2 2