Class: Yeah::Vector

Inherits:
Object
  • Object
show all
Extended by:
Forwardable
Defined in:
lib/yeah/vector.rb

Overview

The Vector represents a mathematical vector. It can be used to describe a position, velocity or direction.

V is an alias for Vector.

Examples:

Basic vector math

V[5, 5] + V[10, 20]
# => Yeah::Vector[15, 25, 0]

V[3, 6, 9] / 3
# => Yeah::Vector[1, 2, 3]

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(*components) ⇒ Vector

Returns a new instance of Vector.

Parameters:

  • first (Numeric) —

    component, defaults to 0

  • second (Numeric) —

    component, defaults to 0

  • third (Numeric) —

    component, defaults to 0



38
39
40
 
# File 'lib/yeah/vector.rb', line 38

def initialize(*components)
  @components = components + [0] * (3 - components.size)
end

Instance Attribute Details

#[] ⇒ Numeric

Returns *n*th component value.

Returns:

  • (Numeric) —

    *n*th component value



33
 
# File 'lib/yeah/vector.rb', line 33

def_delegators :@components, :[]

#components ⇒ Array

Returns vector components.

Returns:

  • (Array) —

    vector components



29
30
31
 
# File 'lib/yeah/vector.rb', line 29

def components
  @components
end

#x ⇒ Numeric

Returns first component value.

Parameters:

  • first (Numeric) —

    component value

Returns:

  • (Numeric) —

    first component value




# File 'lib/yeah/vector.rb', line 47

#y ⇒ Numeric

Returns second component value.

Parameters:

  • second (Numeric) —

    component value

Returns:

  • (Numeric) —

    second component value




# File 'lib/yeah/vector.rb', line 51

#z ⇒ Numeric

Returns third component value.

Parameters:

  • third (Numeric) —

    component value

Returns:

  • (Numeric) —

    third component value



58
59
60
61
 
# File 'lib/yeah/vector.rb', line 58

%i[x y z].each_with_index do |component, i|
  define_method(component) { @components[i] }
  define_method("#{component}=") { |v| @components[i] = v }
end

Class Method Details

.[](*args) ⇒ Vector

Alias for ::new.

Parameters:

  • arguments —

    catch-all

Returns:



23
24
25
 
# File 'lib/yeah/vector.rb', line 23

def [](*args)
  new(*args)
end

Instance Method Details

#*(numeric) ⇒ Vector Also known as: multiply

Returns vector product.

Parameters:

  • numeric (Numeric) —

    to multiply vector by

Returns:



101
102
103
104
105
 
# File 'lib/yeah/vector.rb', line 101

def *(numeric)
  self.class.new(@components[0] * numeric,
                 @components[1] * numeric,
                 @components[2] * numeric)
end

#+(vector) ⇒ Vector Also known as: add

Returns vector sum.

Parameters:

Returns:



85
86
87
88
89
 
# File 'lib/yeah/vector.rb', line 85

def +(vector)
  self.class.new(@components[0] + vector.components[0],
                 @components[1] + vector.components[1],
                 @components[2] + vector.components[2])
end

#-(vector) ⇒ Vector Also known as: subtract

Returns vector difference.

Parameters:

  • vector (Vector) —

    to subtract

Returns:

  • (Vector) —

    vector difference



93
94
95
96
97
 
# File 'lib/yeah/vector.rb', line 93

def -(vector)
  self.class.new(@components[0] - vector.components[0],
                 @components[1] - vector.components[1],
                 @components[2] - vector.components[2])
end

#-@ ⇒ Vector

Returns negative vector.

Returns:

  • (Vector) —

    negative vector



166
167
168
169
170
 
# File 'lib/yeah/vector.rb', line 166

def -@
  self.class.new(-@components[0],
                 -@components[1],
                 -@components[2])
end

#/(numeric) ⇒ Vector Also known as: divide

Returns vector quotient.

Parameters:

  • numeric (Numeric) —

    to divide vector by

Returns:

  • (Vector) —

    vector quotient



109
110
111
112
113
 
# File 'lib/yeah/vector.rb', line 109

def /(numeric)
  self.class.new(@components[0] / numeric,
                 @components[1] / numeric,
                 @components[2] / numeric)
end

#==(other) ⇒ Boolean

Returns whether self equals vector.

Parameters:

  • vector (Vector) —

    to equate

Returns:

  • (Boolean) —

    whether self equals vector



79
80
81
 
# File 'lib/yeah/vector.rb', line 79

def ==(other)
  @components == other.components
end

#add!(vector) ⇒ Vector

Returns self after adding vector.

Parameters:

Returns:

  • (Vector) —

    self after adding vector



125
126
127
128
129
130
131
 
# File 'lib/yeah/vector.rb', line 125

def add!(vector)
  @components[0] += vector.components[0]
  @components[1] += vector.components[1]
  @components[2] += vector.components[2]

  self
end

#along(angle, distance) ⇒ Vector

Returns position moved along an angle for a distance in 2D.

Parameters:

  • angle (Numeric) —

    to move along, in radians

  • distance (Numeric) —

    to move

Returns:

  • (Vector) —

    position moved along an angle for a distance in 2D



190
191
192
193
194
 
# File 'lib/yeah/vector.rb', line 190

def along(angle, distance)
  self.class.new(@components[0] + Math.cos(angle) * distance,
                 @components[1] + Math.sin(angle) * distance,
                 @components[2])
end

#along!(angle, distance) ⇒ Vector

Returns self after moving along an angle for a distance in 2D.

Parameters:

  • angle (Numeric) —

    to move along, in radians

  • distance (Numeric) —

    to move

Returns:

  • (Vector) —

    self after moving along an angle for a distance in 2D



198
199
200
201
202
203
 
# File 'lib/yeah/vector.rb', line 198

def along!(angle, distance)
  @components[0] += Math.cos(angle) * distance
  @components[1] += Math.sin(angle) * distance

  self
end

#angle_to(position) ⇒ Numeric

Returns angle to 2D position, in radians.

Parameters:

Returns:

  • (Numeric) —

    angle to 2D position, in radians



182
183
184
185
 
# File 'lib/yeah/vector.rb', line 182

def angle_to(position)
  diff = position - self
  Math.atan2(diff.y, diff.x)
end

#distance_to(position) ⇒ Numeric

Returns distance to a position.

Parameters:

Returns:

  • (Numeric) —

    distance to a position



174
175
176
177
178
 
# File 'lib/yeah/vector.rb', line 174

def distance_to(position)
  Math.sqrt((@components[0] - position.x) ** 2 +
            (@components[1] - position.y) ** 2 +
            (@components[2] - position.z) ** 2)
end

#divide!(numeric) ⇒ Vector

Returns self after dividing by numeric.

Parameters:

  • numeric (Numeric) —

    to divide vector by

Returns:

  • (Vector) —

    self after dividing by numeric



155
156
157
158
159
160
161
 
# File 'lib/yeah/vector.rb', line 155

def divide!(numeric)
  @components[0] /= numeric
  @components[1] /= numeric
  @components[2] /= numeric

  self
end

#inspect ⇒ String

Returns readable representation.

Returns:

  • (String) —

    readable representation



43
44
45
 
# File 'lib/yeah/vector.rb', line 43

def inspect
  "#{self.class.name}#{@components.to_s}"
end

#length ⇒ Numeric Also known as: magnitude

Returns vector’s length.

Returns:

  • (Numeric) —

    vector’s length



64
65
66
 
# File 'lib/yeah/vector.rb', line 64

def length
  Math.sqrt(@components[0] ** 2 + @components[1] ** 2 + @components[2] ** 2)
end

#multiply!(numeric) ⇒ Vector

Returns self after multiplying by numeric.

Parameters:

  • numeric (Numeric) —

    to multiply vector by

Returns:

  • (Vector) —

    self after multiplying by numeric



145
146
147
148
149
150
151
 
# File 'lib/yeah/vector.rb', line 145

def multiply!(numeric)
  @components[0] *= numeric
  @components[1] *= numeric
  @components[2] *= numeric

  self
end

#normalize ⇒ Vector Also known as: unit

Returns vector of same direction whose length is 1.

Returns:

  • (Vector) —

    vector of same direction whose length is 1



71
72
73
 
# File 'lib/yeah/vector.rb', line 71

def normalize
  self / length
end

#subtract!(vector) ⇒ Vector

Returns self after subtracting vector.

Parameters:

  • vector (Vector) —

    to subtract

Returns:

  • (Vector) —

    self after subtracting vector



135
136
137
138
139
140
141
 
# File 'lib/yeah/vector.rb', line 135

def subtract!(vector)
  @components[0] -= vector.components[0]
  @components[1] -= vector.components[1]
  @components[2] -= vector.components[2]

  self
end

#toward(position, distance) ⇒ Vector

Returns position moved toward other position for a distance.

Parameters:

  • position (Vector) —

    to move to

  • distance (Vector) —

    to move

Returns:

  • (Vector) —

    position moved toward other position for a distance



208
209
210
 
# File 'lib/yeah/vector.rb', line 208

def toward(position, distance)
  self + (position - self).unit * distance
end

#toward!(position, distance) ⇒ Vector

Returns self after moving toward other position for a distance.

Parameters:

  • position (Vector) —

    to move to

  • distance (Vector) —

    to move

Returns:

  • (Vector) —

    self after moving toward other position for a distance



214
215
216
 
# File 'lib/yeah/vector.rb', line 214

def toward!(position, distance)
  self.add! (position - self).unit * distance
end