Neuron®
The Neuron® is the basis for the creation of open and secure federated networks for smart societies.
Loading...
Searching...
No Matches
NewtonSmoothFractal.cs
1using System;
2using System.Numerics;
3using System.Text;
4using SkiaSharp;
5using Waher.Script.Abstraction.Elements;
6using Waher.Script.Exceptions;
7using Waher.Script.Graphs;
8using Waher.Script.Model;
9using Waher.Script.Objects.VectorSpaces;
10
11namespace Waher.Script.Fractals.ComplexFractals
12{
48 public class NewtonSmoothFractal : FunctionMultiVariate
49 {
53 public NewtonSmoothFractal(ScriptNode z, ScriptNode dr, ScriptNode R, ScriptNode c, ScriptNode Palette,
54 ScriptNode DimX, ScriptNode DimY, int Start, int Length, Expression Expression)
55 : base(new ScriptNode[] { z, dr, R, c, Palette, DimX, DimY },
56 new ArgumentType[] { ArgumentType.Scalar, ArgumentType.Scalar, ArgumentType.Scalar,
57 ArgumentType.Normal, ArgumentType.Vector, ArgumentType.Scalar, ArgumentType.Scalar},
58 Start, Length, Expression)
59 {
60 }
61
65 public NewtonSmoothFractal(ScriptNode z, ScriptNode dr, ScriptNode R, ScriptNode c, ScriptNode Palette,
66 ScriptNode DimX, int Start, int Length, Expression Expression)
67 : base(new ScriptNode[] { z, dr, R, c, Palette, DimX },
68 new ArgumentType[] { ArgumentType.Scalar, ArgumentType.Scalar, ArgumentType.Scalar,
69 ArgumentType.Normal, ArgumentType.Vector, ArgumentType.Scalar},
70 Start, Length, Expression)
71 {
72 }
73
77 public NewtonSmoothFractal(ScriptNode z, ScriptNode dr, ScriptNode R, ScriptNode c, ScriptNode Palette,
78 int Start, int Length, Expression Expression)
79 : base(new ScriptNode[] { z, dr, R, c, Palette },
80 new ArgumentType[] { ArgumentType.Scalar, ArgumentType.Scalar, ArgumentType.Scalar,
81 ArgumentType.Normal, ArgumentType.Vector },
82 Start, Length, Expression)
83 {
84 }
85
89 public NewtonSmoothFractal(ScriptNode z, ScriptNode dr, ScriptNode R, ScriptNode c,
90 int Start, int Length, Expression Expression)
91 : base(new ScriptNode[] { z, dr, R, c },
92 new ArgumentType[] { ArgumentType.Scalar, ArgumentType.Scalar, ArgumentType.Scalar,
93 ArgumentType.Normal },
94 Start, Length, Expression)
95 {
96 }
97
101 public override string[] DefaultArgumentNames
102 {
103 get
104 {
105 return new string[] { "z", "dr", "R", "c", "Palette", "DimX", "DimY" };
106 }
107 }
108
112 public override IElement Evaluate(IElement[] Arguments, Variables Variables)
113 {
114 string ColorExpression = null;
115 SKColor[] Palette;
116 double[] Coefficients = null;
117 Complex[] CoefficientsZ = null;
118 ILambdaExpression f = null;
119 ScriptNode fDef = null;
120 double rc, ic;
121 double dr;
122 Complex R;
123 int dimx, dimy;
124 int c = Arguments.Length;
125 int i = 0;
126 object Obj;
127
128 Obj = Arguments[i++].AssociatedObjectValue;
129 if (Obj is Complex z)
130 {
131 rc = z.Real;
132 ic = z.Imaginary;
133 }
134 else
135 {
136 rc = Expression.ToDouble(Obj);
137 ic = Expression.ToDouble(Arguments[i++].AssociatedObjectValue);
138 }
139
140 if (i >= c)
141 throw new ScriptRuntimeException("Insufficient parameters in call to NewtonSmoothFractal().", this);
142
143 dr = Expression.ToDouble(Arguments[i++].AssociatedObjectValue);
144
145 if (i < c && ((Obj = Arguments[i].AssociatedObjectValue) is double || Obj is Complex))
146 {
147 R = Expression.ToComplex(Obj);
148 i++;
149 }
150 else
151 {
152 R = Complex.One;
153
154 if (i < c && this.Arguments[i] is null)
155 i++;
156 }
157
158 if (i < c)
159 {
160 if (Arguments[i] is DoubleVector)
161 Coefficients = (double[])Arguments[i++].AssociatedObjectValue;
162 else if (Arguments[i] is ComplexVector)
163 CoefficientsZ = (Complex[])Arguments[i++].AssociatedObjectValue;
164 /*else if (Parameters[i] is RealPolynomial)
165 Coefficients = ((RealPolynomial)Arguments[i++].AssociatedObjectValue).Coefficients;
166 else if (Parameters[i] is ComplexPolynomial)
167 CoefficientsZ = ((ComplexPolynomial)Arguments[i++].AssociatedObjectValue).Coefficients;*/
168 else if (Arguments[i] is IVector)
169 {
170 IVector Vector = (IVector)Arguments[i++];
171 int j, d = Vector.Dimension;
172
173 CoefficientsZ = new Complex[d];
174 for (j = 0; j < d; j++)
175 CoefficientsZ[j] = Expression.ToComplex(Vector.GetElement(j).AssociatedObjectValue);
176 }
177 else if (Arguments[i].AssociatedObjectValue is ILambdaExpression)
178 {
179 f = (ILambdaExpression)Arguments[i];
180 if (f.NrArguments != 1)
181 throw new ScriptRuntimeException("Lambda expression in calls to NewtonSmoothFractal() must be of one variable.", this);
182
183 fDef = this.Arguments[i++];
184 }
185 else
186 {
187 throw new ScriptRuntimeException("Parameter " + (i + 1).ToString() +
188 " in call to NewtonSmoothFractal has to be a vector of numbers, containing coefficients " +
189 "of the polynomial to use. Now it was of type " + Arguments[i].GetType().FullName,
190 this);
191 }
192 }
193 else
194 throw new ScriptRuntimeException("Missing coefficients or lambda expression.", this);
195
196 if (i < c && !(this.Arguments[i] is null) && Arguments[i] is ObjectVector)
197 {
198 ColorExpression = this.Arguments[i].SubExpression;
199 Palette = FractalGraph.ToPalette((ObjectVector)Arguments[i++]);
200 }
201 else
202 {
203 Palette = ColorModels.RandomLinearAnalogousHSL.CreatePalette(128, 4, out int Seed, this, Variables);
204 ColorExpression = "RandomLinearAnalogousHSL(128,4," + Seed.ToString() + ")";
205
206 if (i < c && this.Arguments[i] is null)
207 i++;
208 }
209
210 if (i < c)
211 dimx = (int)Expression.ToDouble(Arguments[i++].AssociatedObjectValue);
212 else
213 dimx = 320;
214
215 if (i < c)
216 dimy = (int)Expression.ToDouble(Arguments[i++].AssociatedObjectValue);
217 else
218 dimy = 200;
219
220 if (i < c)
221 {
222 throw new ScriptRuntimeException("Parameter mismatch in call to NewtonSmoothFractal(r,c,dr,Coefficients[,Palette][,dimx[,dimy]]).",
223 this);
224 }
225
226 if (dimx <= 0 || dimx > 5000 || dimy <= 0 || dimy > 5000)
227 throw new ScriptRuntimeException("Image size must be within 1x1 to 5000x5000", this);
228
229 if (!(f is null))
230 {
231 return CalcNewtonSmooth(rc, ic, dr, R, f, Variables, Palette, dimx, dimy, this, this.FractalZoomScript,
232 new object[] { Palette, dimx, dimy, R, fDef, ColorExpression });
233 }
234 else if (!(CoefficientsZ is null))
235 {
236 return CalcNewtonSmooth(rc, ic, dr, R, CoefficientsZ, Palette, dimx, dimy,
237 this, Variables, this.FractalZoomScript,
238 new object[] { Palette, dimx, dimy, R, CoefficientsZ, ColorExpression });
239 }
240 else
241 {
242 return CalcNewtonSmooth(rc, ic, dr, R, Coefficients, Palette, dimx, dimy,
243 this, Variables, this.FractalZoomScript,
244 new object[] { Palette, dimx, dimy, R, Coefficients, ColorExpression });
245 }
246 }
247
248 private string FractalZoomScript(double r, double i, double Size, object State)
249 {
250 object[] Parameters = (object[])State;
251 int DimX = (int)Parameters[1];
252 int DimY = (int)Parameters[2];
253 Complex R = (Complex)Parameters[3];
254 double[] Coefficients = Parameters[4] as double[];
255 string ColorExpression = (string)Parameters[5];
256
257 StringBuilder sb = new StringBuilder();
258
259 sb.Append("NewtonSmoothFractal((");
260 sb.Append(Expression.ToString(r));
261 sb.Append(',');
262 sb.Append(Expression.ToString(i));
263 sb.Append("),");
264 sb.Append(Expression.ToString(Size / 4));
265 sb.Append(',');
266 sb.Append(Expression.ToString(R));
267 sb.Append(',');
268
269 if (Parameters[4] is ScriptNode fDef)
270 sb.Append(fDef.SubExpression);
271 else if (Parameters[4] is Complex[] CoefficientsZ)
272 sb.Append(Expression.ToString(CoefficientsZ));
273 else
274 sb.Append(Expression.ToString(Coefficients));
275
276 if (!string.IsNullOrEmpty(ColorExpression))
277 {
278 sb.Append(',');
279 sb.Append(ColorExpression);
280 }
281
282 sb.Append(',');
283 sb.Append(DimX.ToString());
284 sb.Append(',');
285 sb.Append(DimY.ToString());
286 sb.Append(')');
287
288 return sb.ToString();
289 }
290
294 public static FractalGraph CalcNewtonSmooth(double rCenter, double iCenter, double rDelta, Complex R,
295 double[] Coefficients, SKColor[] Palette, int Width, int Height, ScriptNode Node, Variables Variables,
296 FractalZoomScript FractalZoomScript, object State)
297 {
298 double RRe = R.Real;
299 double RIm = R.Imaginary;
300 double r0, i0, r1, i1;
301 double dr, di;
302 double r, i;
303 double zr, zi, zr2, zi2, zr3, zi3, zr4, zi4;
304 double aspect;
305 double Temp;
306 int x, y;
307 int n, N;
308 int Degree = Coefficients.Length - 1;
309
310 N = Palette.Length;
311
312 if (Degree < 2)
313 {
314 Array.Resize(ref Coefficients, 3);
315 while (Degree < 2)
316 Coefficients[++Degree] = 0;
317 }
318
319 if (Width <= 2 || Height <= 2)
320 throw new ScriptRuntimeException("Width and Height has to be greater than 2.", Node);
321
322 double[] Prim = new double[Degree];
323 for (x = 1; x <= Degree; x++)
324 Prim[x - 1] = x * Coefficients[x];
325
326 Array.Reverse(Prim);
327 Coefficients = (double[])Coefficients.Clone();
328 Array.Reverse(Coefficients);
329
330 int Size = Width * Height;
331 double Conv = 1e-10;
332 double Div = 1e10;
333 double[] ColorIndex = new double[Size];
334 int Index = 0;
335
336 rDelta *= 0.5;
337 r0 = rCenter - rDelta;
338 r1 = rCenter + rDelta;
339
340 aspect = ((double)Width) / Height;
341
342 i0 = iCenter - rDelta / aspect;
343 i1 = iCenter + rDelta / aspect;
344
345 dr = (r1 - r0) / Width;
346 di = (i1 - i0) / Height;
347
348 for (y = 0, i = i0; y < Height; y++, i += di)
349 {
350 for (x = 0, r = r0; x < Width; x++, r += dr)
351 {
352 zr = r;
353 zi = i;
354
355 n = 0;
356 do
357 {
358 // f:
359 zr2 = zi2 = 0;
360 foreach (double C in Coefficients)
361 {
362 Temp = zr2 * zr - zi2 * zi + C;
363 zi2 = zr2 * zi + zi2 * zr;
364 zr2 = Temp;
365 }
366
367 // f':
368 zr3 = zi3 = 0;
369 foreach (double C in Prim)
370 {
371 Temp = zr3 * zr - zi3 * zi + C;
372 zi3 = zr3 * zi + zi3 * zr;
373 zr3 = Temp;
374 }
375
376 // f/f':
377
378 Temp = 1.0 / (zr3 * zr3 + zi3 * zi3);
379 zr4 = (zr2 * zr3 + zi2 * zi3) * Temp;
380 zi4 = (zi2 * zr3 - zr2 * zi3) * Temp;
381
382 // R*f/f'
383 Temp = zr4 * RRe - zi4 * RIm;
384 zi4 = zr4 * RIm + zi4 * RRe;
385 zr4 = Temp;
386
387 zr -= zr4;
388 zi -= zi4;
389
390 Temp = Math.Sqrt(zr4 * zr4 + zi4 * zi4);
391 }
392 while ((Temp > Conv) && (Temp < Div) && (n++ < N));
393
394 if (Temp < Conv && n < N)
395 ColorIndex[Index++] = n;
396 else
397 ColorIndex[Index++] = N;
398 }
399 }
400
401 Variables.Preview(Node.Expression, new GraphBitmap(Variables, FractalGraph.ToPixels(ColorIndex, Width, Height, Palette)));
402
403 double[] Boundary = FractalGraph.FindBoundaries(ColorIndex, Width, Height);
404 FractalGraph.Smooth(ColorIndex, Boundary, Width, Height, N, Palette, Node, Variables);
405
406 return new FractalGraph(Variables, FractalGraph.ToPixels(ColorIndex, Width, Height, Palette),
407 r0, i0, r1, i1, rDelta * 2, true, Node, FractalZoomScript, State);
408 }
409
413 public static FractalGraph CalcNewtonSmooth(double rCenter, double iCenter, double rDelta, Complex R,
414 Complex[] Coefficients, SKColor[] Palette, int Width, int Height, ScriptNode Node, Variables Variables,
415 FractalZoomScript FractalZoomScript, object State)
416 {
417 double RRe = R.Real;
418 double RIm = R.Imaginary;
419 double r0, i0, r1, i1;
420 double dr, di;
421 double r, i;
422 double zr, zi, zr2, zi2, zr3, zi3, zr4, zi4;
423 double aspect;
424 double Temp;
425 int x, y;
426 int n, N;
427 int Degree = Coefficients.Length - 1;
428
429 N = Palette.Length;
430
431 if (Degree < 2)
432 {
433 Array.Resize(ref Coefficients, 3);
434 while (Degree < 2)
435 Coefficients[++Degree] = Complex.Zero;
436 }
437
438 if (Width <= 2 || Height <= 2)
439 throw new ScriptRuntimeException("Width and Height has to be greater than 2.", Node);
440
441 Complex[] Prim = new Complex[Degree];
442 for (x = 1; x <= Degree; x++)
443 Prim[x - 1] = x * Coefficients[x];
444
445 Array.Reverse(Prim);
446 Coefficients = (Complex[])Coefficients.Clone();
447 Array.Reverse(Coefficients);
448
449 int j, c = Prim.Length;
450 double[] ReC = new double[c + 1];
451 double[] ImC = new double[c + 1];
452 double[] RePrim = new double[c];
453 double[] ImPrim = new double[c];
454 Complex z;
455
456 for (j = 0; j < c; j++)
457 {
458 z = Coefficients[j];
459 ReC[j] = z.Real;
460 ImC[j] = z.Imaginary;
461
462 z = Prim[j];
463 RePrim[j] = z.Real;
464 ImPrim[j] = z.Imaginary;
465 }
466
467 z = Coefficients[j];
468 ReC[j] = z.Real;
469 ImC[j] = z.Imaginary;
470
471 int Size = Width * Height;
472 double Conv = 1e-10;
473 double Div = 1e10;
474 double[] ColorIndex = new double[Size];
475 int Index = 0;
476
477 rDelta *= 0.5;
478 r0 = rCenter - rDelta;
479 r1 = rCenter + rDelta;
480
481 aspect = ((double)Width) / Height;
482
483 i0 = iCenter - rDelta / aspect;
484 i1 = iCenter + rDelta / aspect;
485
486 dr = (r1 - r0) / Width;
487 di = (i1 - i0) / Height;
488
489 for (y = 0, i = i0; y < Height; y++, i += di)
490 {
491 for (x = 0, r = r0; x < Width; x++, r += dr)
492 {
493 zr = r;
494 zi = i;
495
496 n = 0;
497 do
498 {
499 // f:
500 zr2 = zi2 = 0;
501 for (j = 0; j <= c; j++)
502 {
503 Temp = zr2 * zr - zi2 * zi + ReC[j];
504 zi2 = zr2 * zi + zi2 * zr + ImC[j];
505 zr2 = Temp;
506 }
507
508 // f':
509 zr3 = zi3 = 0;
510 for (j = 0; j < c; j++)
511 {
512 Temp = zr3 * zr - zi3 * zi + RePrim[j];
513 zi3 = zr3 * zi + zi3 * zr + ImPrim[j];
514 zr3 = Temp;
515 }
516
517 // f/f':
518
519 Temp = 1.0 / (zr3 * zr3 + zi3 * zi3);
520 zr4 = (zr2 * zr3 + zi2 * zi3) * Temp;
521 zi4 = (zi2 * zr3 - zr2 * zi3) * Temp;
522
523 // R*f/f'
524 Temp = zr4 * RRe - zi4 * RIm;
525 zi4 = zr4 * RIm + zi4 * RRe;
526 zr4 = Temp;
527
528 zr -= zr4;
529 zi -= zi4;
530
531 Temp = Math.Sqrt(zr4 * zr4 + zi4 * zi4);
532 }
533 while ((Temp > Conv) && (Temp < Div) && (n++ < N));
534
535 if (Temp < Conv && n < N)
536 ColorIndex[Index++] = n;
537 else
538 ColorIndex[Index++] = N;
539 }
540 }
541
542 Variables.Preview(Node.Expression, new GraphBitmap(Variables, FractalGraph.ToPixels(ColorIndex, Width, Height, Palette)));
543
544 double[] Boundary = FractalGraph.FindBoundaries(ColorIndex, Width, Height);
545 FractalGraph.Smooth(ColorIndex, Boundary, Width, Height, N, Palette, Node, Variables);
546
547 return new FractalGraph(Variables, FractalGraph.ToPixels(ColorIndex, Width, Height, Palette),
548 r0, i0, r1, i1, rDelta * 2, true, Node, FractalZoomScript, State);
549 }
550
554 public static FractalGraph CalcNewtonSmooth(double rCenter, double iCenter, double rDelta, Complex R,
555 ILambdaExpression f, Variables Variables, SKColor[] Palette, int Width, int Height,
556 ScriptNode Node, FractalZoomScript FractalZoomScript, object State)
557 {
558 double RRe = R.Real;
559 double RIm = R.Imaginary;
560 double r0, i0, r1, i1;
561 double dr, di;
562 double r, i;
563 double aspect;
564 int x, y;
565 int n, N;
566
567 N = Palette.Length;
568
569 if (Width <= 2 || Height <= 2)
570 throw new ScriptRuntimeException("Width and Height has to be greater than 2.", Node);
571
572 Variables v = new Variables();
573 Variables.CopyTo(v);
574
575 if (!(f is IDifferentiable Differentiable) ||
576 !(Differentiable.Differentiate(Differentiable.DefaultVariableName, v) is ILambdaExpression fPrim))
577 {
578 throw new ScriptRuntimeException("Lambda expression not differentiable.", Node);
579 }
580
581 int Size = Width * Height;
582 double Conv = 1e-10;
583 double Div = 1e10;
584 double[] ColorIndex = new double[Size];
585 int Index = 0;
586
587 Complex[] Row;
588 Complex[] Row2;
589 Complex[] Row3;
590 int[] Offset;
591 IElement[] P = new IElement[1];
592 int j, c, x2;
593 IElement Obj, Obj2;
594 double Mod;
595 Complex z;
596
597 rDelta *= 0.5;
598 r0 = rCenter - rDelta;
599 r1 = rCenter + rDelta;
600
601 aspect = ((double)Width) / Height;
602
603 i0 = iCenter - rDelta / aspect;
604 i1 = iCenter + rDelta / aspect;
605
606 dr = (r1 - r0) / Width;
607 di = (i1 - i0) / Height;
608
609 for (y = 0, i = i0; y < Height; y++, i += di)
610 {
611 Row = new Complex[Width];
612 Offset = new int[Width];
613
614 c = Width;
615 for (x = 0, x2 = y * Width, r = r0; x < Width; x++, r += dr, x2++)
616 {
617 Row[x] = new Complex(r, i);
618 Offset[x] = x2;
619 }
620
621 n = 0;
622 while (n < N && c > 0)
623 {
624 n++;
625 P[0] = new ComplexVector(Row);
626 Obj = f.Evaluate(P, v);
627 Obj2 = fPrim.Evaluate(P, v);
628 Row2 = Obj.AssociatedObjectValue as Complex[];
629 Row3 = Obj2.AssociatedObjectValue as Complex[];
630
631 if (Row2 is null || Row3 is null)
632 {
633 throw new ScriptRuntimeException("Lambda expression (and its first derivative) must be able to accept complex vectors, " +
634 "and return complex vectors of equal length. Type returned: " +
635 Obj.GetType().FullName + " and " + Obj2.GetType().FullName, Node);
636 }
637 else if (Row2.Length != c || Row3.Length != c)
638 {
639 throw new ScriptRuntimeException("Lambda expression (and its first derivative) must be able to accept complex vectors, " +
640 "and return complex vectors of equal length. Length returned: " +
641 Row2.Length.ToString() + " and " + Row3.Length.ToString() +
642 ". Expected: " + c.ToString(), Node);
643 }
644
645 for (x = x2 = 0; x < c; x++)
646 {
647 j = Offset[x];
648 z = R * Row2[x] / Row3[x];
649 Row[x] -= z;
650
651 Mod = z.Magnitude;
652
653 if (Mod > Conv && Mod < Div)
654 {
655 if (x != x2)
656 Offset[x2] = j;
657
658 x2++;
659 }
660 else
661 {
662 if (n >= N)
663 ColorIndex[Index++] = N;
664 else
665 ColorIndex[j++] = n;
666 }
667 }
668
669 if (x2 < x)
670 {
671 Array.Resize(ref Row, x2);
672 Array.Resize(ref Offset, x2);
673 c = x2;
674 }
675 }
676 }
677
678 Variables.Preview(Node.Expression, new GraphBitmap(Variables, FractalGraph.ToPixels(ColorIndex, Width, Height, Palette)));
679
680 double[] Boundary = FractalGraph.FindBoundaries(ColorIndex, Width, Height);
681 FractalGraph.Smooth(ColorIndex, Boundary, Width, Height, N, Palette, Node, Variables);
682
683 return new FractalGraph(Variables, FractalGraph.ToPixels(ColorIndex, Width, Height, Palette),
684 r0, i0, r1, i1, rDelta * 2, true, Node, FractalZoomScript, State);
685 }
686
690 public override string FunctionName => nameof(NewtonSmoothFractal);
691 }
692}
Waher.Script.Expression
Class managing a script expression.
Definition: Expression.cs:39
Waher.Script.Expression.ToComplex
static Complex ToComplex(object Object)
Converts an object to a complex value.
Definition: Expression.cs:4942
Waher.Script.Expression.ToDouble
static double ToDouble(object Object)
Converts an object to a double value.
Definition: Expression.cs:4824
Waher.Script.Expression.ToString
static string ToString(double Value)
Converts a value to a string, that can be parsed as part of an expression.
Definition: Expression.cs:4496
Waher.Script.Fractals.ComplexFractals.NewtonSmoothFractal
Calculates a Newton Fractal Image, and smoothes the colors using the heat equation in two spatial dim...
Definition: NewtonSmoothFractal.cs:49
Waher.Script.Fractals.ComplexFractals.NewtonSmoothFractal.NewtonSmoothFractal
NewtonSmoothFractal(ScriptNode z, ScriptNode dr, ScriptNode R, ScriptNode c, ScriptNode Palette, ScriptNode DimX, int Start, int Length, Expression Expression)
TODO
Definition: NewtonSmoothFractal.cs:65
Waher.Script.Fractals.ComplexFractals.NewtonSmoothFractal.NewtonSmoothFractal
NewtonSmoothFractal(ScriptNode z, ScriptNode dr, ScriptNode R, ScriptNode c, int Start, int Length, Expression Expression)
TODO
Definition: NewtonSmoothFractal.cs:89
Waher.Script.Fractals.ComplexFractals.NewtonSmoothFractal.Evaluate
override IElement Evaluate(IElement[] Arguments, Variables Variables)
TODO
Definition: NewtonSmoothFractal.cs:112
Waher.Script.Fractals.ComplexFractals.NewtonSmoothFractal.CalcNewtonSmooth
static FractalGraph CalcNewtonSmooth(double rCenter, double iCenter, double rDelta, Complex R, Complex[] Coefficients, SKColor[] Palette, int Width, int Height, ScriptNode Node, Variables Variables, FractalZoomScript FractalZoomScript, object State)
TODO
Definition: NewtonSmoothFractal.cs:413
Waher.Script.Fractals.ComplexFractals.NewtonSmoothFractal.NewtonSmoothFractal
NewtonSmoothFractal(ScriptNode z, ScriptNode dr, ScriptNode R, ScriptNode c, ScriptNode Palette, ScriptNode DimX, ScriptNode DimY, int Start, int Length, Expression Expression)
TODO
Definition: NewtonSmoothFractal.cs:53
Waher.Script.Fractals.ComplexFractals.NewtonSmoothFractal.CalcNewtonSmooth
static FractalGraph CalcNewtonSmooth(double rCenter, double iCenter, double rDelta, Complex R, ILambdaExpression f, Variables Variables, SKColor[] Palette, int Width, int Height, ScriptNode Node, FractalZoomScript FractalZoomScript, object State)
TODO
Definition: NewtonSmoothFractal.cs:554
Waher.Script.Fractals.ComplexFractals.NewtonSmoothFractal.NewtonSmoothFractal
NewtonSmoothFractal(ScriptNode z, ScriptNode dr, ScriptNode R, ScriptNode c, ScriptNode Palette, int Start, int Length, Expression Expression)
TODO
Definition: NewtonSmoothFractal.cs:77
Waher.Script.Fractals.ComplexFractals.NewtonSmoothFractal.CalcNewtonSmooth
static FractalGraph CalcNewtonSmooth(double rCenter, double iCenter, double rDelta, Complex R, double[] Coefficients, SKColor[] Palette, int Width, int Height, ScriptNode Node, Variables Variables, FractalZoomScript FractalZoomScript, object State)
TODO
Definition: NewtonSmoothFractal.cs:294
Waher.Script.Fractals.FractalGraph
Defines a clickable fractal graph in the complex plane.
Definition: FractalGraph.cs:22
Waher.Script.Fractals.FractalGraph.ToPixels
static PixelInformation ToPixels(double[] ColorIndex, int Width, int Height, SKColor[] Palette)
TODO
Definition: FractalGraph.cs:1118
Waher.Script.Fractals.FractalGraph.ToPalette
static SKColor[] ToPalette(ObjectVector Vector)
TODO
Definition: FractalGraph.cs:101
Waher.Script.Fractals.FractalGraph.FindBoundaries
static double[] FindBoundaries(double[] ColorIndex, int Width, int Height)
TODO
Definition: FractalGraph.cs:371
Waher.Script.Fractals.FractalGraph.Smooth
static void Smooth(double[] ColorIndex, double[] Boundary, int Width, int Height, int N, SKColor[] Palette, ScriptNode Node, Variables Variables)
TODO
Definition: FractalGraph.cs:115
Waher.Script.Graphs.GraphBitmap
Handles bitmap-based graphs.
Definition: GraphBitmap.cs:13
Waher.Script.Model.FunctionMultiVariate
Base class for multivariate funcions.
Definition: FunctionMultiVariate.cs:15
Waher.Script.Model.FunctionMultiVariate.Arguments
ScriptNode[] Arguments
Function arguments.
Definition: FunctionMultiVariate.cs:183
Waher.Script.Model.ScriptNode
Base class for all nodes in a parsed script tree.
Definition: ScriptNode.cs:69
Waher.Script.Model.ScriptNode.Length
int Length
Length of expression covered by node.
Definition: ScriptNode.cs:101
Waher.Script.Model.ScriptNode.ToString
override string ToString()
Definition: ScriptNode.cs:359
Waher.Script.Model.ScriptNode.Expression
Expression Expression
Expression of which the node is a part.
Definition: ScriptNode.cs:177
Waher.Script.Model.ScriptNode.Start
int Start
Start position in script expression.
Definition: ScriptNode.cs:92
Waher.Script.Variables
Collection of variables.
Definition: Variables.cs:25
Waher.Script.Variables.Preview
void Preview(Expression Expression, IElement Result)
Reports a preview of the final result.
Definition: Variables.cs:455
Waher.Script.Variables.CopyTo
void CopyTo(Variables Variables)
Copies available variables to another variable collection.
Definition: Variables.cs:400
Waher.Script.Abstraction.Elements.IElement
Basic interface for all types of elements.
Definition: IElement.cs:20
Waher.Script.Abstraction.Elements.IElement.AssociatedObjectValue
object AssociatedObjectValue
Associated object value.
Definition: IElement.cs:33
Waher.Script.Abstraction.Elements.IVector
Basic interface for vectors.
Definition: IVector.cs:9
Waher.Script.Abstraction.Elements.IVector.Dimension
int Dimension
Dimension of vector.
Definition: IVector.cs:14
Waher.Script.Abstraction.Elements.IVector.GetElement
IElement GetElement(int Index)
Gets an element of the vector.
Waher.Script.Model.IDifferentiable
Base interface for lambda expressions.
Definition: IDifferentiable.cs:9
Waher.Script.Model.ILambdaExpression
Base interface for lambda expressions.
Definition: ILambdaExpression.cs:11
Waher.Script.Model.ILambdaExpression.Evaluate
IElement Evaluate(IElement[] Arguments, Variables Variables)
Evaluates the lambda expression.
Waher.Script.Fractals.FractalZoomScript
delegate string FractalZoomScript(double r, double i, double Size, object State)
Generates new script when zoomed.
Waher.Script.Model.ArgumentType
ArgumentType
Type of parameter used in a function definition or a lambda definition.
Definition: IFunction.cs:9