epimath100 1.6.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: dfc33b95a013088913670b6a6dad2b4bdec2d199
+  data.tar.gz: edb093c443f19cb614ae2c754cffa59d047af727
+SHA512:
+  metadata.gz: 5613ff9bee2e2234790239a4b4db1c017124ac54933c6601c67720056e8b563d6e7caf60fbda5dfb3df0351988c4993186d643538a98f29ceb9e663e8e9a62d7
+  data.tar.gz: f997b826a3534bdfe8d303c0cc9fd281168e4ac0431b06d9ffbf4f2321de265b46f63192ed6acf886c9e6bf23ae45ecba77e1010029a611a56d4dc599e67e94d

data/lib/epimath100/error.class.rb

@@ -0,0 +1,100 @@
+#encoding: utf-8
+
+=begin
+ Error is a class to display and manage your simple errors
+=end
+
+
+class Error
+  ERR_HIGH = "Fatal Error"
+  ERR_MEDIUM = "Error"
+  ERR_LOW = "Warning"
+  ERR_COLOR_RED = "0;31"
+  ERR_COLOR_GREEN = "0;32"
+  ERR_COLOR_YELLOW = "1;33"
+  ERR_COLOR_BLUE = "0;34"
+  ERR_COLOR_ORANGE = "0;33"
+  @@errors = 0
+  
+  # The function will check if the specified value can be converted to a Numerical value.
+  # == Parameters:
+  # type:: 
+  # ...
+  # == Returns: 
+  # True/False
+  def self.isnum? string
+    if string.is_a?String and string != nil
+      if string.to_i.to_s == string or string.to_f.to_s == string
+        return true
+      elsif string.to_i.to_s == string[1..-1] or string.to_f.to_s == string[1..-1]
+        true
+      else
+        return false
+      end
+    elsif string.is_a?Numeric
+      true
+    else
+      Error.call "'#{string}' is not a String"
+      return false
+    end
+  end
+  
+  # "call" is a function you can acces with:
+  #     Error.call "message", ERR_LEVEL
+  # == The error's levels are :
+  # * ERR_HIGH
+  # * ERR_MEDIUM
+  # * ERR_LOW
+  # The error's level influence the color (visibility) and defined if the programm must exit.
+  # An ERR_HIGH is only to call exit and stop the programm. So be carrefull.
+  # ERR_MEDIUM and ERR_LOW will just display the message and no more.
+  # ERR_HIGH is the default value, you can change it if yo want
+  # def self.call m, level=ERR_MEDIUM
+  #
+  # == Parameters:
+  # m::
+  #   A String that will be display. You don't need to specify the prefix ("Error :") or the final "."
+  # level::
+  #   A optional parameter, wich influence the degree of the error. Default is ERR_HIGH, will kill your programm
+  #   So, be carrefull. You can change this value. It may be ERR_HIGH (Default), ERR_MEDIUM, ERR_LOW
+  #
+  # == Returns:
+  #   nil
+  def self.call m, level=Error::ERR_HIGH
+    
+    if level != Error::ERR_HIGH and level != Error::ERR_MEDIUM and level != Error::ERR_LOW
+      self.call "Error::call : error level invalid", Error::ERR_MEDIUM
+    end
+    
+    #message color
+    if level == Error::ERR_HIGH
+      color = Error::ERR_COLOR_RED
+    elsif level == Error::ERR_MEDIUM
+      color = Error::ERR_COLOR_ORANGE
+    elsif level == Error::ERR_LOW
+      color = Error::ERR_COLOR_YELLOW
+    end
+    
+    #message display
+    if level == Error::ERR_HIGH
+      puts "\033[#{color}m#{level} : #{m}.\033[00m"
+      exit
+    elsif level == Error::ERR_MEDIUM
+      puts "\033[#{color}m#{level} : #{m}.\033[00m"
+    elsif level == Error::ERR_LOW
+      puts "\033[#{color}m#{level} : #{m}.\033[00m"
+    end
+    
+    @@errors += 1
+    return self
+  end
+  
+  # == Parameters:
+  # nothing::
+  #
+  # == Returns:
+  # Integer which contains the numbr of errors called
+  def self.errors
+    @@errors
+  end
+end

data/lib/epimath100/line.class.rb

@@ -0,0 +1,105 @@
+#encoding: utf-8
+
+require_relative 'error.class.rb'
+require_relative 'point.class.rb'
+require_relative 'vector.class.rb'
+
+class Line
+  attr_reader :point, :v_dir, :equ_para
+
+  # == Parameters:
+  # point::
+  #     Any point on the line. It must be a Point (../point/point.class.rb)
+  # vector::
+  #     Any vector director of the line. It must be a Vector (../vector/vector.class.rb)
+  def initialize point, vector
+    Error.call "Line::new : '#{point}' is not a Point" if !point.is_a?Point
+    Error.call "Line::new : '#{vector}' is not a Vector" if !vector.is_a?Vector
+    Error.call "Line::new : '#{vector}' can't be Null" if vector.nil?
+
+    @point = point
+    @v_dir = vector
+    @equ_para = Line::parametric @point, @v_dir
+  end
+
+  # TODO : fix if if if if if
+  # Check if the point specified is ON the line
+  # == Parameter:
+  # p::
+  #     p is a Point
+  # == Returns:
+  # true/false
+  def point_owned? p
+    Error.call "Line::point_owned? : #{p} is not a valid Point" if !p.is_a?Point
+
+    l = parametric()
+
+    ux = (p.x - l[:x][:p]) / l[:x][:v]
+    uy = (p.y - l[:y][:p]) / l[:y][:v]
+    uz = (p.z - l[:z][:p]) / l[:z][:v]
+
+    if l[:x][:v] == 0 and p.x == l[:x][:p]
+      ux = uy
+    end
+
+    if l[:y][:v] == 0 and p.y == l[:y][:p]
+      uy = uz
+    end
+
+    if l[:z][:v] == 0 and p.z == l[:z][:p]
+      uz = ux
+    end
+
+    if ux == uy and ux == uz
+      true
+    else
+      false
+    end
+  end
+
+  # == Returns::
+  #     same than self.parametric but with the current object
+  def parametric
+    return Line::parametric @point, @v_dir
+  end
+
+  # == Parameters:
+  # point::
+  #     point is a Point on the line
+  # v_dir::
+  #     a vector director of the line
+  # == Returns:
+  # Hash
+  def self.parametric point, v_dir
+    Error.call "Line::parametric : Invalid vector" if !v_dir.is_a?Vector
+    Error.call "Line::parametric : Invalid point" if !point.is_a?Point
+
+    þ = 1
+    { :x => { :p => point.x, :v => þ * v_dir.x},
+      :y => { :p => point.y, :v => þ * v_dir.y},
+      :z => { :p => point.z, :v => þ * v_dir.z}}
+  end
+
+  def to_s(options={})
+    if options == {}
+      "droite passant par le point (#{@point.x};#{@point.y};#{@point.z}), de vecteur directeur #{@v_dir.to_s}"
+    else
+      Error.call "Line::to_s : options is not valid"
+    end
+  end
+
+  # This function returns the point on the line where x = v * vx + px, ...
+  # == Parameters:
+  # v::
+  #     The value defined the point wich will be return.
+  # == Returns:
+  # The choosed Point one the line from v (lambda)
+  def function v
+    Error.call "Line::function : unable to execute function : the vector v_dir is null" if self.nil?
+    Error.call "Line::functionx : invalid lambda ( #{v} ) value" if !v.is_a?Numeric
+
+    lp = parametric()
+    Point.new(lp[:x][:p] + v * lp[:x][:v], lp[:y][:p] + v * lp[:y][:v], lp[:z][:p] + v * lp[:z][:v])
+  end
+
+end

data/lib/epimath100/matrix.class.rb

@@ -0,0 +1,307 @@
+#encoding: utf-8
+
+require_relative 'error.class'
+require_relative 'vector.class'
+
+# TODO : improve the documentation
+class Matrix
+  attr_reader :columns, :lines, :v
+
+  # Convert each element of an Array in an Integer => must be implented in Array Class
+  def self.to_inttab arg, num=Float
+    Error.call "Matrix::to_inttab : '#{arg}' is not a valid Array", Error::ERR_HIGH if !arg.is_a?Array
+
+    arg.size.times do |i|
+      # if it's an Array in an Array, the
+      if arg[i].is_a?Array
+        arg[i] = self.to_inttab argv[i]
+
+      else
+        if num == Integer
+          arg[i] = arg[i].to_i
+        else
+          arg[i] = arg[i].to_f
+        end
+      end
+
+    end
+  end
+
+  # == Parameters:
+  # tab::
+  #   tab is a double Array like [ [1,2], [3,4], [1,4] ]. This array should be a valid Matrix tab or an other Matrix
+  #
+  # == Returns:
+  #   nothing
+  def initialize tab=[[]]
+    @v = tab #Must call to_inttab
+    @columns = 0
+    @lines = 0
+
+    if tab.is_a?Array and tab.size > 0 and tab[0].is_a?Array
+      @columns = tab[0].size
+
+      # check if the line have the good size
+      tab.size.times do |i|
+        @lines += 1
+        if (tab[i].size != @columns)
+          Error.call "Matrix::new : '#{tab[i]}' is not a valid line"
+        end
+
+      end
+    elsif tab.is_a?Matrix
+      @v = tab.v
+      @columns = tab.columns
+      @lines = tab.lines
+    else
+      Error.call "Matrix::new : '#{tab}' is not a valid matrix"
+    end
+    return
+  end
+
+  def to_s
+    out = ""
+
+    @v.each do |line|
+      out << "["
+
+      # display all elements of this line
+      line.each do |element|
+        out << element.to_f.round(3).to_s << " "
+      end
+
+      out << "\b]\n" # TODO : FIX THAT broggi_t
+    end
+    out
+  end
+
+  def to_ary
+    @v
+  end
+
+  def to_vector
+    return Vector.new self.get_val(0, 0), self.get_val(1, 0)
+  end
+
+  def new_line tab=[]
+    Error.call "Matrix::new_line : Size of the new line (#{tab} => #{tab.size}) is not valid" if !tab.is_a?Array or tab.size != @column
+
+    @lines += 1
+    @v << tab
+  end
+
+  def new_column tab=[]
+    Error.call "Matrix::new_column : Size of the new column (#{tab} => #{tab.size}) is not valid" if !tab.is_a?Array or tab.size != @lines
+
+    @columns += 1
+    if tab.is_a? Array and tab.size == @lines
+      @lines.times do |i|
+        @v[i] << tab[i]
+      end
+    else
+      @lines.times do |i|
+        @v[i] << 0
+      end
+    end
+  end
+
+  def del_line x=-1
+    if x.is_a?Integer and @v[x] != nil
+       @lines -= 1
+       @v.delete_at x
+    else
+       Error.call "Matrix::del_line : Line '#{x}' doesn't exist"
+    end
+  end
+
+  # == Parameters:
+  # x,y::
+  #   Integers. They are the coordonates of the value which will extract from the matrix
+  # == Returns:
+  # a value fo the matrix
+  def get_val x, y
+    if !x.is_a?Integer
+      Error.call "Matrix::get_val : '#{x}' is not a correct line"
+      return nil
+    elsif !y.is_a?Integer
+      Error.call "Matrix::get_val : '#{y}' is not a correct column"
+      return nil
+    elsif x < 0 or y < 0 or x >= @lines or y >= @columns
+      Error.call "Matrix::get_val : The specified positions are invalids (#{x},#{y})"
+      return nil
+    else
+      return @v[x][y]
+    end
+  end
+
+  # == Parameters:
+  # x,y::
+  #   Integers. They are the coordonates of the value which will write in the matrix
+  # == Returns:
+  # a value fo the matrix
+  def set_val val, x, y
+    if !x.is_a?Integer
+      Error.call "Matrix::set_val : '#{x}' is not a correct line"
+      return nil
+    elsif !y.is_a?Integer
+      Error.call "Matrix::set_val : '#{y}' is not a correct column"
+      return nil
+    elsif !val.is_a?Numeric
+      Error.call "Matrix::set_val : '#{val}' is not a correct value"
+      return nil
+    elsif x < 0 or y < 0 or x >= @lines or y >= @columns
+      Error.call "Matrix::set_val : The specified positions are invalids (#{x} >= #{@lines},#{y} >= #{@columns})\n#{self.to_s}"
+      return nil
+    else
+      @v[x][y] = val
+      return @v[x][y]
+    end
+  end
+
+  # == Parameters:
+  # y::
+  #   Integer. It's the n° line which is extracted
+  # == Returns:
+  # Array
+  def get_line x
+    Error.call "Matrix::get_line : Line #{x} doesn't exist" if !x.is_a?Integer or x < 0 or x >= @lines
+
+    return @v[x]
+  end
+
+  # == Parameters:
+  # y::
+  #   Integer. It's the n° column which is extracted
+  # == Returns:
+  # Array
+  def get_column y
+    Error.call "Matrix::get_column : Column #{y} doesn't exist" if !y.is_a?Integer or y < 0 or y >= @columns
+
+    result = []
+    @lines.times do |i|
+      result << @v[i][y]
+    end
+    return result
+  end
+
+  # == Params:
+  # matrix::
+  #   matrix is a Matrix to compare.
+  # == Returns:
+  # True or False.
+  # == Usage::
+  # The function check if the current matrix and matrix:: have the same dimensions (linse and columns)
+  def have_the_same_dimensions matrix
+    if (matrix.is_a?Matrix and matrix.columns == @columns and matrix.lines == @lines)
+      true
+    else
+      false
+    end
+  end
+
+  # == Parameters:
+  # t1,t2::
+  #   Multiply each elements of t1 and t2 2b2 and sum all
+  # == Returns:
+  # Float
+  def self.mult_array(t1, t2)
+    Error.call "Can't multiply this. One of the arguments is not an array.", Error::ERR_HIGH if (!t1.is_a?Array or !t2.is_a?Array)
+    Error.call "Can't multiply this. Arrays do not have the same size.", Error::ERR_HIGH if t1.size != t2.size
+
+    result = 0.0
+    t1.size.times do |i|
+      result = (result + t1[i].to_f * t2[i].to_f).to_f
+    end
+    return result
+  end
+
+  # == Parameters:
+  # matrix::
+  #   This argument is a Matrix or an Integer.
+  #   If it's a Matrix, it will do matrix product.
+  #   Else, if it's a integer, it will multiply each coeficient of the current Matrix.
+  #
+  # == Returns:
+  # Matrix
+  #
+  # == Matrix_Product:
+  # little explanation::
+  #   If matrix is a Matrix, we will multiply 2by2 each coeficient of the column X of the current Matrix and the line X of matrix.
+  #   Then, we do the sum of them and we put it in a new Matrix at the position X. The is just a sum up, view the details on wiki bitch.
+  def *(matrix)
+    #produit matriciel
+    #convert vector -> matrix
+    if matrix.is_a?Vector
+      Error.call "Matrix::* : Transformation implicite de Vector en Matrix", Error::ERR_LOW
+      matrix = matrix.to_matrix
+    end
+
+    if matrix.is_a?Matrix
+      Error.call "Matrix::* : Invalid multiplication at line #{matrix.lines} and column #{@columns}", Error::ERR_HIGH if @columns != matrix.lines
+
+      result = []
+      @lines.times do |i|
+        result << []
+      end
+      #colonne de resultat = colonne de matrix X
+      #ligne de resutlat = ligne de self Y
+      @lines.times do |y|
+        matrix.columns.times do |x|
+          result[y][x] = Matrix.mult_array(get_line(y), matrix.get_column(x))
+        end
+      end
+
+      return Matrix.new result
+    #produit d'un entier et d'une matrix
+    elsif matrix.is_a?Numeric
+      result = @v
+      @lines.times do |x|
+        @columns.times do |y|
+          result[x][y] = result[x][y].to_f * matrix
+        end
+      end
+    return Matrix.new result
+    #message d'erreur
+    else
+      Error.call "Matrix::* : Impossible de calculer cela (#{matrix} n'est pas une matrix)", Error::ERR_HIGH
+    end
+  end
+
+  # == Parameters:
+  # matrix::
+  #   This argument is a Matrix or an Integer. If it's a Matrix, it must have the same dimensions than the current Matrix.
+  #   Else, if it's a integer, it will be added to each coeficients of the current Matrix.
+  #
+  # == Returns:
+  # Matrix
+  def +(matrix)
+    result = @v
+    if have_the_same_dimensions matrix
+      @lines.times do |x|
+        @columns.times do |y|
+          result[x][y] += matrix.v[x][y]
+        end
+      end
+    elsif matrix.is_a?Numeric
+      @lines.times do |x|
+        @columns.times do |y|
+          result[x][y] += matrix
+        end
+      end
+    else
+      Error.call "Matrix::+ : Impossible de calculer cela", Error::ERR_HIGH
+    end
+    Matrix.new result
+  end
+
+  # == Returns::
+  #   Numerical value which is the determinant of the matrix. It only work on 2x2
+  def get_deter
+    Error.call "Matrix::get_deter : This error comes from get_deter which works only with 2x2 matrix" if @columns != 2 or @lines != 2
+
+    det = get_val(0, 0).to_i * get_val(1, 1).to_i
+    det -= get_val(0, 1).to_i * get_val(1, 0).to_i
+    return det
+  end
+
+end

data/lib/epimath100/point.class.rb

@@ -0,0 +1,50 @@
+#encoding: utf-8
+
+require_relative 'error.class.rb'
+
+class Point
+  def initialize x, y, z
+    if !x.is_a?Numeric or !y.is_a?Numeric or !z.is_a?Numeric
+      Error.call "Point::new : a passed argument is not a valid number"
+    end
+    @coord = {:x => x.to_f, :y => y.to_f, :z => z.to_f}
+  end
+
+  def +(p)
+    if p.is_a?Point
+      @coord.x += p.x
+      @coord.y += p.y
+      @coord.z += p.z
+    elsif p.is_a?Numeric
+      @coord.x += p
+      @coord.y += p
+      @coord.z += p
+    else
+      Error.call "Point::+ : passed argument is invalid"
+    end
+  end
+
+  def *(p)
+    Error.call "Point::+ : passed argument is invalid" if !p.is_a?Numeric
+
+    @coord.x *= p
+    @coord.y *= p
+    @coord.z *= p
+  end
+
+  def to_s
+    "(#{self.x}; #{self.y}; #{self.z})"
+  end
+
+  def x
+    @coord[:x]
+  end
+
+  def y
+    @coord[:y]
+  end
+
+  def z
+    @coord[:z]
+  end
+end

data/lib/epimath100/polynomial.class.rb

@@ -0,0 +1,88 @@
+#encoding: utf-8
+
+require_relative 'error.class'
+require_relative 'vector.class'
+
+class Polynomial
+  EXPOSANT = {"0" => "⁰",
+              "1" => "¹",
+              "2" => "²",
+              "3" => "³",
+              "4" => "⁴",
+              "5" => "⁵",
+              "6" => "⁶",
+              "7" => "⁷",
+              "8" => "⁸",
+              "9" => "⁹"}
+
+  attr_accessor :coef
+
+  # Initialize the polynominal function
+  # Its coeficients are 1, 2, 3, 4 ... with '1'x⁰ + '2'x¹ + '3'x² ... = y
+  # Each coeficients has an associated value (exemple : 2 => 1 correspond to 1x²)
+  #
+  # == Notes:
+  # The function is compatible with the first version, where coeficients keys are :a, :b, ...
+  # == Parameters:
+  # hash::
+  #   hash is a hash which have several keys 1, 2,... which correspond to the coeficients
+  # verb:: default is false
+  #   verb is true or false, or a integer. It will display more information if turned on when to_s.
+  #   if it's a integer, it must be in the list :
+  #   - 0 : returns ""
+  #   - 1 : "y = equation"
+  #   - 2 : "f(x) = equation" (like true)
+  def initialize hash={}, verb=false
+    Error.call "Polynomial::new : You hash is invalid" if !hash.is_a?Hash
+
+    hash.select{|k,v| k.to_s.match(/[a-z]/)}.each do |k,v|
+      key = (k.to_s.ord - "a".ord)
+      hash[key] = v if hash[key] == nil
+    end
+
+    @coef = hash.select{|coef,value| coef.is_a?Numeric and coef >= 0 and value.is_a?Numeric}
+    @verbose = verb
+  end
+
+  #calculate the derivated function of the current polynomial
+  # == Returns:
+  # Polynomial (the derivated function)
+  def derive
+    dérivé = Polynomial.new
+
+    @coef.select{|coef,value| coef != 0}.each do |coef,value|
+      dérivé.coef[coef - 1] = value * coef
+    end
+
+    return dérivé
+  end
+
+  def to_s
+    return "" if @verbose == 0
+
+    str = ""
+    str = "#{@coef[0].to_i}" + str #if @coef[:a]
+
+    @coef.select{|coef,value| coef != 0}.each do |coef,value|
+      #sign = "+"
+      #sign = "-" if value < 0
+      str = "#{value}x^#{coef} + " + str if value != 0
+    end
+    str = "f(x) = " + str if @verbose == true or @verbose == 2
+    str = "y = " + str if @verbose == 1
+
+    return str
+  end
+
+  # Calculate the value of f(x) from x
+  def calc x
+    Error.call "Polynomial::calc: x is not a Numeric value" if !x.is_a?Numeric
+
+    y = 0
+    @coef.each do |coef,value|
+      y += value * x**coef
+    end
+
+    return y
+  end
+end

data/lib/epimath100/vector.class.rb

@@ -0,0 +1,374 @@
+#encoding: utf-8
+
+require_relative 'error.class'
+require_relative 'matrix.class'
+
+class Vector
+  attr_accessor :x, :y, :z, :verbose
+  attr_reader :matrix_op
+
+  # == Parameters:
+  # par1::
+  #   The first parameter may be a point coordonate x, or a other Vector.
+  #   If it's a Vector, it will be copied. Else if it is anything else, it will be converted as Float and stored as a abcissa.
+  # par2,par3::
+  #   Theses optionals parameters are used if the first parameter is not a Vector. If it occure, par2 is mandatory (but not par3).
+  #   They will be stored in @y and @z.
+  # verbose::
+  #   verbose turn on/off the messages with translate, rotate, ...
+  #
+  # == Returns:
+  # himself
+  #
+  # == Errors::
+  # If a parameter is invalid, it may be crash the programm with an ERR_HIGH
+  def initialize par1, par2=nil, par3=nil, verbose=true
+    if par1.is_a?Vector #and par2 == nil and par3 == nil
+      @x = par1.x
+      @y = par1.y
+      @z = par1.z
+
+    elsif par1 != nil and par2 != nil
+      if par3 == nil
+        par3 = 1.0
+      end
+
+      if !Error.isnum?par1 or !Error.isnum?par2 or !Error.isnum?par3
+        Error.call "Vector::new : a passed argument is not a valid number"
+      end
+
+      @x = par1.to_f
+      @y = par2.to_f
+      @z = par3.to_f
+    else
+      Error.call "Vector::new : The vector couldn't be initialisze with theses parameters : :par1 => '#{par1}', :par2 => '#{par2}'"
+    end
+
+    @verbose = verbose
+    @matrix_op = init_matrix_op
+    return self
+  end
+
+  # Return to the norm of the currenet vector
+  def norm
+    Math.sqrt(@x**2 + @y**2 + @z**2)
+  end
+
+  # == Returns:
+  # Matrix.new [[1, 0, 0],[0, 1, 0], [0, 0, 1]]
+  def init_matrix_op
+    @matrix_op = Matrix.new [[1, 0, 0],[0, 1, 0], [0, 0, 1]]
+  end
+
+  # == Parameters:
+  # par1::
+  #   It may be a point coordonate x, or a other Vector.
+  #   If it's a Vector, it will be used as a couple of coordonates. Else if it is anything else, it will be converted as Float added to @x
+  #
+  # == Returns:
+  # nothing
+  #
+  # == Errors::
+  # If a parameter is invalid, it may be crash the programm with an ERR_HIGH
+  # If the vectors do not have the same dimensions, it will display a warning
+  def +(par1)
+    out = Vector.new(self)
+
+    if par1 != nil and par1.is_a?Vector #and par2 == nil and par3 == nil
+      out.x += par1.x
+      out.y += par1.y
+
+    elsif par1 != nil
+      par1 = par1.to_f
+      out.x += par1
+      out.y += par1
+
+      if out.z != nil and par1 == nil
+        Error.call "The vector #{Vector.new(par1, par1, par1).to_s} do not have the same dimensions than #{out.to_s}", Error::ERR_HIGH
+      elsif out.z != nil
+        out.z += par1
+      end
+    else
+      Error.call "The vector couldn't be added with this parameters : #{par1}", Error::ERR_HIGH
+    end
+    return out
+  end
+
+  # == Usage:
+  # It is simply like + buf multiply by -1 par1
+  def -(par1)
+    if par1 == nil
+      Error.call "Can't sub nil from vector"
+    end
+    return (self.+(par1 * -1))
+  end
+
+  # == Parameters:
+  # par1:
+  #     This parameter may be a Vector or a number. If it's a Number, it will multiply all coponents of the Vector.
+  #     If it's an other vector, we will multiplie their components 2by2
+  # == Returns:
+  # Vector
+  def *(par1)
+    out = Vector.new(self)
+    if par1.is_a?Numeric
+      out.x *= par1
+      out.y *= par1
+      if out.z != nil
+        out.z *= par1
+      end
+    elsif par1.is_a?Matrix
+        return (self.to_matrix * par1).to_vector
+    elsif par1.is_a?Vector
+      ary1 = [self.x, self.y]
+      if out.z != nil
+        ary1 << out.z
+      end
+
+      ary2 = [par1.x, par1.y]
+      if out.z != nil
+        ary2 << par1.z
+      end
+
+      aryr = Matrix.mult_array(ary1, ary2)
+      out.x = aryr[0]
+      out.y = aryr[1]
+      if aryr[2] != nil
+        out.z = aryr[2]
+      end
+    else
+      Error.call "Unable to add '#{par1} to this vector", Error::ERR_HIGH
+    end
+    return out
+  end
+
+  # == Parameters:
+  # par1, par2::
+  #     They are the components of the vector to translate.
+  # par3::
+  #     Optional component (z)
+  # see +::
+  def translate par1, par2, par3=0.0
+    if !Error.isnum? par1 or !Error.isnum? par2 or !Error.isnum? par3
+      Error.call "A parameter to the translation is not a valid number", Error::ERR_HIGH
+    end
+
+    s = Matrix.new [[1.0, 0.0, par1.to_f], [0.0, 1.0, par2.to_f], [0.0, 0.0, 1.0]]
+    @matrix_op = s
+    cpy = self
+    cpy.z = 1.0
+
+    puts "translation de vecteur #{Vector.new(par1,par2,par3).to_s}" if @verbose
+
+    return (s * cpy.to_matrix).to_vector
+  end
+
+  # == Parameters:
+  # c1,c2,c3::
+  #   c1 and c2 are the coeficiens of the homothetie. c3 is optional
+  def homothétie c1, c2, c3=1.0
+    if c1 == nil or c2 == nil
+      Error.call "Coefficients are invalids"
+    end
+
+    s = Matrix.new [[c1.to_f, 0, 0], [0, c2.to_f, 0], [0, 0, c3.to_f]]
+    @matrix_op = s
+    cpy = self
+    cpy.z = 1.0
+
+    puts "homothétie de rapports #{c1.to_f}, #{c2.to_f}" if @verbose
+
+    return (s * cpy.to_matrix).to_vector
+  end
+
+  # == Parameters:
+  # a::
+  #     The angle in degree
+  #
+  # == Return value:
+  # It returns the vector after the translation.
+  def rotate a
+    if a == nil
+      Error.call "Angle is invalid"
+    end
+
+    rad = Math::PI * a.to_f / 180.0
+    cpy = self # copy to have the same value in z
+    cpy.z = 0.0
+    s = Matrix.new [[ Math.cos(rad), -Math.sin(rad), 0], [Math.sin(rad), Math.cos(rad), 0], [0, 0, 1]]
+    @matrix_op = s
+
+    puts "rotation d'angle #{a.to_f}" if @verbose
+
+    return (s * cpy.to_matrix).to_vector
+  end
+
+  # == Parameters :
+  # angle::
+  #   It is the incline of the line.
+  #
+  # == Return value:
+  # It returns the vector after the translation.
+  def symetric angle
+    Error.call "Variable angle is not a number (#{angle})", Error::ERR_HIGH if !Error.isnum? angle.to_s
+
+    rad = Math::PI * angle.to_f / 180.0
+    s = Matrix.new [[Math.cos(2 * rad), Math.sin(2 * rad), 0], [Math.sin(2 * rad), -Math.cos(2 * rad), 0], [0, 0, 1]]
+    @matrix_op = s
+    cpy = self.to_matrix
+
+    puts "symétrie par rapport à un axe incliné de #{angle.to_f} degrés" if @verbose
+
+    return (s * cpy).to_vector
+  end
+
+  # == Params:
+  # axe::
+  #   it must be "x" or "y" (case doesn't checked)
+  #
+  # == Return:
+  # The vector after the projection
+  def proj_axe axe="x"
+    if !axe.match(/[xy]/i)
+      Error.call "Vector::proj_axe '#{axe} is not a valid axe", Error::ERR_HIGH
+    end
+
+    s = nil
+    if axe.match(/x/i)
+      s = Matrix.new [[1, 0, 0], [0, 0, 0], [0, 0, 1]]
+    else
+      s = Matrix.new [[0, 0, 0], [0, 1, 0], [0, 0, 1]]
+    end
+
+    @matrix_op = s
+    cpy = self.to_matrix
+
+    puts "projection sur un axe #{axe}." if @verbose
+
+    return (s * cpy).to_vector
+  end
+
+  # == Params:
+  # nothing
+  # == Return:
+  # The vector after the translation
+  def symetric_pointo
+    return homothétie(-1, -1)
+  end
+
+  # == Parameters:
+  # dim::
+  #   Option option to choose the desired number of dimension of the vector (if is it in 3d, it will be flattened)
+  # type::
+  #   Optional and not used yet. It specify the format of the string. It may only be String yet.
+  #
+  # == Returns:
+  # String
+  def to_s dim=3, type=String
+    string = ""
+    if type == String
+      if @y == nil or dim == 1
+        string = "(#{@x.to_f.round(3)})"
+      elsif @z == nil or dim == 2
+        string = "(#{@x.to_f.round(3)}; #{@y.to_f.round(3)})"
+      elsif dim == 3
+        string = "(#{@x.to_f.round(3)}; #{@y.to_f.round(3)}; #{@z.to_f.round(3)})"
+      else
+        Error.call "Vector::to_s : Invalid number of dimension specified"
+      end
+
+    else
+      Error.call "Vector::to_s : Invalid type conversion", ERR_HIGH
+    end
+
+    return string
+  end
+
+  # == Parameters:
+  # type::
+  #   Optionnal. It specify the format of the array returned. It may be "h" (1) or "w" (0).
+  #   * If it's "w" or 0, the Array will be [x,y]
+  #   * If it's "h" or 1, the Array returned will be [[x],[y]]
+  #
+  # == Returns:
+  # Array or an Array of Array
+  def to_ary type=0
+    array = []
+    if type == 0 or type == "w" # everytime true... for the moment
+      array << @x << @y
+      if @z != nil
+        array << @z
+      end
+    else
+      array << [@x] << [@y]
+      if @z != nil
+        array << [@z]
+      end
+    end
+    return array
+  end
+
+  # == Parameters::
+  # Nothing
+  #
+  # == Returns:
+  # Matrix
+  def to_matrix
+    return Matrix.new self.to_ary(1)
+  end
+
+  # == Parameters:
+  # type::
+  #   It specify the return. It may be String or Array.
+  #
+  # == Returns:
+  # String, Array, nil (see type::)
+  #
+  # == Errors:
+  # nil return occures only if the parameter types:: is not supported.
+  def to_a type=String
+    if type == String
+      return self.to_s
+    elsif type == Array
+      return self.to_ary
+    elsif type == Matrix
+      return self.to_matrix
+    else
+      return nil
+    end
+  end
+
+  def nil?
+    if @x == 0 and @y == 0 and @z == 0
+      true
+    else
+      false
+    end
+  end
+
+# == Parameters
+# type::
+#   Verify if two vectors are collinear
+# == Return:
+#  True if vector u and v are collinear else false
+  def collinear? v
+    Vector::colineaire? @self, v
+  end
+
+  def self.collinear? u, v
+    Error.call "Vector::col : invalid parameters" if !u.is_a?Vector or !v.is_a?Vector
+    Error.call "Vector::col : vector v1 null", Error::ERR_LOW if u.nil?
+    Error.call "Vector::col : vector v2 null", Error::ERR_LOW if v.nil?
+
+    x = u.y * v.z - u.z * v.y
+    y = u.z * v.x - u.x * v.z
+    z = u.x * v.y - u.y * v.x
+
+    if x == 0 and y == 0 and z == 0
+      true
+    else
+      false
+    end
+  end
+
+end

data/lib/epimath100.rb

@@ -0,0 +1,11 @@
+#encoding: utf-8
+
+require_relative "epimath100/error.class.rb"
+require_relative "epimath100/line.class.rb"
+require_relative "epimath100/matrix.class.rb"
+require_relative "epimath100/point.class.rb"
+require_relative "epimath100/polynomial.class.rb"
+require_relative "epimath100/vector.class.rb"
+
+class EpiMath100
+end

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification
+name: epimath100
+version: !ruby/object:Gem::Version
+  version: 1.6.0
+platform: ruby
+authors:
+- poulet_a
+- broggi_t
+- bauwen_j
+- caudou_j
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-18 00:00:00.000000000 Z
+dependencies: []
+description: A simple hello world gem
+email:
+- poulet_a@epitech.eu
+- broggi_t@epitech.eu
+- bauwen_j@epitech.eu
+- caudou_j@epitech.eu
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/epimath100.rb
+- lib/epimath100/error.class.rb
+- lib/epimath100/line.class.rb
+- lib/epimath100/matrix.class.rb
+- lib/epimath100/point.class.rb
+- lib/epimath100/polynomial.class.rb
+- lib/epimath100/vector.class.rb
+homepage: https://github.com/Sophen/epimath100
+licenses:
+- GNU/GPLv3
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: EpiMath100, a ruby gem lib to use lines, functions, points, ...
+test_files: []