picrate 1.3.0-java → 2.1.2-java

data/src/main/java/monkstone/complex/JComplex.java

@@ -0,0 +1,252 @@
+package monkstone.complex;
+
+import java.util.Objects;
+
+/**
+ * The purpose of this class is to to make Complex operations more efficient
+ * than JRuby RubyComplex, by having a simpler interface, only modest
+ * improvements were obtained (but this is better than nothing on RaspberryPI).
+ */
+public final class JComplex {
+
+    private final double re;   // the real part
+    private final double im;   // the imaginary part
+    private final static JComplex ZERO = new JComplex(0, 0);
+    private final static JComplex NAN = new JComplex(Double.NaN, Double.NaN);
+
+    /**
+     * create a new object with the given real and imaginary parts
+     *
+     * @param real
+     * @param imag
+     */
+    public JComplex(double real, double imag) {
+        re = real;
+        im = imag;
+    }
+
+    /**
+     * @return a string representation of the invoking Complex object
+     */
+    @Override
+    public String toString() {
+        return "JComplex(" + re + ", " + im + "i)";
+    }
+
+    /**
+     *
+     * @return abs/modulus/magnitude
+     */
+    public final double abs() {
+        return Math.hypot(re, im);
+    }
+
+    /**
+     *
+     * @return square of abs/modulus/magnitude
+     */
+    public final double abs2() {
+        return re * re + im * im;
+    }
+
+    /**
+     *
+     * @return angle/phase/argument, normalized to be between -pi and pi
+     */
+    public final double phase() {
+        return Math.atan2(im, re);
+    }
+
+    /**
+     *
+     * @param b
+     * @return a new Complex object whose value is (this + b)
+     */
+    public final JComplex add(JComplex b) {
+        JComplex a = this;             // invoking object
+        double real = a.re + b.re;
+        double imag = a.im + b.im;
+        return new JComplex(real, imag);
+    }
+
+    /**
+     *
+     * @param scalar
+     * @return a new Complex object whose value is (this + scalar)
+     */
+    public final JComplex add(double scalar) {
+        return new JComplex(re + scalar, im);
+    }
+
+    public final boolean zero() {
+        return this.equals(ZERO);
+    }
+
+    /**
+     *
+     * @param b
+     * @return a new Complex object whose value is (this - b)
+     */
+    public final JComplex sub(JComplex b) {
+        JComplex a = this;
+        double real = a.re - b.re;
+        double imag = a.im - b.im;
+        return new JComplex(real, imag);
+    }
+
+    /**
+     *
+     * @param scalar
+     * @return a new Complex object whose value is (this - scalar)
+     */
+    public final JComplex sub(double scalar) {
+        return new JComplex(re - scalar, im);
+    }
+
+    /**
+     *
+     * @param b
+     * @return a new Complex object whose value is (this * b)
+     */
+    public final JComplex mul(JComplex b) {
+        JComplex a = this;
+        double real = a.re * b.re - a.im * b.im;
+        double imag = a.re * b.im + a.im * b.re;
+        return new JComplex(real, imag);
+    }
+
+    /**
+     * Also known as scale
+     *
+     * @param b
+     * @return a new Complex object whose value is (this * b)
+     */
+    public final JComplex mul(double b) {
+        return new JComplex(re * b, im * b);
+    }
+
+    /**
+     *
+     * @return a new Complex object whose value is the conjugate of this
+     */
+    public final JComplex conjugate() {
+        return new JComplex(re, -im);
+    }
+
+    /**
+     *
+     * @return a new Complex object whose value is the reciprocal of this
+     */
+    private JComplex reciprocal() {
+        double scale = re * re + im * im; // self dot product
+        return new JComplex(re / scale, -im / scale);
+    }
+
+    /**
+     *
+     * @param other
+     * @return this^other
+     */
+    public final JComplex pow(JComplex other) {
+        if (this.zero()) {
+            if (other.zero()) {
+                return ZERO;
+            }
+            return NAN;
+        }
+        return (this).log().mul(other).exp();
+    }
+
+    /**
+     *
+     * @param scalar
+     * @return this^scalar
+     */
+    public final JComplex pow(double scalar) {
+        if (this.zero()) {
+            if (scalar == 0) {
+                return ZERO;
+            }
+            return NAN;
+        }
+        return (this).log().mul(scalar).exp();
+    }
+
+    /**
+     *
+     * @return log
+     */
+    private JComplex log() {
+        return new JComplex(Math.log(abs()), Math.atan2(im, re));
+    }
+
+    /**
+     *
+     * @return real part
+     */
+    public final double re() {
+        return re;
+    }
+
+    /**
+     *
+     * @return imaginary part
+     */
+    public final double im() {
+        return im;
+    }
+
+    /**
+     *
+     * @param b
+     * @return a / b
+     */
+    public final JComplex div(JComplex b) {
+        JComplex a = this;
+        return a.mul(b.reciprocal());
+    }
+
+    /**
+     *
+     * @param b
+     * @return a / b
+     */
+    public final JComplex div(double b) {
+        if (b == 0) {
+            return NAN;
+        }
+        return new JComplex(re / b, im / b);
+    }
+
+    /**
+     *
+     * @return a new Complex object whose value is the complex exponential of
+     * this
+     */
+    public final JComplex exp() {
+        return new JComplex(Math.exp(re) * Math.cos(im), Math.exp(re) * Math.sin(im));
+    }
+
+    @Override
+    public final int hashCode() {
+        return Objects.hash(re, im);
+    }
+
+    @Override
+    public final boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj == null) {
+            return false;
+        }
+        if (getClass() != obj.getClass()) {
+            return false;
+        }
+        final JComplex other = (JComplex) obj;
+        if (Double.doubleToLongBits(this.re) != Double.doubleToLongBits(other.re)) {
+            return false;
+        }
+        return Double.doubleToLongBits(this.im) == Double.doubleToLongBits(other.im);
+    }
+}

data/src/main/java/monkstone/fastmath/Deglut.java

@@ -1,18 +1,18 @@
-/* 
- * Copyright (c) 2018-19 Martin Prout
- * 
+/*
+ * Copyright (c) 2018-20 Martin Prout
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public
  * License as published by the Free Software Foundation; either
  * version 3.0 of the License, or (at your option) any later version.
- * 
+ *
  * http://creativecommons.org/licenses/LGPL/2.1/
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
@@ -35,7 +35,7 @@ import org.jruby.runtime.builtin.IRubyObject;
 */
 @JRubyModule(name = "DegLut")
 public class Deglut {
-  
+
   /**
   * Lookup table for degree cosine/sine, has a fixed precision 1.0
   * degrees Quite accurate but imprecise
@@ -49,11 +49,11 @@ public class Deglut {
   *
   */
   private static boolean initialized = false;
-  
+
   private final static int NINETY = 90;
   private final static int FULL = 360;
   private static final long serialVersionUID = -1466528933765940101L;
-  
+
   /**
   * Initialize sin table with values (first quadrant only)
   */
@@ -65,19 +65,19 @@ public class Deglut {
       initialized = true;
     }
   }
-    
+
   /**
   *
   * @param runtime Ruby
   */
-  
+
   public static void createDeglut(final Ruby runtime){
     RubyModule deglutModule = runtime.defineModule("DegLut");
     deglutModule.defineAnnotatedMethods(Deglut.class);
     Deglut.initTable();
   }
-    
- 
+
+
   /**
   *
   * @param context ThreadContext
@@ -86,7 +86,7 @@ public class Deglut {
   * @return sin IRubyObject
   */
   @JRubyMethod(name = "sin", module = true)
-  
+
   public static IRubyObject sin(ThreadContext context, IRubyObject recv, IRubyObject other) {
     int thet = (int) ((RubyInteger)other).getLongValue();
     while (thet < 0) {
@@ -99,7 +99,7 @@ public class Deglut {
     ? -SIN_DEG_LUT[y] : -SIN_DEG_LUT[NINETY - y];
     return context.runtime.newFloat(result);
   }
-  
+
   /**
   *
   * @param context ThreadContext
@@ -119,5 +119,5 @@ public class Deglut {
     ? -SIN_DEG_LUT[y] : (theta < 270)
     ? -SIN_DEG_LUT[NINETY - y] : SIN_DEG_LUT[y];
     return context.runtime.newFloat(result);
-  }  
+  }
 }

data/src/main/java/monkstone/filechooser/Chooser.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016-18 Martin Prout
+ * Copyright (c) 2016-20 Martin Prout
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public

data/src/main/java/monkstone/noise/SimplexNoise.java

@@ -36,7 +36,7 @@ public class SimplexNoise {  // Simplex noise in 2D, 3D and 4D
         new Grad(1, 1, 1, 0), new Grad(1, 1, -1, 0), new Grad(1, -1, 1, 0), new Grad(1, -1, -1, 0),
         new Grad(-1, 1, 1, 0), new Grad(-1, 1, -1, 0), new Grad(-1, -1, 1, 0), new Grad(-1, -1, -1, 0)};
 
-    private static short p[] = {151, 160, 137, 91, 90, 15,
+    private final static short PERMS[] = {151, 160, 137, 91, 90, 15,
         131, 13, 201, 95, 96, 53, 194, 233, 7, 225, 140, 36, 103, 30, 69, 142, 8, 99, 37, 240, 21, 10, 23,
         190, 6, 148, 247, 120, 234, 75, 0, 26, 197, 62, 94, 252, 219, 203, 117, 35, 11, 32, 57, 177, 33,
         88, 237, 149, 56, 87, 174, 20, 125, 136, 171, 168, 68, 175, 74, 165, 71, 134, 139, 48, 27, 166,
@@ -51,11 +51,11 @@ public class SimplexNoise {  // Simplex noise in 2D, 3D and 4D
         138, 236, 205, 93, 222, 114, 67, 29, 24, 72, 243, 141, 128, 195, 78, 66, 215, 61, 156, 180};
     // To remove the need for index wrapping, double the permutation table length
     static final short[] PERM = new short[512];
-    static short[] PERM_MOD_12 = new short[512];
+    static final short[] PERM_MOD_12 = new short[512];
 
     static {
         for (int i = 0; i < 512; i++) {
-            PERM[i] = p[i & 255];
+            PERM[i] = PERMS[i & 255];
             PERM_MOD_12[i] = (short) (PERM[i] % 12);
         }
     }

data/src/main/java/monkstone/slider/CustomHorizontalSlider.java

@@ -1,5 +1,5 @@
 /* 
- * Copyright (c) 2016-18 Martin Prout
+ * Copyright (c) 2016-20 Martin Prout
  * 
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public

data/src/main/java/monkstone/slider/CustomVerticalSlider.java

@@ -1,5 +1,5 @@
 /* 
- * Copyright (c) 2016-18 Martin Prout
+ * Copyright (c) 2016-20 Martin Prout
  * 
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public

data/src/main/java/monkstone/slider/SimpleHorizontalSlider.java

@@ -1,18 +1,18 @@
-/* 
- * Copyright (c) 2016-18 Martin Prout
- * 
+/*
+ * Copyright (c) 2016-20 Martin Prout
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public
  * License as published by the Free Software Foundation; either
  * version 3.0 of the License, or (at your option) any later version.
- * 
+ *
  * http://creativecommons.org/licenses/LGPL/2.1/
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
@@ -27,10 +27,10 @@ import processing.core.PConstants;
  * @author Martin Prout
  */
 public class SimpleHorizontalSlider extends SimpleSlider {
-    
+
     final int SPACING = 20;
     final int LEFT_SPC = SPACING * 2;
-    final int RIGHT_SPC = SPACING * 4;    
+    final int RIGHT_SPC = SPACING * 4;
 
     /**
      *
@@ -62,7 +62,7 @@ public class SimpleHorizontalSlider extends SimpleSlider {
             applet.registerMethod("dispose", this);
             applet.registerMethod("draw", this);
         } else {
-            applet.unregisterMethod("draw", this);            
+            applet.unregisterMethod("draw", this);
         }
     }
 
@@ -84,7 +84,7 @@ public class SimpleHorizontalSlider extends SimpleSlider {
             applet.text(String.format(lFormat, (int) vMax), pX + pW, pY );
         }
     }
-    
+
     @Override
     void drawGui() {
         if (backgroundVisible) {
@@ -94,7 +94,7 @@ public class SimpleHorizontalSlider extends SimpleSlider {
         applet.noStroke();
         applet.fill(255);
         applet.ellipse(pX + pScaled, pY + pH / 2, 10, 10);
-    }    
+    }
 
     /**
      *
@@ -136,7 +136,7 @@ public class SimpleHorizontalSlider extends SimpleSlider {
             pScaled = map(pValue, vMin, vMax, 0, pW);
         }
     }
-   
+
     /**
      *
      * @return