public override Point Fun(Point p)
{
var r = VariationHelper.R(p);
var q = W * (4.0 / (r * r + 4.0));
return(new Point(q * p.X, q * p.Y));
}
public override Point Fun(Point p)
{
var cx = p.X;
var cy = p.Y;
var sqrt = Math.Sqrt(VariationHelper.Sqr(cx) + VariationHelper.Sqr(cy));
double n2;
double n3;
if (sqrt < _cs)
{
n2 = cx;
n3 = cy;
}
else
{
var atan2 = Math.Atan2(cy, cx);
var n4 = sqrt + P2;
n2 = Math.Cos(atan2) * n4;
n3 = Math.Sin(atan2) * n4;
}
var x = W * n2;
var y = W * n3;
return(new Point(x, y));
}
public override Point Fun(Point p)
{
var point = new Point();
var n2 = p.X * p.X + p.Y * p.Y;
var n3 = n2 + 1.0;
var n4 = 2.0 * p.X;
var n5 = 0.5 * Math.Atan2(2.0 * p.Y, n2 - 1.0) + -VariationHelper.HalfPi * P1;
if (n5 > VariationHelper.HalfPi)
{
n5 = -VariationHelper.HalfPi + VariationHelper.Fmod(n5 + VariationHelper.HalfPi, Math.PI);
}
else if (n5 < -VariationHelper.HalfPi)
{
n5 = VariationHelper.HalfPi - VariationHelper.Fmod(VariationHelper.HalfPi - n5, Math.PI);
}
var n6 = n3 + n4;
var n7 = n3 - n4;
if (Math.Abs(n7) < 1E-300 || n6 / n7 <= 0.0)
{
return(p);
}
point.X += _wRadiant25 * Math.Log((n3 + n4) / (n3 - n4));
point.Y += _wRadiant * n5;
return(point);
}
public override Point Fun(Point p)
{
// var p1 = P1 * (Math.PI / 2.0);
// var t1 = .0;
// for (var i = 0; i < 4; i++) t1 += VariationHelper.Psi - 2.0;
// var t2 = VariationHelper.Phi(p) + t1 * Math.Sin(p1);
// var t3 = t1 * Math.Cos(p1) - 1.0;
// var q = 1.0 / t1;
// var r = VariationHelper.R(p);
// return new Point(
// q * (r * Math.Cos(t2) + t3 * p.X),
// q * (r * Math.Sin(t2) + t3 * p.Y)
// );
var n2 = VariationHelper.Psi + VariationHelper.Psi + VariationHelper.Psi +
VariationHelper.Psi - 2.0;
// var n2 = VariationHelper.Psi * 3.0 + VariationHelper.Psi - 2.0;
// var q = P1 * VariationHelper.HalfPi;
// _n3 = W * Math.Sin(q);
// _n4 = W * Math.Cos(q);
var sqrt = VariationHelper.R(p);
var n5 = Math.Atan2(p.Y, p.X) + _n3 * n2;
var sin = Math.Sin(n5);
var cos = Math.Cos(n5);
var n6 = _n4 * n2 - 1.0;
return(new Point(sqrt * cos + n6 * p.X, sqrt * sin + n6 * p.Y));
}
public override void Init()
{
_angle = VariationHelper.Map(P4, -10, 10, 0, 180);
_invert = P3;
_zoom = P2;
_mode = P1;
}
public override Point Fun(Point p)
{
// var p2 = Math.PI * 2.0 / P2;
// var phi = VariationHelper.Phi(p);
// var t3 = phi - p2 * Math.Floor(phi / p2);
// var q = p2 / 2.0;
// var t4 = t3 > q ? t3 : t3 - p2;
// var r = VariationHelper.R(p);
// var k = (P3 * (1.0 / Math.Cos(t4) - 1.0) + P4) / Math.Pow(r, P1);
// return new Point(k * p.X, k * p.Y);
//"power", "sides", "corners", "circle"
var corners = P3;
var circle = P4;
var pow = Math.Pow(VariationHelper.PreSumSq(p), _power);
var preAtanYx = VariationHelper.PreAtanYx(p);
var n3 = preAtanYx - _n2 * Math.Floor(preAtanYx / _n2);
if (n3 > _n2Half)
{
n3 -= _n2;
}
var n4 = (corners * (1.0 / (Math.Cos(n3) + 1.0E-300) - 1.0) + circle) / (pow + 1.0E-300);
return(new Point(W * p.X * n4, W * p.Y * n4));
}
public override Point Fun(Point p)
{
var rotate = P1;
var power = P2;
var move = P3;
var split = P4;
var point = new Point();
var n2 = 0.5 * (Math.Log(VariationHelper.Sqr(p.X + 1.0) + VariationHelper.Sqr(p.Y)) -
Math.Log(VariationHelper.Sqr(p.X - 1.0) + VariationHelper.Sqr(p.Y))) / power + move;
var n3 = (Math.PI - Math.Atan2(p.Y, p.X + 1.0) - Math.Atan2(p.Y, 1.0 - p.X) + rotate) / power +
VariationHelper.TwoPi / power * Math.Floor(VariationHelper.Psi * power);
double n4;
if (p.X >= 0.0)
{
n4 = n2 + split;
}
else
{
n4 = n2 - split;
}
var sinh = Math.Sinh(n4);
var cosh = Math.Cosh(n4);
var sin = Math.Sin(n3);
var n5 = cosh - Math.Cos(n3);
point.X += W * sinh / n5;
point.Y += W * sin / n5;
return(point);
}
public override Point Fun(Point p)
{
var point = new Point();
var sqr = 2.0 * _sqrVVar;
if (p.X > 1.0E-300)
{
sqr = VariationHelper.Sqr((VariationHelper.Sqr(p.X) + VariationHelper.Sqr(p.Y)) / p.X);
}
if (sqr < _sqrVVar)
{
var n2 = W * Math.Sqrt(_sqrVVar / sqr - 1.0);
point.X += n2 * p.X;
point.Y += n2 * p.Y;
}
else
{
point.X += W * p.X;
point.Y += W * p.Y;
}
return(point);
}
public override Point Fun(Point p)
{
// var sin = Math.Sin(p.X);
// var cos = Math.Cos(p.X);
// var sinh = Math.Sinh(p.Y);
// var cosh = Math.Cosh(p.Y);
// var n2 = Math.Cos(2.0 * p.X) + Math.Cosh(2.0 * p.Y);
// if (n2 == 0.0) return p;
// var n3 = 2.0 / n2;
// return new Point(W * n3 * cos * cosh, W * n3 * sin * sinh);
var cos = Math.Cos(W * VariationHelper.PreSqrt(p));
if (Math.Abs(cos) <= VariationHelper.SmallDouble)
{
return(p);
}
var point = new Point();
var n2 = 1.0 / cos;
point.X = W * p.X;
if (cos < 0.0)
{
point.Y = W * (n2 + 1.0);
}
else
{
point.Y = W * (n2 - 1.0);
}
return(point);
}
public override Point Fun(Point p)
{
var r = VariationHelper.R(p);
var q = 1.0 / (r * r) * W;
return(new Point(p.X * q, p.Y * q));
}
public override void Init()
{
_zoom = P2;
_mode = P1;
_invert = P3;
_power = VariationHelper.Map(P4, -10, 10, 0, 10);
}
public override Point Fun(Point p)
{
var n2 = VariationHelper.Psi < 0.5 ? 1.0 : -1.0;
var sqrt = VariationHelper.R(p);
var random = VariationHelper.Psi;
double n3;
double n4;
if (random < 0.5)
{
n3 = p.X / sqrt - 1.0;
n4 = n2 * p.Y / sqrt;
}
else if (random < 0.75)
{
n3 = p.X / 3.0;
n4 = p.Y / 3.0;
}
else
{
n3 = p.X / 3.0 + 0.6666666666666666;
n4 = p.Y / 3.0;
}
var x = n3 * W;
var y = n4 * W;
return(new Point(x, y));
}
public override Point Fun(Point p)
{
var point = new Point();
if (Math.Abs(p.Y) <= W)
{
var sqrt = Math.Sqrt(VariationHelper.Sqr(W) - VariationHelper.Sqr(p.Y));
if (Math.Abs(p.X) <= sqrt)
{
var n2 = p.X + _shift * W;
if (Math.Abs(n2) >= sqrt)
{
point.X -= W * p.X;
}
else
{
point.X += W * n2;
}
}
else
{
point.X += W * p.X;
}
point.Y += W * p.Y;
}
else
{
point.X += W * p.X;
point.Y += W * p.Y;
}
return(point);
}
public override Point Fun(Point p)
{
// var r = VariationHelper.R(p);
// var theta = VariationHelper.Theta(p);
// var pp0 = Math.Sin(theta + r);
// var pp1 = Math.Cos(theta - r);
// var p0Cube = pp0 * pp0 * pp0;
// var p1Cube = pp1 * pp1 * pp1;
//
// return new Point(
// r * (p0Cube + p1Cube),
// r * (p0Cube - p1Cube));
var sqrt = VariationHelper.R(p);
var preAtan = VariationHelper.PreAtan(p);
var sin = Math.Sin(preAtan + sqrt);
var cos = Math.Cos(preAtan - sqrt);
var n2 = sin * sin * sin;
var n3 = cos * cos * cos;
var n4 = sqrt * W;
return(new Point(
n4 * (n2 + n3),
n4 * (n2 - n3)
));
}
public override Point Fun(Point p)
{
return(new Point(Math.Atan2(p.X, p.Y) * _w, (VariationHelper.R(p) - 1.0) * W));
// return new Point(
// VariationHelper.Theta(p) / Math.PI,
// VariationHelper.R(p) - 1.0);
}
public override Point Fun(Point p)
{
var x = (P3 - P1 * VariationHelper.Sqr(p.X) + p.Y) * W;
var y = P2 * p.X * W;
return(new Point(x, y));
}
public override Point Fun(Point p)
{
// var r = VariationHelper.R(p);
// var pp3 = VariationHelper.Trunc( Math.Abs(P1) * VariationHelper.Psi);
// var t = (VariationHelper.Lambda * VariationHelper.Phi(p) + 2.0 * Math.PI * pp3) / P1;
// var r2 = Math.Pow(r, P2 / P1);
// var dx = r2 * Math.Cos(t);
// var dy = r2 * Math.Sin(t);
// return new Point(dx, dy);
var random = VariationHelper.RandomNext(_absPower);
double n2;
if ((random & 0x1) == 0x0)
{
n2 = (TwoPi * random + Math.Atan2(p.Y, p.X)) / _power;
}
else
{
n2 = (TwoPi * random - Math.Atan2(p.Y, p.X)) / _power;
}
var sin = Math.Sin(n2);
var cos = Math.Cos(n2);
var n3 = W * Math.Pow(p.X * p.X + p.Y * p.Y, _cPower);
return(new Point(n3 * cos, n3 * sin));
}
public override Point Fun(Point p)
{
var n2 = (int)VariationHelper.Rint(p.X * _cs) + (int)VariationHelper.Rint(p.Y * _cs);
var n3 = P4 * VariationHelper.Psi;
var n4 = P4 * VariationHelper.Psi;
double xx;
double ncy;
if (n2 % 2 == 0)
{
xx = _ncx + n3;
ncy = _ncy;
}
else
{
xx = P1;
ncy = P2 + n4;
}
var x = W * (p.X + xx);
var y = W * (p.Y + ncy);
return(new Point(x, y));
}
public override Point Fun(Point p)
{
var point = new Point();
var n2 = _rScale * Math.Sqrt(VariationHelper.Sqr(p.X) + VariationHelper.Sqr(p.Y));
if (n2 > _rThresh && p.Y > _yThresh)
{
if (VariationHelper.Psi > 0.5)
{
var n3 = _dScale * Math.Sqrt(n2 + p.X);
if (Math.Abs(n3) <= VariationHelper.SmallDouble)
{
return(p);
}
point.X += _var2 * n3;
point.Y -= _var2 / n3 * p.Y;
}
else
{
var n4 = _dScale * (n2 + p.X);
var sqrt = Math.Sqrt(n2 * (VariationHelper.Sqr(p.Y) + VariationHelper.Sqr(n4)));
if (Math.Abs(sqrt) <= VariationHelper.SmallDouble)
{
return(p);
}
var n5 = W / sqrt;
point.X += n5 * n4;
point.Y += n5 * p.Y;
}
}
else if (VariationHelper.Psi > 0.5)
{
var n6 = _dScale * Math.Sqrt(n2 + p.X);
if (Math.Abs(n6) <= VariationHelper.SmallDouble)
{
return(p);
}
point.X -= _var2 * n6;
point.Y -= _var2 / n6 * p.Y;
}
else
{
var n7 = _dScale * (n2 + p.X);
var sqrt2 = Math.Sqrt(n2 * (VariationHelper.Sqr(p.Y) + VariationHelper.Sqr(n7)));
if (Math.Abs(sqrt2) <= VariationHelper.SmallDouble)
{
return(p);
}
var n8 = W / sqrt2;
point.X -= n8 * n7;
point.Y += n8 * p.Y;
}
return(point);
}
public override Point Fun(Point p)
{
var x = W * Math.Log(VariationHelper.Sqr(p.X) + VariationHelper.Sqr(p.Y)) * _denom;
var y = W * Math.Atan2(p.Y, p.X);
return(new Point(x, y));
}
public override Point Fun(Point p)
{
var point = new Point();
var n2 = VariationHelper.Rint(p.X) * _c;
var n3 = VariationHelper.Rint(p.Y) * _d;
if (n3 <= 0.0)
{
if (n2 > 0.0)
{
if (-n3 >= n2)
{
point.X += W * (p.X + _a);
point.Y += W * p.Y;
}
else
{
point.X += W * p.X;
point.Y += W * (p.Y + _b);
}
}
else if (n3 <= n2)
{
point.X += W * (p.X + _a);
point.Y += W * p.Y;
}
else
{
point.X += W * p.X;
point.Y += W * (p.Y - _b);
}
}
else if (n2 > 0.0)
{
if (n3 >= n2)
{
point.X += W * (p.X - _a);
point.Y += W * p.Y;
}
else
{
point.X += W * p.X;
point.Y += W * (p.Y + _b);
}
}
else if (n3 > -n2)
{
point.X += W * (p.X - _a);
point.Y += W * p.Y;
}
else
{
point.X += W * p.X;
point.Y += W * (p.Y - _b);
}
return(point);
}
public override Point Fun(Point p)
{
var r = VariationHelper.R(p);
var q = 2.0 / (r + 1.0) * W;
return(new Point(
q * p.Y,
q * p.X));
}
public override Point Fun(Point p)
{
var preAtan = VariationHelper.PreAtan(p);
var n2 = VariationHelper.R(p) * (P1 + _dif * (0.5 + 0.5 * Math.Sin(P3 * preAtan)));
var n3 = Math.Sin(preAtan) * n2;
var n4 = Math.Cos(preAtan) * n2;
return(new Point(W * n3, W * n4));
}
public override Point Fun(Point p)
{
var n2 = p.X * P1;
var n3 = VariationHelper.Sqr(p.X) + VariationHelper.Sqr(p.Y) + 1.0E-8;
var x = W * n2 * Math.Cos(n3);
var y = W * n2 * Math.Sin(n3);
return(new Point(x, y));
}
private bool HitsCircleAroundOrigin(double n, Double2 double2, MutableDouble mutableDouble)
{
if (Math.Abs(n) <= VariationHelper.SmallDouble)
{
return(true);
}
mutableDouble.Value = Math.Sqrt(VariationHelper.Sqr(double2.X) + VariationHelper.Sqr(double2.Y));
return(mutableDouble.Value <= n);
}
public override Point Fun(Point p)
{
var n2 = W * (VariationHelper.Psi - P2) * P1 / (1.0 + P1 * (p.X / VariationHelper.PreSqrt(p))) /
VariationHelper.PreSqrt(p);
var x = n2 * p.X;
var y = n2 * p.Y;
return(new Point(x, y));
}
public override Point Fun(Point p)
{
var point = new Point();
var sqrt = Math.Sqrt(VariationHelper.Sqr(p.X) + VariationHelper.Sqr(p.Y));
if (sqrt >= 1.0)
{
if (VariationHelper.Psi > 0.5)
{
var sqrt2 = Math.Sqrt(sqrt + p.X);
if (Math.Abs(sqrt2) <= VariationHelper.SmallDouble)
{
return(p);
}
point.X += _var2 * sqrt2;
point.Y -= _var2 / sqrt2 * p.Y;
}
else
{
var n2 = sqrt + p.X;
var sqrt3 = Math.Sqrt(sqrt * (VariationHelper.Sqr(p.Y) + VariationHelper.Sqr(n2)));
if (Math.Abs(sqrt3) <= VariationHelper.SmallDouble)
{
return(p);
}
var n3 = W / sqrt3;
point.X += n3 * n2;
point.Y += n3 * p.Y;
}
}
else if (VariationHelper.Psi > 0.5)
{
var sqrt4 = Math.Sqrt(sqrt + p.X);
if (Math.Abs(sqrt4) <= VariationHelper.SmallDouble)
{
return(p);
}
point.X -= _var2 * sqrt4;
point.Y -= _var2 / sqrt4 * p.Y;
}
else
{
var n4 = sqrt + p.X;
var sqrt5 = Math.Sqrt(sqrt * (VariationHelper.Sqr(p.Y) + VariationHelper.Sqr(n4)));
if (Math.Abs(sqrt5) <= VariationHelper.SmallDouble)
{
return(p);
}
var n5 = W / sqrt5;
point.X -= n5 * n4;
point.Y += n5 * p.Y;
}
return(point);
}
public override Point Fun(Point p)
{
var point = new Point();
var n2 = W / ((VariationHelper.Sqr(p.X) + VariationHelper.Sqr(p.Y)) / 4.0 + 1.0);
point.X += p.X * n2 * P1;
point.Y += p.Y * n2 * P2;
point.X += (1.0 - P3 * VariationHelper.Sqr(p.X) + p.Y) * W;
point.Y += P4 * p.X * W;
return(point);
}
public override void Init()
{
_seed = (int)VariationHelper.Map(P1, -10, 10, int.MinValue, int.MaxValue);
_mode = P2;
_zoom = VariationHelper.Map(P3, -10, 10, -20, 20);
_invert = P4;
_vec3 = new Vec3(1.0);
_randomize = new Random(_seed);
_x0 = _seed * _randomize.NextDouble();
_y0 = _seed * _randomize.NextDouble();
}
public override void Init()
{
var seed = (int)VariationHelper.Map(P1, -10, 10, int.MinValue, int.MaxValue);
_randomize = new Random(seed);
_x0 = 0.0;
_y0 = 0.0;
_theta = 0.0;
_phi = 0.0;
_s = _randomize.NextDouble();
}
