public static bool Example_EvaluateUnitTorus(SpanF qx, SpanF qy, SpanF qz)
{
// var qv = spanVectorScale (
// spanVector (qx, qy, qz),
// spanExactly (1.0)
// );
var scaler = spanExactly(1.75);
var qv = spanVector(
spanMult(qx, scaler),
spanMult(qy, scaler),
spanMult(qz, scaler));
var plane = spanVectorNormalize(spanVector(qv.X, qv.Y, spanExactly(0)));
var delta = spanVectorMagnitude(spanVectorSubtract(qv, plane));
return(spanContains(delta, 1.0));
// var r = spanDivide (spanExactly (1.0), spanVectorMagnitude (qv));
// var up = spanVector (spanExactly (0), spanExactly (1), spanExactly (0));
// var c = spanVectorCross (qv, up);
// var m = spanVectorMagnitude (c);
//
// var f = spanMult (m, r);
// return spanContains (f, 1.0);
}
public static Cubic <float> spanColorSignedToRGB(SpanF v)
{
return(Cubic <float> .Create(
spanColorChannelToFloat(spanColorSignedForRed(v)),
spanColorChannelToFloat(spanColorSignedForGreen(v)),
spanColorChannelToFloat(spanColorSignedForBlue(v))));
}
public static SpanF spanDivide(SpanF _sa, SpanF _sb)
{
spanCheck(_sa);
spanCheck(_sb);
return(spanUnsorted4(_sa.From / _sb.From, _sa.From / _sb.To, _sa.To / _sb.From, _sa.To / _sb.To));
//return spanUnsorted(_sa.From / _sb.From, _sa.To / _sb.To);
}
// Span Creation Methods:
public static SpanF span(double from, double to)
{
var ans = SpanF.Create(from, to);
spanCheck(ans);
return(ans);
}
public static Cubic <SpanF> spanVectorScale(Cubic <SpanF> a, SpanF scl)
{
return(new Cubic <SpanF> (
spanMult(a.X, scl),
spanMult(a.Y, scl),
spanMult(a.Z, scl)));
}
public Color ColorFromChakraField(SpanF pct)
{
Color curColor = this.ChakraColor;
curColor.a = Mathf.Clamp01((float)(((pct.From + pct.To) * 0.5) * 1.0));
return(curColor);
}
public static SpanF spanProjSpan(SpanOf <SpanF> _sproj, SpanF _sindex)
{
spanProjCheck(_sproj);
spanCheck(_sindex);
return(spanAdd(spanExactly(_sproj.From.To),
spanMult(_sproj.To, spanAdd(_sindex, spanExactly(-_sproj.From.From)))));
//return spanAdd(_sproj.From, spanMult(_sproj.To, _sindex));
}
public static SpanF spanGreaterThan(SpanF _sa, SpanF _sb)
{
WeakTODO(); // the line below is not good
var cmpr = spanSubtract(_sa, _sb);
var d = ((((cmpr.From + cmpr.To) * 0.5) > 0.0) ? 1.0 : 0.0);
return(span(d, d));
}
public static SpanF spanBounded(SpanF _sa, SpanF _val)
{
spanCheck(_sa);
spanCheck(_val);
return(span(
util_bounded(_sa.From, _val.From, _val.To),
util_bounded(_sa.To, _val.From, _val.To)));
}
public static SpanF spanClampRange(SpanF v, SpanF range)
{
spanCheck(v);
spanCheck(range);
return(span(
spanClampValue(v.From, range),
spanClampValue(v.To, range)));
}
public static Color Example_SpanToColor(SpanF _s)
{
var f = Example_SingleToColor(_s.From);
var m = Example_SingleToColor(util_spanCenter(_s));
var t = Example_SingleToColor(_s.To);
return(Color.Lerp(Color.Lerp(f, t, 0.5f), m, 0.5f));
}
public static SpanF spanAbs(SpanF _s)
{
var ans = spanUnsorted(Math.Abs(_s.From), Math.Abs(_s.To));
if (spanContains(_s, 0.0))
{
ans = spanIncluding(ans, 0.0);
}
return(ans);
}
public static SpanOf <SpanF> spanProjFromDomainAndRange(SpanF _sdomain, SpanF _srange)
{
spanCheck(_sdomain);
spanCheck(_srange);
var delta = (_srange.To - _srange.From) / (_sdomain.To - _sdomain.From);
return(new SpanOf <SpanF>(
spanCreateInvalid(_sdomain.From, _srange.From),
spanExactly(delta)));
}
/*
* function spanColorSignedForGreen(v) {
* return v.boundedBy(span(-1.0, 1.0)).times(exactly(Math.PI)).cos().times(exactly(0.5)).add(exactly(0.5));
* }
*
* function spanColorSignedForRed(v) {
* return spanColorSignedForGreen(v.add(exactly(-0.5)).times(exactly(1.0)));
* }
*
* function spanColorSignedForBlue(v) {
* return spanColorSignedForGreen(v.add(exactly(0.5)).times(exactly(1.0)));
* }
*/
// Example Math Stuff:
public static bool Example_EvaluateUnitCircle(SpanF qx, SpanF qy, SpanF qz)
{
//return qz.To > qy.To;
//return spanContains (spanAdd (spanMult (qx, qx), spanMult (qy, qy)), 1);
return(spanContains(
spanAdd(spanAdd(
spanMult(qx, qx),
spanMult(qy, qy)
), spanMult(qz, qz))
, 1));
}
public static SpanF spanATan2(SpanF _y, SpanF _x)
{
WeakTODO();
return(spanUnsorted4(
Math.Atan2(_y.From, _x.From),
Math.Atan2(_y.From, _x.To),
Math.Atan2(_y.To, _x.From),
Math.Atan2(_y.To, _x.To)
));
}
void ContextMenu_TestColorSystem()
{
int maxi = 10;
double dm = 1.0 / maxi;
for (int i = -maxi; i < maxi; i++)
{
var fi = ((double)i) / ((double)(maxi / 2));
var s = SpanF.Create(fi, fi + dm);
var g = SpanAPI.spanColorSignedForGreen(s);
Debug.Log("s=g: " + s + "=" + g);
}
}
public static void spanCheck(SpanF chk)
{
if (double.IsInfinity(chk.From) || double.IsInfinity(chk.To))
{
return;
}
if (double.IsNaN(chk.From) || double.IsNaN(chk.To))
{
return;
//throw new ArgumentOutOfRangeException("Span contains NaN: " + chk.ToString() );
}
if ((chk.To >= chk.From))
{
}
else
{
throw new ArgumentOutOfRangeException("Not a valid span!: " + chk.ToString());
}
}
public static SpanF spanSin(SpanF _s)
{
spanCheck(_s);
var ans = spanUnsorted(Math.Sin(_s.From), Math.Sin(_s.To));
// TODO: Optimize, this walks through the critcal points ensuring they are in the interval:
var cycleLength = Math.PI / 4.0;
var unitFrom = _s.From / cycleLength;
var unitTo = Math.Min(_s.To / cycleLength, unitFrom + (cycleLength * 6));
while (Math.Floor(unitFrom) < Math.Floor(unitTo))
{
unitFrom = Math.Floor(unitFrom) + 1;
var curVal = Math.Sin(unitFrom * cycleLength);
ans = spanIncluding(ans, curVal);
}
return(ans);
}
public static double util_spanCenter(SpanF _s)
{
return((_s.From + _s.To) * 0.5f);
}
public SpanF times(SpanF other)
{
return(SpanAPI.spanMult(this, other));
}
public static Cubic <SpanF> Example_FieldFromParticle(Cubic <SpanF> pos, Cubic <SpanF> particle, SpanF charge)
{
var r1 = spanVectorSubtract(pos, particle);
var invSqrR1 = spanDivide(spanExactly(1), spanVectorDot(r1, r1));
var nr = spanVectorNormalize(r1);
var ans = spanVectorScale(nr, spanMult(charge, invSqrR1));
return(ans);
}
public SpanF minus(SpanF other)
{
return(SpanAPI.spanSubtract(this, other));
}
public static SpanF spanIncluding(SpanF _s, double _val)
{
spanCheck(_s);
return(span(Math.Min(_s.From, _val), Math.Max(_s.To, _val)));
}
public SpanF add(SpanF other)
{
return(SpanAPI.spanAdd(this, other));
}
public static SpanF spanSqrt(SpanF _s)
{
spanCheck(_s);
return(span(util_sqrtSigned(_s.From), util_sqrtSigned(_s.To)));
}
public static float spanColorChannelToFloat(SpanF v)
{
return((float)(v.To + v.From) * 0.5f);
}
public static SpanF spanColorSignedForBlue(SpanF v)
{
return(spanColorSignedForGreen(v.add(SpanF.exactly(0.5)).times(SpanF.exactly(1.0))));
}
// Color System:
public static SpanF spanColorSignedForGreen(SpanF v)
{
return(v.boundedBy(span(-1.0, 1.0)).times(SpanF.exactly(Math.PI)).cos().times(SpanF.exactly(0.5)).add(SpanF.exactly(0.5)));
}
public SpanF boundedBy(SpanF range)
{
return(SpanAPI.spanBounded(this, range));
}
// Span Vector Operations
public static Cubic <SpanF> spanVector(SpanF x, SpanF y, SpanF z)
{
return(new Cubic <SpanF> (x, y, z));
}
