/** Compute the cosine of a function.
\param f function
\param tol maximum error
\param order maximum degree polynomial to use
*/
Piecewise<SBasis> cos( SBasis const &f, double tol, int order){
double alpha = (f.at0()+f.at1())/2.;
SBasis x = f-alpha;
double d = x.tailError(0),err=1;
//estimate cos(x)-sum_0^order (-1)^k x^2k/2k! by the first neglicted term
for (int i=1; i<=2*order; i++) err*=d/i;
if (err<tol){
SBasis xk=Linear(1), c=Linear(1), s=Linear(0);
for (int k=1; k<=2*order; k+=2){
xk*=x/k;
//take also truncature errors into account...
err+=xk.tailError(order);
xk.truncate(order);
s+=xk;
xk*=-x/(k+1);
//take also truncature errors into account...
err+=xk.tailError(order);
xk.truncate(order);
c+=xk;
}
if (err<tol){
return Piecewise<SBasis>(std::cos(alpha)*c-std::sin(alpha)*s);
}
}
Piecewise<SBasis> c0,c1;
c0 = cos(compose(f,Linear(0.,.5)),tol,order);
c1 = cos(compose(f,Linear(.5,1.)),tol,order);
c0.setDomain(Interval(0.,.5));
c1.setDomain(Interval(.5,1.));
c0.concat(c1);
return c0;
}
Piecewise<SBasis> convole(SBasisOf<double> const &f, Interval dom_f,
SBasisOf<double> const &g, Interval dom_g,
bool f_cst_ends = false){
if ( dom_f.extent() < dom_g.extent() ) return convole(g, dom_g, f, dom_f);
Piecewise<SBasis> result;
SBasisOf<SBasisOf<double> > u,v;
u.push_back(LinearOf<SBasisOf<double> >(SBasisOf<double>(LinearOf<double>(0,1))));
v.push_back(LinearOf<SBasisOf<double> >(SBasisOf<double>(LinearOf<double>(0,0)),
SBasisOf<double>(LinearOf<double>(1,1))));
SBasisOf<SBasisOf<double> > v_u = (v - u)*(dom_f.extent()/dom_g.extent());
v_u += SBasisOf<SBasisOf<double> >(SBasisOf<double>(-dom_g.min()/dom_g.extent()));
SBasisOf<SBasisOf<double> > gg = multi_compose(g,v_u);
SBasisOf<SBasisOf<double> > ff = SBasisOf<SBasisOf<double> >(f);
SBasisOf<SBasisOf<double> > hh = integral(ff*gg,0);
result.cuts.push_back(dom_f.min()+dom_g.min());
//Note: we know dom_f.extent() >= dom_g.extent()!!
//double rho = dom_f.extent()/dom_g.extent();
double t0 = dom_g.min()/dom_f.extent();
double t1 = dom_g.max()/dom_f.extent();
double t2 = t0+1;
double t3 = t1+1;
SBasisOf<double> a,b,t;
SBasis seg;
a = SBasisOf<double>(LinearOf<double>(0,0));
b = SBasisOf<double>(LinearOf<double>(0,t1-t0));
t = SBasisOf<double>(LinearOf<double>(t0,t1));
seg = toSBasis(compose(hh,b,t)-compose(hh,a,t));
result.push(seg,dom_f.min() + dom_g.max());
if (dom_f.extent() > dom_g.extent()){
a = SBasisOf<double>(LinearOf<double>(0,t2-t1));
b = SBasisOf<double>(LinearOf<double>(t1-t0,1));
t = SBasisOf<double>(LinearOf<double>(t1,t2));
seg = toSBasis(compose(hh,b,t)-compose(hh,a,t));
result.push(seg,dom_f.max() + dom_g.min());
}
a = SBasisOf<double>(LinearOf<double>(t2-t1,1.));
b = SBasisOf<double>(LinearOf<double>(1.,1.));
t = SBasisOf<double>(LinearOf<double>(t2,t3));
seg = toSBasis(compose(hh,b,t)-compose(hh,a,t));
result.push(seg,dom_f.max() + dom_g.max());
result*=dom_f.extent();
//--constant ends correction--------------
if (f_cst_ends){
SBasis ig = toSBasis(integraaal(g))*dom_g.extent();
ig -= ig.at0();
Piecewise<SBasis> cor;
cor.cuts.push_back(dom_f.min()+dom_g.min());
cor.push(reverse(ig)*f.at0(),dom_f.min()+dom_g.max());
cor.push(Linear(0),dom_f.max()+dom_g.min());
cor.push(ig*f.at1(),dom_f.max()+dom_g.max());
result+=cor;
}
//----------------------------------------
return result;
}
Interval bounds_exact(SBasis const &a) {
Interval result = Interval(a.at0(), a.at1());
SBasis df = derivative(a);
vector<double>extrema = roots(df);
for (unsigned i=0; i<extrema.size(); i++){
result.extendTo(a(extrema[i]));
}
return result;
}
//-Sqrt----------------------------------------------------------
static Piecewise<SBasis> sqrt_internal(SBasis const &f,
double tol,
int order){
SBasis sqrtf;
if(f.isZero() || order == 0){
return Piecewise<SBasis>(sqrtf);
}
if (f.at0()<-tol*tol && f.at1()<-tol*tol){
return sqrt_internal(-f,tol,order);
}else if (f.at0()>tol*tol && f.at1()>tol*tol){
sqrtf.resize(order+1, Linear(0,0));
sqrtf[0] = Linear(std::sqrt(f[0][0]), std::sqrt(f[0][1]));
SBasis r = f - multiply(sqrtf, sqrtf); // remainder
for(unsigned i = 1; int(i) <= order && i<r.size(); i++) {
Linear ci(r[i][0]/(2*sqrtf[0][0]), r[i][1]/(2*sqrtf[0][1]));
SBasis cisi = shift(ci, i);
r -= multiply(shift((sqrtf*2 + cisi), i), SBasis(ci));
r.truncate(order+1);
sqrtf[i] = ci;
if(r.tailError(i) == 0) // if exact
break;
}
}else{
sqrtf = Linear(std::sqrt(fabs(f.at0())), std::sqrt(fabs(f.at1())));
}
double err = (f - multiply(sqrtf, sqrtf)).tailError(0);
if (err<tol){
return Piecewise<SBasis>(sqrtf);
}
Piecewise<SBasis> sqrtf0,sqrtf1;
sqrtf0 = sqrt_internal(compose(f,Linear(0.,.5)),tol,order);
sqrtf1 = sqrt_internal(compose(f,Linear(.5,1.)),tol,order);
sqrtf0.setDomain(Interval(0.,.5));
sqrtf1.setDomain(Interval(.5,1.));
sqrtf0.concat(sqrtf1);
return sqrtf0;
}
/**
* Centroid using sbasis integration.
\param p the Element.
\param centroid on return contains the centroid of the shape
\param area on return contains the signed area of the shape.
\relates Piecewise
This approach uses green's theorem to compute the area and centroid using integrals. For curved shapes this is much faster than converting to polyline. Note that without an uncross operation the output is not the absolute area.
* Returned values:
0 for normal execution;
2 if area is zero, meaning centroid is meaningless.
*/
unsigned Geom::centroid(Piecewise<D2<SBasis> > const &p, Point& centroid, double &area) {
Point centroid_tmp(0,0);
double atmp = 0;
for(unsigned i = 0; i < p.size(); i++) {
SBasis curl = dot(p[i], rot90(derivative(p[i])));
SBasis A = integral(curl);
D2<SBasis> C = integral(multiply(curl, p[i]));
atmp += A.at1() - A.at0();
centroid_tmp += C.at1()- C.at0(); // first moment.
}
// join ends
centroid_tmp *= 2;
Point final = p[p.size()-1].at1(), initial = p[0].at0();
const double ai = cross(final, initial);
atmp += ai;
centroid_tmp += (final + initial)*ai; // first moment.
area = atmp / 2;
if (atmp != 0) {
centroid = centroid_tmp / (3 * atmp);
return 0;
}
return 2;
}
