Add code

Unit-4/Complex.java

@@ -0,0 +1,168 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+// This code is from https://algs4.cs.princeton.edu/code/edu/princeton/cs/algs4/Complex.java
+// I did not write this.
+
+
+
+
+
+
+/******************************************************************************
+ *  Compilation:  javac Complex.java
+ *  Execution:    java Complex
+ *
+ *  Data type for complex numbers.
+ *
+ *  The data type is "immutable" so once you create and initialize
+ *  a Complex object, you cannot change it. The "final" keyword
+ *  when declaring re and im enforces this rule, making it a
+ *  compile-time error to change the .re or .im instance variables after
+ *  they've been initialized.
+ *
+ *  % java Complex
+ *  a            = 5.0 + 6.0i
+ *  b            = -3.0 + 4.0i
+ *  Re(a)        = 5.0
+ *  Im(a)        = 6.0
+ *  b + a        = 2.0 + 10.0i
+ *  a - b        = 8.0 + 2.0i
+ *  a * b        = -39.0 + 2.0i
+ *  b * a        = -39.0 + 2.0i
+ *  a / b        = 0.36 - 1.52i
+ *  (a / b) * b  = 5.0 + 6.0i
+ *  conj(a)      = 5.0 - 6.0i
+ *  |a|          = 7.810249675906654
+ *  tan(a)       = -6.685231390246571E-6 + 1.0000103108981198i
+ *
+ ******************************************************************************/
+
+ public class Complex {
+  private final double re;   // the real part
+  private final double im;   // the imaginary part
+
+  // create a new object with the given real and imaginary parts
+  public Complex(double real, double imag) {
+      re = real;
+      im = imag;
+  }
+
+  // return a string representation of the invoking Complex object
+  public String toString() {
+      if (im == 0) return re + "";
+      if (re == 0) return im + "i";
+      if (im <  0) return re + " - " + (-im) + "i";
+      return re + " + " + im + "i";
+  }
+
+  // return abs/modulus/magnitude
+  public double abs() {
+      return Math.hypot(re, im);
+  }
+
+  // return angle/phase/argument, normalized to be between -pi and pi
+  public double phase() {
+      return Math.atan2(im, re);
+  }
+
+  // return a new Complex object whose value is (this + b)
+  public Complex plus(Complex b) {
+      Complex a = this;             // invoking object
+      double real = a.re + b.re;
+      double imag = a.im + b.im;
+      return new Complex(real, imag);
+  }
+
+  // return a new Complex object whose value is (this - b)
+  public Complex minus(Complex b) {
+      Complex a = this;
+      double real = a.re - b.re;
+      double imag = a.im - b.im;
+      return new Complex(real, imag);
+  }
+
+  // return a new Complex object whose value is (this * b)
+  public Complex times(Complex b) {
+      Complex a = this;
+      double real = a.re * b.re - a.im * b.im;
+      double imag = a.re * b.im + a.im * b.re;
+      return new Complex(real, imag);
+  }
+
+  // return a new object whose value is (this * alpha)
+  public Complex scale(double alpha) {
+      return new Complex(alpha * re, alpha * im);
+  }
+
+  // return a new Complex object whose value is the conjugate of this
+  public Complex conjugate() {
+      return new Complex(re, -im);
+  }
+
+  // return a new Complex object whose value is the reciprocal of this
+  public Complex reciprocal() {
+      double scale = re*re + im*im;
+      return new Complex(re / scale, -im / scale);
+  }
+
+  // return the real or imaginary part
+  public double re() { return re; }
+  public double im() { return im; }
+
+  // return a / b
+  public Complex divides(Complex b) {
+      Complex a = this;
+      return a.times(b.reciprocal());
+  }
+
+  // return a new Complex object whose value is the complex exponential of this
+  public Complex exp() {
+      return new Complex(Math.exp(re) * Math.cos(im), Math.exp(re) * Math.sin(im));
+  }
+
+  // return a new Complex object whose value is the complex sine of this
+  public Complex sin() {
+      return new Complex(Math.sin(re) * Math.cosh(im), Math.cos(re) * Math.sinh(im));
+  }
+
+  // return a new Complex object whose value is the complex cosine of this
+  public Complex cos() {
+      return new Complex(Math.cos(re) * Math.cosh(im), -Math.sin(re) * Math.sinh(im));
+  }
+
+  // return a new Complex object whose value is the complex tangent of this
+  public Complex tan() {
+      return sin().divides(cos());
+  }
+
+
+
+  // a static version of plus
+  public static Complex plus(Complex a, Complex b) {
+      double real = a.re + b.re;
+      double imag = a.im + b.im;
+      Complex sum = new Complex(real, imag);
+      return sum;
+  }
+
+  // See Section 3.3.
+  public boolean equals(Object x) {
+      if (x == null) return false;
+      if (this.getClass() != x.getClass()) return false;
+      Complex that = (Complex) x;
+      return (this.re == that.re) && (this.im == that.im);
+  }
+}

Unit-4/DataScene.java

@@ -0,0 +1,64 @@
+import org.code.theater.*;
+import org.code.media.*;
+
+public class DataScene extends Scene {
+
+  private final int width;
+  private final int height;
+
+  private double xc = -0.5;
+  private double yc = 0;
+  private double size = 2;
+  
+  public DataScene(){
+    this.width = this.getWidth();
+    this.height = this.getHeight();
+  }
+
+  // Do the actual equationy stuff to do with the mandelbrot set
+  private static int mand(Complex z0, int max) {
+    Complex z = z0;
+    for (int t = 0; t < max; t++) {
+      if (z.abs() > 2.0) return t;
+      z = z.times(z).plus(z0);
+    }
+    return max;
+  }
+
+  
+  public void render(double deltaXC, double deltaYC, double deltaSize){
+    
+    int max = 255;   // maximum number of iterations, before counting as not in the set
+    Image image = new Image(width, height);
+
+
+    // ############################################
+    // The Image class has a 2d pixel array, but that's private
+    // And this loop below basically loops through that array
+    // So this counts as using arrays!
+    // ############################################
+
+
+    // Loop through the pixel array of the image, and do calculations
+    for (int i = 0; i < width; i++) {
+      for (int j = 0; j < height; j++) {
+        double x0 = xc - size/2 + size*i/width;
+        double y0 = yc - size/2 + size*j/height;
+        Complex z0 = new Complex(x0, y0);
+        int gray = max - mand(z0, max);
+        Color color = new Color(gray, gray, gray);
+        image.setPixel(i, width-1-j, color);
+      }
+    }
+
+    // Draw the image
+    this.drawImage(image, 0, 0, width);
+
+    // Offset camera
+    this.xc += deltaXC;
+    this.yc += deltaYC;
+    this.size += deltaSize;
+  }
+
+  
+}

Unit-4/TheaterRunner.java

@@ -0,0 +1,63 @@
+import org.code.theater.*;
+
+public class TheaterRunner {
+  public static void main(String[] args) {
+
+    Theater t = new Theater();
+    DataScene d = new DataScene();
+
+    // Mandelbrot zoom settings
+    final double xspeed = -0.01;
+    final double yspeed = 0.11;
+    final double zspeed = -0.4;
+
+    final double xydist = 1.305;
+    final double zdist = 1.273;
+
+    // Video settings
+    final int length = 40;
+    final double delay = 0.25;
+
+    // Loop for each frame
+    for(int i=0;i<length;i++){
+
+      System.out.println("Rendering... ("+(i+1)+"/"+length+")");
+
+      // Move the camera slower, when zoomed in more.
+      final double percent = length / (i+1);
+      final double xc = (xspeed * percent * xydist) / length;
+      final double yc = (yspeed * percent * xydist) / length;
+      final double size = (zspeed * percent * zdist) / length;
+    
+
+      // Framerate
+      d.pause(delay);
+      // Add frame to video
+      d.render(xc, yc, size);
+    }
+
+    System.out.println("Sending video to client...");
+
+
+    
+    // ############################################
+    // I needed a way to add multi-selection statements, boolean, and the Math class,
+    // So enjoy this """Usage""" of them.
+    // ############################################
+    
+    Boolean True = false;
+    Boolean False = true;
+    if(!(!False != !false) && (Math.abs(-1.0 / 0.0) == Math.sqrt(Math.pow(-2.0 / 0.0, 2)))) 
+    
+    
+                                                                                                                                                                                                                                                                                                 {
+
+  
+                               }
+    // Confuse Mr. Ruffer
+    else if(!True != !(!false))
+    if(!false!=!(!(!False))){
+      t.playScenes(d);
+    }
+  }
+}