136 lines
2.4 KiB
HolyC
Executable File
136 lines
2.4 KiB
HolyC
Executable File
#help_index "Math"
|
|
public U0 R2P(F64 *_mag=NULL,F64 *_arg=NULL,F64 x,F64 y)
|
|
{//Rect to polar
|
|
//Returns angle in range (-ã,ã]
|
|
if (_arg)
|
|
*_arg=Arg(x,y);
|
|
if (_mag)
|
|
*_mag=Sqrt(x*x+y*y);
|
|
}
|
|
|
|
public U0 P2R(F64 *_x=NULL,F64 *_y=NULL,F64 mag,F64 arg)
|
|
{//Polar to Rect
|
|
if (_x)
|
|
*_x=mag*Cos(arg);
|
|
if (_y)
|
|
*_y=mag*Sin(arg);
|
|
}
|
|
|
|
public F64 Wrap(F64 é,F64 base=-ã)
|
|
{//Returns angle in range [base,base+2*ã)
|
|
F64 res=é%(2*ã);
|
|
if (res>=base+2*ã)
|
|
res-=2*ã;
|
|
else if (res<base)
|
|
res+=2*ã;
|
|
return res;
|
|
}
|
|
|
|
public I64 DistSqrI64(I64 x1,I64 y1,I64 x2,I64 y2)
|
|
{//Distance-squared between 2 points.
|
|
I64 dx=x1-x2,dy=y1-y2;
|
|
return dx*dx+dy*dy;
|
|
}
|
|
|
|
public F64 ASin(F64 s)
|
|
{//Arc Sin (Inverse Sin).
|
|
F64 c;
|
|
c=s*s;
|
|
if (c>=1.0)
|
|
return ã/2.0;
|
|
c=Sqrt(1.0-c);
|
|
return ATan(s/c);
|
|
}
|
|
|
|
public F64 ACos(F64 c)
|
|
{//Arc Cos (Inverse Cos).
|
|
F64 s;
|
|
if (!c)
|
|
return ã/2.0;
|
|
s=c*c;
|
|
if (s>=1.0)
|
|
return 0.0;
|
|
s=Sqrt(1.0-s);
|
|
return ATan(s/c);
|
|
}
|
|
|
|
public F64 Sinh(F64 x)
|
|
{//Hyperbolic Sine.
|
|
return 0.5*(Exp(x)-Exp(-x));
|
|
}
|
|
|
|
public F64 Cosh(F64 x)
|
|
{//Hyperbolic Cosine.
|
|
return 0.5*(Exp(x)+Exp(-x));
|
|
}
|
|
|
|
#help_index "Math/Complex;Data Types/Complex"
|
|
public Complex *CAdd(Complex *sum,Complex *n1,Complex *n2)
|
|
{//sum=n1+n2
|
|
sum->x=n1->x+n2->x;
|
|
sum->y=n1->y+n2->y;
|
|
return sum;
|
|
}
|
|
|
|
public Complex *CSub(Complex *diff,Complex *n1,Complex *n2)
|
|
{//diff=n1-n2
|
|
diff->x=n1->x-n2->x;
|
|
diff->y=n1->y-n2->y;
|
|
return diff;
|
|
}
|
|
|
|
public Complex *CMul(Complex *prod,Complex *n1,Complex *n2)
|
|
{//prod=n1*n2
|
|
prod->x=n1->x*n2->x-n1->y*n2->y;
|
|
prod->y=n1->x*n2->y+n1->y*n2->x;
|
|
return prod;
|
|
}
|
|
|
|
public Complex *CDiv(Complex *quot,Complex *n1,Complex *n2)
|
|
{//quot=n1/n2
|
|
F64 m1,arg1,m2,arg2;
|
|
R2P(&m1,&arg1,n1->x,n1->y);
|
|
R2P(&m2,&arg2,n2->x,n2->y);
|
|
m1/=m2;
|
|
arg1-=arg2;
|
|
quot->x=m1*Cos(arg1);
|
|
quot->y=m1*Sin(arg1);
|
|
return quot;
|
|
}
|
|
|
|
public Complex *CScale(Complex *dst,F64 s)
|
|
{//dst*=s
|
|
dst->x*=s;
|
|
dst->y*=s;
|
|
return dst;
|
|
}
|
|
|
|
public Complex *CCopy(Complex *dst,Complex *src)
|
|
{//dst=src
|
|
dst->x=src->x;
|
|
dst->y=src->y;
|
|
return dst;
|
|
}
|
|
|
|
public Complex *CEqu(Complex *dst,F64 x,F64 y)
|
|
{//dst=(x,y)
|
|
dst->x=x;
|
|
dst->y=y;
|
|
return dst;
|
|
}
|
|
|
|
public Complex *CPoly(Complex *dst,I64 n,Complex *zeros,Complex *x)
|
|
{//Eval complex polynomial
|
|
I64 i;
|
|
Complex n1,n2;
|
|
if (n>0) {
|
|
CSub(dst,x,&zeros[0]);
|
|
for (i=1;i<n;i++) {
|
|
CCopy(&n1,dst);
|
|
CMul(dst,&n1,CSub(&n2,x,&zeros[i]));
|
|
}
|
|
} else
|
|
CEqu(dst,1.0,0.0);
|
|
return dst;
|
|
}
|