CRLF fix

(bzr r4247)

1 files changed, 489 insertions, 489 deletions

diff --git a/src/2geom/sbasis.cpp b/src/2geom/sbasis.cpp
index 5bf0d2876..7157bc885 100644
--- a/src/2geom/sbasis.cpp
+++ b/src/2geom/sbasis.cpp
@@ -1,490 +1,490 @@
-/*

- *  sbasis.cpp - S-power basis function class + supporting classes

- *

- *  Authors:

- *   Nathan Hurst <njh@mail.csse.monash.edu.au>

- *   Michael Sloan <mgsloan@gmail.com>

- *

- * Copyright (C) 2006-2007 authors

- *

- * This library is free software; you can redistribute it and/or

- * modify it either under the terms of the GNU Lesser General Public

- * License version 2.1 as published by the Free Software Foundation

- * (the "LGPL") or, at your option, under the terms of the Mozilla

- * Public License Version 1.1 (the "MPL"). If you do not alter this

- * notice, a recipient may use your version of this file under either

- * the MPL or the LGPL.

- *

- * You should have received a copy of the LGPL along with this library

- * in the file COPYING-LGPL-2.1; if not, write to the Free Software

- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

- * You should have received a copy of the MPL along with this library

- * in the file COPYING-MPL-1.1

- *

- * The contents of this file are subject to the Mozilla Public License

- * Version 1.1 (the "License"); you may not use this file except in

- * compliance with the License. You may obtain a copy of the License at

- * http://www.mozilla.org/MPL/

- *

- * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY

- * OF ANY KIND, either express or implied. See the LGPL or the MPL for

- * the specific language governing rights and limitations.

- */

-

-#include <cmath>

-

-#include "sbasis.h"

-#include "isnan.h"

-

-namespace Geom{

-

-/*** At some point we should work on tighter bounds for the error.  It is clear that the error is

- * bounded by the L1 norm over the tail of the series, but this is very loose, leading to far too

- * many cubic beziers.  I've changed this to be \sum _i=tail ^\infty |hat a_i| 2^-i but I have no

- * evidence that this is correct.

- */

-

-/*

-double SBasis::tail_error(unsigned tail) const {

-    double err = 0, s = 1./(1<<(2*tail)); // rough

-    for(unsigned i = tail; i < size(); i++) {

-        err += (fabs((*this)[i][0]) + fabs((*this)[i][1]))*s;

-        s /= 4;

-    }

-    return err;

-}

+/*
+ *  sbasis.cpp - S-power basis function class + supporting classes
+ *
+ *  Authors:
+ *   Nathan Hurst <njh@mail.csse.monash.edu.au>
+ *   Michael Sloan <mgsloan@gmail.com>
+ *
+ * Copyright (C) 2006-2007 authors
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it either under the terms of the GNU Lesser General Public
+ * License version 2.1 as published by the Free Software Foundation
+ * (the "LGPL") or, at your option, under the terms of the Mozilla
+ * Public License Version 1.1 (the "MPL"). If you do not alter this
+ * notice, a recipient may use your version of this file under either
+ * the MPL or the LGPL.
+ *
+ * You should have received a copy of the LGPL along with this library
+ * in the file COPYING-LGPL-2.1; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ * You should have received a copy of the MPL along with this library
+ * in the file COPYING-MPL-1.1
+ *
+ * The contents of this file are subject to the Mozilla Public License
+ * Version 1.1 (the "License"); you may not use this file except in
+ * compliance with the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
+ * OF ANY KIND, either express or implied. See the LGPL or the MPL for
+ * the specific language governing rights and limitations.
+ */
+
+#include <cmath>
+
+#include "sbasis.h"
+#include "isnan.h"
+
+namespace Geom{
+
+/*** At some point we should work on tighter bounds for the error.  It is clear that the error is
+ * bounded by the L1 norm over the tail of the series, but this is very loose, leading to far too
+ * many cubic beziers.  I've changed this to be \sum _i=tail ^\infty |hat a_i| 2^-i but I have no
+ * evidence that this is correct.
+ */
+
+/*
+double SBasis::tail_error(unsigned tail) const {
+    double err = 0, s = 1./(1<<(2*tail)); // rough
+    for(unsigned i = tail; i < size(); i++) {
+        err += (fabs((*this)[i][0]) + fabs((*this)[i][1]))*s;
+        s /= 4;
+    }
+    return err;
+}
 */
-

-double SBasis::tailError(unsigned tail) const {

-  Interval bs = bounds_fast(*this, tail);

-  return std::max(fabs(bs.min()),fabs(bs.max()));

-}

-

-bool SBasis::isFinite() const {

-    for(unsigned i = 0; i < size(); i++) {

-        if(!(*this)[i].isFinite())

-            return false;

-    }

-    return true;

-}

-

-SBasis operator+(const SBasis& a, const SBasis& b) {

-    SBasis result;

-    const unsigned out_size = std::max(a.size(), b.size());

-    const unsigned min_size = std::min(a.size(), b.size());

-    result.reserve(out_size);

-    

-    for(unsigned i = 0; i < min_size; i++) {

-        result.push_back(a[i] + b[i]);

-    }

-    for(unsigned i = min_size; i < a.size(); i++)

-        result.push_back(a[i]);

-    for(unsigned i = min_size; i < b.size(); i++)

-        result.push_back(b[i]);

-

-    assert(result.size() == out_size);

-    return result;

-}

-

-SBasis operator-(const SBasis& a, const SBasis& b) {

-    SBasis result;

-    const unsigned out_size = std::max(a.size(), b.size());

-    const unsigned min_size = std::min(a.size(), b.size());

-    result.reserve(out_size);

-    

-    for(unsigned i = 0; i < min_size; i++) {

-        result.push_back(a[i] - b[i]);

-    }

-    for(unsigned i = min_size; i < a.size(); i++)

-        result.push_back(a[i]);

-    for(unsigned i = min_size; i < b.size(); i++)

-        result.push_back(-b[i]);

-

-    assert(result.size() == out_size);

-    return result;

-}

-

-SBasis& operator+=(SBasis& a, const SBasis& b) {

-    const unsigned out_size = std::max(a.size(), b.size());

-    const unsigned min_size = std::min(a.size(), b.size());

-    a.reserve(out_size);

-        

-    for(unsigned i = 0; i < min_size; i++)

-        a[i] += b[i];

-    for(unsigned i = min_size; i < b.size(); i++)

-        a.push_back(b[i]);

-    

-    assert(a.size() == out_size);

-    return a;

-}

-

-SBasis& operator-=(SBasis& a, const SBasis& b) {

-    const unsigned out_size = std::max(a.size(), b.size());

-    const unsigned min_size = std::min(a.size(), b.size());

-    a.reserve(out_size);

-        

-    for(unsigned i = 0; i < min_size; i++)

-        a[i] -= b[i];

-    for(unsigned i = min_size; i < b.size(); i++)

-        a.push_back(-b[i]);

-    

-    assert(a.size() == out_size);

-    return a;

-}

-

-SBasis operator*(SBasis const &a, double k) {

-    SBasis c;

-    c.reserve(a.size());

-    for(unsigned i = 0; i < a.size(); i++)

-        c.push_back(a[i] * k);

-    return c;

-}

-

-SBasis& operator*=(SBasis& a, double b) {

-    if (a.isZero()) return a;

-    if (b == 0)

-        a.clear();

-    else

-        for(unsigned i = 0; i < a.size(); i++)

-            a[i] *= b;

-    return a;

-}

-

-SBasis shift(SBasis const &a, int sh) {

-    SBasis c = a;

-    if(sh > 0) {

-        c.insert(c.begin(), sh, Linear(0,0));

-    } else {

-        //TODO: truncate

-    }

-    return c;

-}

-

-SBasis shift(Linear const &a, int sh) {

-    SBasis c;

-    if(sh > 0) {

-        c.insert(c.begin(), sh, Linear(0,0));

-        c.push_back(a);

-    }

-    return c;

-}

-

-SBasis multiply(SBasis const &a, SBasis const &b) {

-    // c = {a0*b0 - shift(1, a.Tri*b.Tri), a1*b1 - shift(1, a.Tri*b.Tri)}

-    

-    // shift(1, a.Tri*b.Tri)

-    SBasis c;

-    if(a.isZero() || b.isZero())

-        return c;

-    c.resize(a.size() + b.size(), Linear(0,0));

-    c[0] = Linear(0,0);

-    for(unsigned j = 0; j < b.size(); j++) {

-        for(unsigned i = j; i < a.size()+j; i++) {

-            double tri = Tri(b[j])*Tri(a[i-j]);

-            c[i+1/*shift*/] += Linear(Hat(-tri));

-        }

-    }

-    for(unsigned j = 0; j < b.size(); j++) {

-        for(unsigned i = j; i < a.size()+j; i++) {

-            for(unsigned dim = 0; dim < 2; dim++)

-                c[i][dim] += b[j][dim]*a[i-j][dim];

-        }

-    }

-    c.normalize();

-    //assert(!(0 == c.back()[0] && 0 == c.back()[1]));

-    return c;

-}

-

-SBasis integral(SBasis const &c) {

-    SBasis a;

-    a.resize(c.size() + 1, Linear(0,0));

-    a[0] = Linear(0,0);

-    

-    for(unsigned k = 1; k < c.size() + 1; k++) {

-        double ahat = -Tri(c[k-1])/(2*k);

-        a[k] = Hat(ahat);

-    }

-    double aTri = 0;

-    for(int k = c.size()-1; k >= 0; k--) {

-        aTri = (Hat(c[k]).d + (k+1)*aTri/2)/(2*k+1);

-        a[k][0] -= aTri/2;

-        a[k][1] += aTri/2;

-    }

-    a.normalize();

-    return a;

-}

-

-SBasis derivative(SBasis const &a) {

-    SBasis c;

-    c.resize(a.size(), Linear(0,0));

-    

-    for(unsigned k = 0; k < a.size(); k++) {

-        double d = (2*k+1)*Tri(a[k]);

-        

-        for(unsigned dim = 0; dim < 2; dim++) {

-            c[k][dim] = d;

-            if(k+1 < a.size()) {

-                if(dim)

-                    c[k][dim] = d - (k+1)*a[k+1][dim];

-                else

-                    c[k][dim] = d + (k+1)*a[k+1][dim];

-            }

-        }

-    }

-    

-    return c;

-}

-

-//TODO: convert int k to unsigned k, and remove cast

-SBasis sqrt(SBasis const &a, int k) {

-    SBasis c;

-    if(a.isZero() || k == 0)

-        return c;

-    c.resize(k, Linear(0,0));

-    c[0] = Linear(std::sqrt(a[0][0]), std::sqrt(a[0][1]));

-    SBasis r = a - multiply(c, c); // remainder

-    

-    for(unsigned i = 1; i <= (unsigned)k and i<r.size(); i++) {

-        Linear ci(r[i][0]/(2*c[0][0]), r[i][1]/(2*c[0][1]));

-        SBasis cisi = shift(ci, i);

-        r -= multiply(shift((c*2 + cisi), i), SBasis(ci));

-        r.truncate(k+1);

-        c += cisi;

-        if(r.tailError(i) == 0) // if exact

-            break;

-    }

-    

-    return c;

-}

-

-// return a kth order approx to 1/a)

-SBasis reciprocal(Linear const &a, int k) {

-    SBasis c;

-    assert(!a.isZero());

-    c.resize(k, Linear(0,0));

-    double r_s0 = (Tri(a)*Tri(a))/(-a[0]*a[1]);

-    double r_s0k = 1;

-    for(unsigned i = 0; i < (unsigned)k; i++) {

-        c[i] = Linear(r_s0k/a[0], r_s0k/a[1]);

-        r_s0k *= r_s0;

-    }

-    return c;

-}

-

-SBasis divide(SBasis const &a, SBasis const &b, int k) {

-    SBasis c;

-    assert(!a.isZero());

-    SBasis r = a; // remainder

-    

-    k++;

-    r.resize(k, Linear(0,0));

-    c.resize(k, Linear(0,0));

-

-    for(unsigned i = 0; i < (unsigned)k; i++) {

-        Linear ci(r[i][0]/b[0][0], r[i][1]/b[0][1]); //H0

-        c[i] += ci;

-        r -= shift(multiply(ci,b), i);

-        r.truncate(k+1);

-        if(r.tailError(i) == 0) // if exact

-            break;

-    }

-    

-    return c;

-}

-

-// a(b)

-// return a0 + s(a1 + s(a2 +...  where s = (1-u)u; ak =(1 - u)a^0_k + ua^1_k

-SBasis compose(SBasis const &a, SBasis const &b) {

-    SBasis s = multiply((SBasis(Linear(1,1))-b), b);

-    SBasis r;

-    

-    for(int i = a.size()-1; i >= 0; i--) {

-        r = SBasis(Linear(Hat(a[i][0]))) - b*a[i][0] + b*a[i][1] + multiply(r,s);

-    }

-    return r;

-}

-

-// a(b)

-// return a0 + s(a1 + s(a2 +...  where s = (1-u)u; ak =(1 - u)a^0_k + ua^1_k

-SBasis compose(SBasis const &a, SBasis const &b, unsigned k) {

-    SBasis s = multiply((SBasis(Linear(1,1))-b), b);

-    SBasis r;

-    

-    for(int i = a.size()-1; i >= 0; i--) {

-        r = SBasis(Linear(Hat(a[i][0]))) - b*a[i][0] + b*a[i][1] + multiply(r,s);

-    }

-    r.truncate(k);

-    return r;

-}

-

-/*

-Inversion algorithm. The notation is certainly very misleading. The

-pseudocode should say:

-

-c(v) := 0

-r(u) := r_0(u) := u

-for i:=0 to k do

-  c_i(v) := H_0(r_i(u)/(t_1)^i; u)

-  c(v) := c(v) + c_i(v)*t^i

-  r(u) := r(u) ? c_i(u)*(t(u))^i

-endfor

-*/

-

-//#define DEBUG_INVERSION 1 

-

-SBasis inverse(SBasis a, int k) {

-    assert(a.size() > 0);

-// the function should have 'unit range'("a00 = 0 and a01 = 1") and be monotonic.

-    double a0 = a[0][0];

-    if(a0 != 0) {

-        a -= a0;

-    }

-    double a1 = a[0][1];

-    assert(a1 != 0); // not invertable.

-    

-    if(a1 != 1) {

-        a /= a1;

-    }

-    SBasis c;                           // c(v) := 0

-    if(a.size() >= 2 && k == 2) {

-        c.push_back(Linear(0,1));

-        Linear t1(1+a[1][0], 1-a[1][1]);    // t_1

-        c.push_back(Linear(-a[1][0]/t1[0], -a[1][1]/t1[1]));

-    } else if(a.size() >= 2) {                      // non linear

-        SBasis r = Linear(0,1);             // r(u) := r_0(u) := u

-        Linear t1(1./(1+a[1][0]), 1./(1-a[1][1]));    // 1./t_1

-        Linear one(1,1);

-        Linear t1i = one;                   // t_1^0

-        SBasis one_minus_a = SBasis(one) - a;

-        SBasis t = multiply(one_minus_a, a); // t(u)

-        SBasis ti(one);                     // t(u)^0

-#ifdef DEBUG_INVERSION

-        std::cout << "a=" << a << std::endl;

-        std::cout << "1-a=" << one_minus_a << std::endl;

-        std::cout << "t1=" << t1 << std::endl;

-        //assert(t1 == t[1]);

-#endif

-    

-        c.resize(k+1, Linear(0,0));

-        for(unsigned i = 0; i < (unsigned)k; i++) {   // for i:=0 to k do

-#ifdef DEBUG_INVERSION

-            std::cout << "-------" << i << ": ---------" <<std::endl;

-            std::cout << "r=" << r << std::endl

-                      << "c=" << c << std::endl

-                      << "ti=" << ti << std::endl

-                      << std::endl;

-#endif

-            if(r.size() <= i)                // ensure enough space in the remainder, probably not needed

-                r.resize(i+1, Linear(0,0));

-            Linear ci(r[i][0]*t1i[0], r[i][1]*t1i[1]); // c_i(v) := H_0(r_i(u)/(t_1)^i; u)

-#ifdef DEBUG_INVERSION

-            std::cout << "t1i=" << t1i << std::endl;

-            std::cout << "ci=" << ci << std::endl;

-#endif

-            for(int dim = 0; dim < 2; dim++) // t1^-i *= 1./t1

-                t1i[dim] *= t1[dim];

-            c[i] = ci; // c(v) := c(v) + c_i(v)*t^i

-            // change from v to u parameterisation

-            SBasis civ = one_minus_a*ci[0] + a*ci[1]; 

-            // r(u) := r(u) - c_i(u)*(t(u))^i

-            // We can truncate this to the number of final terms, as no following terms can

-            // contribute to the result.

-            r -= multiply(civ,ti);

-            r.truncate(k);

-            if(r.tailError(i) == 0)

-                break; // yay!

-            ti = multiply(ti,t);

-        }

-#ifdef DEBUG_INVERSION

-        std::cout << "##########################" << std::endl;

-#endif

-    } else

-        c = Linear(0,1); // linear

-    c -= a0; // invert the offset

-    c /= a1; // invert the slope

-    return c;

-}

-

-SBasis sin(Linear b, int k) {

-    SBasis s = Linear(std::sin(b[0]), std::sin(b[1]));

-    Tri tr(s[0]);

-    double t2 = Tri(b);

-    s.push_back(Linear(std::cos(b[0])*t2 - tr, -std::cos(b[1])*t2 + tr));

-    

-    t2 *= t2;

-    for(int i = 0; i < k; i++) {

-        Linear bo(4*(i+1)*s[i+1][0] - 2*s[i+1][1],

-                  -2*s[i+1][0] + 4*(i+1)*s[i+1][1]);

-        bo -= s[i]*(t2/(i+1));

-        

-        

-        s.push_back(bo/double(i+2));

-    }

-    

-    return s;

-}

-

-SBasis cos(Linear bo, int k) {

-    return sin(Linear(bo[0] + M_PI/2,

-                      bo[1] + M_PI/2),

-               k);

-}

-

-//compute fog^-1. ("zero" = double comparison threshold. *!*we might divide by "zero"*!*)

-//TODO: compute order according to tol?

-//TODO: requires g(0)=0 & g(1)=1 atm... adaptation to other cases should be obvious!

-SBasis compose_inverse(SBasis const &f, SBasis const &g, unsigned order, double zero){

-    SBasis result; //result

-    SBasis r=f; //remainder

-    SBasis Pk=Linear(1)-g,Qk=g,sg=Pk*Qk;

-    Pk.truncate(order);

-    Qk.truncate(order);

-    Pk.resize(order,Linear(0.));

-    Qk.resize(order,Linear(0.));

-    r.resize(order,Linear(0.));

-

-    int vs= valuation(sg,zero);

-    

-    for (unsigned k=0; k<order; k+=vs){

-        double p10 = Pk.at(k)[0];// we have to solve the linear system:

-        double p01 = Pk.at(k)[1];//

-        double q10 = Qk.at(k)[0];//   p10*a + q10*b = r10

-        double q01 = Qk.at(k)[1];// &                    

-        double r10 =  r.at(k)[0];//   p01*a + q01*b = r01

-        double r01 =  r.at(k)[1];//

-        double a,b;

-        double det = p10*q01-p01*q10;

-

-        //TODO: handle det~0!! 

-        if (fabs(det)<zero){

-            det = zero;

-            a=b=0;

-        }else{

-            a=( q01*r10-q10*r01)/det;

-            b=(-p01*r10+p10*r01)/det;

-        }

-        result.push_back(Linear(a,b));

-        r=r-Pk*a-Qk*b;

-        

-        Pk=Pk*sg;

-        Qk=Qk*sg;

-        Pk.truncate(order);

-        Qk.truncate(order);

-        r.truncate(order);

-    }

-    result.normalize();

-    return result;

-}

-

-}

-

-/*

-  Local Variables:

-  mode:c++

-  c-file-style:"stroustrup"

-  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))

-  indent-tabs-mode:nil

-  fill-column:99

-  End:

-*/

-// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :

+
+double SBasis::tailError(unsigned tail) const {
+  Interval bs = bounds_fast(*this, tail);
+  return std::max(fabs(bs.min()),fabs(bs.max()));
+}
+
+bool SBasis::isFinite() const {
+    for(unsigned i = 0; i < size(); i++) {
+        if(!(*this)[i].isFinite())
+            return false;
+    }
+    return true;
+}
+
+SBasis operator+(const SBasis& a, const SBasis& b) {
+    SBasis result;
+    const unsigned out_size = std::max(a.size(), b.size());
+    const unsigned min_size = std::min(a.size(), b.size());
+    result.reserve(out_size);
+
+    for(unsigned i = 0; i < min_size; i++) {
+        result.push_back(a[i] + b[i]);
+    }
+    for(unsigned i = min_size; i < a.size(); i++)
+        result.push_back(a[i]);
+    for(unsigned i = min_size; i < b.size(); i++)
+        result.push_back(b[i]);
+
+    assert(result.size() == out_size);
+    return result;
+}
+
+SBasis operator-(const SBasis& a, const SBasis& b) {
+    SBasis result;
+    const unsigned out_size = std::max(a.size(), b.size());
+    const unsigned min_size = std::min(a.size(), b.size());
+    result.reserve(out_size);
+
+    for(unsigned i = 0; i < min_size; i++) {
+        result.push_back(a[i] - b[i]);
+    }
+    for(unsigned i = min_size; i < a.size(); i++)
+        result.push_back(a[i]);
+    for(unsigned i = min_size; i < b.size(); i++)
+        result.push_back(-b[i]);
+
+    assert(result.size() == out_size);
+    return result;
+}
+
+SBasis& operator+=(SBasis& a, const SBasis& b) {
+    const unsigned out_size = std::max(a.size(), b.size());
+    const unsigned min_size = std::min(a.size(), b.size());
+    a.reserve(out_size);
+
+    for(unsigned i = 0; i < min_size; i++)
+        a[i] += b[i];
+    for(unsigned i = min_size; i < b.size(); i++)
+        a.push_back(b[i]);
+
+    assert(a.size() == out_size);
+    return a;
+}
+
+SBasis& operator-=(SBasis& a, const SBasis& b) {
+    const unsigned out_size = std::max(a.size(), b.size());
+    const unsigned min_size = std::min(a.size(), b.size());
+    a.reserve(out_size);
+
+    for(unsigned i = 0; i < min_size; i++)
+        a[i] -= b[i];
+    for(unsigned i = min_size; i < b.size(); i++)
+        a.push_back(-b[i]);
+
+    assert(a.size() == out_size);
+    return a;
+}
+
+SBasis operator*(SBasis const &a, double k) {
+    SBasis c;
+    c.reserve(a.size());
+    for(unsigned i = 0; i < a.size(); i++)
+        c.push_back(a[i] * k);
+    return c;
+}
+
+SBasis& operator*=(SBasis& a, double b) {
+    if (a.isZero()) return a;
+    if (b == 0)
+        a.clear();
+    else
+        for(unsigned i = 0; i < a.size(); i++)
+            a[i] *= b;
+    return a;
+}
+
+SBasis shift(SBasis const &a, int sh) {
+    SBasis c = a;
+    if(sh > 0) {
+        c.insert(c.begin(), sh, Linear(0,0));
+    } else {
+        //TODO: truncate
+    }
+    return c;
+}
+
+SBasis shift(Linear const &a, int sh) {
+    SBasis c;
+    if(sh > 0) {
+        c.insert(c.begin(), sh, Linear(0,0));
+        c.push_back(a);
+    }
+    return c;
+}
+
+SBasis multiply(SBasis const &a, SBasis const &b) {
+    // c = {a0*b0 - shift(1, a.Tri*b.Tri), a1*b1 - shift(1, a.Tri*b.Tri)}
+
+    // shift(1, a.Tri*b.Tri)
+    SBasis c;
+    if(a.isZero() || b.isZero())
+        return c;
+    c.resize(a.size() + b.size(), Linear(0,0));
+    c[0] = Linear(0,0);
+    for(unsigned j = 0; j < b.size(); j++) {
+        for(unsigned i = j; i < a.size()+j; i++) {
+            double tri = Tri(b[j])*Tri(a[i-j]);
+            c[i+1/*shift*/] += Linear(Hat(-tri));
+        }
+    }
+    for(unsigned j = 0; j < b.size(); j++) {
+        for(unsigned i = j; i < a.size()+j; i++) {
+            for(unsigned dim = 0; dim < 2; dim++)
+                c[i][dim] += b[j][dim]*a[i-j][dim];
+        }
+    }
+    c.normalize();
+    //assert(!(0 == c.back()[0] && 0 == c.back()[1]));
+    return c;
+}
+
+SBasis integral(SBasis const &c) {
+    SBasis a;
+    a.resize(c.size() + 1, Linear(0,0));
+    a[0] = Linear(0,0);
+
+    for(unsigned k = 1; k < c.size() + 1; k++) {
+        double ahat = -Tri(c[k-1])/(2*k);
+        a[k] = Hat(ahat);
+    }
+    double aTri = 0;
+    for(int k = c.size()-1; k >= 0; k--) {
+        aTri = (Hat(c[k]).d + (k+1)*aTri/2)/(2*k+1);
+        a[k][0] -= aTri/2;
+        a[k][1] += aTri/2;
+    }
+    a.normalize();
+    return a;
+}
+
+SBasis derivative(SBasis const &a) {
+    SBasis c;
+    c.resize(a.size(), Linear(0,0));
+
+    for(unsigned k = 0; k < a.size(); k++) {
+        double d = (2*k+1)*Tri(a[k]);
+
+        for(unsigned dim = 0; dim < 2; dim++) {
+            c[k][dim] = d;
+            if(k+1 < a.size()) {
+                if(dim)
+                    c[k][dim] = d - (k+1)*a[k+1][dim];
+                else
+                    c[k][dim] = d + (k+1)*a[k+1][dim];
+            }
+        }
+    }
+
+    return c;
+}
+
+//TODO: convert int k to unsigned k, and remove cast
+SBasis sqrt(SBasis const &a, int k) {
+    SBasis c;
+    if(a.isZero() || k == 0)
+        return c;
+    c.resize(k, Linear(0,0));
+    c[0] = Linear(std::sqrt(a[0][0]), std::sqrt(a[0][1]));
+    SBasis r = a - multiply(c, c); // remainder
+
+    for(unsigned i = 1; i <= (unsigned)k and i<r.size(); i++) {
+        Linear ci(r[i][0]/(2*c[0][0]), r[i][1]/(2*c[0][1]));
+        SBasis cisi = shift(ci, i);
+        r -= multiply(shift((c*2 + cisi), i), SBasis(ci));
+        r.truncate(k+1);
+        c += cisi;
+        if(r.tailError(i) == 0) // if exact
+            break;
+    }
+
+    return c;
+}
+
+// return a kth order approx to 1/a)
+SBasis reciprocal(Linear const &a, int k) {
+    SBasis c;
+    assert(!a.isZero());
+    c.resize(k, Linear(0,0));
+    double r_s0 = (Tri(a)*Tri(a))/(-a[0]*a[1]);
+    double r_s0k = 1;
+    for(unsigned i = 0; i < (unsigned)k; i++) {
+        c[i] = Linear(r_s0k/a[0], r_s0k/a[1]);
+        r_s0k *= r_s0;
+    }
+    return c;
+}
+
+SBasis divide(SBasis const &a, SBasis const &b, int k) {
+    SBasis c;
+    assert(!a.isZero());
+    SBasis r = a; // remainder
+
+    k++;
+    r.resize(k, Linear(0,0));
+    c.resize(k, Linear(0,0));
+
+    for(unsigned i = 0; i < (unsigned)k; i++) {
+        Linear ci(r[i][0]/b[0][0], r[i][1]/b[0][1]); //H0
+        c[i] += ci;
+        r -= shift(multiply(ci,b), i);
+        r.truncate(k+1);
+        if(r.tailError(i) == 0) // if exact
+            break;
+    }
+
+    return c;
+}
+
+// a(b)
+// return a0 + s(a1 + s(a2 +...  where s = (1-u)u; ak =(1 - u)a^0_k + ua^1_k
+SBasis compose(SBasis const &a, SBasis const &b) {
+    SBasis s = multiply((SBasis(Linear(1,1))-b), b);
+    SBasis r;
+
+    for(int i = a.size()-1; i >= 0; i--) {
+        r = SBasis(Linear(Hat(a[i][0]))) - b*a[i][0] + b*a[i][1] + multiply(r,s);
+    }
+    return r;
+}
+
+// a(b)
+// return a0 + s(a1 + s(a2 +...  where s = (1-u)u; ak =(1 - u)a^0_k + ua^1_k
+SBasis compose(SBasis const &a, SBasis const &b, unsigned k) {
+    SBasis s = multiply((SBasis(Linear(1,1))-b), b);
+    SBasis r;
+
+    for(int i = a.size()-1; i >= 0; i--) {
+        r = SBasis(Linear(Hat(a[i][0]))) - b*a[i][0] + b*a[i][1] + multiply(r,s);
+    }
+    r.truncate(k);
+    return r;
+}
+
+/*
+Inversion algorithm. The notation is certainly very misleading. The
+pseudocode should say:
+
+c(v) := 0
+r(u) := r_0(u) := u
+for i:=0 to k do
+  c_i(v) := H_0(r_i(u)/(t_1)^i; u)
+  c(v) := c(v) + c_i(v)*t^i
+  r(u) := r(u) ? c_i(u)*(t(u))^i
+endfor
+*/
+
+//#define DEBUG_INVERSION 1
+
+SBasis inverse(SBasis a, int k) {
+    assert(a.size() > 0);
+// the function should have 'unit range'("a00 = 0 and a01 = 1") and be monotonic.
+    double a0 = a[0][0];
+    if(a0 != 0) {
+        a -= a0;
+    }
+    double a1 = a[0][1];
+    assert(a1 != 0); // not invertable.
+
+    if(a1 != 1) {
+        a /= a1;
+    }
+    SBasis c;                           // c(v) := 0
+    if(a.size() >= 2 && k == 2) {
+        c.push_back(Linear(0,1));
+        Linear t1(1+a[1][0], 1-a[1][1]);    // t_1
+        c.push_back(Linear(-a[1][0]/t1[0], -a[1][1]/t1[1]));
+    } else if(a.size() >= 2) {                      // non linear
+        SBasis r = Linear(0,1);             // r(u) := r_0(u) := u
+        Linear t1(1./(1+a[1][0]), 1./(1-a[1][1]));    // 1./t_1
+        Linear one(1,1);
+        Linear t1i = one;                   // t_1^0
+        SBasis one_minus_a = SBasis(one) - a;
+        SBasis t = multiply(one_minus_a, a); // t(u)
+        SBasis ti(one);                     // t(u)^0
+#ifdef DEBUG_INVERSION
+        std::cout << "a=" << a << std::endl;
+        std::cout << "1-a=" << one_minus_a << std::endl;
+        std::cout << "t1=" << t1 << std::endl;
+        //assert(t1 == t[1]);
+#endif
+
+        c.resize(k+1, Linear(0,0));
+        for(unsigned i = 0; i < (unsigned)k; i++) {   // for i:=0 to k do
+#ifdef DEBUG_INVERSION
+            std::cout << "-------" << i << ": ---------" <<std::endl;
+            std::cout << "r=" << r << std::endl
+                      << "c=" << c << std::endl
+                      << "ti=" << ti << std::endl
+                      << std::endl;
+#endif
+            if(r.size() <= i)                // ensure enough space in the remainder, probably not needed
+                r.resize(i+1, Linear(0,0));
+            Linear ci(r[i][0]*t1i[0], r[i][1]*t1i[1]); // c_i(v) := H_0(r_i(u)/(t_1)^i; u)
+#ifdef DEBUG_INVERSION
+            std::cout << "t1i=" << t1i << std::endl;
+            std::cout << "ci=" << ci << std::endl;
+#endif
+            for(int dim = 0; dim < 2; dim++) // t1^-i *= 1./t1
+                t1i[dim] *= t1[dim];
+            c[i] = ci; // c(v) := c(v) + c_i(v)*t^i
+            // change from v to u parameterisation
+            SBasis civ = one_minus_a*ci[0] + a*ci[1];
+            // r(u) := r(u) - c_i(u)*(t(u))^i
+            // We can truncate this to the number of final terms, as no following terms can
+            // contribute to the result.
+            r -= multiply(civ,ti);
+            r.truncate(k);
+            if(r.tailError(i) == 0)
+                break; // yay!
+            ti = multiply(ti,t);
+        }
+#ifdef DEBUG_INVERSION
+        std::cout << "##########################" << std::endl;
+#endif
+    } else
+        c = Linear(0,1); // linear
+    c -= a0; // invert the offset
+    c /= a1; // invert the slope
+    return c;
+}
+
+SBasis sin(Linear b, int k) {
+    SBasis s = Linear(std::sin(b[0]), std::sin(b[1]));
+    Tri tr(s[0]);
+    double t2 = Tri(b);
+    s.push_back(Linear(std::cos(b[0])*t2 - tr, -std::cos(b[1])*t2 + tr));
+
+    t2 *= t2;
+    for(int i = 0; i < k; i++) {
+        Linear bo(4*(i+1)*s[i+1][0] - 2*s[i+1][1],
+                  -2*s[i+1][0] + 4*(i+1)*s[i+1][1]);
+        bo -= s[i]*(t2/(i+1));
+
+
+        s.push_back(bo/double(i+2));
+    }
+
+    return s;
+}
+
+SBasis cos(Linear bo, int k) {
+    return sin(Linear(bo[0] + M_PI/2,
+                      bo[1] + M_PI/2),
+               k);
+}
+
+//compute fog^-1. ("zero" = double comparison threshold. *!*we might divide by "zero"*!*)
+//TODO: compute order according to tol?
+//TODO: requires g(0)=0 & g(1)=1 atm... adaptation to other cases should be obvious!
+SBasis compose_inverse(SBasis const &f, SBasis const &g, unsigned order, double zero){
+    SBasis result; //result
+    SBasis r=f; //remainder
+    SBasis Pk=Linear(1)-g,Qk=g,sg=Pk*Qk;
+    Pk.truncate(order);
+    Qk.truncate(order);
+    Pk.resize(order,Linear(0.));
+    Qk.resize(order,Linear(0.));
+    r.resize(order,Linear(0.));
+
+    int vs= valuation(sg,zero);
+
+    for (unsigned k=0; k<order; k+=vs){
+        double p10 = Pk.at(k)[0];// we have to solve the linear system:
+        double p01 = Pk.at(k)[1];//
+        double q10 = Qk.at(k)[0];//   p10*a + q10*b = r10
+        double q01 = Qk.at(k)[1];// &
+        double r10 =  r.at(k)[0];//   p01*a + q01*b = r01
+        double r01 =  r.at(k)[1];//
+        double a,b;
+        double det = p10*q01-p01*q10;
+
+        //TODO: handle det~0!!
+        if (fabs(det)<zero){
+            det = zero;
+            a=b=0;
+        }else{
+            a=( q01*r10-q10*r01)/det;
+            b=(-p01*r10+p10*r01)/det;
+        }
+        result.push_back(Linear(a,b));
+        r=r-Pk*a-Qk*b;
+
+        Pk=Pk*sg;
+        Qk=Qk*sg;
+        Pk.truncate(order);
+        Qk.truncate(order);
+        r.truncate(order);
+    }
+    result.normalize();
+    return result;
+}
+
+}
+
+/*
+  Local Variables:
+  mode:c++
+  c-file-style:"stroustrup"
+  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+  indent-tabs-mode:nil
+  fill-column:99
+  End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :