arbol 0.0.2

data/lib/functions/greater_than.rb

@@ -0,0 +1,70 @@
+class GreaterThan < Base
+  Arbol.add_mapped_class(
+    'greater_than', 
+    GreaterThan,
+%{void greater_than(long left[3], long right[3], long out[3]) {
+  if(left[0] > right[0]) { out[0] = INTEGER_SCALE; } else { out[0] = 0; }
+  if(left[1] > right[1]) { out[1] = INTEGER_SCALE; } else { out[1] = 0; }
+  if(left[2] > right[2]) { out[2] = INTEGER_SCALE; } else { out[2] = 0; }
+}}
+  )
+  attr_accessor :left
+  attr_accessor :right
+  
+  def param_keys
+    [:left, :right]
+  end
+
+  def arduino_code
+    unless @frame_optimized 
+      [
+        "greater_than(#{@left.name}, #{@right.name}, #{@name});"
+      ]
+    else
+      []
+    end
+  end
+  
+  def cycle_level_arduino_code
+    if @frame_optimized
+      [
+        "greater_than(#{@left.name}, #{@right.name}, #{@name});"
+      ]
+    else
+      []
+    end
+  end
+
+  def top_level_scope_code
+    [
+      "long #{@name}[3];"
+    ]
+  end
+end
+
+module Arbol
+  class Documentation
+
+  def greater_than 
+%{--
+### greater\_than(left, right)
+
+* **left** - left operand
+* **right** - right operand
+
+left > right as a logical operation returning 0 or 1.0.
+Can be used in the form `left > right`.
+
+}
+  end
+
+  end
+end
+
+def greater_than(left, right)
+  h = ArbolHash.new
+  h[:type] = 'greater_than'
+  h[:left] = resolve(left)
+  h[:right] = resolve(right)
+  h
+end

data/lib/functions/greater_than_equals.rb

@@ -0,0 +1,70 @@
+class GreaterThanEquals < Base
+  Arbol.add_mapped_class(
+    'greater_than_equals', 
+    GreaterThanEquals,
+%{void greater_than_equals(long left[3], long right[3], long out[3]) {
+  if(left[0] >= right[0]) { out[0] = INTEGER_SCALE; } else { out[0] = 0; }
+  if(left[1] >= right[1]) { out[1] = INTEGER_SCALE; } else { out[1] = 0; }
+  if(left[2] >= right[2]) { out[2] = INTEGER_SCALE; } else { out[2] = 0; }
+}}
+  )
+  attr_accessor :left
+  attr_accessor :right
+  
+  def param_keys
+    [:left, :right]
+  end
+
+  def arduino_code
+    unless @frame_optimized 
+      [
+        "greater_than_equals(#{@left.name}, #{@right.name}, #{@name});"
+      ]
+    else
+      []
+    end
+  end
+  
+  def cycle_level_arduino_code
+    if @frame_optimized
+      [
+        "greater_than_equals(#{@left.name}, #{@right.name}, #{@name});"
+      ]
+    else
+      []
+    end
+  end
+  
+  def top_level_scope_code
+    [
+      "long #{@name}[3];"
+    ]
+  end
+end
+
+module Arbol
+  class Documentation
+
+  def greater_than_equals  
+%{--
+### greater\\_than\\_equals(left, right)
+
+* **left** - left operand
+* **right** - right operand
+
+left >= right as a logical operation returning 0 or 1.0.
+Can be used in the form `left >= right`.
+
+}
+  end
+
+  end
+end
+
+def greater_than_equals(left, right)
+  h = ArbolHash.new
+  h[:type] = 'greater_than_equals'
+  h[:left] = resolve(left)
+  h[:right] = resolve(right)
+  h
+end

data/lib/functions/lamp_phase.rb

@@ -0,0 +1,39 @@
+class LampPhase < Base
+  Arbol.add_mapped_class('lamp_phase', LampPhase, nil)
+
+  def initialize(params)
+    super(params)
+    @frame_optimized = false
+  end
+    
+  def arduino_code
+    [
+      "long #{@name}[3] = {this_phase, this_phase, this_phase};"
+    ]
+  end
+
+  def top_level_scope_code
+    []
+  end
+end
+
+module Arbol
+  class Documentation
+
+  def lamp_phase 
+%{--
+### lamp\_phase
+
+Returns current lamp number expressed as a phase 0-~1.0.
+
+}
+  end
+
+  end
+end
+
+def lamp_phase
+  h = ArbolHash.new
+  h[:type] = 'lamp_phase'
+  h
+end

data/lib/functions/less_than.rb

@@ -0,0 +1,70 @@
+class LessThan < Base
+  Arbol.add_mapped_class(
+    'less_than', 
+    LessThan,
+%{void less_than(long left[3], long right[3], long out[3]) {
+  if(left[0] < right[0]) { out[0] = INTEGER_SCALE; } else { out[0] = 0; }
+  if(left[1] < right[1]) { out[1] = INTEGER_SCALE; } else { out[1] = 0; }
+  if(left[2] < right[2]) { out[2] = INTEGER_SCALE; } else { out[2] = 0; }
+}}
+  )
+  attr_accessor :left
+  attr_accessor :right
+  
+  def param_keys
+    [:left, :right]
+  end
+
+  def arduino_code
+    unless @frame_optimized 
+      [
+        "less_than(#{@left.name}, #{@right.name}, #{@name});"
+      ]
+    else
+      []
+    end
+  end
+  
+  def cycle_level_arduino_code
+    if @frame_optimized
+      [
+        "less_than(#{@left.name}, #{@right.name}, #{@name});"
+      ]
+    else
+      []
+    end
+  end
+  
+  def top_level_scope_code
+    [
+      "long #{@name}[3];"
+    ]
+  end
+end
+
+module Arbol
+  class Documentation
+
+  def less_than  
+%{--
+### less\\_than(left, right)
+
+* **left** - left operand
+* **right** - right operand
+
+left < right as a logical operation returning 0 or 1.0.
+Can be used in the form `left < right`.
+
+}
+  end
+
+  end
+end
+
+def less_than(left, right)
+  h = ArbolHash.new
+  h[:type] = 'less_than'
+  h[:left] = resolve(left)
+  h[:right] = resolve(right)
+  h
+end

data/lib/functions/less_than_equals.rb

@@ -0,0 +1,70 @@
+class LessThanEquals < Base
+  Arbol.add_mapped_class(
+    'less_than_equals', 
+    LessThanEquals,
+%{void less_than_equals(long left[3], long right[3], long out[3]) {
+  if(left[0] <= right[0]) { out[0] = INTEGER_SCALE; } else { out[0] = 0; }
+  if(left[1] <= right[1]) { out[1] = INTEGER_SCALE; } else { out[1] = 0; }
+  if(left[2] <= right[2]) { out[2] = INTEGER_SCALE; } else { out[2] = 0; }
+}}
+  )
+  attr_accessor :left
+  attr_accessor :right
+  
+  def param_keys
+    [:left, :right]
+  end
+
+  def arduino_code
+    unless @frame_optimized 
+      [
+        "less_than_equals(#{@left.name}, #{@right.name}, #{@name});"
+      ]
+    else
+      []
+    end
+  end
+  
+  def cycle_level_arduino_code
+    if @frame_optimized
+      [
+        "less_than_equals(#{@left.name}, #{@right.name}, #{@name});"
+      ]
+    else
+      []
+    end
+  end
+  
+  def top_level_scope_code
+    [
+      "long #{@name}[3];"
+    ]
+  end
+end
+
+module Arbol
+  class Documentation
+
+  def less_than_equals  
+%{--
+### less\\_than\\_equals(left, right)
+
+* **left** - left operand
+* **right** - right operand
+
+left <= right as a logical operation returning 0 or 1.0.
+Can be used in the form `left <= right`.
+
+}
+  end
+
+  end
+end
+
+def less_than_equals(left, right)
+  h = ArbolHash.new
+  h[:type] = 'less_than_equals'
+  h[:left] = resolve(left)
+  h[:right] = resolve(right)
+  h
+end

data/lib/functions/lfo_square.rb

@@ -0,0 +1,68 @@
+class LFOSquare < Base
+  Arbol.add_mapped_class(
+    'lfo_square', 
+    LFOSquare,
+%{long half_int_scale_vec[3] = {long(INTEGER_SCALE / 2), long(INTEGER_SCALE / 2), long(INTEGER_SCALE / 2)};
+void lfo_square(long mils, long cycle_ms[3], long out[3]) {
+  long phase[3];
+  phasor(mils, cycle_ms, phase);
+  greater_than(phase, half_int_scale_vec, out);
+}}
+  )
+  attr_accessor :cycle_ms
+  
+  def param_keys
+    [:cycle_ms]
+  end
+
+  def arduino_code
+    unless @frame_optimized 
+      [
+        "lfo_square(mils, #{@cycle_ms.name}, #{@name});"
+      ]
+    else
+      []
+    end
+  end
+  
+  def cycle_level_arduino_code
+    if @frame_optimized
+      [
+        "lfo_square(mils, #{@cycle_ms.name}, #{@name});"
+      ]
+    else
+      []
+    end
+  end
+  
+  def top_level_scope_code
+    [
+      "long #{@name}[3];"
+    ]
+  end
+end
+
+module Arbol
+  class Documentation
+
+  def lfo_square  
+%{--
+### lfo\\_square(cycle\\_ms)
+
+* **cycle\\_ms** - cycle length expressed as milliseconds
+
+Outputs a square wave. Note that the cycle length value is interpreted literally
+as milliseconds, so you should use integer constants as input.
+
+}
+  end
+
+  end
+end
+
+def lfo_square(cycle_ms)
+  h = ArbolHash.new
+  h[:type] = 'lfo_square'
+  h[:cycle_ms] = resolve(cycle_ms)
+  h
+end

data/lib/functions/lfo_triangle.rb

@@ -0,0 +1,72 @@
+class LFOTriangle < Base
+  Arbol.add_mapped_class(
+    'lfo_triangle', 
+    LFOTriangle,
+%{long twice_int_scale_vec[3] = {long(INTEGER_SCALE * 2), long(INTEGER_SCALE * 2), long(INTEGER_SCALE * 2)};
+void lfo_triangle(long mils, long cycle_ms[3], long out[3]) {
+  long phase[3];
+  phasor(mils, cycle_ms, phase);
+  long times_result[3];
+  times(phase, twice_int_scale_vec, times_result);
+  if(times_result[0] > INTEGER_SCALE) { out[0] = (twice_int_scale_vec[0] - times_result[0]); } else { out[0] = times_result[0]; }
+  if(times_result[1] > INTEGER_SCALE) { out[1] = (twice_int_scale_vec[1] - times_result[1]); } else { out[1] = times_result[1]; }
+  if(times_result[2] > INTEGER_SCALE) { out[2] = (twice_int_scale_vec[2] - times_result[2]); } else { out[2] = times_result[2]; }
+}}
+  )
+  attr_accessor :cycle_ms
+  
+  def param_keys
+    [:cycle_ms]
+  end
+
+  def arduino_code
+    unless @frame_optimized 
+      [
+        "lfo_triangle(mils, #{@cycle_ms.name}, #{@name});"
+      ]
+    else
+      []
+    end
+  end
+  
+  def cycle_level_arduino_code
+    if @frame_optimized
+      [
+        "lfo_triangle(mils, #{@cycle_ms.name}, #{@name});"
+      ]
+    else
+      []
+    end
+  end
+
+  def top_level_scope_code
+    [
+      "long #{@name}[3];"
+    ]
+  end
+end
+
+module Arbol
+  class Documentation
+
+  def lfo_triangle 
+%{--
+### lfo\\_triangle(cycle\\_ms)
+
+* **cycle\\_ms** - cycle length expressed as milliseconds
+
+Outputs a triangle wave. Note that the cycle length value is interpreted literally
+as milliseconds, so you should use integer constants as input.
+
+}
+  end
+
+  end
+end
+
+def lfo_triangle(cycle_ms)
+  h = ArbolHash.new
+  h[:type] = 'lfo_triangle'
+  h[:cycle_ms] = resolve(cycle_ms)
+  h
+end