propane 3.3.1-java → 3.6.0-java

data/propane.gemspec

@@ -1,5 +1,6 @@
-# -*- encoding: utf-8 -*-
-lib = File.expand_path('../lib', __FILE__)
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'propane/version'
 
@@ -8,14 +9,14 @@ Gem::Specification.new do |gem|
   gem.version       = Propane::VERSION
   gem.authors       = ['monkstone']
   gem.email         = ['mamba2928@yahoo.co.uk']
-  gem.licenses     = %w(GPL-3.0 LGPL-2.0)
+  gem.licenses     = %w[GPL-3.0 LGPL-2.0]
   gem.description  = <<-EOS
   A batteries included version of processing in ruby targetting jdk11.
   EOS
-  gem.summary       = %q{ruby implementation of processing-4.0 on MacOS, linux and windows (64bit only)}
+  gem.summary       = 'ruby implementation of processing-4.0 on MacOS, linux and windows (64bit only)'
   gem.homepage      = 'https://ruby-processing.github.io/propane/'
-  gem.files         = `git ls-files`.split($/)
-  gem.files << 'lib/propane-3.3.0.jar'
+  gem.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
+  gem.files << "lib/propane-#{Propane::VERSION}.jar"
   gem.files << 'lib/gluegen-rt.jar'
   gem.files << 'lib/jogl-all.jar'
   gem.files << 'lib/gluegen-rt-natives-linux-amd64.jar'
@@ -24,12 +25,13 @@ Gem::Specification.new do |gem|
   gem.files << 'lib/jogl-all-natives-linux-amd64.jar'
   gem.files << 'lib/jogl-all-natives-macosx-universal.jar'
   gem.files << 'lib/jogl-all-natives-windows-amd64.jar'
-  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.executables   = gem.files.grep(%r{^bin/}).map { |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
-  gem.add_development_dependency 'rake', '~> 12.3'
-  gem.add_development_dependency 'minitest', '~> 5.10'
-  gem.add_runtime_dependency 'arcball', '~> 1.0', '>= 1.0.0'
+  gem.add_development_dependency 'jruby-openssl', '~> 0.1.0', '>=0.1.3'
+  gem.add_development_dependency 'minitest', '~> 5.14'
+  gem.add_runtime_dependency 'rake', '~> 12.3'
+  gem.add_runtime_dependency 'arcball', '~> 1.0', '>= 1.0.2'
   gem.require_paths = ['lib']
   gem.platform      = 'java'
-  gem.requirements << 'java runtime >= 11.0.1+'
+  gem.requirements << 'java runtime >= 11.0.2+'
 end

data/src/main/java/monkstone/ColorUtil.java

@@ -3,7 +3,7 @@
  * in their sketches. Includes a method to efficiently convert an array of web
  * strings to an array of color int, and another to convert an array of color
  * int to a string that can be used in ruby code (to generate web color array).
- * Copyright (c) 2015-19 Martin Prout.
+ * Copyright (c) 2015-20 Martin Prout.
  * This utility is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as published by
  * the Free Software Foundation; either version 2.1 of the License, or (at
@@ -13,6 +13,7 @@
  */
 package monkstone;
 
+import java.util.Random;
 /**
  *
  * @author Martin Prout
@@ -102,6 +103,17 @@ public class ColorUtil {
         return (float) hex;
     }
 
+    static public int[] shuffle(int[] cols) {
+    Random rgen = new Random();  // Random number generator
+    for (int i = 0; i < cols.length; i++) {
+        int randomPosition = rgen.nextInt(cols.length);
+        int temp = cols[i];
+        cols[i] = cols[randomPosition];
+        cols[randomPosition] = temp;
+    }
+    return cols;
+}
+
     /**
      *
      * @param hue

data/src/main/java/monkstone/MathToolModule.java

@@ -1,13 +1,14 @@
 /**
- * The purpose of this tool is to allow propane users to use an alternative
- * to processing.org map, lerp and norm methods in their sketches
- * Copyright (c) 2015-19 Martin Prout. This tool is free software; you can
- * redistribute it and/or modify it under the terms of the GNU Lesser General
- * Public License as published by the Free Software Foundation; either version
- * 2.1 of the License, or (at your option) any later version.
- *
- * Obtain a copy of the license at http://www.gnu.org/licenses/lgpl-2.1.html
- */
+* The purpose of this tool is to allow JRubyArt users to use an alternative
+* to processing.org map, lerp and norm methods in their sketches and to implement
+* JRubyArt convenenience method grid(width, height, stepW, stepH) { |x, y| do stuff }
+* Copyright (c) 2015-20 Martin Prout. This tool is free software; you can
+* redistribute it and/or modify it under the terms of the GNU Lesser General
+* Public License as published by the Free Software Foundation; either version
+* 2.1 of the License, or (at your option) any later version.
+*
+* Obtain a copy of the license at http://www.gnu.org/licenses/lgpl-2.1.html
+*/
 package monkstone;
 
 import org.jruby.Ruby;
@@ -22,216 +23,265 @@ import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
 
 /**
- *
- * @author Martin Prout
- */
+*
+* @author Martin Prout
+*/
 @JRubyModule(name = "MathTool")
 public class MathToolModule {
 
-    /**
-     *
-     * @param runtime Ruby
-     */
-    public static void createMathToolModule(Ruby runtime) {
-        RubyModule mtModule = runtime.defineModule("MathTool");
-        mtModule.defineAnnotatedMethods(MathToolModule.class);
-    }
+  /**
+  *
+  * @param runtime Ruby
+  */
+  public static void createMathToolModule(Ruby runtime) {
+    RubyModule mtModule = runtime.defineModule("MathTool");
+    mtModule.defineAnnotatedMethods(MathToolModule.class);
+  }
 
-    /**
-     *
-     * @param context ThreadContext
-     * @param recv IRubyObject
-     * @param args array of RubyRange (must be be numeric)
-     * @return mapped value RubyFloat
-     */
-    @JRubyMethod(name = "map1d", rest = true, module = true)
-    public static IRubyObject mapOneD(ThreadContext context, IRubyObject recv, IRubyObject[] args) {
-        double value = (args[0] instanceof RubyFloat)
-                ? ((RubyFloat) args[0]).getValue() : ((RubyFixnum) args[0]).getDoubleValue();
-        RubyRange r1 = (RubyRange) args[1];
-        RubyRange r2 = (RubyRange) args[2];
-        double first1 = (r1.first(context) instanceof RubyFloat)
-                ? ((RubyFloat) r1.first(context)).getValue() : ((RubyFixnum) r1.first(context)).getDoubleValue();
-        double first2 = (r2.first(context) instanceof RubyFloat)
-                ? ((RubyFloat) r2.first(context)).getValue() : ((RubyFixnum) r2.first(context)).getDoubleValue();
-        double last1 = (r1.last(context) instanceof RubyFloat)
-                ? ((RubyFloat) r1.last(context)).getValue() : ((RubyFixnum) r1.last(context)).getDoubleValue();
-        double last2 = (r2.last(context) instanceof RubyFloat)
-                ? ((RubyFloat) r2.last(context)).getValue() : ((RubyFixnum) r2.last(context)).getDoubleValue();
-        return mapMt(context, value, first1, last1, first2, last2);
-    }
+  /**
+  *
+  * @param context ThreadContext
+  * @param recv IRubyObject
+  * @param args array of RubyRange (must be be numeric)
+  * @return mapped value RubyFloat
+  */
+  @JRubyMethod(name = "map1d", rest = true, module = true)
+  public static IRubyObject mapOneD(ThreadContext context, IRubyObject recv, IRubyObject[] args) {
+    double value = (args[0] instanceof RubyFloat)
+    ? ((RubyFloat) args[0]).getValue() : ((RubyFixnum) args[0]).getDoubleValue();
+    RubyRange r1 = (RubyRange) args[1];
+    RubyRange r2 = (RubyRange) args[2];
+    double first1 = (r1.first(context) instanceof RubyFloat)
+    ? ((RubyFloat) r1.first(context)).getValue() : ((RubyFixnum) r1.first(context)).getDoubleValue();
+    double first2 = (r2.first(context) instanceof RubyFloat)
+    ? ((RubyFloat) r2.first(context)).getValue() : ((RubyFixnum) r2.first(context)).getDoubleValue();
+    double last1 = (r1.last(context) instanceof RubyFloat)
+    ? ((RubyFloat) r1.last(context)).getValue() : ((RubyFixnum) r1.last(context)).getDoubleValue();
+    double last2 = (r2.last(context) instanceof RubyFloat)
+    ? ((RubyFloat) r2.last(context)).getValue() : ((RubyFixnum) r2.last(context)).getDoubleValue();
+    return mapMt(context, value, first1, last1, first2, last2);
+  }
 
-    /**
-     *
-     * @param context ThreadContext
-     * @param recv IRubyObject
-     * @param args array of RubyRange (must be be numeric)
-     * @return mapped value RubyFloat
-     */
-    @JRubyMethod(name = "constrained_map", rest = true, module = true)
-    public static IRubyObject constrainedMap(ThreadContext context, IRubyObject recv, IRubyObject[] args) {
-        double value = (args[0] instanceof RubyFloat) ? ((RubyFloat) args[0]).getValue() : ((RubyFixnum) args[0]).getDoubleValue();
-        RubyRange r1 = (RubyRange) args[1];
-        RubyRange r2 = (RubyRange) args[2];
-        double first1 = (r1.first(context) instanceof RubyFloat)
-                ? ((RubyFloat) r1.first(context)).getValue() : ((RubyFixnum) r1.first(context)).getDoubleValue();
-        double first2 = (r2.first(context) instanceof RubyFloat)
-                ? ((RubyFloat) r2.first(context)).getValue() : ((RubyFixnum) r2.first(context)).getDoubleValue();
-        double last1 = (r1.last(context) instanceof RubyFloat)
-                ? ((RubyFloat) r1.last(context)).getValue() : ((RubyFixnum) r1.last(context)).getDoubleValue();
-        double last2 = (r2.last(context) instanceof RubyFloat)
-                ? ((RubyFloat) r2.last(context)).getValue() : ((RubyFixnum) r2.last(context)).getDoubleValue();
-        double max = Math.max(first1, last1);
-        double min = Math.min(first1, last1);
-        if (value < min) {
-            return mapMt(context, min, first1, last1, first2, last2);
-        }
-        if (value > max) {
-            return mapMt(context, max, first1, last1, first2, last2);
-        }
-        return mapMt(context, value, first1, last1, first2, last2);
+  /**
+  *
+  * @param context ThreadContext
+  * @param recv IRubyObject
+  * @param args array of RubyRange (must be be numeric)
+  * @return mapped value RubyFloat
+  */
+  @JRubyMethod(name = "constrained_map", rest = true, module = true)
+  public static IRubyObject constrainedMap(ThreadContext context, IRubyObject recv, IRubyObject[] args) {
+    double value = (args[0] instanceof RubyFloat) ? ((RubyFloat) args[0]).getValue() : ((RubyFixnum) args[0]).getDoubleValue();
+    RubyRange r1 = (RubyRange) args[1];
+    RubyRange r2 = (RubyRange) args[2];
+    double first1 = (r1.first(context) instanceof RubyFloat)
+    ? ((RubyFloat) r1.first(context)).getValue() : ((RubyFixnum) r1.first(context)).getDoubleValue();
+    double first2 = (r2.first(context) instanceof RubyFloat)
+    ? ((RubyFloat) r2.first(context)).getValue() : ((RubyFixnum) r2.first(context)).getDoubleValue();
+    double last1 = (r1.last(context) instanceof RubyFloat)
+    ? ((RubyFloat) r1.last(context)).getValue() : ((RubyFixnum) r1.last(context)).getDoubleValue();
+    double last2 = (r2.last(context) instanceof RubyFloat)
+    ? ((RubyFloat) r2.last(context)).getValue() : ((RubyFixnum) r2.last(context)).getDoubleValue();
+    double max = Math.max(first1, last1);
+    double min = Math.min(first1, last1);
+    if (value < min) {
+      return mapMt(context, min, first1, last1, first2, last2);
     }
-
-    /**
-     *
-     * @param context ThreadContext
-     * @param recv self IRubyObject
-     * @param args floats as in processing map function
-     * @return mapped value RubyFloat
-     */
-    @JRubyMethod(name = "p5map", rest = true, module = true)
-    public static IRubyObject mapProcessing(ThreadContext context, IRubyObject recv, IRubyObject[] args) {
-        double value = (args[0] instanceof RubyFloat) ? ((RubyFloat) args[0]).getValue() : ((RubyFixnum) args[0]).getDoubleValue();
-        double first1 = (args[1] instanceof RubyFloat) ? ((RubyFloat) args[1]).getValue() : ((RubyFixnum) args[1]).getDoubleValue();
-        double first2 = (args[3] instanceof RubyFloat) ? ((RubyFloat) args[3]).getValue() : ((RubyFixnum) args[3]).getDoubleValue();
-        double last1 = (args[2] instanceof RubyFloat) ? ((RubyFloat) args[2]).getValue() : ((RubyFixnum) args[2]).getDoubleValue();
-        double last2 = (args[4] instanceof RubyFloat) ? ((RubyFloat) args[4]).getValue() : ((RubyFixnum) args[4]).getDoubleValue();
-        return mapMt(context, value, first1, last1, first2, last2);
+    if (value > max) {
+      return mapMt(context, max, first1, last1, first2, last2);
     }
+    return mapMt(context, value, first1, last1, first2, last2);
+  }
 
-    /**
-     * A more correct version than processing.org version
-     *
-     * @param context ThreadContext
-     * @param recv self IRubyObject
-     * @param args args[2] should be between 0 and 1.0 if not returns start or
-     * stop
-     * @return lerped value RubyFloat
-     */
-    @JRubyMethod(name = "lerp", rest = true, module = true)
-    public static IRubyObject lerpP(ThreadContext context, IRubyObject recv, IRubyObject[] args) {
-        double start = (args[0] instanceof RubyFloat) ? ((RubyFloat) args[0]).getValue() : ((RubyFixnum) args[0]).getDoubleValue();
-        double stop = (args[1] instanceof RubyFloat) ? ((RubyFloat) args[1]).getValue() : ((RubyFixnum) args[1]).getDoubleValue();
-        double amount = (args[2] instanceof RubyFloat) ? ((RubyFloat) args[2]).getValue() : ((RubyFixnum) args[2]).getDoubleValue();
-        if (amount <= 0) {
-            return args[0];
-        }
-        if (amount >= 1.0) {
-            return args[1];
-        }
-        return context.runtime.newFloat((1 - amount) * start + (stop * amount));
-    }
+  /**
+  *
+  * @param context ThreadContext
+  * @param recv self IRubyObject
+  * @param args floats as in processing map function
+  * @return mapped value RubyFloat
+  */
+  @JRubyMethod(name = "p5map", rest = true, module = true)
+  public static IRubyObject mapProcessing(ThreadContext context, IRubyObject recv, IRubyObject[] args) {
+    double value = (args[0] instanceof RubyFloat) ? ((RubyFloat) args[0]).getValue() : ((RubyFixnum) args[0]).getDoubleValue();
+    double first1 = (args[1] instanceof RubyFloat) ? ((RubyFloat) args[1]).getValue() : ((RubyFixnum) args[1]).getDoubleValue();
+    double first2 = (args[3] instanceof RubyFloat) ? ((RubyFloat) args[3]).getValue() : ((RubyFixnum) args[3]).getDoubleValue();
+    double last1 = (args[2] instanceof RubyFloat) ? ((RubyFloat) args[2]).getValue() : ((RubyFixnum) args[2]).getDoubleValue();
+    double last2 = (args[4] instanceof RubyFloat) ? ((RubyFloat) args[4]).getValue() : ((RubyFixnum) args[4]).getDoubleValue();
+    return mapMt(context, value, first1, last1, first2, last2);
+  }
 
-    /**
-     * Identical to p5map(value, low, high, 0, 1). Numbers outside of the range
-     * are not clamped to 0 and 1, because out-of-range values are often
-     * intentional and useful.
-     *
-     * @param context ThreadContext
-     * @param recv IRubyObject
-     * @param args array of args must be be numeric
-     * @return mapped value RubyFloat
-     */
-    @JRubyMethod(name = "norm", rest = true, module = true)
-    public static IRubyObject normP(ThreadContext context, IRubyObject recv, IRubyObject[] args) {
-        double value = (args[0] instanceof RubyFloat) ? ((RubyFloat) args[0]).getValue() : ((RubyFixnum) args[0]).getDoubleValue();
-        double start = (args[1] instanceof RubyFloat) ? ((RubyFloat) args[1]).getValue() : ((RubyFixnum) args[1]).getDoubleValue();
-        double stop = (args[2] instanceof RubyFloat) ? ((RubyFloat) args[2]).getValue() : ((RubyFixnum) args[2]).getDoubleValue();
-        return mapMt(context, value, start, stop, 0, 1.0);
+  /**
+  * A more correct version than processing.org version
+  *
+  * @param context ThreadContext
+  * @param recv self IRubyObject
+  * @param args args[2] should be between 0 and 1.0 if not returns start or
+  * stop
+  * @return lerped value RubyFloat
+  */
+  @JRubyMethod(name = "lerp", rest = true, module = true)
+  public static IRubyObject lerpP(ThreadContext context, IRubyObject recv, IRubyObject[] args) {
+    double start = (args[0] instanceof RubyFloat) ? ((RubyFloat) args[0]).getValue() : ((RubyFixnum) args[0]).getDoubleValue();
+    double stop = (args[1] instanceof RubyFloat) ? ((RubyFloat) args[1]).getValue() : ((RubyFixnum) args[1]).getDoubleValue();
+    double amount = (args[2] instanceof RubyFloat) ? ((RubyFloat) args[2]).getValue() : ((RubyFixnum) args[2]).getDoubleValue();
+    if (amount <= 0) {
+      return args[0];
     }
-
-    /**
-     * Identical to p5map(value, low, high, 0, 1) but 'clamped'. Numbers outside
-     * of the range are clamped to 0 and 1,
-     *
-     * @param context ThreadContext
-     * @param recv IRubyObject
-     * @param args array of args must be be numeric
-     * @return mapped value RubyFloat
-     */
-    @JRubyMethod(name = "norm_strict", rest = true, module = true)
-    public static IRubyObject norm_strict(ThreadContext context, IRubyObject recv, IRubyObject[] args) {
-        Ruby ruby = context.runtime;
-        double value = (args[0] instanceof RubyFloat) ? ((RubyFloat) args[0]).getValue() : ((RubyFixnum) args[0]).getDoubleValue();
-        double start = (args[1] instanceof RubyFloat) ? ((RubyFloat) args[1]).getValue() : ((RubyFixnum) args[1]).getDoubleValue();
-        double stop = (args[2] instanceof RubyFloat) ? ((RubyFloat) args[2]).getValue() : ((RubyFixnum) args[2]).getDoubleValue();
-        double max = Math.max(start, stop);
-        double min = Math.min(start, stop);
-        if (value < min) {
-            return mapMt(context, min, start, stop, 0, 1.0);
-        }
-        if (value > max) {
-            return mapMt(context, max, start, stop, 0, 1.0);
-        }
-        return mapMt(context, value, start, stop, 0, 1.0);
+    if (amount >= 1.0) {
+      return args[1];
     }
-    // start2 + (stop2 - start2) * ((value - start1) / (stop1 - start1));
+    return context.runtime.newFloat((1 - amount) * start + (stop * amount));
+  }
+
+  /**
+  * Identical to p5map(value, low, high, 0, 1). Numbers outside of the range
+  * are not clamped to 0 and 1, because out-of-range values are often
+  * intentional and useful.
+  *
+  * @param context ThreadContext
+  * @param recv IRubyObject
+  * @param args array of args must be be numeric
+  * @return mapped value RubyFloat
+  */
+  @JRubyMethod(name = "norm", rest = true, module = true)
+  public static IRubyObject normP(ThreadContext context, IRubyObject recv, IRubyObject[] args) {
+    double value = (args[0] instanceof RubyFloat) ? ((RubyFloat) args[0]).getValue() : ((RubyFixnum) args[0]).getDoubleValue();
+    double start = (args[1] instanceof RubyFloat) ? ((RubyFloat) args[1]).getValue() : ((RubyFixnum) args[1]).getDoubleValue();
+    double stop = (args[2] instanceof RubyFloat) ? ((RubyFloat) args[2]).getValue() : ((RubyFixnum) args[2]).getDoubleValue();
+    return mapMt(context, value, start, stop, 0, 1.0);
+  }
+
+  /**
+  * Identical to p5map(value, low, high, 0, 1) but 'clamped'. Numbers outside
+  * of the range are clamped to 0 and 1,
+  *
+  * @param context ThreadContext
+  * @param recv IRubyObject
+  * @param args array of args must be be numeric
+  * @return mapped value RubyFloat
+  */
+  @JRubyMethod(name = "norm_strict", rest = true, module = true)
+  public static IRubyObject norm_strict(ThreadContext context, IRubyObject recv, IRubyObject[] args) {
 
-    static final RubyFloat mapMt(ThreadContext context, double value, double first1, double last1, double first2, double last2) {
-        double result = first2 + (last2 - first2) * ((value - first1) / (last1 - first1));
-        return context.runtime.newFloat(result);
+    double value = (args[0] instanceof RubyFloat) ? ((RubyFloat) args[0]).getValue() : ((RubyFixnum) args[0]).getDoubleValue();
+    double start = (args[1] instanceof RubyFloat) ? ((RubyFloat) args[1]).getValue() : ((RubyFixnum) args[1]).getDoubleValue();
+    double stop = (args[2] instanceof RubyFloat) ? ((RubyFloat) args[2]).getValue() : ((RubyFixnum) args[2]).getDoubleValue();
+    double max = Math.max(start, stop);
+    double min = Math.min(start, stop);
+    if (value < min) {
+      return mapMt(context, min, start, stop, 0, 1.0);
     }
+    if (value > max) {
+      return mapMt(context, max, start, stop, 0, 1.0);
+    }
+    return mapMt(context, value, start, stop, 0, 1.0);
+  }
+  // start2 + (stop2 - start2) * ((value - start1) / (stop1 - start1));
+  static final RubyFloat mapMt(ThreadContext context, double value, double first1, double last1, double first2, double last2) {
+    Ruby ruby = context.runtime;
+    double result = first2 + (last2 - first2) * ((value - first1) / (last1 - first1));
+    return ruby.newFloat(result);
+  }
 
-    /**
-     * Provides processing constrain method as a ruby module method
-     *
-     * @param context ThreadContext
-     * @param recv IRubyObject
-     * @param args array of args must be be numeric
-     * @return original or limit values
-     */
-    @JRubyMethod(name = "constrain", rest = true, module = true)
-    public static IRubyObject constrainValue(ThreadContext context, IRubyObject recv, IRubyObject[] args) {
-        RubyFloat value = args[0].convertToFloat();
-        RubyFloat start = args[1].convertToFloat();
-        RubyFloat stop = args[2].convertToFloat();
-        if (value.op_ge(context, start).isTrue() && value.op_le(context, stop).isTrue()) {
-            return args[0];
-        } else if (value.op_ge(context, start).isTrue()) {
-            return args[2];
-        } else {
-            return args[1];
-        }
+  /**
+  * Provides processing constrain method as a ruby module method
+  *
+  * @param context ThreadContext
+  * @param recv IRubyObject
+  * @param args array of args must be be numeric
+  * @return original or limit values
+  */
+  @JRubyMethod(name = "constrain", rest = true, module = true)
+  public static IRubyObject constrainValue(ThreadContext context, IRubyObject recv, IRubyObject[] args) {
+    RubyFloat value = args[0].convertToFloat();
+    RubyFloat start = args[1].convertToFloat();
+    RubyFloat stop = args[2].convertToFloat();
+    if (value.op_ge(context, start).isTrue() && value.op_le(context, stop).isTrue()) {
+      return args[0];
+    } else if (value.op_ge(context, start).isTrue()) {
+      return args[2];
+    } else {
+      return args[1];
     }
+  }
 
-    /**
-     * Provides propane grid method as a ruby module method
-     *
-     * @param context ThreadContext
-     * @param recv IRubyObject
-     * @param args array of args should be Fixnum
-     * @param block { |x, y| `do something` }
-     * @return nil
-     */
-    @JRubyMethod(name = "grid", rest = true, module = true)
-    public static IRubyObject createGrid(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block) {
-        int row = (int) args[0].toJava(Integer.class);
-        int column = (int) args[1].toJava(Integer.class);
-        int rowStep = 1;
-        int colStep = 1;
-        if (args.length == 4) {
-            rowStep = (int) args[2].toJava(Integer.class);
-            colStep = (int) args[3].toJava(Integer.class);
-        }
-        if (block.isGiven()) {
-            int tempRow = row / rowStep;
-            for (int z = 0; z < (tempRow * (column / colStep)); z++) {
-                int x = z % tempRow;
-                int y = z / tempRow;
-                block.yieldSpecific(context, context.runtime.newFixnum(x * rowStep), context.runtime.newFixnum(y * colStep));
-            }
+  /**
+  * Provides JRubyArt grid method as a ruby module method behaves like:-
+  * def grid(dx, dy, sx = 1, sy = 1)
+  *   (0...dx).step(sx) do |x|
+  *     (0...dy).step(sy) do |y|
+  *       yield(x, y)
+  *     end
+  *   end
+  * end
+  * @param context ThreadContext
+  * @param recv IRubyObject
+  * @param args array of args should be Fixnum
+  * @param block { |x, y| `do something` }
+  * @return nil
+  */
+  @JRubyMethod(name = "grid", rest = true, module = true)
+  public static IRubyObject createGrid(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block) {
+    Ruby ruby = context.runtime;
+    int row = (int) args[0].toJava(Integer.class);
+    int column =  (int) args[1].toJava(Integer.class);
+    int rowStep = 1;
+    int colStep = 1;
+    if (args.length == 4){
+      rowStep = (int) args[2].toJava(Integer.class);
+      colStep = (int) args[3].toJava(Integer.class);
+    }
+    if (block.isGiven()) {
+      int tempRow = row / rowStep;
+      int tempColumn = column /colStep;
+      for (int z = 0; z < (tempRow * tempColumn); z++){
+        int y = z % tempColumn;
+        int x = z / tempColumn;
+        block.yieldSpecific(context, ruby.newFixnum(x * rowStep), ruby.newFixnum(y * colStep));
+      }
+    }
+    return context.nil;
+  }
+  /**
+  * Provides JRubyArt mesh_grid method as a ruby module method
+  * def grid(dx, dy, dz, sx = 1, sy = 1, sz = 1)
+  *   (0...dx).step(sx) do |x|
+  *     (0...dy).step(sy) do |y|
+  *       (0...dz).step(sy) do |z|
+  *         yield(x, y, z)
+  *       end
+  *     end
+  *   end
+  * end
+  *
+  * @param context ThreadContext
+  * @param recv IRubyObject
+  * @param args array of args should be Fixnum
+  * @param block { |x, y, z| `do something` }
+  * @return nil
+  */
+  @JRubyMethod(name = "mesh_grid", rest = true, module = true)
+  public static IRubyObject createGrid3D(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block) {
+    Ruby ruby = context.runtime;
+    int xDim = (int) args[0].toJava(Integer.class);
+    int yDim =  (int) args[1].toJava(Integer.class);
+    int zDim =  (int) args[2].toJava(Integer.class);
+    int xStep = (args.length > 3) ? (int) args[3].toJava(Integer.class) : 1;
+    int yStep = (args.length > 4) ? (int) args[4].toJava(Integer.class) : 1;
+    int zStep = (args.length == 6) ? (int) args[5].toJava(Integer.class) : 1;
+    int dimX = xDim / xStep;
+    int dimY = yDim / yStep;
+    int dimZ = zDim / zStep;
+    if (block.isGiven()) {
+      int count = dimX * dimY * dimZ;
+      for (int x = 0; x < xDim; x += xStep){
+        for (int j = 0; j < (dimZ * dimY); j++){
+          int z = j % dimZ;
+          int y = j / dimZ;
+          block.yieldSpecific(context, ruby.newFixnum(x), ruby.newFixnum(y * yStep), ruby.newFixnum(z * zStep));
         }
-        return context.nil;
-
+      }
     }
+    return context.nil;
+  }
 }