Tc - Revision history

Arnaud Cheritat: /* Operator overloading */

2015-12-20T19:37:10Z

‎Operator overloading

Arnaud Cheritat: /* Derivatives */

2015-12-18T22:01:39Z

‎Derivatives

Arnaud Cheritat: /* Implementation */

2015-12-18T21:50:49Z

‎Implementation

Arnaud Cheritat: /* Implementation */

2015-12-18T21:44:44Z

‎Implementation

Arnaud Cheritat: /* Implementation */

2015-12-18T21:38:21Z

‎Implementation

Arnaud Cheritat: /* Implementation */

2015-12-18T21:37:45Z

‎Implementation

Arnaud Cheritat at 20:51, 18 December 2015

2015-12-18T20:51:33Z

Arnaud Cheritat: /* Operator overloading */

2015-12-18T20:32:05Z

‎Operator overloading

Arnaud Cheritat: /* Derivatives */

2014-02-27T21:56:26Z

‎Derivatives

Arnaud Cheritat: /* Derivatives */

2014-02-27T14:23:14Z

‎Derivatives

@@ Line 23: / Line 23: @@
 z=mul(u,mul(z,add(mul(z,z),add(cos(mul(c,z)),d))));
 </syntaxhighlight>
-or worse, with C
+or with C
 <syntaxhighlight lang="c">
 mul(w,c,z);

@@ Line 58: / Line 58: @@
 The tc objects compute derivatives for you!
 Say you defined Z=(z,1), computed W=cos(Z×Z) and got W=(a,b). Then a=cos(z×z) and b=the derivative ∂a/∂z at z: you did not need to determine that $\partial \cos(z^2)/\partial z=-2z\sin(z^2)$, the class computed b iteratively for you.
 == Implementation ==

@@ Line 65: / Line 65: @@
 The code below is a possible implementation.
 Only the functions I most use are implemented (not cosh, not ==, etc... for instance).
 It not optimized and there is no specific handling of division by 0 and overflow, which I imagine may be problematic.
 <syntaxhighlight>
 #include <complex>
 typedef double reel;
-typedef complex<reel> cplx;
+typedef std::complex<reel> cplx;
 class tc {

@@ Line 70: / Line 70: @@
 #include <complex>
-typedef double real;
+using namespace std;
-typedef complex<real> cplx;
 class tc {
@@ Line 86: / Line 88: @@
    // assigment operations : unlike math operations and math functions, they /have/ to belong to the class
    tc& operator=(const tc&);
-   const real& operator=(const real&);
+   const reel& operator=(const reel&);
    const cplx& operator=(const cplx&);
 };
@@ Line 115: / Line 117: @@
+}
-const real& tc::operator=(const real& r)
+const reel& tc::operator=(const reel& r)
+{
   z = r;
@@ Line 135: / Line 137: @@
+}
-tc operator*(const real& a, const tc& b) {
+tc operator*(const reel& a, const tc& b) {
   return tc(a*b.z, a*b.dz);
+}
-tc operator*(const tc& a, const real& b) {
+tc operator*(const tc& a, const reel& b) {
   return tc(a.z*b, a.dz*b);
+}
@@ Line 147: / Line 149: @@
+}
-tc operator+(const real& a, const tc& b) {
+tc operator+(const reel& a, const tc& b) {
   return tc(a+b.z,b.dz);
+}
-tc operator+(const tc& a, const real& b) {
+tc operator+(const tc& a, const reel& b) {
   return tc(a.z+b,a.dz);
+}
@@ Line 163: / Line 165: @@
+}
-tc operator-(const real& a, const tc& b) {
+tc operator-(const reel& a, const tc& b) {
   return tc(a-b.z,-b.dz);
+}
-tc operator-(const tc& a, const real& b) {
+tc operator-(const tc& a, const reel& b) {
   return tc(a.z-b,a.dz);
+}
@@ Line 175: / Line 177: @@
+}
-tc operator/(const real& a, const tc& b) {
+tc operator/(const reel& a, const tc& b) {
   return tc(a/b.z,-a*b.dz/(b.z*b.z));
+}
-tc operator/(const tc& a, const real& b) {
+tc operator/(const tc& a, const reel& b) {
   return tc(a.z/b,a.dz/b);
+}
@@ Line 208: / Line 210: @@
+}
-tc conj(const tc& a) { // CAUTION : here when interpreting the dz part, only real values of 'time' make sense
+tc conj(const tc& a) { // CAUTION : here when interpreting the dz part, only reel values of 'time' make sense
   return tc(conj(a.z), conj(a.dz));
+}

@@ Line 212: / Line 212: @@
+}
-static const complex I(0,1);
+static const cplx I(0,1);
 </syntaxhighlight>

← Older revision		Revision as of 21:37, 18 December 2015
Line 63:		Line 63:
	== Implementation ==		== Implementation ==

−	~~Either I will put~~ code ~~here or~~ a ~~link~~ to ~~download~~ code.	+	The code below is a possible implementation.
		+	Only the functions I most use are implemented (not cosh, not ==, etc... for instance).
		+	It not optimized and there is no specific handling of division by 0 and overflow, which I imagine may be problematic.
		+
		+	<syntaxhighlight>
		+	#include <complex>
		+
		+	typedef double real;
		+	typedef complex<real> cplx;
		+
		+	class tc {
		+	public : // all the members below are accessible by users of the package
		+	// data members
		+	cplx z;
		+	cplx dz;
		+	// member functions (declarations only, the code is given below*)
		+	// *: for this C++ unses the following (ugly) syntax
		+	// return-type class-name::function-name(parameters) { code; }
		+	// constructors
		+	tc(cplx=cplx(0,0), cplx=cplx(0,0)); // default constructor
		+	tc(const tc&); // copy constructor
		+	// assigment operations : unlike math operations and math functions, they /have/ to belong to the class
		+	tc& operator=(const tc&);
		+	const real& operator=(const real&);
		+	const cplx& operator=(const cplx&);
		+	};
		+
		+	// now we give the code of the member functions
		+
		+	// a constructor
		+	tc::tc(cplx point, cplx vecteur)
		+	{
		+	z = point;
		+	dz = vecteur;
		+	}
		+
		+	// the copy constructor
		+	tc::tc(const tc& t)
		+	{
		+	z = t.z;
		+	dz = t.dz;
		+	}
		+
		+	// assignment operators
		+
		+	tc& tc::operator=(const tc& t)
		+	{
		+	z = t.z;
		+	dz = t.dz;
		+	return *this;
		+	}
		+
		+	const real& tc::operator=(const real& r)
		+	{
		+	z = r;
		+	dz = 0;
		+	return r;
		+	}
		+
		+	const cplx& tc::operator=(const cplx& c)
		+	{
		+	z = c;
		+	dz = 0;
		+	return c;
		+	}
		+
		+	// non-member functions : usual math operators and math functions
		+
		+	tc operator*(const tc& a, const tc& b) {
		+	return tc(a.zb.z, a.zb.dz+a.dz*b.z);
		+	}
		+
		+	tc operator*(const real& a, const tc& b) {
		+	return tc(ab.z, ab.dz);
		+	}
		+
		+	tc operator*(const tc& a, const real& b) {
		+	return tc(a.zb, a.dzb);
		+	}
		+
		+	tc operator+(const tc& a, const tc& b) {
		+	return tc(a.z+b.z,a.dz+b.dz);
		+	}
		+
		+	tc operator+(const real& a, const tc& b) {
		+	return tc(a+b.z,b.dz);
		+	}
		+
		+	tc operator+(const tc& a, const real& b) {
		+	return tc(a.z+b,a.dz);
		+	}
		+
		+	tc operator-(const tc& a) {
		+	return tc(-a.z,-a.dz);
		+	}
		+
		+	tc operator-(const tc& a, const tc& b) {
		+	return tc(a.z-b.z,a.dz-b.dz);
		+	}
		+
		+	tc operator-(const real& a, const tc& b) {
		+	return tc(a-b.z,-b.dz);
		+	}
		+
		+	tc operator-(const tc& a, const real& b) {
		+	return tc(a.z-b,a.dz);
		+	}
		+
		+	tc operator/(const tc& a, const tc& b) {
		+	return tc(a.z/b.z,a.dz/b.z-a.zb.dz/(b.zb.z));
		+	}
		+
		+	tc operator/(const real& a, const tc& b) {
		+	return tc(a/b.z,-ab.dz/(b.zb.z));
		+	}
		+
		+	tc operator/(const tc& a, const real& b) {
		+	return tc(a.z/b,a.dz/b);
		+	}
		+
		+	tc exp(const tc& a) {
		+	cplx aux=exp(a.z);
		+	return tc(aux,aux*a.dz);
		+	}
		+
		+	tc sin(const tc& a) {
		+	return((exp(atc(0,1))-exp(atc(0,-1)))*tc(0,-0.5));
		+	}
		+
		+	tc cos(const tc& a) {
		+	return((exp(atc(0,1))+exp(atc(0,-1)))*0.5);
		+	}
		+
		+	tc tan(const tc& a) {
		+	return(sin(a)/cos(a));
		+	}
		+
		+	tc log(const tc& a) {
		+	return tc(log(a.z),a.dz/a.z);
		+	}
		+
		+	tc sqrt(const tc& a) {
		+	return exp(0.5*log(a));
		+	}
		+
		+	tc conj(const tc& a) { // CAUTION : here when interpreting the dz part, only real values of 'time' make sense
		+	return tc(conj(a.z), conj(a.dz));
		+	}
		+
		+	static const complex I(0,1);
		+	</syntaxhighlight>

@@ Line 1: / Line 1: @@
-This is a very useful tool, especially for distance estimator methods.
+A tc is a data structure encoding a complex number and a variation of this number. The operations I define on these numbers are the same as most operations on complex numbers.
-A tc is a complex number z together with a complex vector dz attached to.
+== Overview ==
 The notation dz is probably not the best but it is to mimic physicist notation, like
 \[(z+dz)\times(w+dw)=w\,z+(w\,dz+z\,dw)+\text{neglected}\]
 or
 \[\cos(z+dz)=\cos(z)-\sin(z)dz.\]
 == Operator overloading ==
@@ Line 32: / Line 36: @@
 == Operations ==
-One defines
+One defines operations on tc objects as follows:
 \[(z,dz) + (w,dw) = (z+w,dz+dw)\]
 \[(z,dz) \times (w,dw) = (z\,w,w\,dz+z\,dw)\]
@@ Line 48: / Line 52: @@
 In other words it is an element in the tangent space TC of the complex numbers field C.
 This is why I chose the name tc for the C++ class.
-It can also be considered as 1-jets (can be generalized to higher degree power series expansions, like $(z,b,c)$ representing $z(t)=z+b\,t+c\,t^2+o(t^2)$).
+It can also be considered as 1-jets (can be generalized to higher degree power series expansions, like the $(z,b,c)$ being a 2-jet representing $z(t)=z+b\,t+c\,t^2+o(t^2)$).
 == Derivatives ==
-It computes derivatives for you.
+The tc objects compute derivatives for you!
 Say you defined Z=(z,1), computed W=cos(Z×Z) and got W=(a,b). Then a=cos(z×z) and b=the derivative ∂a/∂z at z: you did not need to determine that $\partial \cos(z^2)/\partial z=-2z\sin(z^2)$, the class computed b iteratively for you.

@@ Line 11: / Line 11: @@
 C++ allows [https://en.wikipedia.org/wiki/Operator_overloading operator overloading]. In other words, you can use instructions like d=c+a*b in your programs, with any kind type of objects for a,b,c,d.
-This is why it is much easier to program with complex numbers in C++ than in Java for instance. Compare C++
+This is why it is much easier to program with complex numbers in C++ than in many other languages. Compare C++
 <syntaxhighlight lang="cpp">
 z=u*z*(z*z+cos(c*z)+d);
 </syntaxhighlight>
-with Java
+with Java (no operator overloading)
 <syntaxhighlight lang="java">
 z=mul(u,mul(z,add(mul(z,z),add(cos(mul(c,z)),d))));

@@ Line 54: / Line 54: @@
 It computes derivatives for you.
-Say you defined Z=(z,1) and computed W=cos(Z×Z). Then you get W=(a,b) with a=cos(z×z) and b= the derivative $\partial a/\partial z$.: you did not need to determine that $\partial \cos(z^2)/\partial z=-2z\sin(z^2)$, the class computed b iteratively for you.
+Say you defined Z=(z,1) and computed W=cos(Z×Z). Then you get W=(a,b) with a=cos(z×z) and b= the derivative $\partial a/\partial z$: you did not need to determine that $\partial \cos(z^2)/\partial z=-2z\sin(z^2)$, the class computed b iteratively for you.
 == Implementation ==
 Either I will put code here or a link to download code.