t-rex 1.0.5 → 2.0

data/bin/t-rex

@@ -0,0 +1,760 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+#
+# Title:      T-REX (Terminal - Rpn EXperiment)
+# Language:   Pure Ruby, best viewed in VIM
+# Author:     Geir Isene <g@isene.com> http://isene.com/
+# Github:     https://github.com/isene/t-rex/
+# License:    I release all copyright claims. This code is in the public domain.
+#             Permission is granted to use, copy modify, distribute, and sell
+#             this software for any purpose. I make no guarantee about the
+#             suitability of this software for any purpose and I am not liable
+#             for any damages resulting from its use. Further, I am under no
+#             obligation to maintain or extend this software. It is provided 
+#             on an 'as is' basis without any expressed or implied warranty.
+@version    = "2.0" # Full rewrite with rcurses, face lift, new functionality, bug fixes
+
+require 'rcurses'
+include Rcurses::Input
+
+def help # HELP text
+help = <<HELPTEXT
+  
+  T-REX - Terminal Rpn calculator EXperiment. GitHub: https://github.com/isene/T-REX
+  This is a Reverse Polish Notation calculator similar to the traditional Hewlett 
+  Packard calculators. See https://www.hpmuseum.org/rpn.htm for info on RPN.
+ 
+  The stack is shown to the top left. The X, Y, Z and  T registers comprise the 
+  operating stack. L is the "Last X" register showing the previous value in X.
+  Toggle US and European number formats by pressing '. 
+ 
+  Functions available are shown under the stack registers. The orange symbol 
+  corresponds to the key to be pressed. For functions above each label (grey 
+  functions), press the Control key (Ctrl) and the orange key (asin = Ctrl+i).
+  
+  For Rectangular to Polar conversions:
+  R-P: X value in x, Y in y - yields "θ" in y and "r" in x.
+  P-R: "θ" in y and "r" in x - yeilds X in x and Y in y.
+
+  Use the "f" key to set the fixed number of decimal places. Use the "s" key to set 
+  the limit for viewing numbers in the "scientific" notation (e.g. 5e+06 for 5000000).
+ 
+  Content of registers #0-#9 are shown below the functions.
+  Store/recall using capital "S"/"R". "M" clears the regs.
+ 
+  Copy/yank the X register to clipboard with "y". Use "Y" to yank all the memory regs.
+
+  You can undo (with "u") all the way to the beginning of the session.
+
+  The 'H' key toggles between the help text in the right pane or a continuous printout.
+  Save the full printout to ~/t-rex.txt with "Ctrl-P".
+
+  The stack, register contents, modes and help text settings are saved on Quit.
+
+  Additionally, you can access the "Ruby mode" via '@'. Here you can address the stack 
+  directly, e.g. 'x = y + (z / t); puts x'. Quit Ruby mode with ESC.
+
+  Alternative keys: Left/Right keys (in addition to "<") exchanges X and Y registers. 
+  Backspace clears the x register.
+HELPTEXT
+  if @hlp
+    @p_hlp.fg = 239
+    @p_hlp.ix = 0
+    @p_hlp.puts(help)
+  else
+    @p_hlp.ix = @history.length - @h + 3
+    histprint
+  end
+end
+
+class Stack # STACK class
+  attr_accessor :x, :y, :z, :t, :l, :deg
+
+  def initialize(x, y, z, t, l)
+    self.x = x.to_f
+    self.y = y.to_f
+    self.z = z.to_f
+    self.t = t.to_f
+    self.l = l.to_f
+  end
+  def lift
+    self.y, self.z, self.t = self.x, self.y, self.z
+  end
+  def drop
+    self.y, self.z = self.z, self.t
+  end
+  def rdn
+    self.x, self.y, self.z, self.t = self.y, self.z, self.t, self.x
+  end
+  def rup
+    self.x, self.y, self.z, self.t = self.t, self.x, self.y, self.z
+  end
+  def xy
+    self.x, self.y = self.y, self.x
+  end
+  def add
+    self.l = self.x
+    self.x = self.y + self.x
+    self.drop
+  end
+  def subtract
+    self.l = self.x
+    self.x = self.y - self.x
+    self.drop
+  end
+  def multiply
+    self.l = self.x
+    self.x = self.y * self.x
+    self.drop
+  end
+  def divide
+    begin
+      throw if self.x == 0
+      self.l = self.x
+      self.x = self.y / self.x
+      self.drop
+    rescue
+      return "Error"
+    end
+  end
+  def mod
+    begin
+      throw if self.x == 0
+      self.l = self.x
+      self.x = self.y % self.x
+      self.drop
+    rescue
+      return "Error"
+    end
+  end
+  def percent
+    begin
+      throw if self.y == 0
+      self.l = self.x
+      self.x = 100*(self.x / self.y)
+      self.drop
+    rescue
+      return "Error"
+    end
+  end
+  def chs
+    self.x = -self.x
+  end
+  def pi
+    self.l = self.x
+    self.lift
+    self.x = Math::PI
+  end
+  def pow
+    self.l = self.x
+    self.x = self.y ** self.x
+    self.drop
+  end
+  def root
+    begin
+      self.l = self.x
+      self.x = self.y ** (1 / self.x)
+      self.drop
+    rescue
+      return "Error"
+    end
+  end
+  def recip
+    begin
+      throw if self.x == 0
+      self.l = self.x
+      self.x = 1 / self.x
+    rescue
+      return "Error"
+    end
+  end
+  def sqr
+    self.l = self.x
+    self.x = self.x ** 2
+  end
+  def sqrt
+    self.l = self.x
+    begin
+      self.x = Math::sqrt(self.x)
+    rescue
+      return "Error"
+    end
+  end
+  def cube
+    self.l = self.x
+    self.x = self.x ** 3
+  end
+  def ln
+    self.l = self.x
+    begin
+      self.x = Math::log(self.x)
+    rescue
+      return "Error"
+    end
+  end
+  def ex
+    self.l = self.x
+    self.x = Math::exp(self.x)
+  end
+  def log
+    self.l = self.x
+    begin
+      self.x = Math::log10(self.x)
+    rescue
+      return "Error"
+    end
+  end
+  def tenx
+    self.l = self.x
+    self.x = 10 ** self.x
+  end
+  def sin
+    self.l = self.x
+    self.x = self.x * Math::PI / 180 if self.deg
+    self.x = Math::sin(self.x)
+  end
+  def cos
+    self.l = self.x
+    self.x = self.x * Math::PI / 180 if self.deg
+    self.x = Math::cos(self.x)
+  end
+  def tan
+    self.l = self.x
+    self.x = self.x * Math::PI / 180 if self.deg
+    self.x = Math::tan(self.x)
+  end
+  def asin
+    self.l = self.x
+    begin
+      self.x = Math::asin(self.x)
+      self.x = self.x * 180 / Math::PI if self.deg 
+    rescue
+      return "Error"
+    end
+  end
+  def acos
+    self.l = self.x
+    begin
+      self.x = Math::acos(self.x)
+      self.x = self.x * 180 / Math::PI if self.deg 
+    rescue
+      return "Error"
+    end
+  end
+  def atan
+    self.l = self.x
+    self.x = Math::atan(self.x)
+    self.x = self.x * 180 / Math::PI if self.deg 
+  end
+  def rp
+    begin
+      throw if self.x == 0
+      self.l = self.x
+      x = self.x
+      y = self.y
+      self.x = Math::sqrt(x*x + y*y)
+      self.y = Math::atan(y/x)
+      if x < 0  # Q2 & Q3
+        self.y += Math::PI
+      elsif x >= 0 and y < 0 # Q4
+        self.y += 2 * Math::PI
+      end
+      self.y = self.y * 180 / Math::PI if self.deg
+    rescue
+      return "Error"
+    end
+  end
+  def pr
+    self.l = self.x
+    r = self.x
+    t = self.y
+    t = t * Math::PI / 180 if self.deg
+    self.x = r * Math::cos(t)
+    self.y = r * Math::sin(t)
+  end
+end
+
+begin # BASIC setup
+  @stk = Stack.new(0, 0, 0, 0, 0)
+  @reg = %w[0 0 0 0 0 0 0 0 0 0] 
+  @fix = 4
+  @sci = 6
+  @dot = true
+  @mod = "Deg"
+  @hlp = true
+
+  load(Dir.home+'/.t-rex.conf') if File.exist?(Dir.home+'/.t-rex.conf')
+  @mod == "Deg" ? @stk.deg = true : @stk.deg = false
+
+  @history = [" "]
+  @u    = []
+  @undo = false
+end
+
+begin # PANE setup
+  @h, @w = IO.console.winsize
+
+  #  pane = Rcurses::Pane.new(  x,  y,   width,  height,  fg,  bg)
+  @p_bck  = Rcurses::Pane.new(  1,  1,      @w,      @h, 235, 235) # Back
+  @p_inf  = Rcurses::Pane.new(  2,  2,      32,       1, 168, 238) # Info-line
+  @p_lbl  = Rcurses::Pane.new(  2,  3,       1,       5, 250, 238) # LTZYX lables
+  @p_key  = Rcurses::Pane.new(  2,  9,      32,      11,   0,   0) # Key panel
+  @p_reg  = Rcurses::Pane.new(  2, 21,      32, @h - 21, 242,   0) # Regs
+  @p_hlp  = Rcurses::Pane.new( 35,  2, @w - 35, @h -  2, 239,   0) # Help
+  @p_l    = Rcurses::Pane.new(  4,  3,      30,       1,  60, 235) # L
+  @p_t    = Rcurses::Pane.new(  4,  4,      30,       1,  68, 233) # T
+  @p_z    = Rcurses::Pane.new(  4,  5,      30,       1,  75, 233) # Z
+  @p_y    = Rcurses::Pane.new(  4,  6,      30,       1, 117, 233) # Y
+  @p_x    = Rcurses::Pane.new(  4,  7,      30,       1,   7,   0) # X
+
+  @p_lbl.align = "r"
+  @p_l.align   = "r"
+  @p_t.align   = "r"
+  @p_z.align   = "r"
+  @p_y.align   = "r"
+  @p_x.align   = "r"
+
+  @p_lbl.text  = "ltzyx".i
+
+  class String
+    def t ; self.fg(111) ; end
+    def k ; self.fg(214) ; end
+    def s ; self.fg(242) ; end
+  end
+
+  keys  = "\n"
+  keys += " r".t + "↓".k + " r".t + "↑".k + " x".t + "<".k + ">y".t
+  keys += " + - * / \\ %".k + " c".t + "h".k + "s".t + " p".k + "i".t
+  keys += "\n\n"
+  keys += " y√x  x^2 x^3  e^x 10^x  redrw".s
+  keys += "\n"
+  keys += " y".t + "^".k + "x".t + "  1/".t + "x".k + " s".t + "q".k + "rt".t 
+  keys += " l".t + "n".k + "  lo".t + "g".k + "   l".k + "astx".t
+  keys += "\n\n"
+  keys += " asin acos atan  R→P P→R  cstk".s
+  keys += "\n"
+  keys += "  s".t + "i".k + "n".t + "  c".t + "o".k + "s".t + "  t".t + "a".k + "n".t
+  keys += "  r".k + "ad".t + " d".k + "eg".t + "  c".k + "lx".t
+  keys += "\n\n"
+  keys += " S".k + "to".t + " R".k + "cl".t + " s".k + "ci".t + " f".k + "ix".t
+  keys += " u".k + "ndo".t + " H".k + "lp".t + " Q".k + "uit".t  
+  @p_key.text = keys
+end
+
+# FUNCTIONS
+def history(entry)
+  @history.push(entry.b, "  #{@stk.t}".i, "  #{@stk.z}".i, "  #{@stk.y}".i, "  #{@stk.x}".i.b, " ")
+end
+def histprint
+  print = @history.join("\n ")
+  @p_hlp.ix = 0 if @p_hlp.ix < 0
+  @p_hlp.fg = 145
+  @p_hlp.puts(print)
+  return print
+end
+def num_format(n) # THE NUMBER FORMAT FUNCTION
+  if n.abs >= 10 ** @sci.to_i
+    n = "%.#{@sci}g" % n
+  elsif n.abs <= 10 ** (1 / @sci.to_i) and n > 10
+    n = "%.#{@sci}g" % n
+  else
+    n = n.round(@fix)
+    n = "%.#{@fix}f" % n
+    m = n[/^-/]
+    m = "" if m == nil
+    n.sub!(/-/, '')
+    i = n[/\d*/]
+    i.gsub!(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1,")
+    f = n.sub(/\d*\.(\d*)/, '\1')
+    n = m + i + "." + f
+    if not @dot
+      n.gsub!(/,/, ' ')
+      n.sub!(/\./, ',')
+    end
+  end
+  return n
+end
+def main_getkey(c) # GET KEY FROM USER
+  c == "" ? chr = getchr : chr = c
+  case chr
+  when 'ENTER'
+    @stk.l = @stk.x
+    @stk.y, @stk.z, @stk.t = @stk.x, @stk.y, @stk.z
+    history("ENTER")
+  when "'"
+    @dot = !@dot
+  when 'UP'   # Roll stack up
+    @stk.rup
+    history("↑")
+  when 'DOWN' # Roll stack down
+    @stk.rdn
+    history("↓")
+  when '<', 'LEFT', 'RIGHT' # x<>y
+    @stk.xy
+    history("x<>y")
+  when '+'
+    @stk.add
+    history("+")
+  when '-'
+    @stk.subtract
+    history("-")
+  when '*'
+    @stk.multiply
+    history("*")
+  when '/'
+    e = @stk.divide
+    history("/")
+    error ("Error: Divide by zero") if e == "Error"
+  when '\\'   # \ (modulo)
+    @stk.mod
+    history("MOD")
+  when '%'    # 100*x/y
+    e = @stk.percent
+    history("%")
+    error ("Error: Divide by zero") if e == "Error"
+  when 'h'    # Change sign
+    @stk.chs
+    history("chs")
+  when 'p'    # pi
+    @stk.l = @stk.x
+    @stk.pi
+    history("pi")
+  when '^'    # y^x
+    @stk.pow
+    history("y^x")
+  when 'C-^'  # y^(1/x)
+    e = @stk.root 
+    history("y^(1/x)")
+    error ("Error: Divide by zero") if e == "Error"
+  when 'x'    # 1/x
+    e = @stk.recip
+    history("1/x")
+    error ("Error: Divide by zero") if e == "Error"
+  when 'C-X'  # x^2
+    @stk.sqr  
+    history("x^2")
+  when 'q'    # Square root
+    e = @stk.sqrt
+    history("sqrt")
+    error ("Error: Imaginary number") if e == "Error"
+  when 'C-Q'  # x^3
+    @stk.cube
+    history("x^3")
+  when 'n'    # ln(x)
+    e = @stk.ln
+    history("ln")
+    error ("Error: Negative x") if e == "Error"
+  when 'C-N'  # e^x
+    @stk.ex
+    history("e^x")
+  when 'g'    # log(x)
+    e = @stk.log
+    history("log")
+    error ("Error: Negative x") if e == "Error"
+  when 'C-G'  # 10^x
+    @stk.tenx
+    history("10^x")
+  when 'l'    # Recall Lastx (l) to x
+    @stk.lift
+    @stk.x = @stk.l
+    history("lastx")
+  when 'C-L'  # Redraw
+    refresh
+  when 'i'
+    @stk.sin
+    history("sin")
+  when 'TAB' # Same as 'C-I'
+    e = @stk.asin
+    history("asin")
+    error ("Error: Number out of domain") if e == "Error"
+  when 'o'
+    @stk.cos
+    history("cos")
+  when 'C-O'
+    e = @stk.acos
+    history("acos")
+    error ("Error: Number out of domain") if e == "Error"
+  when 'a'
+    @stk.tan
+    history("tan")
+  when 'C-A'
+    @stk.atan
+    history("atan")
+  when 'r'     # Rad mode
+    @mod     = "Rad"
+    @stk.deg = false
+    history("Rad")
+  when 'C-R'   # R->P
+    e = @stk.rp
+    history("R->P")
+    error ("Error: Divide by zero") if e == "Error"
+  when 'd'     # Deg mode
+    @mod     = "Deg"
+    @stk.deg = true
+    history("Deg")
+  when 'C-D'   # P->R
+    @stk.pr
+    history("P->R")
+  when 'c', 'BACK'
+    @stk.x = 0
+  when 'C-C'   # Clear stack
+    @stk.x = 0
+    @stk.y = 0
+    @stk.z = 0
+    @stk.t = 0
+    @stk.l = 0
+    history("CLR")
+  when 'M'
+    @reg = %w[0 0 0 0 0 0 0 0 0 0] 
+  when 'S' # Store to Reg
+    @p_x.puts(" Store x in Reg #(0-9)")
+    r = getchr
+    if r =~ /[0-9]/
+      @reg[r.to_i] = @stk.x
+    end
+    history("STO #{r}")
+  when 'R'  # Recall from Reg
+    @p_x.puts(" Recall from Reg #(0-9)")
+    r = getchr
+    if r =~ /[0-9]/
+      @stk.lift
+      @stk.x = @reg[r.to_i].to_f
+    end
+    history("RCL #{r}")
+  when 's'     # Set Sci size/limit
+    @p_x.puts(" Sci notation limit (2-9)")
+    s = getchr
+    if s =~ /[2-9]/
+      @sci = s.to_i
+    end
+    history("Sci #{s}")
+  when 'f'     # Set Fix size
+    @p_x.puts(" Fixed decimals (0-9)")
+    f = getchr
+    if f =~ /[0-9]/
+      @fix = f.to_i
+    end
+    history("Fix #{f}")
+  when 'u'     # Undo
+    unless @u.empty?
+      @stk = @u.last.dup
+      @u.pop
+      @undo = true
+    end
+    history("UNDO")
+  when 'y'
+    begin
+      @p_x.bg = 250
+      @p_x.refresh
+      system("echo '#{@stk.x}' | xclip")
+      sleep(0.1)
+      @p_x.bg = 0
+      @p_x.refresh
+    rescue
+      @p_x.text = " Install xclip to yank"
+      @p_x.refresh
+      getchr
+    end
+  when 'Y'
+    begin
+      @p_x.bg = 244
+      @p_x.refresh
+      mem = ""
+      10.times do |i|
+        reg = @reg[i]
+        mem += "#{reg}\n"
+      end
+      system("echo '#{mem}' | xclip")
+      sleep(0.1)
+      @p_x.bg = 0
+      @p_x.refresh
+    rescue
+      @p_x.text = " Install xclip to yank"
+      @p_x.refresh
+      getchr
+    end
+  when 'H' # Toggle help/histprint
+    @hlp = !@hlp
+  when 'C-B'
+    if !@hlp
+      loop do
+        @p_hlp.ix -= @h + 3
+        histprint
+        break if getchr != 'C-B'
+      end
+    end
+  when 'C-P'
+    cont = histprint.pure
+    File.write(Dir.home+'/t-rex.txt', cont)
+    error ("History written to t-rex.txt")
+  when '@' # Ruby console
+    @p_hlp.fg = 168
+    loop do
+      @p_hlp.puts("")
+      @p_hlp.prompt = " Ruby: "
+      @p_hlp.editline
+      Rcurses::Cursor.set(4,36)
+      x = @stk.x
+      y = @stk.y
+      z = @stk.z
+      t = @stk.t
+      l = @stk.l
+      begin
+        eval(@p_hlp.text)
+      rescue
+      end
+      break if getchr == "ESC"
+    end
+    @p_hlp.fg = 239
+    getchr
+    @hlp ? help : @p_hlp.puts("")
+  when 'Q' # QUIT 
+    exit 0
+  when /[0-9.,]/ # Go to entry mode for x
+    @stk.lift
+    pstack
+    number, c = entry(chr)
+    if number != ""
+      @stk.l = @stk.x
+      @stk.lift unless @stk.x == 0
+      @stk.x = number
+    end
+    history(number.to_s)
+    @stk.drop if c == "ENTER"
+    if %w[< + - * / \ % ^ x C-X q C-Q n C-N g C-G i C-I o C-O a C-A c C-C].include?(c)
+      @stk.drop
+      main_getkey(c)
+    end
+  end
+end
+def entry(chr) # X REGISTER ENTRY
+  num = chr
+  pos = 1
+  Rcurses::Cursor.set(7,33)
+  Rcurses::Cursor.show
+  while %w[0 1 2 3 4 5 6 7 8 9 . , h RIGHT LEFT HOME END DEL BACK WBACK LDEL].include?(chr)
+    @p_x.puts(num)
+    chr = getchr
+    case chr
+    when 'RIGHT'
+      pos += 1 unless pos >= num.length
+    when 'LEFT'
+      pos -= 1 unless pos == 0
+    when 'HOME'
+      pos = 0
+    when 'END'
+      pos = num.length
+    when 'DEL'
+      unless pos == 0
+        pos -= 1
+        num[pos] = ""
+      end
+    when 'BACK'
+      unless pos == 0
+        pos -= 1
+        num[pos - 1] = ""
+      end
+    when 'WBACK'
+      unless pos == 0
+        until num[pos - 1] == " " or pos == 0
+          pos -= 1
+          num[pos] = ""
+        end
+        if num[pos - 1] == " "
+          pos -= 1
+          num[pos] = ""
+        end
+      end
+    when 'LDEL'
+      num = ""
+      pos = 0
+    when 'h'
+      if num[0] == "-"
+        num[0] = "" 
+        pos -= 1
+      else
+        num.insert(0, "-")
+        pos += 1
+      end
+    when /[0-9.,]/
+      num.insert(pos,chr)
+      pos += 1
+    end
+    Rcurses::Cursor.col(33 - num.length + pos)
+  end
+  num = "" if %w[DOWN UP].include?(chr)
+  num.gsub!(/,/, '.')
+  num != "" ? number = num.to_f : number = ""
+  Rcurses::Cursor.hide
+  return number, chr
+end
+def refresh # REFRESH ALL PANES
+  @p_bck.refresh
+  @p_inf.refresh
+  @p_lbl.refresh
+  @p_key.refresh
+  @p_reg.refresh
+  help
+  @p_l.refresh  
+  @p_t.refresh  
+  @p_z.refresh  
+  @p_y.refresh  
+  @p_x.refresh  
+end
+def pstack # PRINT STACK (XYZTL)
+  @p_l.puts(num_format(@stk.l))  
+  @p_t.puts(num_format(@stk.t))  
+  @p_z.puts(num_format(@stk.z))  
+  @p_y.puts(num_format(@stk.y))  
+  @p_x.puts(num_format(@stk.x).b)  
+end
+def pregs # PRINT CONTENT OF REGS (0-9)
+  @p_reg.text = "\n"
+  10.times do |i| 
+    r = num_format(@reg[i].to_f)
+    @p_reg.text += " R##{i}".i + "#{r}".rjust(27) + "\n" 
+  end
+  @p_reg.refresh
+end
+def error(err) # PRINT ERRORS TO X
+  @p_x.puts(err)
+  @history.insert(-2, err)
+  getchr
+end
+def conf_write # WRITE TO .t-rex.conf
+  conf  = "@fix = #{@fix}\n"
+  conf += "@sci = #{@sci}\n"
+  @dot ? d = "true" : d = "false"
+  conf += "@dot = #{d}\n"
+  conf += "@mod = \"#{@mod}\"\n"
+  conf += "@stk = Stack.new(#{@stk.x}, #{@stk.y}, #{@stk.z}, #{@stk.t}, #{@stk.l})\n"
+  conf += "@reg = %w[#{@reg[0]} #{@reg[1]} #{@reg[2]} #{@reg[3]} #{@reg[4]} #{@reg[5]} #{@reg[6]} #{@reg[7]} #{@reg[8]} #{@reg[9]}]\n" 
+  @hlp ? h = "true" : h = "false"
+  conf += "@hlp = #{h}\n"
+  File.write(Dir.home+'/.t-rex.conf', conf)
+end
+
+# MAIN PROGRAM
+refresh
+Rcurses::Cursor.hide
+begin # Capture main loop
+  loop do # Main loop
+    @p_inf.puts("  #{@mod} Sci=#{@sci} Fix=#{@fix}".i)
+    pstack
+    pregs
+    @t = @stk.dup
+    main_getkey("") # Get key input from user 
+    help
+    @u.push(@t.dup) if @t != @stk and @undo == false
+    @undo = false
+    h1, w1 = IO.console.winsize
+    if h1 != @h or w1 != @w # Refresh on terminal resize 
+      @h, @w = IO.console.winsize
+      refresh
+    end
+  end
+ensure # Write to .t-rex.conf on exit
+  conf_write
+end
+
+# vim: set sw=2 sts=2 et fdm=syntax fdn=2 fcs=fold\:\ :