nudge 0.2.6 → 0.2.7

data/lib/instructions/float/float_sqrt.rb

@@ -1,3 +1,13 @@
+# pops the top item of the +:float+ stack;
+# pushes a ValuePoint with its square root onto the +:float+ stack
+#
+# note: pushes an +:error+ item if the value is negative
+#
+# *needs:* 1 +:float+
+#
+# *pushes:* 1 +:float+
+#
+
 class FloatSqrtInstruction < Instruction
   def preconditions?
     needs :float, 1

data/lib/instructions/float/float_subtract.rb

@@ -1,3 +1,13 @@
+# pops the top 2 items of the +:float+ stack;
+# pushes a ValuePoint with their difference onto the +:float+ stack
+#
+# note: the top item is the value subtracted from the second stack item's value
+#
+# *needs:* 2 +:float+
+#
+# *pushes:* 1 +:float+
+#
+
 class FloatSubtractInstruction < Instruction
   def preconditions?
     needs :float, 2

data/lib/instructions/float/float_swap.rb

@@ -1,3 +1,6 @@
+# exchanges the position of the top 2 items on the +:float+ stack
+#
+
 class FloatSwapInstruction < Instruction
   include SwapInstruction
   def initialize(context)

data/lib/instructions/float/float_tangent.rb

@@ -1,3 +1,11 @@
+# pops the top item of the +:float+ stack;
+# pushes a ValuePoint with its tangent onto the +:float+ stack
+#
+# *needs:* 1 +:float+
+#
+# *pushes:* 1 +:float+
+#
+
 class FloatTangentInstruction < Instruction
   def preconditions?
     needs :float, 1

data/lib/instructions/float/float_yank.rb

@@ -1,3 +1,15 @@
+# pops the top item of the +:int+ stack (the "index");
+# then repositions an item from down "inside" the +:float+ stack to its top.
+# 
+# If the index value is negative or 0, the bottom item on the stack is moved;
+# if the index value is greater than or equal to the depth of the stack, there is no change;
+# otherwise, the index value refers to the bottom-to-top order of stack items.
+#
+# *needs:* 1 +:int+, 1 +:float+
+#
+# *pushes:* 1 +:float+ (sortof)
+#
+
 class FloatYankInstruction < Instruction
   include YankInstruction
   def initialize(context)

data/lib/instructions/float/float_yankdup.rb

@@ -1,3 +1,15 @@
+# pops the top item of the +:int+ stack (the "index");
+# pushes a duplicate of an item from down "inside" the +:float+ stack to its top.
+# 
+# If the index value is negative or 0, the bottom item on the stack is copied;
+# if the index value is greater than or equal to the depth of the stack, the top item is copied;
+# otherwise, the index value refers to the bottom-to-top order of stack items.
+#
+# *needs:* 1 +:int+, 1 +:float+
+#
+# *pushes:* 1 +:float+ (sortof)
+#
+
 class FloatYankdupInstruction < Instruction
   include YankdupInstruction
   def initialize(context)

data/lib/instructions/int/int_abs.rb

@@ -1,4 +1,12 @@
-class IntAbsInstruction < Instruction
+# pops the top item of the +:int+ stack;
+# pushes a ValuePoint with its absolute value onto the +:int+ stack
+#
+# *needs:* 1 +:int+
+#
+# *pushes:* 1 +:int+
+#
+
+class IntAbsInstruction < Instruction  
   def preconditions?
     needs :int, 1
   end

data/lib/instructions/int/int_add.rb

@@ -1,3 +1,11 @@
+# pops the top 2 items of the +:int+ stack;
+# pushes a ValuePoint with their sum onto the +:int+ stack
+#
+# *needs:* 2 +:int+
+#
+# *pushes:* 1 +:int+
+#
+
 class IntAddInstruction < Instruction
   def preconditions?
     needs :int, 2

data/lib/instructions/int/int_define.rb

@@ -1,6 +1,15 @@
+# pops the top item of the +:int+ stack and the +:name+ stack;
+# if the name string is not a bound variable (as opposed to a local name),
+# it binds the name to the +:int+ ValuePoint
+#
+# *needs:* 1 +:int+, 1 +:name+
+#
+# *pushes:* nothing
+#
+
 class IntDefineInstruction < Instruction
   include DefineInstruction
-  def initialize(context)
+  def initialize(context) #:nodoc:
     super(context, :int)
   end
 end

data/lib/instructions/int/int_depth.rb

@@ -1,3 +1,8 @@
+# pushes a ValuePoint with the number of items in the +:int+ stack onto the +:int+ stack
+#
+# *pushes:* 1 +:int+
+#
+
 class IntDepthInstruction < Instruction
   include DepthInstruction
   def initialize(context)

data/lib/instructions/int/int_divide.rb

@@ -1,3 +1,15 @@
+# pops the top 2 items of the +:int+ stack;
+# pushes a ValuePoint with their (integer) quotient onto the +:int+ stack
+#
+# note: the top item is the denominator, the second item is the numerator
+#
+# note: will push an +:error+ ValuePoint instead of an +:int+ if the numerator is 0
+#
+# *needs:* 2 +:int+
+#
+# *pushes:* 1 +:int+
+#
+
 class IntDivideInstruction < Instruction
   def preconditions?
     needs :int, 2

data/lib/instructions/int/int_duplicate.rb

@@ -1,3 +1,10 @@
+# makes and pushes a clone of the top item on the +:int+ stack
+#
+# *needs:* 1 +:int+
+#
+# *pushes:* 1 +:int+
+#
+
 class IntDuplicateInstruction < Instruction
   include DuplicateInstruction
   def initialize(context)

data/lib/instructions/int/int_equal_q.rb

@@ -1,3 +1,11 @@
+# pops the top 2 items of the +:int+ stack;
+# pushes a new ValuePoint onto the +:bool+ stack, with value +true+ if the integers are identical
+#
+# *needs:* 2 +:int+
+#
+# *pushes:* 1 +:bool+
+#
+
 class IntEqualQInstruction < Instruction
   def preconditions?
     needs :int, 2

data/lib/instructions/int/int_flush.rb

@@ -1,3 +1,6 @@
+# deletes all items from the +:int+ stack
+#
+
 class IntFlushInstruction < Instruction
   include FlushInstruction
   def initialize(context)

data/lib/instructions/int/int_greater_than_q.rb

@@ -1,3 +1,12 @@
+# pops the top 2 items of the +:int+ stack;
+# pushes a new ValuePoint onto the +:bool+ stack,
+# with value +true+ if the second one is strictly greater than the top one
+#
+# *needs:* 2 +:int+
+#
+# *pushes:* 1 +:bool+
+#
+
 class IntGreaterThanQInstruction < Instruction
   def preconditions?
     needs :int, 2

data/lib/instructions/int/int_if.rb

@@ -1,3 +1,11 @@
+# pops the top 2 items of the +:int+ stack, and one +:bool+;
+# returns the top +:int+ item if the +:bool+ is +false+, the second one if +true+
+#
+# *needs:* 2 +:int+, 1 +:bool+
+#
+# *pushes:* 1 +:int+
+#
+
 class IntIfInstruction < Instruction
   
   include IfInstruction

data/lib/instructions/int/int_less_than_q.rb

@@ -1,3 +1,12 @@
+# pops the top 2 items of the +:int+ stack;
+# pushes a new ValuePoint onto the +:bool+ stack,
+# with value +true+ if the second one is strictly less than the top one
+#
+# *needs:* 2 +:int+
+#
+# *pushes:* 1 +:bool+
+#
+
 class IntLessThanQInstruction < Instruction
   def preconditions?
     needs :int, 2

data/lib/instructions/int/int_max.rb

@@ -1,3 +1,11 @@
+# pops the top 2 items of the +:int+ stack;
+# pushes a new ValuePoint onto the +:int+ stack with the largest of the two values
+#
+# *needs:* 2 +:int+
+#
+# *pushes:* 1 +:int+
+#
+
 class IntMaxInstruction < Instruction
   def preconditions?
     needs :int, 2

data/lib/instructions/int/int_min.rb

@@ -1,3 +1,11 @@
+# pops the top 2 items of the +:int+ stack;
+# pushes a new ValuePoint onto the +:int+ stack with the smallest of the two values
+#
+# *needs:* 2 +:int+
+#
+# *pushes:* 1 +:int+
+#
+
 class IntMinInstruction < Instruction
   def preconditions?
     needs :int, 2

data/lib/instructions/int/int_modulo.rb

@@ -1,3 +1,15 @@
+# pops the top 2 items of the +:int+ stack;
+# pushes a ValuePoint with their (integer) remainder onto the +:int+ stack
+#
+# note: the top item is the denominator, the second item is the numerator
+#
+# note: will push an +:error+ ValuePoint instead of an +:int+ if the numerator is 0
+#
+# *needs:* 2 +:int+
+#
+# *pushes:* 1 +:int+
+#
+
 class IntModuloInstruction < Instruction
   def preconditions?
     needs :int, 2

data/lib/instructions/int/int_multiply.rb

@@ -1,3 +1,11 @@
+# pops the top 2 items of the +:int+ stack;
+# pushes a ValuePoint with their product onto the +:int+ stack
+#
+# *needs:* 2 +:int+
+#
+# *pushes:* 1 +:int+
+#
+
 class IntMultiplyInstruction < Instruction
   def preconditions?
     needs :int, 2

data/lib/instructions/int/int_negative.rb

@@ -1,3 +1,11 @@
+# pops the top item of the +:int+ stack;
+# pushes a ValuePoint with the value negated onto the +:int+ stack
+#
+# *needs:* 1 +:int+
+#
+# *pushes:* 1 +:int+
+#
+
 class IntNegativeInstruction < Instruction
   def preconditions?
     needs :int, 1

data/lib/instructions/int/int_pop.rb

@@ -1,3 +1,6 @@
+# pops (and discards) the topmost item from the +:int+ stack
+#
+
 class IntPopInstruction < Instruction
   include PopInstruction
   def initialize(context)

data/lib/instructions/int/int_power.rb

@@ -1,3 +1,15 @@
+# pops the top 2 items of the +:int+ stack;
+# pushes a ValuePoint with value x**y, where x is the second stack item, y the top one
+#
+# note: the top item is the exponent, the second item is the base
+#
+# note: will push an +:error+ ValuePoint instead of an +:int+ if asked to take a negative root of 0
+#
+# *needs:* 2 +:int+
+#
+# *pushes:* 1 +:int+
+#
+
 class IntPowerInstruction < Instruction
   def preconditions?
     needs :int, 2

data/lib/instructions/int/int_random.rb

@@ -1,3 +1,6 @@
+# pushes a new +:int+ ValuePoint, with value determined by a call to IntType.any_value
+#
+
 class IntRandomInstruction < Instruction
   def preconditions?
     true # no preconditions

data/lib/instructions/int/int_rotate.rb

@@ -1,3 +1,14 @@
+# pops the top 3 items of the +:int+ stack;
+# pushes them back in _rotated_ order
+# 
+# If they were A, B and C (with C originally at the top of the stack)
+# the result will be B, C, A (with A at the top)
+#
+# *needs:* 3 +:int+
+#
+# *pushes:* 3 +:int+
+#
+
 class IntRotateInstruction < Instruction
   include RotateInstruction
   def initialize(context)

data/lib/instructions/int/int_shove.rb

@@ -1,3 +1,17 @@
+# pops the top 2 items of the +:int+ stack;
+# pushes the top item down "into" the +:int+ stack, at a level determined by the second value.
+# 
+# If the destination value is negative or 0, the item stays on top;
+# if the destination value is greater than or equal to the depth of the stack, the item goes to the bottom;
+# otherwise, the item is inserted farther from the stack's top as the destination value increases.
+# 
+# note: the destination depth is calculated after the items have been popped
+#
+# *needs:* 2 +:int+
+#
+# *pushes:* 1 +:int+ (sortof)
+#
+
 class IntShoveInstruction < Instruction
   include ShoveInstruction
   def initialize(context)

data/lib/instructions/int/int_subtract.rb

@@ -1,3 +1,13 @@
+# pops the top 2 items of the +:int+ stack;
+# pushes a ValuePoint with their difference onto the +:int+ stack
+#
+# note: the top item is the value subtracted from the second stack item's value
+#
+# *needs:* 2 +:int+
+#
+# *pushes:* 1 +:int+
+#
+
 class IntSubtractInstruction < Instruction
   def preconditions?
     needs :int, 2

data/lib/instructions/int/int_swap.rb

@@ -1,3 +1,6 @@
+# exchanges the position of the top 2 items on the +:int+ stack
+#
+
 class IntSwapInstruction < Instruction
   include SwapInstruction
   def initialize(context)

data/lib/instructions/int/int_yank.rb

@@ -1,3 +1,17 @@
+# pops the top item of the +:int+ stack (the "index");
+# repositions an item from down "inside" the +:int+ stack to its top.
+# 
+# If the index value is negative or 0, the bottom item on the stack is moved;
+# if the index value is greater than or equal to the depth of the stack, there is no change;
+# otherwise, the index value refers to the bottom-to-top order of stack items.
+# 
+# note: the destination depth is calculated after the index has been popped
+#
+# *needs:* 2 +:int+
+#
+# *pushes:* 1 +:int+
+#
+
 class IntYankInstruction < Instruction
   include YankInstruction
   def initialize(context)

data/lib/instructions/int/int_yankdup.rb

@@ -1,3 +1,17 @@
+# pops the top item of the +:int+ stack (the "index");
+# pushes a duplicate of an item from down "inside" the +:int+ stack at its top.
+# 
+# If the index value is negative or 0, the bottom item on the stack is copied;
+# if the index value is greater than or equal to the depth of the stack, the top item is copied;
+# otherwise, the index value refers to the bottom-to-top order of stack items.
+# 
+# note: the destination depth is calculated after the index has been popped
+#
+# *needs:* 2 +:int+
+#
+# *pushes:* 1 +:int+
+#
+
 class IntYankdupInstruction < Instruction
   include YankdupInstruction
   def initialize(context)

data/lib/instructions/name/name_depth.rb

@@ -1,3 +1,8 @@
+# pushes a ValuePoint with the number of items in the +:name+ stack onto the +:int+ stack
+#
+# *pushes:* 1 +:int+
+#
+
 class NameDepthInstruction < Instruction
   include DepthInstruction
   def initialize(context)