termular 0.1.2 → 0.1.4

data/lib/termular/graph.rb

@@ -126,6 +126,26 @@ module Termular
       end
     end
   
+    class ImplicitCartesian < Graph
+      def render
+        @needs_redraw = false
+        Console.buffered_print do |buff|
+          buff << render_axes
+          ctx = Context.new Context.global
+          ctx["time"] = Time.now.to_f - @start_time
+          buff << Console.color(:green)
+          1.upto(Console.rows - 1) do |sy|
+            1.upto(Console.cols) do |sx|
+              ctx["x"], ctx["y"] = screen_to_point sx, sy
+              if expression.eval ctx
+                buff << Console.move(sx, Console.rows - sy) << "+"
+              end
+            end
+          end
+        end
+      end
+    end
+    
     class Polar < Graph
       def render
         @needs_redraw = false
@@ -150,5 +170,26 @@ module Termular
         end
       end
     end
+    
+    class ImplicitPolar < Graph
+      def render
+        @needs_redraw = false
+        Console.buffered_print do |buff|
+          buff << render_axes
+          ctx = Context.new Context.global
+          ctx["time"] = Time.now.to_f - @start_time
+          buff << Console.color(:green)
+          1.upto(Console.rows - 1) do |sy|
+            1.upto(Console.cols) do |sx|
+              x, y = screen_to_point sx, sy
+              ctx["r"], ctx["t"] = Math.sqrt(x**2 + y**2), Math.atan2(y, x)
+              if expression.eval ctx
+                buff << Console.move(sx, Console.rows - sy) << "+"
+              end
+            end
+          end
+        end
+      end
+    end
   end
 end

data/lib/termular/parser.rb

@@ -12,11 +12,15 @@ module Termular
       attr_accessor :left, :right
     end
     
-    class Add < Binary;       def eval(ctx) left.eval(ctx) + right.eval(ctx) end end
-    class Subtract < Binary;  def eval(ctx) left.eval(ctx) - right.eval(ctx) end end
-    class Multiply < Binary;  def eval(ctx) left.eval(ctx) * right.eval(ctx) end end
-    class Divide < Binary;    def eval(ctx) left.eval(ctx) / right.eval(ctx) end end
-    class Power < Binary;     def eval(ctx) left.eval(ctx) ** right.eval(ctx) end end
+    class Add < Binary;               def eval(ctx) left.eval(ctx) +  right.eval(ctx) end end
+    class Subtract < Binary;          def eval(ctx) left.eval(ctx) -  right.eval(ctx) end end
+    class Multiply < Binary;          def eval(ctx) left.eval(ctx) *  right.eval(ctx) end end
+    class Divide < Binary;            def eval(ctx) left.eval(ctx) /  right.eval(ctx) end end
+    class Power < Binary;             def eval(ctx) left.eval(ctx) ** right.eval(ctx) end end
+    class LessThan < Binary;          def eval(ctx) left.eval(ctx) <  right.eval(ctx) end end
+    class LessThanEqual < Binary;     def eval(ctx) left.eval(ctx) <= right.eval(ctx) end end
+    class GreaterThan < Binary;       def eval(ctx) left.eval(ctx) >  right.eval(ctx) end end
+    class GreaterThanEqual < Binary;  def eval(ctx) left.eval(ctx) >= right.eval(ctx) end end
     
     class Negate < Base
       attr_accessor :expression
@@ -51,10 +55,18 @@ module Termular
       attr_accessor :expression
     end
     
+    class ImplicitCartesianCommand < Base
+      attr_accessor :relation
+    end
+    
     class PolarCommand < Base
       attr_accessor :expression
     end
     
+    class ImplicitPolarCommand < Base
+      attr_accessor :relation
+    end
+    
     class OptionCommand < Base
       attr_accessor :option, :expression
     end
@@ -78,7 +90,11 @@ module Termular
         [ :OPEN_BRACKET,  /\[/ ],
         [ :CLOSE_BRACKET, /\]/ ],
         [ :COMMA,         /\,/ ],
-        [ :COMMAND,       /:([a-z][a-z0-9]*)/, ->m { m[1] } ]
+        [ :COMMAND,       /:([a-z][a-z0-9]*)/, ->m { m[1] } ],
+        [ :LTE,           /<=/ ],
+        [ :LT,            /</ ],
+        [ :GTE,           />=/ ],
+        [ :GT,            />/ ]
       ].map { |a| [a[0], Regexp.new("\\A#{a[1].source}", Regexp::MULTILINE), a[2]] }
       
     def self.lex!(original_src)
@@ -139,18 +155,29 @@ module Termular
       assert_type next_token, :COMMAND
       case token[1]
       when "q";   AST::QuitCommand.new
+      when "ic";  AST::ImplicitCartesianCommand.new relation: relation
       when "c";   AST::CartesianCommand.new expression: expression
+      when "ip";  AST::ImplicitPolarCommand.new relation: relation
       when "p";   AST::PolarCommand.new expression: expression
       when "opt"; option_command
       end
     end
     
+    def relation
+      left = expression
+      assert_type next_token, :LT, :LTE, :GT, :GTE
+      op = token[0]
+      right = expression
+      { LT: AST::LessThan, LTE: AST::LessThanEqual, GT: AST::GreaterThan,
+        GTE: AST::GreaterThanEqual }[op].new left: left, right: right
+    end
+
     def option_command
       assert_type next_token, :BAREWORD
       opt = token[1]
       AST::OptionCommand.new option: opt, expression: expression
     end
-    
+  
     def expression
       additive_expression
     end

data/lib/termular/ui.rb

@@ -84,9 +84,15 @@ module Termular
           if current_command.is_a? AST::CartesianCommand
             @current_graph = Graph::Cartesian.new current_command.expression
             @needs_tick = expression =~ /time/
+          elsif current_command.is_a? AST::ImplicitCartesianCommand
+            @current_graph = Graph::ImplicitCartesian.new current_command.relation
+            @needs_tick = expression =~ /time/
           elsif current_command.is_a? AST::PolarCommand
             @current_graph = Graph::Polar.new current_command.expression
             @needs_tick = expression =~ /time/
+          elsif current_command.is_a? AST::ImplicitPolarCommand
+            @current_graph = Graph::ImplicitPolar.new current_command.relation
+            @needs_tick = expression =~ /time/
           elsif current_command.is_a? AST::OptionCommand
             if current_graph
               current_graph.options[current_command.option] = current_command.expression.eval(Context.global)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: termular
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-01-07 00:00:00.000000000 Z
+date: 2012-01-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ncurses-ruby
-  requirement: &2154884800 !ruby/object:Gem::Requirement
+  requirement: &2169471840 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *2154884800
+  version_requirements: *2169471840
 - !ruby/object:Gem::Dependency
   name: paint
-  requirement: &2154883580 !ruby/object:Gem::Requirement
+  requirement: &2169471380 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,7 +32,7 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *2154883580
+  version_requirements: *2169471380
 description: Termular Grapher is a simple graphing program that's capable of cartesian
   and polar graphs
 email: