Class: Coltrane::Theory::IntervalSequence

Inherits:
Object
  • Object
show all
Extended by:
Forwardable
Defined in:
lib/coltrane/theory/interval_sequence.rb

Overview

It describes a sequence of intervals

Direct Known Subclasses

ChordQuality

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(*intervals, notes: nil, relative_intervals: nil) ⇒ IntervalSequence

Returns a new instance of IntervalSequence.



13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 
# File 'lib/coltrane/theory/interval_sequence.rb', line 13

def initialize(*intervals, notes: nil, relative_intervals: nil)
  if intervals.any?
    @intervals = if intervals.first.is_a?(Interval)
                   intervals
                 else
                   intervals.map { |i| Interval[i] }
    end

  elsif notes
    notes = NoteSet[*notes] if notes.is_a?(Array)
    @intervals = intervals_from_notes(notes)
  elsif relative_intervals
    @relative_intervals = relative_intervals
    @intervals = intervals_from_relative_intervals(relative_intervals)
  else
    raise WrongKeywordsError,
          'Provide: [notes:] || [intervals:] || [relative_intervals:]'
  end
end

Instance Attribute Details

#intervals ⇒ Object (readonly)

Returns the value of attribute intervals.



8
9
10
 
# File 'lib/coltrane/theory/interval_sequence.rb', line 8

def intervals
  @intervals
end

Instance Method Details

#&(other) ⇒ Object 



137
138
139
140
141
142
 
# File 'lib/coltrane/theory/interval_sequence.rb', line 137

def &(other)
  case other
  when Array then intervals & other
  when IntervalSequence then intervals & other.semitones
  end
end

#[](x) ⇒ Object 



87
88
89
 
# File 'lib/coltrane/theory/interval_sequence.rb', line 87

def [](x)
  intervals[x]
end

#all ⇒ Object 



83
84
85
 
# File 'lib/coltrane/theory/interval_sequence.rb', line 83

def all
  intervals
end

#find(interval) ⇒ Object 



65
66
67
 
# File 'lib/coltrane/theory/interval_sequence.rb', line 65

def find(interval)
  interval.clone if detect { |i| interval == i }
end

#find_by_distance(n, accept_altered = true) ⇒ Object 



73
74
75
76
77
78
79
 
# File 'lib/coltrane/theory/interval_sequence.rb', line 73

def find_by_distance(n, accept_altered = true)
  strategy = (accept_altered ? :as : :as!)
  map { |interval| interval.send(strategy, n) }
    .compact
    .sort_by { |i| i.alteration.abs }
    .first
end

#full_names ⇒ Object 



125
126
127
 
# File 'lib/coltrane/theory/interval_sequence.rb', line 125

def full_names
  map(&:full_name)
end

#has?(interval) ⇒ Boolean

Returns:

  • (Boolean) 


69
70
71
 
# File 'lib/coltrane/theory/interval_sequence.rb', line 69

def has?(interval)
  !!find(interval)
end

#interval_names ⇒ Object 



81
82
83
 
# File 'lib/coltrane/theory/interval_sequence.rb', line 81

def names
  intervals.map(&:name)
end

#intervals_semitones ⇒ Object 



117
118
119
 
# File 'lib/coltrane/theory/interval_sequence.rb', line 117

def intervals_semitones
  map(&:semitones)
end

#inversion(index) ⇒ Object 



101
102
103
 
# File 'lib/coltrane/theory/interval_sequence.rb', line 101

def inversion(index)
  self.class.new(*intervals.rotate(index)).zero_it
end

#inversions ⇒ Object 



113
114
115
 
# File 'lib/coltrane/theory/interval_sequence.rb', line 113

def inversions
  Array.new(intervals.length) { |i| inversion(i) }
end

#names ⇒ Object 



61
62
63
 
# File 'lib/coltrane/theory/interval_sequence.rb', line 61

def names
  intervals.map(&:name)
end

#next_inversion ⇒ Object 



105
106
107
 
# File 'lib/coltrane/theory/interval_sequence.rb', line 105

def next_inversion
  inversion(index + 1)
end

#notes_for(root_note) ⇒ Object 



129
130
131
132
133
134
135
 
# File 'lib/coltrane/theory/interval_sequence.rb', line 129

def notes_for(root_note)
  NoteSet[
    *intervals.reduce([]) do |memo, interval|
      memo + [root_note + interval]
    end
  ]
end

#previous_inversion ⇒ Object 



109
110
111
 
# File 'lib/coltrane/theory/interval_sequence.rb', line 109

def previous_inversion
  inversion(index - 1)
end

#relative_intervals ⇒ Object 



51
52
53
54
55
56
57
58
59
 
# File 'lib/coltrane/theory/interval_sequence.rb', line 51

def relative_intervals
  intervals_semitones[1..-1].each_with_index.map do |n, i|
    if i.zero?
      n
    elsif i < intervals_semitones.size
      n - intervals_semitones[i]
    end
  end + [12 - intervals_semitones.last]
end

#shift(ammount) ⇒ Object 



91
92
93
94
95
 
# File 'lib/coltrane/theory/interval_sequence.rb', line 91

def shift(ammount)
  self.class.new(*intervals.map do |i|
    (i.semitones + ammount) % 12
  end)
end

#zero_it ⇒ Object 



97
98
99
 
# File 'lib/coltrane/theory/interval_sequence.rb', line 97

def zero_it
  shift(-intervals.first.semitones)
end