ragni-cas 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 865e68bc49826e2cf3c598fcb830c38929cb226d
+  data.tar.gz: e2685fded45fa443f467f3a40033c25595a006d7
+SHA512:
+  metadata.gz: 0c1084b05b544cf06f8ff9248cd74a3a9774054ff3b96901370bfbf3336763eabf218c0346b539acd1128d7aabf56de9f8355743e4aa4c8263f381903d46b207
+  data.tar.gz: 97b1c18b185911086f604db022e5f2943a75e667f9a3320463bd747b6ffeaa71afa63b8b9da622e04e609448b3409f58aedf369a15c4bcb1d03b20a5053cc1b0

data/lib/fnc-base.rb

@@ -0,0 +1,333 @@
+#!/usr/vin/env ruby
+
+module CAS
+  #  ___
+  # / __|_  _ _ __
+  # \__ \ || | '  \
+  # |___/\_,_|_|_|_|
+  class Sum < CAS::BinaryOp
+    def diff(v)
+      left, right = super v
+      return left if (right == nil or right == CAS::Zero)
+      return right if (left == nil or left == CAS::Zero)
+      left + right
+    end
+
+    def call(f)
+      return @x.call(f) + @y.call(f)
+    end
+
+    def to_s
+      "(#{@x} + #{@y})"
+    end
+
+    def simplify
+      super
+      if @x == CAS::Zero
+        return @y
+      end
+      if @y == CAS::Zero
+        return @x
+      end
+      if @x == @y
+        return @x * 2.0
+      end
+      if @x.is_a? CAS::Constant and @y.is_a? CAS::Constant
+        return CAS.const(self.call({}))
+      end
+      return self
+    end
+  end # Sum
+
+  #  ___  _  __  __
+  # |   \(_)/ _|/ _|
+  # | |) | |  _|  _/
+  # |___/|_|_| |_|
+  class Diff < CAS::BinaryOp
+    def diff(v)
+      left, right = super v
+      return left if (right == nil or right == CAS::Zero)
+      return CAS::Invert.new(right) if (left == nil or left == CAS::Zero)
+      left - right
+    end
+
+    def call(f)
+      return @x.call(f) - @y.call(f)
+    end
+
+    def to_s
+      "(#{@x} - #{@y})"
+    end
+
+    def simplify
+      super
+      if @x == CAS::Zero
+        return CAS.invert(@y)
+      end
+      if @y == CAS::Zero
+        return @x
+      end
+      if @x == @y
+        return CAS::Zero
+      end
+      if @x.is_a? CAS::Constant and @y.is_a? CAS::Constant
+        return CAS.const(self.call({}))
+      end
+      return self
+    end
+  end # Difference
+
+  #  ___             _
+  # | _ \_ _ ___  __| |
+  # |  _/ '_/ _ \/ _` |
+  # |_| |_| \___/\__,_|
+  class Prod < CAS::BinaryOp
+    def diff(v)
+      left, right = super v
+      return left * @y if (right == nil or right == CAS::Zero)
+      return right * @x if (left == nil or left == CAS::Zero)
+      (left * @y) + (right * @x)
+    end
+
+    def call(f)
+      return @x.call(f) * @y.call(f)
+    end
+
+    def to_s
+      "(#{@x} * #{@y})"
+    end
+
+    def simplify
+      super
+      if @x == CAS::Zero or @y == CAS::Zero
+        return CAS::Zero
+      end
+      if @x == CAS::One
+        return @y
+      end
+      if @y == CAS::One
+        return @x
+      end
+      if @x == @y
+        return @x ** 2.0
+      end
+      if @x.is_a? CAS::Constant and @y.is_a? CAS::Constant
+        return CAS.const(self.call({}))
+      end
+      return self
+    end
+  end # Prod
+
+  #  ___
+  # | _ \_____ __ __
+  # |  _/ _ \ V  V /
+  # |_| \___/\_/\_/
+  class Pow < CAS::BinaryOp
+    def diff(v)
+      diff_x, diff_y = super v
+      if diff_y == nil or diff_y == CAS::Zero
+        return ((@x ** (@y - 1.0)) * @y * diff_x)
+      elsif diff_x == nil or diff_x == CAS::Zero
+        return (@x ** @y) * diff_y * CAS.ln(@x)
+      else
+        return (@x ** @y) * ((diff_y * CAS.ln(@x)) + (@y * diff_x / @x))
+      end
+    end
+
+    def call(f)
+      @x.call(f) ** @y.call(f)
+    end
+
+    def to_s
+      "#{@x}^#{@y}"
+    end
+
+    def simplify
+      super
+      if @x == CAS::Zero
+        return CAS::Zero
+      end
+      if @x == CAS::One
+        return CAS::One
+      end
+      if @y == CAS::One
+        return @x
+      end
+      if @y == CAS::Zero
+        return CAS::One
+      end
+      if @x.is_a? CAS::Constant and @y.is_a? CAS::Constant
+        return CAS.const(self.call({}))
+      end
+      return self
+    end
+  end
+
+  def self.pow(x, y)
+    CAS::Pow.new x, y
+  end
+
+  #  ___  _
+  # |   \(_)_ __
+  # | |) | \ V /
+  # |___/|_|\_/
+  class Div < CAS::BinaryOp
+    def diff(v)
+      diff_x, diff_y = super v
+      if diff_y == nil or diff_y == CAS::Zero
+        return (diff_x/@y)
+      elsif diff_x == nil or diff_x == CAS::Zero
+        return CAS.invert(@x * diff_y / CAS.pow(@y, CAS.const(2.0)))
+      else
+        return ((diff_x * @y) - (diff_y * @x))/CAS.pow(@y, CAS.const(2.0))
+      end
+    end
+
+    def call(f)
+      @x.call(f)/@y.call(f)
+    end
+
+    def to_s
+      "(#{@x}) / (#{@y})"
+    end
+
+    def simplify
+      super
+      if @x == CAS::Zero
+        return CAS::Zero
+      end
+      if @y == CAS::Zero
+        return CAS::Infinity
+      end
+      if @y == CAS::One
+        return @x
+      end
+      if @y == CAS::Infinity
+        return CAS::Zero
+      end
+      if @x.is_a? CAS::Constant and @y.is_a? CAS::Constant
+        return CAS.const(self.call({}))
+      end
+      return self
+    end
+  end # Div
+
+  #  ___           _
+  # / __| __ _ _ _| |_
+  # \__ \/ _` | '_|  _|
+  # |___/\__, |_|  \__|
+  #         |_|
+  class Sqrt < CAS::Op
+    def diff(v)
+      if @x.depend? v
+        return (@x.diff(v) / (CAS.const(2.0) * CAS.sqrt(@x)))
+      else
+        return CAS::Zero
+      end
+    end
+
+    def call(f)
+      Math::sqrt @x.call(f)
+    end
+
+    def to_s
+      "√(#{@x})"
+    end
+
+    def simplify
+      super
+      if @x.is_a? CAS::Pow
+        return CAS.pow(@x.x, @y - 0.5)
+      end
+      if @x == CAS::Zero
+        return CAS::Zero
+      end
+      if @x == CAS::One
+        return CAS::One
+      end
+      if @x.is_a? CAS::Constant and @y.is_a? CAS::Constant
+        return CAS.const(self.call({}))
+      end
+      return self
+    end
+  end # Sqrt
+
+  def self.sqrt(x)
+    CAS::Sqrt.new x
+  end
+
+  #  ___                 _
+  # |_ _|_ ___ _____ _ _| |_
+  #  | || ' \ V / -_) '_|  _|
+  # |___|_||_\_/\___|_|  \__|
+  class Invert < CAS::Op
+    def diff(v)
+      if @x.depend? v
+        CAS::const(-1.0) * @x.diff
+      else
+        CAS::Zero
+      end
+    end
+
+    def call(f)
+      -1.0 * @x.call(f)
+    end
+
+    def to_s
+      "-#{@x}"
+    end
+
+    def simplify
+      super
+      if @x == CAS::Zero
+        return CAS::Zero
+      end
+      if @x.is_a? CAS::Invert
+        return @x.x
+      end
+      return self
+    end
+  end
+
+  def self.invert(x)
+    CAS::Invert.new x
+  end
+
+  #    _   _
+  #   /_\ | |__ ___
+  #  / _ \| '_ (_-<
+  # /_/ \_\_.__/__/
+  class Abs < CAS::Op
+    def diff(v)
+      if @x.depend? v
+        return @x.diff * (@x/CAS.abs(@x))
+      else
+        return CAS::Zero
+      end
+    end
+
+    def call(f)
+      s = (@x.call(f) >= 0 ? 1 : -1)
+      return s * @x.call(f)
+    end
+
+    def to_s
+      "|#{@x}|"
+    end
+
+    def simplify
+      super
+      if @x == CAS::Zero
+        return CAS::Zero
+      end
+      if @x.is_a? CAS::Invert
+        return CAS.abs(@x.x)
+      end
+      return self
+    end
+  end
+
+  def self.abs(x)
+    CAS::Abs.new x
+  end
+end

data/lib/fnc-trig.rb

@@ -0,0 +1,246 @@
+#!/usr/bin/env ruby
+
+module CAS
+  #  ___ _
+  # / __(_)_ _
+  # \__ \ | ' \
+  # |___/_|_||_|
+  class Sin < CAS::Op
+    def diff(v)
+      if @x.depend? v
+        return @x.diff(v) * CAS.cos(@x)
+      else
+        return CAS::Zero
+      end
+    end
+
+    def call(f)
+      Math::sin @x.call(f)
+    end
+
+    def to_s
+      "sin(#{@x})"
+    end
+
+    def simplify
+      super
+      if @x == CAS::Zero
+        return CAS::Zero
+      end
+      if @x == CAS::Pi
+        return CAS::Zero
+      end
+      if @x.is_a? CAS::Asin
+        return @x.x
+      end
+      return self
+    end
+  end # Sin
+
+  def self.sin(x)
+    CAS::Sin.new x
+  end
+
+  #    _       _
+  #   /_\   __(_)_ _
+  #  / _ \ (_-< | ' \
+  # /_/ \_\/__/_|_||_|
+  class Asin < CAS::Op
+    def diff(v)
+      if @x.depend? v
+        return @x.diff(v) / CAS.sqrt(CAS::One - CAS.pow(@x, CAS::Two))
+      else
+        return CAS::Zero
+      end
+    end
+
+    def call(f)
+      Math::acos @x.call(f)
+    end
+
+    def to_s
+      "asin(#{@x})"
+    end
+
+    def simplify
+      super
+      if @x == CAS::Zero
+        return CAS::Zero
+      end
+      if @x == CAS::One
+        return CAS::Pi / 2
+      end
+      if @x.is_a? CAS::Sin
+        return @x.x
+      end
+      return self
+    end
+  end
+
+  def self.asin(x)
+    CAS::Asin.new x
+  end
+
+  #   ___
+  #  / __|___ ___
+  # | (__/ _ (_-<
+  #  \___\___/__/
+  class Cos < CAS::Op
+    def diff(v)
+      if @x.depend? v
+        return CAS.invert(@x.diff(v) * CAS.sin(@x))
+      else
+        return CAS::Zero
+      end
+    end
+
+    def call(f)
+      Math::cos self.x.call(f)
+    end
+
+    def to_s
+      "cos(#{self.x})"
+    end
+
+    def simplify
+      super
+      if @x == CAS::Zero
+        return CAS::One
+      end
+      if @x == CAS::Pi
+        return CAS::One
+      end
+      if @x.is_a? CAS::Acos
+        return @x.x
+      end
+      return self
+    end
+  end
+
+  def self.cos(x)
+    CAS::Cos.new x
+  end
+
+  #    _
+  #   /_\  __ ___ ___
+  #  / _ \/ _/ _ (_-<
+  # /_/ \_\__\___/__/
+  class Acos < CAS::Op
+    def diff(v)
+      if @x.depend? v
+        return CAS.invert(@x.diff(v)/CAS.sqrt(CAS::One - CAS.pow(@x, CAS::Two)))
+      else
+        return CAS::Zero
+      end
+    end
+
+    def call(f)
+
+    end
+
+    def to_s
+      "acos(#{self.x})"
+    end
+
+    def simplify
+      super
+      if @x == CAS::Zero
+        return CAS::Pi / 2
+      end
+      if @x == CAS::One
+        return CAS::Zero
+      end
+      if @x.is_a? CAS::Cos
+        return @x.x
+      end
+      return self
+    end
+  end
+
+  def self.acos(x)
+    CAS::Acos.new x
+  end
+
+  #  _____
+  # |_   _|_ _ _ _
+  #   | |/ _` | ' \
+  #   |_|\__,_|_||_|
+  class Tan < CAS::Op
+    def diff(v)
+      if @x.depend? v
+        return @x.diff(v) * CAS.pow(CAS::One/CAS.cos(@x), CAS::Two)
+      else
+        return CAS::Zero
+      end
+    end
+
+    def call(f)
+      Math::tan self.x.call
+    end
+
+    def to_s
+      "tan(#{self.x})"
+    end
+
+    def simplify
+      super
+      if @x == CAS::Zero
+        return CAS::Zero
+      end
+      if @x == CAS::Pi
+        return CAS::Zero
+      end
+      if @x.is_a? CAS::Atan
+        return @x.x
+      end
+      return self
+    end
+  end
+
+  def self.tan(x)
+    CAS::Tan.new x
+  end
+
+  #    _  _
+  #   /_\| |_ __ _ _ _
+  #  / _ \  _/ _` | ' \
+  # /_/ \_\__\__,_|_||_|
+  class Atan < CAS::Op
+    def diff(v)
+      if @x.depend? v
+        return @x.diff(v) / (CAS.pow(@x, CAS::Two) + CAS::One)
+      else
+        return CAS::Zero
+      end
+    end
+
+    def call
+      Math::atan self.x.call
+    end
+
+    def to_s
+      "atan(#{self.x})"
+    end
+
+    def simplify
+      super
+      if @x == CAS::Zero
+        return CAS::Zero
+      end
+      if @x == CAS::One
+        return CAS::Pi / 4
+      end
+      if @x == CAS::Infinity
+        return CAS::Pi / 2
+      end
+      if @x.is_a? CAS::Tan
+        return @x.x
+      end
+      return self
+    end
+  end
+
+  def self.atan(x)
+    CAS::Atan.new x
+  end
+end

data/lib/fnc-trsc.rb

@@ -0,0 +1,96 @@
+#!/usr/bin/env ruby
+
+module CAS
+  #  ___                            _
+  # | __|_ ___ __  ___ _ _  ___ _ _| |_
+  # | _|\ \ / '_ \/ _ \ ' \/ -_) ' \  _|
+  # |___/_\_\ .__/\___/_||_\___|_||_\__|
+  #         |_|
+  class Exp < CAS::Op
+    def diff(v)
+      if @x.depend? v
+        return @x.diff(v) * CAS.exp(@x)
+      else
+        return CAS::Zero
+      end
+    end
+
+    def call(f)
+      Math::exp @x.call(f)
+    end
+
+    def to_s
+      "exp(#{@x})"
+    end
+
+    def simplify
+      super
+      if @x == CAS::Zero
+        return CAS::One
+      end
+      if @x == CAS::One
+        return CAS::E
+      end
+      if @x == CAS::Infinity
+        return CAS::Infinity
+      end
+      if @x.is_a? CAS::Ln
+        return @x.x
+      end
+      return self
+    end
+  end # Exp
+
+  def self.exp(x)
+    CAS::Exp.new x
+  end
+
+  #  _                       _ _   _
+  # | |   ___  __ _ __ _ _ _(_) |_| |_  _ __
+  # | |__/ _ \/ _` / _` | '_| |  _| ' \| '  \
+  # |____\___/\__, \__,_|_| |_|\__|_||_|_|_|_|
+  #           |___/
+  class Ln < CAS::Op
+    def diff(v)
+      if @x.depend? v
+        return CAS::One / @x
+      else
+        return CAS::Zero
+      end
+    end
+
+    def call(f)
+      # I'm leaving to Math the honor
+      # of handling negative values...
+      Math::log @x.call(f)
+    end
+
+    def to_s
+      "log(#{@x})"
+    end
+
+    def simplify
+      super
+      if @x == CAS::Zero
+        return CAS.invert(CAS::Infinity)
+      end
+      if @x == CAS::One
+        return CAS::Zero
+      end
+      if @x == CAS::E
+        return CAS::One
+      end
+      if @x.is_a? CAS::Exp
+        return @x.x
+      end
+      return self
+    end
+  end # Ln
+
+  def self.ln(x)
+    CAS::Ln.new x
+  end
+  def self.log(x)
+    CAS::Ln.new x
+  end
+end

data/lib/numbers.rb

@@ -0,0 +1,177 @@
+#!/usr/bin/env ruby
+
+module CAS
+  #   ___             _            _
+  #  / __|___ _ _  __| |_ __ _ _ _| |_
+  # | (__/ _ \ ' \(_-<  _/ _` | ' \  _|
+  #  \___\___/_||_/__/\__\__,_|_||_\__|
+  class Constant < CAS::Op
+    def initialize(x)
+      @x = x
+    end
+
+    def diff(v); CAS::Zero; end
+    def call(f = {}); @x; end
+    def depend?(v); false; end
+    def to_s; "#{@x}"; end
+    def simplify
+      case x
+      when 0
+        return CAS::Zero
+      when 1
+        return CAS::One
+      when Math::PI
+        return CAS::Pi
+      when Math::E
+        return CAS::E
+      when 1.0/0.0
+        return CAS::Infinity
+      else
+        return self
+      end
+    end
+  end
+  def self.const(f)
+    CAS::Constant.new f
+  end
+
+  # __   __        _      _    _
+  # \ \ / /_ _ _ _(_)__ _| |__| |___
+  #  \ V / _` | '_| / _` | '_ \ / -_)
+  #   \_/\__,_|_| |_\__,_|_.__/_\___|
+  class Variable < CAS::Op
+    def initialize(name = "x")
+      self.is(name)
+    end
+
+    def is(name)
+      @name = name
+    end
+
+    def diff(v)
+      CAS::One
+    end
+
+    def depend?(v)
+      self == v
+    end
+
+    def call(f)
+      f[self]
+    end
+
+    def to_s
+      "#{@name}"
+    end
+
+    def simplify
+      return self
+    end
+  end # Number
+
+  #  _______ ___  ___
+  # |_  / __| _ \/ _ \
+  #  / /| _||   / (_) |
+  # /___|___|_|_\\___/
+  class ZERO_CONSTANT < CAS::Constant
+    def initialize
+      @x = 0.0
+    end
+
+    def to_s
+      "0"
+    end
+  end # Zero
+  Zero = CAS::ZERO_CONSTANT.new
+
+  #   ___
+  #  / _ \ _ _  ___
+  # | (_) | ' \/ -_)
+  #  \___/|_||_\___|
+  class ONE_CONSTANT < CAS::Constant
+    def initialize
+      @x = 1.0
+    end
+
+    def to_s
+      "1"
+    end
+  end # Zero
+  One = CAS::ONE_CONSTANT.new
+
+  #  _____
+  # |_   _|_ __ _____
+  #   | | \ V  V / _ \
+  #   |_|  \_/\_/\___/
+  class TWO_CONSTANT < CAS::Constant
+    def initialize
+      @x = 2.0
+    end
+
+    def to_s
+      "2"
+    end
+  end # Zero
+  Two = CAS::TWO_CONSTANT.new
+
+  #  ___ ___
+  # | _ \_ _|
+  # |  _/| |
+  # |_| |___|
+  class PI_CONSTANT < CAS::Constant
+    def initialize
+      @x = Math::PI
+    end
+
+    def to_s
+      "π"
+    end
+  end
+  Pi = CAS::PI_CONSTANT.new
+
+  #  ___
+  # | __|
+  # | _|
+  # |___|
+  class E_CONSTANT < CAS::Constant
+    def initialize
+      @x = Math::E
+    end
+
+    def to_s
+      "e"
+    end
+  end
+  E = CAS::E_CONSTANT.new
+
+  #  ___       __ _      _ _
+  # |_ _|_ _  / _(_)_ _ (_) |_ _  _
+  #  | || ' \|  _| | ' \| |  _| || |
+  # |___|_||_|_| |_|_||_|_|\__|\_, |
+  #                            |__/
+  class INFINITY_CONSTANT < CAS::Constant
+    def initialize
+      @x = (1.0/0.0)
+    end
+
+    def to_s
+      "∞"
+    end
+  end
+  Infinity = CAS::INFINITY_CONSTANT.new
+
+  #      _
+  #  ___/ |
+  # |___| |
+  #     |_|
+  class MINUS_ONE_CONSTANT < CAS::Constant
+    def initialize
+      @x = -1.0
+    end
+
+    def to_s
+      "-1"
+    end
+  end
+  MinusOne = CAS::MINUS_ONE_CONSTANT.new
+end

data/lib/op.rb

@@ -0,0 +1,143 @@
+#!/usr/bin/env ruby
+
+module CAS
+  class CASError < RuntimeError; end
+
+  #   ___
+  #  / _ \ _ __
+  # | (_) | '_ \
+  #  \___/| .__/
+  #       |_|
+  class Op
+    attr_reader :x
+
+    def initialize(x)
+      if x.is_a? Numeric
+        case x
+        when 0
+          x = CAS::Zero
+        when 1
+          x = CAS::One
+        else
+          x = CAS.const x
+        end
+      end
+      @x = x
+    end
+
+    def depend?(v)
+      @x.depend? v
+    end
+
+    def diff(v)
+      if @x.depend? v
+        return @x.diff(v)
+      end
+      CAS::Zero
+    end
+
+    def call(f)
+      @x.call(f)
+    end
+
+    def to_s
+      "#{@x}"
+    end
+
+    def +(op)
+      CAS::Sum.new self, op
+    end
+
+    def -(op)
+      CAS::Diff.new self, op
+    end
+
+    def *(op)
+      CAS::Prod.new self, op
+    end
+
+    def /(op)
+      CAS::Div.new self, op
+    end
+
+    def **(op)
+      CAS.pow(self, op)
+    end
+
+    def simplify # TODO: improve this
+      hash = @x.to_s
+      @x = @x.simplify
+      while @x.to_s != hash
+        hash = @x.to_s
+        @x = @x.simplify
+      end
+    end
+  end # Op
+
+  #  ___ _                     ___
+  # | _ |_)_ _  __ _ _ _ _  _ / _ \ _ __
+  # | _ \ | ' \/ _` | '_| || | (_) | '_ \
+  # |___/_|_||_\__,_|_|  \_, |\___/| .__/
+  #                      |__/      |_|
+  class BinaryOp < CAS::Op
+    attr_reader :x, :y
+
+    def initialize(x, y)
+      if x.is_a? Numeric
+        case x
+        when 0
+          x = CAS::Zero
+        when 1
+          x = CAS::One
+        else
+          x = CAS.const x
+        end
+      end
+      if y.is_a? Numeric
+        case y
+        when 0
+          y = CAS::Zero
+        when 1
+          y = CAS::One
+        else
+          y = CAS.const y
+        end
+      end
+      @x = x
+      @y = y
+    end
+
+    def depend?(v)
+      @x.depend? v or @y.depend? v
+    end
+
+    def diff(v)
+      left = @x.diff(v) if @x.depend? v
+      right = @y.diff(v) if @y.depend? v
+      return left, right
+    end
+
+    def call
+      raise CASError, "Not Implemented. This is a virtual method"
+    end
+
+    def to_s
+      raise CASError, "Not Implemented. This is a virtual method"
+    end
+
+    def simplify # TODO: improve this
+      hash = @x.to_s
+      @x = @x.simplify
+      while @x.to_s != hash
+        hash = @x.to_s
+        @x = @x.simplify
+      end
+      hash = @y.to_s
+      @y = @y.simplify
+      while @y.to_s != hash
+        hash = @y.to_s
+        @y = @y.simplify
+      end
+    end
+  end # BinaryOp
+end

data/lib/ragni-cas.rb

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require_relative 'op.rb'
+require_relative 'numbers.rb'
+require_relative 'fnc-base.rb'
+require_relative 'fnc-trig.rb'
+require_relative 'fnc-trsc.rb'

data.tar.gz.sig

@@ -0,0 +1,2 @@
+���n�T�3�DR��Z�.�����Mz�ȅm"nU��-���~M�M\[�}��&���S�Xh!��(�>\d�0��5�/U�k�����^y�3�U���iи��7pF��;.:�ȟ�6��
+0E��f�A61þ�׀u6)*��y�;3D��yKL+ޞ[��R%<
N�7Dƅ�s��Ș��W�M�,hAR鉗a�4V(�6K�[�[��Qb�ؔo@�u�rZ@�v~J�Z�[�`�(���zmͬ6&(d

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: ragni-cas
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Matteo Ragni
+autorequire: 
+bindir: bin
+cert_chain:
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIDXDCCAkSgAwIBAgIBATANBgkqhkiG9w0BAQUFADA6MQ0wCwYDVQQDDARpbmZv
+  MRUwEwYKCZImiZPyLGQBGRYFcmFnbmkxEjAQBgoJkiaJk/IsZAEZFgJtZTAeFw0x
+  NjA3MTkwOTM5NDlaFw0xNzA3MTkwOTM5NDlaMDoxDTALBgNVBAMMBGluZm8xFTAT
+  BgoJkiaJk/IsZAEZFgVyYWduaTESMBAGCgmSJomT8ixkARkWAm1lMIIBIjANBgkq
+  hkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA5pUTV/VZWpaYCwB2rr98GHoqv7UfD4Fo
+  3pFi+Ds21h0laaniQ0LrJSj0JVQmYQwcqJ0AZKDuunQvMo23PZyIJAqKXktaGaYX
+  4y0KT0wIiZqlQLlwgRgkdMkVpKOSQGXrfNdXrULnHVTBLpE5f/S6ZQbsgWZudy1x
+  vDjgp3KTeLymcCBuIcypPziSFL/M9kUXYz13hxJsPjkEJ/BGmkXE03dG9o9VF202
+  gvQ5P5PWfLoSraVySngdVeT961eLvyBSBXAxVwdyRdI7Xm/TndjJNWh87q0Jhy8Q
+  WIV5gL/uNj8MXJX+g9h95TUbygg+FkI/dQHyIlAQ2xkVEH5NJ6Y/CQIDAQABo20w
+  azAJBgNVHRMEAjAAMAsGA1UdDwQEAwIEsDAdBgNVHQ4EFgQUHVooQSoXXUXlIT4/
+  9PIoqmGwd/IwGAYDVR0RBBEwD4ENaW5mb0ByYWduaS5tZTAYBgNVHRIEETAPgQ1p
+  bmZvQHJhZ25pLm1lMA0GCSqGSIb3DQEBBQUAA4IBAQBcPsPbIm7Oo3qQ3X9niTxZ
+  pv6eocyknwGZXZCH9LLgEXRSWXKHKr/MODo+zCUzi7cNV0hDf5v9+VATMNILH1L8
+  OXWyvnb80Shs9mCgSVbkgb0QImllwIdLiPJF9ywFs3WJDbUVXPRfGWS8BfSxUbvV
+  +fanYc7ZC6ffsjv7+2rEgWhPlZKnWG7cqCxv5gVVldCOSvbot6ai9x6hFHlG7rud
+  XorZtzkkLImvKFj35xKLFfVkv0Vd8tGQoiL8vdmQNJjAjtE+C+Y7OI4dpiZPKO4G
+  R/8JOvUuk9jPbyLxjQH/sFaFqqYGX2xo1zk2CRy/A0WhJrSaXVw1r5lEi7b0W5gg
+  -----END CERTIFICATE-----
+date: 2016-07-19 00:00:00.000000000 Z
+dependencies: []
+description: 
+email: info@ragni.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/fnc-base.rb
+- lib/fnc-trig.rb
+- lib/fnc-trsc.rb
+- lib/numbers.rb
+- lib/op.rb
+- lib/ragni-cas.rb
+homepage: https://github.com/MatteoRagni/cas-rb
+licenses:
+- MIT
+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.5.1
+signing_key: 
+specification_version: 4
+summary: An extremely simple CAS system for my optimizers
+test_files: []