linmeric 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 341e267a03b8fea5821479cf3572e1525b80c328
-  data.tar.gz: 59fb9adb800c906fdbc186ace484ac4392323c44
+  metadata.gz: 1282f00fc5f4e28e4e8a8a1070b9dbe7901b56f4
+  data.tar.gz: e9a17c5fb317d7ee863952408f281256a718200a
 SHA512:
-  metadata.gz: 6c57ef652f21153f0b2ad5bccb3c184db5919591535bfe73f809bd68cf38ff7025584e7bf07c3b8339f74a775a4c67d5f5b95dc4e37bcc4bc148200173886933
-  data.tar.gz: 288c4ec1de4395995a952e3af6ad96999414a3575d0897c217e4568c723959ab446476ec58d071aefec7b5e631d122dba457bcf993c319b0036d983fd818273d
+  metadata.gz: 03082a05f5d02d883060c4320dbd4da93cf3467ce08cd9e2dd6e85922765aec7fd2d4626144ef2c42ef93962ab7346213c714c0153ea33e38ed66fd276fc8ac0
+  data.tar.gz: 8de488ffb8ad277452c109829fbabf154c68e1ba19edf6ded763030ce9a8148cff1894009c9af07b08daf13440a50a0e8e6605f58bf555075388592b0bd3a7ec

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org" do
+  gem 'io-console'
+end
+
+
+

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 TODO: Write your name
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,51 @@
+# Linmeric
+
+This simple numeric calulator provides an easy command line user interface to make operations
+with matrices and functions (integration)
+
+## Installation
+
+rom the command line type:
+```sh
+  $ sudo gem install linmeric
+```
+or click here to go to the linmeric rubygems page and download the .gem file. Then open the directory where the .gem file is saved on the commend line and type:
+```sh
+  $ sudo gem install ./linmeric-<version>.gem
+```
+`<version>` must be replaced by the version number of the gem you downloaded
+
+## Usage
+Instructions are available on the [linmeric page](https://max-codeware.github.io/linmeric/) or you can use the following commands
+to display the guides:
+
+### Displaying the command line guide:
+
+From the command line type:
+```sh
+  $ linmeric -h
+```
+or
+```sh
+  $ linmeric --help
+```
+and a quick help menu will be runned. Choose the option you’re most interested in!
+
+### Viewing the linmeric guide on gedit:
+From the command line type:
+```sh
+  $ linguide <lang>
+```
+to open the user guide on gedit. `<lang>` must be replaced by the language you want. The supported languages are:
+* en (English)
+* it (Italian)
+
+Linguide is also provided by a `-h` command to view its help guide
+
+## Contributing
+
+Bug and mistake reports and pull requests are absolutely welcomed! To report any bug in the code or a mistake in the provided guides or in this website, please email me at max.codeware@gmail.com or on [GitHub](https://github.com/max-codeware/linmeric/) to pull requests too.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rdoc/task"
+task :default => :spec
+
+RDoc::Task.new do |rdoc|
+  rdoc.main = "README.md"
+  rdoc.rdoc_dir = "./doc"
+  rdoc.rdoc_files.include("README.md","lib/*/*.rb")
+  rdoc.options << "--all"
+end

data/bin/help/Help.rb

@@ -0,0 +1,184 @@
+#! /usr/bin/env ruby
+
+require_relative "Help_inst.rb"
+
+##
+# Help menu module -user interface
+#
+# Author:: Massimiliano Dal Mas (mailto:max.codeware@gmail.com0)
+# License:: Distributed under MIT license
+module Help
+  MENU = [
+           "[0] Variable assignment",
+           "[1] Variable displaying",
+           "[2] Comparisons",
+           "[3] Creating a function",
+           "[4] Creating a matrix",
+           "[5] Operations on matrices",
+           "[6] Function intagration",
+           "[7] LU factorization",
+           "[8] Wrinting values and datas on files",
+           "[9] Symbols",
+           "[10] exit"
+         ]
+         
+  MATRIX_OP = [
+                "[a] Transposition",
+                "[b] Norm",
+                "[c] Determinant",
+                "[d] to return to main menu"
+              ]
+              
+  NUMBER        = /[0-9]/
+  LETTER        = /[a-d]/
+  
+  SINGLE_NUMBER = ("0".."9").map do |n|
+                    n
+                  end
+  
+  SINGLE_LETTER = ("a".."d").map do |l|
+                    l
+                  end
+  def self.ask
+    puts MENU
+    print ">> "
+    cmd = STDIN.gets.downcase.chomp
+    while cmd != "10" do
+      case cmd
+        when NUMBER then menu(cmd)
+        self.clrscr
+        puts MENU
+      end
+      print ">> "
+      cmd = STDIN.gets.downcase.chomp
+    end
+    exit 0
+  end
+  
+  def self.menu(choice)
+    if SINGLE_NUMBER.include? choice then
+      self.send("_#{choice}_")
+    end
+  end
+  
+  def self.matrix_op(choice)
+    if SINGLE_LETTER.include? choice then
+      self.send("_#{cmd}_")
+    end
+  end
+  
+  def self.clrscr
+    print "\e[H\e[2J"
+  end
+  
+  def self.back_to_menu
+    puts
+    print "[m] to return to menu >> "
+    key = STDIN.gets.downcase.chomp
+    while key != "m"
+      print "[m] to return to menu >> "
+      key = STDIN.gets.downcase.chomp
+    end
+    # self.clrscr   
+  end
+  
+  def self.back_to_sub_menu
+    puts
+    print "[s] to return to sub menu >> "
+    key = STDIN.gets.downcase.chomp
+    while key != "s"
+      print "[s] to return to sub menu >> "
+      key = STDIN.gets.downcase.chomp
+    end
+    # self.clrscr
+  end
+  
+  def self._0_
+    self.clrscr
+    self.var_assign
+    self.back_to_menu
+  end
+  
+  def self._1_
+    self.clrscr
+    self.var_displaying
+    self.back_to_menu
+  end
+  
+  def self._2_
+    self.clrscr
+    self.comparisons
+    self.back_to_menu
+  end
+  
+  def self._3_
+    self.clrscr
+    self.function
+    self.back_to_menu
+  end
+  
+  def self._4_
+    self.clrscr
+    self.matrix
+    self.back_to_menu
+  end
+  
+  def self._5_
+    self.clrscr
+    puts MATRIX_OP
+    print "*>> "
+    cmd = STDIN.gets.downcase.chomp
+    while cmd != "d" do
+      if SINGLE_LETTER.include? cmd
+        self.send(cmd)
+        self.clrscr
+        puts MATRIX_OP
+      end
+      print "*>> "
+      cmd = STDIN.gets.downcase.chomp
+    end
+  end
+  
+  def self.a
+    self.clrscr
+    self.matrix_tr
+    self.back_to_sub_menu
+  end
+  
+  def self.b
+    self.clrscr
+    self.matrix_norm
+    self.back_to_sub_menu
+  end
+  
+  def self.c
+    self.clrscr
+    self.matrix_det
+    self.back_to_sub_menu
+  end
+  
+  def self._6_
+    self.clrscr
+    self.integration
+    self.back_to_menu
+  end
+  
+  def self._7_
+    self.clrscr
+    self.lu
+    self.back_to_menu
+  end
+  
+  def self._8_
+    self.clrscr
+    self.data_writing
+    self.back_to_menu
+  end
+  
+  def self._9_
+    self.clrscr
+    self.symbols
+    self.back_to_menu
+  end
+
+end

data/bin/help/Help_inst.rb

@@ -0,0 +1,244 @@
+#! /usr/bin/env ruby
+
+
+##
+# Help menu module -instructions
+#
+# Author:: Massimiliano Dal Mas (mailto:max.codeware@gmail.com0)
+# License:: Distributed under MIT license
+module Help
+
+   def self.write(syntax,example)
+     ["SINTAX",syntax,"","EXAMPLES",example].each do |el|
+        puts el
+      end	
+   end
+  VAR_ASSIGNMENT = [
+                     "  <variable_name> = <value>",
+                     "",
+                     "  <variable_name> = <expression>"                    
+                   ]
+  VAR_ASSIGN_EG  = [
+                     "  v1 = 13    #=> 13",
+                     "",
+                     "  v2 = 3*4^2 #=> 48",
+                     "",
+                     "  v3 = v1+v2 #=> 61",
+                     "",
+                     "(Allowed operations: +,-,*,/,^)",
+                     "", 
+                     "This interpreter sees as different uppercase and lowercase",
+                     "letters in variable definition. (A1 <> a1)"
+                   ]
+  def self.var_assign
+    self.write(VAR_ASSIGNMENT,VAR_ASSIGN_EG)
+  end
+  VAR_DISPLAYING = [
+                      "  shw: <variable_name>  // displays <variable_name>",
+                      "",
+                      "  <variable_name>       // displays <variable_name>",
+                      "",
+                      "  shwvar:               // displays all the variables in memory",
+                      "                           no argument required"   
+                   ]
+  VAR_DISPLAY_EG = [
+                     "  # v1 = 13, v2 = 6",
+                     "  shw: v1 #=> 13",
+                     "",
+                     "  v1      #=> 13",
+                     "",
+                     "  shwvar: #=> 13; #=> 6" 
+                   ] 
+  def self.var_displaying
+    self.write(VAR_DISPLAYING,VAR_DISPLAY_EG)
+  end
+  COMPARISONS    = [
+                     "  <expression> = <expression>"
+                   ]
+  COMPARISONS_EG = [
+                     "  12+7 = 10+9   #=> true",
+                     "",
+                     "  12*8 = 20^123 #=> false",
+                     "",
+                     "  a/b = c*f     #=> true/false"
+                   ] 
+  def self.comparisons
+    self.write(COMPARISONS,COMPARISONS_EG)
+  end 
+  FUNCTION_DEF   = [
+                      "  <function_name> = f: \"<function_definition>\""
+                   ]
+  FUNCTION_DEF_E = [
+                     "  fx = f: \"x*log(x)\" #=> x*log(x)",
+                     "",
+                     "  gx = f: \"y^z\"      #=> y^z",
+                     "",
+                     "At the moment, the following algebric functions are supported:",
+                     " log, sin, cos, exp, tan",
+                     "Constants: PI (PI = 3,14...)",
+                     "",
+                     "Restriction: parameters must be composed by only one letter (x,y,k,a...)",
+                     "",
+                     "Warning: this interpreter uses ruby methods to solve functions.",
+                     "Therefore, divisions with numbers return a number in the format",
+                     "corresponding to the one of the denominator.",
+                     "Example: 1/2   #=> 0 (integer => integer)",
+                     "         1/2.0 #=> 0.5 (float => float)"
+                   ]
+  def self.function
+    self.write(FUNCTION_DEF,FUNCTION_DEF_E)
+  end
+  MATRIX_CREATE  = [
+                      "// Matrix inserted by hand:",
+                      "",
+                      "  <matrix_name> = mx: \"<rows>,<columns>\"",
+                      "",
+                      "// Matrix according to a certain function rows-columns (or number):",
+                      "",
+                      "  <matrix_name> = mx: \"<rows>,<columns>\" as: \"<function_definition>\"",
+                      "",
+                      "  <matrix_name> = mx: \"<rows>,<columns>\" as: <function_name>",
+                      "",
+                      "// Matrix from a .csv file:",
+                      "",
+                      "  <matrix_name> = mx: from: \"<file_path>\"",
+                      "",
+                      "// Identity matrix:",
+                      "",
+                      "  <matrix_name> = id_mx: <size>"
+                   ]
+  MATRIX_EXAMPLE = [
+                     "  m1 = mx: \"4,4\"            // it creates a 4x4 matrix with values inserted",
+                     "                               by the user",
+                     "",
+                     "  m2 = mx: \"4,4\" as: \"r*c\"  // it creates a 4x4 matrix in which each element is",
+                     "                               given by the product row_number*column_number",
+                     "",
+                     "  # kx = f: \"r*c\"",
+                     "  m4 = mx: \"4,4\" as: kx     // equals to the previous example",
+                     "",
+                     "  m5 = mx: from: \"/home/usr/Desktop/matrix.csv\" // it loads the matrix written",
+                     "                                                    in the .csv file",
+                     "",
+                     "  id = id_mx: 5             // it creates an identity 5x5 matrix",
+                     "",
+                     "Allowed operations: +, -, *",
+                     "/ (Matrix-number) It divides each element for the given number",
+                     "^ (Matrix-number) It elevates each element at the given exponent",
+                     "",
+                     "It is possible to insert as value simple operations as 3/4, 10^5..."
+                   ]
+  def self.matrix
+    self.write(MATRIX_CREATE,MATRIX_EXAMPLE)
+  end                
+  MATRIX_OP_TR   = ["  t: <matrix_name>"]
+  MATRIX_OP_EG   = [
+                      "  # m1: // 4x7 matrix",
+                      "  t: m1 #=> 7x4 matrix ",
+                      "",
+                      "Results can be stored in a variable"]
+  def self.matrix_tr
+     self.write(MATRIX_OP_TR,MATRIX_OP_EG)
+  end
+  MATRIX_OP_NORM = ["  norm: <matrix_name>"]
+  MATRIX_NORM_EG = [
+                     "  norm: m1 // sqrt (sum (m1[r,c]^2))",
+                     "",
+                     "Results can be stored in a variable"
+                     ]
+  def self.matrix_norm
+    self.write(MATRIX_OP_NORM,MATRIX_NORM_EG)
+  end
+  MATRIX_OP_DET  = ["  det: <matrix_name>"]
+  MATRIX_DET_EG  = [
+                     "  # m0 // 6,6 matrix",
+                     "  det: m0",
+                     "",
+                     "Results can be stored in a variable"  
+                   ]
+  def self.matrix_det
+    self.write(MATRIX_OP_DET,MATRIX_DET_EG)
+  end                 
+  FUNCT_INTEG    = [
+                     "  integ: \"<function_definitio>\" \"<range>\" <number_of_points> (\"<method>\")",
+                     "",
+                     "It is possible to replace the function definition with a variable containing",
+                     "the function itself.",
+                     "Results can be stored in a variable."
+                   ]
+  FUNCT_INTEG_EG = [
+                     "  integ: \"x*log(x^2)\" \"3,10\" 50            // integration of 'x*log(x^2)'",
+                     "                                              from 3 to 10 on 50 points",
+                     "  integ: \"x*log(x^2)\" \"3,10\" 50 \"midpoint\" // integration method specified",
+                     "",
+                     "  # sx = f: \"x*log(x^2)\"",
+                     "  integ: sx \"3,10\" 50",
+                     "",
+                     "Available integration methods:",
+                     " * trapezes  // trapezes method",
+                     " * rectl     // left-rectangles method",
+                     " * rectr     // right-rectangles method",
+                     " * midpoint  // middle-rectangles method",
+                     " * simpson   // simpson method (default)",
+                     " * boole     // boole method"
+                   ]
+  def self.integration
+    self.write(FUNCT_INTEG,FUNCT_INTEG_EG)
+  end                 
+  LU_FACT        = [
+                      "  solve: <matrix_name> ~ <solution_matrix_name>",
+                      "",
+                      "  solve: <expression_with_matrices> ~ <expression_with_matrices>"
+                   ]
+  LU_FACT_EG     = [
+                     "  # a,b,c // 3x3 matrices",
+                     "  # d     // 3x1 matrix",
+                     "",
+                     "  solve: a ~ d     // returns the x-matrix containing the solution",
+                     "                      of the system (d: known system values matrix)",
+                     "  solve: a*b ~ c*d // returns the x-matrix solution of the matrix",
+                     "                      returned by a*b",
+                     "",
+                     "LU factorization with direct matrix creation:",
+                     "  solve: (mx: \"4,4\") ~ (mx: \"4,1\")",
+                     "",
+                     "L and U matrices are saved as variables with their default names (L,U)"
+                   ]
+  def self.lu
+    self.write(LU_FACT,LU_FACT_EG)
+  end
+  DATA_WRITING   = [
+                     "  <value> > \"<file_path>\"",
+                     "",
+                     "  <expression> > \"<file_path>\"",
+                     "",
+                     "  <variable_name> > \"<file_path>\""
+                   ]
+  DATA_WRITING_E = [
+                     "  23 > \"home/usr/Desktop/val.txt\" // the number 23 will be written",
+                     "                                    in val.txt. If the file does not exist,",
+                     "                                    it will be created",
+                     "  s*q0+1 > \"home/usr/Desktop/val.txt\"  // the result of 's*q0+1' will be",
+                     "                                         written in val.txt (s,q0 are variables)",
+                     "  # mk // 8x8 matrix",
+                     "mk > \"home/usr/Desktop/matrx.csv\"  // Matrix 'mk' will be written in matrix.csv"
+                   ]
+  def self.data_writing
+    self.write(DATA_WRITING ,DATA_WRITING_E)
+  end                 
+  SYMBOLS = [
+              "Symbols used in this help menu:",
+              "  <text> : kind of argument to replace",
+              "  #=>    : output of the program",
+              "  //     : comments",
+              "  #      : specifications",
+              "  <>     : different"
+            ]
+  def self.symbols
+    puts SYMBOLS
+  end
+end
+
+
+
+

data/bin/linguide

@@ -0,0 +1,23 @@
+#! /usr/bin/env ruby
+
+path = File.expand_path(__FILE__)
+dir  = File.dirname(path)
+
+case ARGV[0]
+  when "en"
+    exec( "cd
+           cd #{dir}
+           cd ..
+           cd doc
+           gedit Instructions_en.txt")
+  when "it"
+    exec( "cd
+           cd #{dir}
+           cd ..
+           cd doc
+           gedit Instructions_it.txt")   
+  when "-h"
+    puts "supported languages:\n * en      type: linguide en\n * it      type: linguide it"
+  else
+    exit 0  
+end