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
DEFAULT_EQUAVE = 
2

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

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

Examples:

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

Parameters:

Raises:

  • (ArgumentError) 


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

def initialize(antecedent, consequent=nil, label: nil, equave: DEFAULT_EQUAVE)
  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.



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

def antecedent
  @antecedent
end

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

Returns the value of attribute consequent.



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

def consequent
  @consequent
end

#equave ⇒ Object (readonly)

Returns the value of attribute equave.



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

def equave
  @equave
end

#label ⇒ String

Returns symbolic representation of Tonal::Ratio.

Returns:

  • (String) —

    symbolic representation of Tonal::Ratio



553
554
555
 
# File 'lib/tonal/ratio.rb', line 553

def label
  @label
end

#reduced_antecedent ⇒ Object (readonly)

Returns the value of attribute reduced_antecedent.



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

def reduced_antecedent
  @reduced_antecedent
end

#reduced_consequent ⇒ Object (readonly)

Returns the value of attribute reduced_consequent.



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

def reduced_consequent
  @reduced_consequent
end

Class Method Details

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

Returns the ratio of step in the modulo.

Examples:

Tonal::Ratio.ed(12, 7) => 1.5

Parameters:

  • modulo —

    the number of steps in the equal division

  • step —

    the step number in the equal division of the equave

  • equave (defaults to: DEFAULT_EQUAVE) —

    the interval of equivalence, default 2/1

Returns:



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

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

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

Returns a randomly generated ratio.

Examples:

Tonal::Ratio.random_ratio => 169/1

Parameters:

  • number_of_factors (defaults to: 2) —

    the number of prime factors to include in the ratio

  • within (defaults to: 100) —

    the upper limit for prime factors

  • reduced (defaults to: (self == Tonal::ReducedRatio) ? true : false) —

    boolean determining whether to use Tonal::ReducedRatio or Tonal::Ratio

Returns:



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

def self.random_ratio(number_of_factors = 2, within: 100, reduced: (self == Tonal::ReducedRatio) ? true : 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



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

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



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

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



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

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

Instance Method Details

#*(rhs) ⇒ Tonal::Ratio

Returns result of multiplying self and rhs.

Examples:

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

Parameters:

Returns:



597
598
599
 
# File 'lib/tonal/ratio.rb', line 597

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

#**(rhs) ⇒ Tonal::Ratio

Returns result of raising self to the rhs power.

Examples:

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

Parameters:

Returns:

  • (Tonal::Ratio) —

    result of raising self to the rhs power



615
616
617
 
# File 'lib/tonal/ratio.rb', line 615

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

#+(rhs) ⇒ Tonal::Ratio

Returns result of adding self and rhs.

Examples:

Tonal::Ratio.new(3,2) + Tonal::Ratio.new(4,3) => (17/12)

Parameters:

Returns:



579
580
581
 
# File 'lib/tonal/ratio.rb', line 579

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

#-(rhs) ⇒ Tonal::Ratio

Returns result of subtracting rhs from self.

Examples:

Tonal::Ratio.new(3,2) - Tonal::Ratio.new(4,3) => (1/6)

Parameters:

Returns:



588
589
590
 
# File 'lib/tonal/ratio.rb', line 588

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

#/(rhs) ⇒ Tonal::Ratio

Returns result of dividing self by rhs.

Examples:

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

Parameters:

Returns:



606
607
608
 
# File 'lib/tonal/ratio.rb', line 606

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

#<=>(rhs) ⇒ Integer

Returns comparison of self to rhs.

Examples:

Tonal::Ratio.new(3,2) <=> Tonal::Ratio.new(4,3) => 1

Parameters:

Returns:

  • (Integer) —

    comparison of self to rhs



635
636
637
638
639
 
# File 'lib/tonal/ratio.rb', line 635

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:



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

def approximate
  @approximation
end

#benedetti_height ⇒ Integer Also known as: product_complexity

Measures of complexity

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 ⇒ Tonal::Cents

Returns cent difference between self and other ratio.

Examples:

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

Parameters:

Returns:

  • (Tonal::Cents) —

    cent difference between self and other ratio



469
470
471
 
# File 'lib/tonal/ratio.rb', line 469

def cents_difference_with(other_ratio)
  to_cents - other_ratio.ratio.to_cents
end

#cents_difference_with(other_ratio, is_lower: true) ⇒ Tonal::Cents

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

Examples:

Tonal::ReducedRatio.new(3,2).cents_difference_with(4/3r) => 203.91
Tonal::ReducedRatio.new(3,2).cents_difference_with(4/3r, is_lower: false) => 996.09

Parameters:

Returns:

  • (Tonal::Cents) —

    difference between ratio (upper) and self (lower)



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

def cents_difference_with(other_ratio)
  to_cents - other_ratio.ratio.to_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



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

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



520
521
522
 
# File 'lib/tonal/ratio.rb', line 520

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, is_step_efficiency: false) ⇒ 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, is_step_efficiency: false)
  # For single ratios, we normally want the efficiency from the ratio (self).
  # If the step efficiency is X cents, then the ratio efficiency is -X cents.
  step(modulo).efficiency * (is_step_efficiency ? 1.0 : -1.0)
end

#eql?(other) ⇒ Boolean

Set uses Hash as storage and equality of elements is determined according to Object#eql? and Object#hash.

Returns:

  • (Boolean) 


643
644
645
 
# File 'lib/tonal/ratio.rb', line 643

def eql?(other)
   other.instance_of?(self.class) && to_r == other.to_r
end

#equave_reduce(equave = DEFAULT_EQUAVE) ⇒ 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: DEFAULT_EQUAVE) —

    Numeric

Returns:

  • (Tonal::Ratio) —

    copy of self reduced to the given equave



217
218
219
 
# File 'lib/tonal/ratio.rb', line 217

def equave_reduce(equave=DEFAULT_EQUAVE)
  self.class.new(*_equave_reduce(equave))
end

#equave_reduce!(equave = DEFAULT_EQUAVE) ⇒ 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: DEFAULT_EQUAVE) —

    Numeric

Returns:



228
229
230
231
 
# File 'lib/tonal/ratio.rb', line 228

def equave_reduce!(equave=DEFAULT_EQUAVE)
  @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:



208
209
210
 
# File 'lib/tonal/ratio.rb', line 208

def fraction_reduce
  self.class.new(to_r)
end

#hash ⇒ Object 



647
648
649
650
651
 
# File 'lib/tonal/ratio.rb', line 647

def hash
   p, q = 17, 37
   p = q * @id.hash
   p = q * @name.hash
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



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

def inspect
  # Return the "antecedent/consequent", if antecedent is less than 7 digits long; or
  # Return the floating point representation rounded to PRECISION digits
  func = -> (n) { n.zero? ? n : Math.log10(n).to_i + 1 }
  ((func.call(antecedent)) <= 6 ? "#{antecedent}/#{consequent}" : "#{to_f.round(PRECISION)}")
end

#interval_with(other_ratio, is_lower: true) ⇒ Tonal::Interval

Returns between self and another ratio.

Examples:

Tonal::ReducedRatio.new(3,2).interval_with(4/3r)
=> 9/8 (3/2 / 4/3)
Tonal::ReducedRatio.new(3,2).interval_with(4/3r, is_lower: false)
=> 16/9 (4/3 / 3/2)

Parameters:

  • other_ratio (Tonal::ReducedRatio, Numeric) —

    the ratio to form the interval with

  • is_lower (Boolean) (defaults to: true) —

    whether other_ratio is the lower ratio of the interval

Returns:



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

def interval_with(other_ratio, is_lower: true)
  other_ratio = self.class.new(other_ratio)
  args = is_lower ? [self, other_ratio] : [other_ratio, self]
  Tonal::Interval.new(*args)
end

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

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



248
249
250
 
# File 'lib/tonal/ratio.rb', line 248

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:



258
259
260
261
 
# File 'lib/tonal/ratio.rb', line 258

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



476
477
478
 
# File 'lib/tonal/ratio.rb', line 476

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



369
370
371
 
# File 'lib/tonal/ratio.rb', line 369

def max_prime
  prime_divisions.flatten(1).map(&:first).max
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



624
625
626
 
# File 'lib/tonal/ratio.rb', line 624

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



377
378
379
 
# File 'lib/tonal/ratio.rb', line 377

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)



268
269
270
 
# File 'lib/tonal/ratio.rb', line 268

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:



276
277
278
 
# File 'lib/tonal/ratio.rb', line 276

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



190
191
192
 
# File 'lib/tonal/ratio.rb', line 190

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



199
200
201
 
# File 'lib/tonal/ratio.rb', line 199

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



324
325
326
 
# File 'lib/tonal/ratio.rb', line 324

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



333
334
335
 
# File 'lib/tonal/ratio.rb', line 333

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

#power(power, root = nil, approximant: 0, by_method: :continued_fraction, from: :lower_ratio) ⇒ Tonal::Ratio

Returns self raised to the given power and root.

Examples:

Tonal::ReducedRatio.new(3,2).power(2) => 9/8

Parameters:

  • power (Numeric)
  • root (Numeric, nil) (defaults to: nil)
  • approximant (Integer) (defaults to: 0) —

    the index of the approximant to use

  • by_method (Symbol) (defaults to: :continued_fraction) —

    the method used to calculate approximation of the root intervalic ratio

  • from (Symbol) (defaults to: :lower_ratio) —

    whether to calculate the root interval from the lower or upper ratio of the interval

Returns:

  • (Tonal::Ratio) —

    self raised to the given power and root



543
544
545
 
# File 'lib/tonal/ratio.rb', line 543

def power(power, root=nil, approximant: 0, by_method: :continued_fraction, from: :lower_ratio)
  to_interval.root_interval(power:, root:, approximant:, by_method:, from:).intervalic_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



341
342
343
 
# File 'lib/tonal/ratio.rb', line 341

def prime_divisions
  [antecedent.prime_division, consequent.prime_division]
end

#prime_vector ⇒ Vector Also known as: monzo, prime_exponent_vector

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



349
350
351
352
353
354
355
356
357
358
359
360
361
 
# File 'lib/tonal/ratio.rb', line 349

def prime_vector
  pds = prime_divisions
  return nil if pds.all?(&:empty?)

  max = [pds.first.max{|p| p.first}, pds.last.max{|p| p.first}].compact.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:



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

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:



303
304
305
306
 
# File 'lib/tonal/ratio.rb', line 303

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:



314
315
316
317
 
# File 'lib/tonal/ratio.rb', line 314

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



181
182
183
 
# File 'lib/tonal/ratio.rb', line 181

def step(modulo=12)
  Tonal::Scale::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



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

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:



172
173
174
 
# File 'lib/tonal/ratio.rb', line 172

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

#to_f ⇒ Float Also known as: number

Returns self as a Float.

Examples:

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

Returns:

  • (Float) —

    self as a Float



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

def to_f
  antecedent.to_f / consequent.to_f
end

#to_interval ⇒ Tonal::Interval

Returns between 1/1 and self.

Examples:

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

Returns:



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

def to_interval
  interval_with(1/1r)
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:



154
155
156
 
# File 'lib/tonal/ratio.rb', line 154

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:



163
164
165
 
# File 'lib/tonal/ratio.rb', line 163

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



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

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:



239
240
241
 
# File 'lib/tonal/ratio.rb', line 239

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



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

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



292
293
294
295
 
# File 'lib/tonal/ratio.rb', line 292

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