Class: Tonal::Ratio

Inherits:
Object
  • Object
show all
Extended by:
Forwardable
Includes:
Comparable
Defined in:
lib/tonal/approximation.rb,
lib/tonal/ratio.rb

Direct Known Subclasses

ReducedRatio

Defined Under Namespace

Classes: Approximation

Constant Summary collapse

PRECISION = 
2

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(antecedent, consequent = nil, label: nil, equave: 2) ⇒ Tonal::Ratio

Examples:

Tonal::Ratio.new(3,2) => (3/2)

Parameters:

Raises:

  • (ArgumentError) 


19
20
21
22
23
24
 
# File 'lib/tonal/ratio.rb', line 19

def initialize(antecedent, consequent=nil, label: nil, equave: 2/1r)
  raise ArgumentError, "Antecedent must be Numeric" unless antecedent.kind_of?(Numeric)
  raise ArgumentError, "Consequent must be Numeric or nil" unless (consequent.kind_of?(Numeric) || consequent.nil?)

  _initialize(antecedent, consequent, label:, equave:)
end

Instance Attribute Details

#antecedent ⇒ Object (readonly) Also known as: numerator

Returns the value of attribute antecedent.



9
10
11
 
# File 'lib/tonal/ratio.rb', line 9

def antecedent
  @antecedent
end

#consequent ⇒ Object (readonly) Also known as: denominator

Returns the value of attribute consequent.



9
10
11
 
# File 'lib/tonal/ratio.rb', line 9

def consequent
  @consequent
end

#equave ⇒ Object (readonly)

Returns the value of attribute equave.



9
10
11
 
# File 'lib/tonal/ratio.rb', line 9

def equave
  @equave
end

#label ⇒ String

Returns symbolic representation of Tonal::Ratio.

Returns:

  • (String) —

    symbolic representation of Tonal::Ratio



472
473
474
 
# File 'lib/tonal/ratio.rb', line 472

def label
  @label
end

#reduced_antecedent ⇒ Object (readonly)

Returns the value of attribute reduced_antecedent.



9
10
11
 
# File 'lib/tonal/ratio.rb', line 9

def reduced_antecedent
  @reduced_antecedent
end

#reduced_consequent ⇒ Object (readonly)

Returns the value of attribute reduced_consequent.



9
10
11
 
# File 'lib/tonal/ratio.rb', line 9

def reduced_consequent
  @reduced_consequent
end

Class Method Details

.ed(modulo, step, equave: 2) ⇒ Tonal::Ratio

Returns the ratio of step in the modulo.

Examples:

Tonal::Ratio.ed(12, 7)
  => (4771397596969315/4503599627370496)

Parameters:

  • modulo
  • step
  • equave (defaults to: 2)

Returns:



82
83
84
 
# File 'lib/tonal/ratio.rb', line 82

def self.ed(modulo, step, equave: 2/1r)
  self.new(2**(step.to_f/modulo), equave: equave)
end

.random_ratio(number_of_factors = 2, within: 100, reduced: false) ⇒ Tonal::Ratio

Returns a randomly generated ratio.

Examples:

Tonal::Ratio.random_ratio => (169/1)

Parameters:

  • number_of_factors (defaults to: 2)
  • within (defaults to: 100)

Returns:



63
64
65
66
67
68
69
70
71
72
 
# File 'lib/tonal/ratio.rb', line 63

def self.random_ratio(number_of_factors = 2, within: 100, reduced: false)
  primes = Prime.each(within).to_a
  nums = []
  dens = []
  1.upto(number_of_factors) do
    nums << [primes[rand(10)], rand(3)]
    dens << [primes[rand(10)], rand(3)]
  end
  [nums, dens].ratio_from_prime_divisions(reduced:)
end

.superparticular(n, factor: 1, superpart: :upper) ⇒ Tonal::Ratio

Returns ratio who’s numerator and denominator are seperated by a difference of 1.

Examples:

Tonal::Ratio.superparticular(100) = (101/100)

Parameters:

  • n (Integer) —

    number from which the superior part is calculated

  • factor (Rational) (defaults to: 1) —

    multiplied into the resulting ratio, default 1/1

  • superpart (Symbol) (defaults to: :upper) —

    assigning the superior part to the antecedent or consequent

Returns:

  • (Tonal::Ratio) —

    ratio who’s numerator and denominator are seperated by a difference of 1



36
37
38
 
# File 'lib/tonal/ratio.rb', line 36

def self.superparticular(n, factor: 1/1r, superpart: :upper)
  superpartient(n, summand: 1, factor:, superpart:)
end

.superpartient(n, summand:, factor: 1, superpart: :upper) ⇒ Tonal::Ratio

Returns ratio who’s numerator and denominator are separated by a summand difference.

Examples:

Tonal::Ratio.superpartient(23, summand: 3) => (26/23)

Parameters:

  • n (Integer) —

    number from which the superior part is calculated

  • summand (Integer) —

    term added to the superior part

  • factor (Rational) (defaults to: 1) —

    multiplied into the resulting ratio, default 1/1

  • superpart (Symbol) (defaults to: :upper) —

    assigning the superior part to the antecedent or consequent

Returns:

  • (Tonal::Ratio) —

    ratio who’s numerator and denominator are separated by a summand difference



48
49
50
51
52
53
54
55
 
# File 'lib/tonal/ratio.rb', line 48

def self.superpartient(n, summand:, factor: 1/1r, superpart: :upper)
  case superpart.to_sym.downcase
  when :lower, :consequent, :denominator
    self.new(n*factor.numerator, (n+summand)*factor.denominator)
  else
    self.new((n+summand)*factor.numerator, n*factor.denominator)
  end
end

.within_cents?(cents1, cents2, within) ⇒ Boolean

Returns if pair of ratios are within the given cents limit.

Examples:

Tonal::Ratio.within_cents?(100, 105, 2) => false

Parameters:

  • cents1
  • cents2
  • within

Returns:

  • (Boolean) —

    if pair of ratios are within the given cents limit



93
94
95
 
# File 'lib/tonal/ratio.rb', line 93

def self.within_cents?(cents1, cents2, within)
  (cents1 - cents2).abs <= within
end

Instance Method Details

#*(rhs) ⇒ Object 



496
497
498
 
# File 'lib/tonal/ratio.rb', line 496

def *(rhs)
  operate(rhs, :*)
end

#**(rhs) ⇒ Object 



504
505
506
 
# File 'lib/tonal/ratio.rb', line 504

def **(rhs)
  operate(rhs, :**)
end

#+(rhs) ⇒ Object 



488
489
490
 
# File 'lib/tonal/ratio.rb', line 488

def +(rhs)
  operate(rhs, :+)
end

#-(rhs) ⇒ Object 



492
493
494
 
# File 'lib/tonal/ratio.rb', line 492

def -(rhs)
  operate(rhs, :-)
end

#/(rhs) ⇒ Object 



500
501
502
 
# File 'lib/tonal/ratio.rb', line 500

def /(rhs)
  operate(rhs, :/)
end

#<=>(rhs) ⇒ Object 



562
563
564
565
566
 
# File 'lib/tonal/ratio.rb', line 562

def <=>(rhs)
  left = consequent == 0 ? Float::INFINITY : Rational(antecedent, consequent)
  right = rhs.denominator == 0 ? Float::INFINITY : Rational(rhs.numerator, rhs.denominator)
  left <=> right
end

#approximate ⇒ Tonal::Ratio::Approximation

Returns self’s approximation instance.

Returns:



106
107
108
 
# File 'lib/tonal/ratio.rb', line 106

def approximate
  @approximation
end

#benedetti_height ⇒ Integer Also known as: product_complexity

Returns the product complexity of self.

Examples:

Tonal::ReducedRatio.new(3/2r).benedetti_height => 6

Returns:

  • (Integer) —

    the product complexity of self



389
390
391
 
# File 'lib/tonal/ratio.rb', line 389

def benedetti_height
  reduced_antecedent * reduced_consequent
end

#cent_diff(other_ratio) ⇒ Tonal::Cents

Returns cent difference between self and other ratio.

Examples:

Tonal::ReducedRatio.new(3,2).cent_diff(4/3r) => 203.92

Parameters:

Returns:

  • (Tonal::Cents) —

    cent difference between self and other ratio



466
467
468
 
# File 'lib/tonal/ratio.rb', line 466

def cent_diff(other_ratio)
  cents - other_ratio.ratio.cents
end

#combination ⇒ Integer Also known as: comb

Returns the sum of antecedent and consequent.

Examples:

Tonal::ReducedRatio.new(3,2).combination => 5

Returns:

  • (Integer) —

    the sum of antecedent and consequent



557
558
559
 
# File 'lib/tonal/ratio.rb', line 557

def combination
  antecedent + consequent
end

#difference ⇒ Integer Also known as: diff

Returns the difference between antecedent and consequent.

Examples:

Tonal::ReducedRatio.new(3,2).difference => 1

Returns:

  • (Integer) —

    the difference between antecedent and consequent



548
549
550
 
# File 'lib/tonal/ratio.rb', line 548

def difference
  antecedent - consequent
end

#div_times(other_ratio) ⇒ Array

Returns the results of ratio dividing and multiplying self.

Examples:

Tonal::ReducedRatio.new(3/2r).div_times(5/4r) => [(6/5), (15/8)]

Parameters:

  • other_ratio —

    to divide and multiple on self

Returns:

  • (Array) —

    the results of ratio dividing and multiplying self



445
446
447
448
 
# File 'lib/tonal/ratio.rb', line 445

def div_times(other_ratio)
  other_ratio = self.class.new(other_ratio)
  [self / other_ratio, self * other_ratio]
end

#efficiency(modulo) ⇒ Tonal::Cents

Returns the cents difference between self and its step in the given modulo.

Examples:

Tonal::ReducedRatio.new(3,2).efficiency(12) => -1.96

Parameters:

  • modulo —

    against which the difference of self is compared

Returns:

  • (Tonal::Cents) —

    the cents difference between self and its step in the given modulo



434
435
436
437
438
 
# File 'lib/tonal/ratio.rb', line 434

def efficiency(modulo)
  # We want the efficiency from the ratio (self).
  # If the step efficiency is X cents, then the ratio efficiency is -X cents.
  step(modulo).efficiency * -1.0
end

#equave_reduce(equave = 2) ⇒ Tonal::Ratio Also known as: reduce, reduced

Returns copy of self reduced to the given equave.

Examples:

Tonal::Ratio.new(48,14).equave_reduce(3) => (8/7)

Parameters:

  • equave (defaults to: 2) —

    Numeric

Returns:

  • (Tonal::Ratio) —

    copy of self reduced to the given equave



215
216
217
 
# File 'lib/tonal/ratio.rb', line 215

def equave_reduce(equave=2/1r)
  self.class.new(*_equave_reduce(equave))
end

#equave_reduce!(equave = 2) ⇒ Tonal::Ratio Also known as: reduce!, reduced!

Returns self reduced to the given equave.

Examples:

Tonal::Ratio.new(48,14).equave_reduce!(3) => (8/7)

Parameters:

  • equave (defaults to: 2) —

    Numeric

Returns:



226
227
228
229
 
# File 'lib/tonal/ratio.rb', line 226

def equave_reduce!(equave=2/1r)
  @antecedent, @consequent = _equave_reduce(equave)
  self
end

#fraction_reduce ⇒ Tonal::Ratio

Returns copy of self rationally reduced.

Examples:

Tonal::Ratio.new(16,14).fraction_reduce => (8/7)

Returns:

See Also:



206
207
208
 
# File 'lib/tonal/ratio.rb', line 206

def fraction_reduce
  self.class.new(to_r)
end

#inspect ⇒ String Also known as: to_s

Returns the string representation of Tonal::Ratio.

Examples:

Tonal::Ratio.new(3, 2).inspect => "(3/2)"

Returns:

  • (String) —

    the string representation of Tonal::Ratio



483
484
485
 
# File 'lib/tonal/ratio.rb', line 483

def inspect
  "(#{antecedent}/#{consequent})"
end

#interval_with(antecedent, consequent = nil) ⇒ Tonal::Interval

Returns between ratio (upper) and self (lower).

Examples:

Tonal::ReducedRatio.new(133).interval_with(3/2r)
=> (192/133) ((3/2) / (133/128))

Parameters:

  • antecedent
  • consequent (defaults to: nil)

Returns:



539
540
541
542
 
# File 'lib/tonal/ratio.rb', line 539

def interval_with(antecedent, consequent=nil)
  r = self.class.new(antecedent, consequent)
  Tonal::Interval.new(self, r)
end

#invert ⇒ Tonal::Ratio Also known as: reflect

Returns copy of self with the antecedent and precedent switched.

Examples:

Tonal::Ratio.new(3,2).invert => (2/3)

Returns:

  • (Tonal::Ratio) —

    copy of self with the antecedent and precedent switched



246
247
248
 
# File 'lib/tonal/ratio.rb', line 246

def invert
  self.class.new(consequent, antecedent)
end

#invert! ⇒ Tonal::Ratio

Returns with antecedent and precedent switched.

Examples:

Tonal::Ratio.new(3,2).invert! => (2/3)

Returns:



255
256
257
258
 
# File 'lib/tonal/ratio.rb', line 255

def invert!
  _initialize(consequent, antecedent, label: label, equave: equave)
  self
end

#lcm(lhs) ⇒ Integer

Returns the least common multiple with self’s denominator and the given number’s denominator.

Examples:

Tonal::Ratio.new(3/2r).lcm(5/4r) => 4

Parameters:

Returns:

  • (Integer) —

    the least common multiple with self’s denominator and the given number’s denominator



528
529
530
 
# File 'lib/tonal/ratio.rb', line 528

def lcm(lhs)
  [self.denominator, lhs.denominator].lcm
end

#log_weil_height ⇒ Tonal::Log2

Returns the log of Weil height.

Examples:

Tonal::ReducedRatio.new(3/2r).log_weil_height => 1.58

Returns:



417
418
419
 
# File 'lib/tonal/ratio.rb', line 417

def log_weil_height
  Tonal::Log2.new(logarithmand: weil_height)
end

#max_prime ⇒ Integer

Returns the maximum prime factor of self.

Examples:

Tonal::Ratio.new(31/30r).max_prime => 31

Returns:

  • (Integer) —

    the maximum prime factor of self



364
365
366
 
# File 'lib/tonal/ratio.rb', line 364

def max_prime
  prime_divisions.flatten(1).map(&:first).max
end

#max_prime_within?(number) ⇒ Boolean

Returns whether self’s max prime is within the given number.

Examples:

Tonal::Ratio.new(31/30r).max_prime_within?(7) => false

Parameters:

  • number —

    to compare max prime against

Returns:

  • (Boolean) —

    whether self’s max prime is within the given number



381
382
383
 
# File 'lib/tonal/ratio.rb', line 381

def max_prime_within?(number)
  max_prime <= number
end

#mediant_sum(number) ⇒ Tonal::Ratio Also known as: mediant, farey_sum

Returns the mediant (Farey) sum of self and another number.

Examples:

Tonal::Ratio.new(3,2).mediant_sum(4/3r) => (7/5)

Parameters:

Returns:

  • (Tonal::Ratio) —

    the mediant (Farey) sum of self and another number



513
514
515
 
# File 'lib/tonal/ratio.rb', line 513

def mediant_sum(number)
  self.class.new(antecedent + number.numerator, consequent + number.denominator)
end

#min_prime ⇒ Integer

Returns the minimum prime factor of self.

Examples:

Tonal::Ratio.new(31/30r).min_prime => 2

Returns:

  • (Integer) —

    the minimum prime factor of self



372
373
374
 
# File 'lib/tonal/ratio.rb', line 372

def min_prime
  prime_divisions.flatten(1).map(&:first).min
end

#mirror(axis = 1) ⇒ Tonal::Ratio

Returns the mirror of self along the axis (default 1/1).

Examples:

Tonal::ReducedRatio.new(4,3).mirror => (3/2)

Parameters:

  • axis (defaults to: 1)

Returns:

  • (Tonal::Ratio) —

    the mirror of self along the axis (default 1/1)



265
266
267
 
# File 'lib/tonal/ratio.rb', line 265

def mirror(axis=1/1r)
  (self.class.new(axis) ** 2) / self
end

#negative ⇒ Tonal::ReducedRatio

Returns the Ernst Levy negative of self.

Examples:

Tonal::ReducedRatio.new(7/4r).negative => (12/7)

Returns:



273
274
275
 
# File 'lib/tonal/ratio.rb', line 273

def negative
  self.class.new(3/2r) / self
end

#period_degrees(round: PRECISION) ⇒ Float

Returns degrees.

Examples:

Tonal::Ratio.new(3,2).period_degrees => 210.59

Parameters:

  • round (defaults to: PRECISION)

Returns:

  • (Float) —

    degrees



188
189
190
 
# File 'lib/tonal/ratio.rb', line 188

def period_degrees(round: PRECISION)
  (360.0 * Math.log(to_f, equave)).round(round)
end

#period_radians(round: PRECISION) ⇒ Float

Returns radians.

Examples:

Tonal::Ratio.new(3,2).period_radians => 3.68

Parameters:

  • round (defaults to: PRECISION)

Returns:

  • (Float) —

    radians



197
198
199
 
# File 'lib/tonal/ratio.rb', line 197

def period_radians(round: PRECISION)
  (2 * Math::PI * Math.log(to_f, equave)).round(round)
end

#planar_degrees(round: PRECISION) ⇒ Float

Returns degrees of antecedent (x) and consequent (y) on a 2D plane.

Examples:

Tonal::Ratio.new(3,2).planar_degrees => 33.69

Parameters:

  • round (defaults to: PRECISION)

Returns:

  • (Float) —

    degrees of antecedent (x) and consequent (y) on a 2D plane



321
322
323
 
# File 'lib/tonal/ratio.rb', line 321

def planar_degrees(round: PRECISION)
  (Math.atan2(consequent, antecedent) * 180/Math::PI).round(round)
end

#planar_radians(round: PRECISION) ⇒ Float

Returns radians.

Examples:

Tonal::Ratio.new(3,2).planar_radians => 0.59

Parameters:

  • round (defaults to: PRECISION)

Returns:

  • (Float) —

    radians



330
331
332
 
# File 'lib/tonal/ratio.rb', line 330

def planar_radians(round: PRECISION)
  Math.atan2(consequent, antecedent).round(round)
end

#plus_minus(other_ratio) ⇒ Array Also known as: min_plus

Returns the results of ratio subtracted and added to self.

Examples:

Tonal::ReducedRatio.new(3/2r).plus_minus(5/4r) => [(1/1), (11/8)]

Parameters:

  • other_ratio —

    to add and subtract from self

Returns:

  • (Array) —

    the results of ratio subtracted and added to self



455
456
457
458
 
# File 'lib/tonal/ratio.rb', line 455

def plus_minus(other_ratio)
  other_ratio = self.class.new(other_ratio)
  [self - other_ratio, self + other_ratio]
end

#prime_divisions ⇒ Array

Returns , self decomposed into its prime factors.

Examples:

Tonal::Ratio.new(31/30r).prime_divisions => [[[31, 1]], [[2, 1], [3, 1], [5, 1]]]

Returns:

  • (Array) —

    , self decomposed into its prime factors



338
339
340
341
 
# File 'lib/tonal/ratio.rb', line 338

def prime_divisions
  return [[[2, 1]], [[2, 1]]] if antecedent == 1
  [antecedent.prime_division, consequent.prime_division]
end

#prime_vector ⇒ Vector Also known as: monzo

Returns , self represented as a prime vector.

Examples:

Tonal::Ratio.new(3/2r).prime_vector => Vector[-1, 1]

Returns:

  • (Vector) —

    , self represented as a prime vector



347
348
349
350
351
352
353
354
355
356
357
 
# File 'lib/tonal/ratio.rb', line 347

def prime_vector
  pds = prime_divisions
  max = [pds.first.max{|p| p.first}, pds.last.max{|p| p.first}].max.first

  pds.last.collect!{|i| [i.first, -i.last]}

  p_arr = Prime.each(max).to_a
  Array.new(p_arr.count, 0).tap do |arr|
    pds.flatten(1).each{|e| arr[p_arr.find_index(e.first)] = e.last}
  end.to_vector
end

#ratio ⇒ Tonal::Ratio Also known as: to_ratio

Returns convenience method returning self.

Returns:



99
100
101
 
# File 'lib/tonal/ratio.rb', line 99

def ratio
  self
end

#scale(a, b = a) ⇒ Tonal::Ratio

Returns self scaled by given arguments.

Examples:

Tonal::Ratio.new(3,2).scale(2**5) => (96/64)

Parameters:

Returns:



300
301
302
303
 
# File 'lib/tonal/ratio.rb', line 300

def scale(a, b=a)
  raise_if_negative(a,b)
  self.class.new(*(Matrix[[a, 0],[0, b]] * Vector[antecedent, consequent]))
end

#shear(a, b = a) ⇒ Tonal::Ratio

Returns self sheared by given arguments.

Examples:

Tonal::Ratio.new(3,2).shear(1, 3) => (14/11)

Parameters:

Returns:



311
312
313
314
 
# File 'lib/tonal/ratio.rb', line 311

def shear(a, b=a)
  raise_if_negative(a,b)
  self.class.new(*((Matrix[[1,a],[0,1]] * Matrix[[1,0], [b,1]]) * Vector[antecedent, consequent]))
end

#step(modulo = 12) ⇒ Integer

Returns the step of self in the given modulo.

Examples:

Tonal::ReducedRatio.new(3,2).step(12) => 7\12

Returns:

  • (Integer) —

    the step of self in the given modulo



179
180
181
 
# File 'lib/tonal/ratio.rb', line 179

def step(modulo=12)
  Tonal::Step.new(ratio: to_r, modulo: modulo)
end

#tenney_height ⇒ Tonal::Log2 Also known as: log_product_complexity, harmonic_distance

Returns the log product complexity of self.

Examples:

Tonal::ReducedRatio.new(3/2r).tenney_height => 2.58

Returns:



398
399
400
 
# File 'lib/tonal/ratio.rb', line 398

def tenney_height
  Tonal::Log2.new(logarithmand: benedetti_height)
end

#to_a ⇒ Array

Returns antecedent and consequent as elements of Array.

Examples:

Tonal::Ratio.new(3,2).to_a => [3, 2]

Returns:

  • (Array) —

    antecedent and consequent as elements of Array



118
119
120
 
# File 'lib/tonal/ratio.rb', line 118

def to_a
  [antecedent, consequent]
end

#to_cents ⇒ Tonal::Cents Also known as: cents

Returns cents value of self.

Examples:

Tonal::Ratio.new(3,2).to_cents => 701.96

Returns:



170
171
172
 
# File 'lib/tonal/ratio.rb', line 170

def to_cents
  Tonal::Cents.new(ratio: to_r)
end

#to_f ⇒ Float

Returns self as a Float.

Examples:

Tonal::Ratio.new(3,2).to_f => 1.5

Returns:

  • (Float) —

    self as a Float



143
144
145
 
# File 'lib/tonal/ratio.rb', line 143

def to_f
  antecedent.to_f / consequent.to_f
end

#to_log(base = 2) ⇒ Tonal::Log Also known as: log

Returns Math.log of self in given base.

Examples:

Tonal::Ratio.new(3,2).log(3) => 0.37

Parameters:

  • base (defaults to: 2)

Returns:



152
153
154
 
# File 'lib/tonal/ratio.rb', line 152

def to_log(base=2)
  Tonal::Log.new(logarithmand: to_r, base: base)
end

#to_log2 ⇒ Tonal::Log2 Also known as: log2

Returns Math.log2 of self.

Examples:

Tonal::ReducedRatio.new(3,2).to_log2 => 0.58

Returns:



161
162
163
 
# File 'lib/tonal/ratio.rb', line 161

def to_log2
  Tonal::Log2.new(logarithmand: to_r)
end

#to_r ⇒ Rational

Returns self as a Rational.

Examples:

Tonal::Ratio.new(3,2).to_r => (3/2)

Returns:

  • (Rational) —

    self as a Rational



134
135
136
137
 
# File 'lib/tonal/ratio.rb', line 134

def to_r
  return Float::INFINITY if consequent.zero? || !antecedent.finite?
  Rational(antecedent, consequent)
end

#to_reduced_ratio ⇒ Tonal::ReducedRatio Also known as: reduced_ratio

Returns of self.

Examples:

Tonal::Ratio.new(1,9).to_reduced_ratio => (16/9)

Returns:



237
238
239
 
# File 'lib/tonal/ratio.rb', line 237

def to_reduced_ratio
  Tonal::ReducedRatio.new(reduced_antecedent, reduced_consequent, equave: equave)
end

#to_v ⇒ Vector

Returns antecedent and consequent as elements of Vector.

Examples:

Tonal::Ratio.new(3,2).to_v => Vector[3, 2]

Returns:

  • (Vector) —

    antecedent and consequent as elements of Vector



126
127
128
 
# File 'lib/tonal/ratio.rb', line 126

def to_v
  Vector[antecedent, consequent]
end

#translate(x = 1, y = 0) ⇒ Tonal::Ratio

Ratio grid transformations numerator mapped on x-axis, denominator mapped on y-axis

Examples:

Tonal::Ratio.new(3,2).translate(3,3) => (6/5)

Parameters:

Returns:

  • (Tonal::Ratio) —

    with the antecedent and consequent translated by x and y



289
290
291
292
 
# File 'lib/tonal/ratio.rb', line 289

def translate(x=1, y=0)
  raise_if_negative(x,y)
  self.class.new(*(Vector[antecedent, consequent] + Vector[x, y]))
end

#weil_height ⇒ Integer

Returns the Weil height.

Examples:

Tonal::ReducedRatio.new(3/2r).weil_height => 3

Returns:



408
409
410
 
# File 'lib/tonal/ratio.rb', line 408

def weil_height
  [reduced_antecedent, reduced_consequent].max
end

#wilson_height(prime_rejects: [2]) ⇒ Integer

Returns the Wilson height. The sum of self’s prime factors (greater than 2) times the absolute values of their exponents.

Examples:

Tonal::ReducedRatio.new(14/9r).wilson_height => 13

Returns:

  • (Integer) —

    the Wilson height. The sum of self’s prime factors (greater than 2) times the absolute values of their exponents



425
426
427
 
# File 'lib/tonal/ratio.rb', line 425

def wilson_height(prime_rejects: [2])
  benedetti_height.prime_division.reject{|p| prime_rejects.include?(p.first) }.sum{|p| p.first * p.last }
end