Class: CAS::Variable

Inherits:
Op
  • Object
show all
Defined in:
lib/numbers/variables.rb,
lib/Mr.CAS/graphviz.rb

Overview

Container for a variable. It can be resolved in a numerical value. It can also be used for derivatives.

Constant Summary collapse

@@container =

Contains all define variable, in an hash. Variables are accessible through variable name.

{}

Instance Attribute Summary collapse

Attributes inherited from Op

#x

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from Op

#!=, #*, #**, #+, #-, #[email protected], #/, #as_proc, #dot_graph, #equal, #greater, #greater_equal, init_simplify_dict, #limit, numeric_to_const, simplify_dict, #simplify_dictionary, #smaller, #smaller_equal, #to_c_lib

Constructor Details

#initialize(name) ⇒ Variable

Variable is a container for an atomic simbol that becomes a number when `CAS::Op#call` method is used.

* **argument**: `Object` that is a identifier for the variable
* **returns**: `CAS::Variable` instance

Raises:


79
80
81
82
83
84
# File 'lib/numbers/variables.rb', line 79

def initialize(name)
  CAS::Help.assert_name name
  raise CASError, "Variable #{name} already exists" if CAS::Variable.exist? name
  @name = name
  @@container[@name] = self
end

Instance Attribute Details

#nameObject (readonly)

The attribute `name` identifies the current variable. A variable with the same name of an existing variable connot be defined


72
73
74
# File 'lib/numbers/variables.rb', line 72

def name
  @name
end

Class Method Details

.[](s) ⇒ Object

Returns a variable given its name

* **argument**: `Object` name of the variable
* **returns**: `CAS::Variable` instance if exists, creates a new variable if does not

58
59
60
# File 'lib/numbers/variables.rb', line 58

def self.[](s)
  @@container[s] || CAS::vars(s)
end

.exist?(name) ⇒ Boolean

Returns `true` if a variable already exists

* **argument**: `Object` that represent the variable
* **returns**: `TrueClass` if variable exists, `FalseClass` if not

Returns:

  • (Boolean)

66
67
68
# File 'lib/numbers/variables.rb', line 66

def self.exist?(name)
  @@container.keys.include? name
end

.listObject

Returns the `Hash` that contains all the variable

* **returns**: `Hash`

43
44
45
# File 'lib/numbers/variables.rb', line 43

def self.list
  @@container
end

.new(name) ⇒ Object

Overrides new method. This will return an existing variable if in variable container

  • *requires*: `Object` that is an identifier for the variable

  • *returns*: new variable instance o


90
91
92
# File 'lib/numbers/variables.rb', line 90

def Variable.new(name)
  @@container[name] || super
end

.sizeObject

Return the number of variable defined

* **returns**: `Fixnum`

50
51
52
# File 'lib/numbers/variables.rb', line 50

def self.size
  @@container.keys.size
end

Instance Method Details

#==(op) ⇒ Object

Equality operator, the standard operator is overloaded :warning: this operates on the graph, not on the math See `CAS::equal`, etc.

* **argument**: `CAS::Op` to be tested against
* **returns**: `TrueClass` if equal, `FalseClass` if differs

123
124
125
126
127
128
129
130
# File 'lib/numbers/variables.rb', line 123

def ==(op)
  # CAS::Help.assert(op, CAS::Op)
  if op.is_a? CAS::Variable
    return self.inspect == op.inspect
  else
    false
  end
end

#argsObject

Returns an array containing `self`

* **returns**: `Array` containing `self`

170
171
172
# File 'lib/numbers/variables.rb', line 170

def args
  [self]
end

#call(f) ⇒ Object

Call resolves the operation tree in a `Numeric` (if `Fixnum`) or `Float` (depends upon promotions). As input, it requires an hash with `CAS::Variable` or `CAS::Variable#name` as keys, and a `Numeric` as a value

“` ruby x, y = CAS::vars :x, :y f = (x ** 2) + (y ** 2) f.call(=> 1, y => 2) # => 2 “`

* **argument**: `Hash` with feed dictionary
* **returns**: `Numeric`

146
147
148
149
150
151
# File 'lib/numbers/variables.rb', line 146

def call(f)
  CAS::Help.assert(f, Hash)

  return f[self] if f[self]
  return f[@name] if f[@name]
end

#depend?(v) ⇒ Boolean

Returns `TrueClass` if argument of the function is equal to `self`

* **argument**: `CAS::Op`
* **returns**: `TrueClass` or `FalseClass`

Returns:

  • (Boolean)

113
114
115
# File 'lib/numbers/variables.rb', line 113

def depend?(v)
  self == v
end

#diff(v) ⇒ Object

Returns the derivative of a variable

“`

dx      dx
-- = 1; -- = 0
dx      dy

“`

* **argument**: `CAS::Op` for the derivative denominator
* **returns**: `CAS::Constant`, 0 if not depended, 1 if dependent

104
105
106
# File 'lib/numbers/variables.rb', line 104

def diff(v)
  (self == v ? CAS::One : CAS::Zero)
end

#inspectObject

Inspector for the current object

* **returns**: `String`

196
197
198
# File 'lib/numbers/variables.rb', line 196

def inspect
  "Var(#{@name})"
end

#simplifyObject

Simplification callback. The only possible simplification is returning `self`

* **returns**: `CAS::Variable` as `self`

204
205
206
# File 'lib/numbers/variables.rb', line 204

def simplify
  self
end

#subs(dt) ⇒ Object

Terminal substitutions for variables. If input datatable contains the variable will perform the substitution with the value.

* **argument**: `Hash` of substitutions
* **returns**: `CAS::Op` of substitutions

180
181
182
183
184
185
186
187
188
189
190
191
# File 'lib/numbers/variables.rb', line 180

def subs(dt)
  CAS::Help.assert(dt, Hash)
  if dt.keys.include? self
    if dt[self].is_a? CAS::Op
      return dt[self]
    elsif dt[self].is_a? Numeric
      return CAS::const(dt[self])
    else
      raise CASError, "Impossible subs. Received a #{dt[self].class} = #{dt[self]}"
    end
  end
end

#to_codeObject

Convert expression to code (internal, for `CAS::Op#to_proc` method)

* **returns**: `String` that represent Ruby code to be parsed in `CAS::Op#to_proc`

163
164
165
# File 'lib/numbers/variables.rb', line 163

def to_code
  "#{@name}"
end

#to_dotObject

Return the local Graphviz node of the tree

* **returns**: `String` of local Graphiz node

76
77
78
# File 'lib/Mr.CAS/graphviz.rb', line 76

def to_dot
  "#{@name}"
end

#to_sObject

Convert expression to string

* **returns**: `String` to print on screen

156
157
158
# File 'lib/numbers/variables.rb', line 156

def to_s
  "#{@name}"
end