Hello All

 

As I continue my fascination with the fractal structures contained in Per Norgard's infinity series, I am wondering whether it might be possible to apply the infinity to particular scales or modes?

 

Say I want to generate an infinity-series based on a pre-existing scales/modes (like in G major) or by any self-defined mode such as  (make-scale 'c2 49  :alt '(1 2 1 1))

 

Any help much appreciated as always.

 

Kind regards

 

Brian

(infinity-series 100 (expand-chord '(c4 ionian-augmented :row t)))

 

Same as above:

(infinity-series 100 (expand-chord-name 'ionian-augmented :type :pitch))

 

Mapping the output of the INFINITY-SERIES with TONALITY-MAP to the same scale:

(tonality-map '(ionian-augmented :root c4)
             (infinity-series 100 (expand-chord '(c4 ionian-augmented :row t))))

 

Thanks Janusz

 

I'm not sure if I'm understanding this correctly.  If I wanted to use a scale of C major but start the infinity series on the pitches G4 A4 (or G4 B4 etc) so that it only returns notes from the C major scale, would this work to produce the following?

 

Thanks Brian

 

http://web.archive.org/web/20070523051434/http://www.pernoergaard.dk:80/eng/strukturer/uendelig/ukonstruktion01.html

Check the INFINITY-SERIES documentation how the function works.

So  0, 1, −1, 2, 1, 0, −2, 3, cannot be interpreted as steps up and down a pre-defined scale comprising tones and semitones (G4 A4 F4 B4 A4 etc) but only as semitone intervals?

here are some solutions: user- or OPMO-defined

 

 

greetings

andré

 

Thanks André

 

I tried to superimpose the first 64 infinity-series onto the c major scale but it kept returning an error?  Also, I couldn't find the tonality-step function? Brian

 

(step-to-pitch :steps '(0 1 -1 2 1 0 -2 3 -1 2 0 1 2 -1 -3 4 1 0 -2 3 0 1 -1 2 -2 3 1 0 3 -2 -4 5 -1 2 0 1 2 -1 -3 4 0 1 -1 2 1 0 -2 3 2 -1 -3 4 -1 2 0 1 -3 4 2 -1 4 -3 -5 6)
               :pitches '(c3 d3 e3 f3 g3 a3 b3 c4 d4 e4 f4 g4 a4 b4 c5 d5 e5 f5 g5 a5 b5 c6)
               :start 'g4)

dear brian

 

your pitch-range is too small for the step-sum... if you want to use it you have to enlarge your pitch-range.

i've now done a small change - so you don' t have an error -> step-stack will now be set to 0, if pitches are lower or higher then your pitch-range, but in this case you don't have exact results mapping the STEPS

so, enlarge your pitch-range -> perhaps with my "multiple-expand..."-function -> EXAMPLE 2

 

(defun step-to-pitch (&key steps pitches start)
  (let ((pos (car (position-item start pitches))))
    (append (list (nth pos pitches))
            (loop for i in steps
              ;; setting pos by add the step to pos
              do (setf pos (+ pos i))
              ;; when pitch-range to small then reset to lowest pitch+step
              ;; could be a more intelligent solution
              when (or (>= pos (length pitches))
                       (< pos 0))
              do (setf pos 0);(+ 0 i))
              collect (nth pos pitches)))))



;;; EXAMPLE 1


(step-to-pitch :steps '(0 1 -1 2 1 0 -2 3 -1 2 0 1 2 -1 -3 4 1 0 -2 3 0 1 -1 2 -2 3 1 0 3 -2 -4 5 -1 2 0 1 2 -1 -3 4 0 1 -1 2 1 0 -2 3 2 -1 -3 4 -1 2 0 1 -3 4 2 -1 4 -3 -5 6)
               :pitches '(c3 d3 e3 f3 g3 a3 b3 c4 d4 e4 f4 g4 a4 b4 c5 d5 e5 f5 g5 a5 b5 c6)
               :start 'g4)




;;; here a function which enlarges TONALITIES OVER X-ocavtes
;;; so, that's easier then to type :-9


(defun multiple-expand-tonality (&key startpitch octaves tonality)
  (remove-duplicates ;remove is for "cutting" if there are too much pitches (OMN loops last octave!)
   (loop repeat octaves
     with pitch = startpitch
     with cnt = 0 

     when (= cnt (length tonality))
     do (setq cnt 0)

     append (expand-tonality (list pitch (nth cnt tonality)))
     do (incf cnt)
     do (setq pitch (car (pitch-transpose 12 (list pitch)))))))


(multiple-expand-tonality :startpitch 'c1 
                          :octaves 6 
                          :tonality '(major))


;;; EXAMPLE 2

(step-to-pitch :steps '(0 1 -1 2 1 0 -2 3 -1 2 0 1 2 -1 -3 4 1 0 -2 3 0 1 -1 2 -2 3 1 0 3 -2 -4 5 -1 2 0 1 2 -1 -3 4 0 1 -1 2 1 0 -2 3 2 -1 -3 4 -1 2 0 1 -3 4 2 -1 4 -3 -5 6)
               :pitches (multiple-expand-tonality :startpitch 'c0 
                          :octaves 7 
                          :tonality '(major))
               :start 'g4)

 

 

 

 

 

Thanks André, I thought it might be that.  It works now with the integers as they are but I still need to solve the problem of how the infinity-series projects the intervals.  The integers produced by the infinity series work like this http://web.archive.org/web/20070523051434/http://www.pernoergaard.dk:80/eng/strukturer/uendelig/ukonstruktion01.html

 

So, applying the resultant integers from the infinity-series function doesn't work.  I think the scale mode would need to be built into the function?

 

Best wishes

 

Brian

but YOUR steps are not the same from the web-archive-example

 

-> in the web-example it's from G in C-major, steps are -> 1 -2

-> YOU are starting with steps ->  0 1 -1 2 ...

 

???

 

but, i have no idea about this infinity-things, i only MAP your SEQ to MAJOR-scale... in the way you asked for (i think), so perhaps you have to rethink the MAIN-thing?

 

best wishes

andré 

 

added 6 minutes later

you have to think different - these are NOT steps, these is a INTEGER-TO-PITCH thing...

perhaps mixed with tonality-map - but haven't time for that at the moment, sorry

Thanks André, I'll give it some more thought.

 

Best wishes

 

Brian

is this correct? i think it is - not smart-coded but it works - you could merge the functions into ONE (sorry for my english). perhaps there is an OPMO-library-solution, but i don't know it...

 

greetings

 

(defun step-to-pitch (&key steps pitches start)
  (let ((pos (car (position-item start pitches))))
    (append (list (nth pos pitches))
            (loop for i in steps
              ;; setting pos by add the step to pos
              do (setf pos (+ pos i))
              ;; when pitch-range to small then reset to lowest pitch+step
              ;; could be a more intelligent solution
              when (or (>= pos (length pitches))
                       (< pos 0))
              do (setf pos 0);(+ 0 i))
              collect (nth pos pitches)))))

(defun multiple-expand-tonality (&key startpitch octaves tonality)
  (remove-duplicates ;remove is for "cutting" if there are too much pitches (OMN loops last octave!)
   (loop repeat octaves
     with pitch = startpitch
     with cnt = 0 
     when (= cnt (length tonality))
     do (setq cnt 0)
     append (expand-tonality (list pitch (nth cnt tonality)))
     do (incf cnt)
     do (setq pitch (car (pitch-transpose 12 (list pitch)))))))

(defun reset-seq (seq)
  (let ((n (abs (find-min seq))))
    (loop for i in seq
      collect (+ n i))))
        
(step-to-pitch :steps (integer-to-interval (reset-seq '(0 1 -1 2 1 0 -2 3 -1 2 0 1 2 -1 -3 4 1 0 -2 3 0 1 -1 2 -2 3 1 0 3 -2 -4 5 -1 2 0 1 2 -1 -3 4 0 1 -1 2 1 0 -2 3 2 -1 -3 4 -1 2 0 1 -3 4 2 -1 4 -3 -5 6)))
               :pitches (multiple-expand-tonality :startpitch 'c0 
                          :octaves 7 
                          :tonality '(major))
               :start 'g4)

 

Thanks André, yes that produces the same sequence as the c major example starting on g4.  Tried it with longer sequences and with different modes: 

(setf pitch (step-to-pitch :steps (integer-to-interval (reset-seq (infinity-series 2848 '(1 0))))
               :pitches (multiple-expand-tonality :startpitch 'c0
                          :octaves 7
                          :tonality '(minor-hexatonic))
               :start 'g4))

 

Perfect!! I really appreciate your help with this.  Combined with the new time-swallow it's amazing.

 

Best wishes

 

Brian

i will write you a "merged"-function, takes not a lot of time, then it looks smarter :-)

do you know how to use USER LIBRARY? very usefull - take a look... then you could import and use it like an ordinary OPMO-function

36 minutes ago, AM said:

i will write you a "merged"-function, takes not a lot of time, then it looks smarter :-)

do you know how to use USER LIBRARY? very usefull - take a look... then you could import and use it like an ordinary OPMO-function

Thank you.  No, I've only ever used libraries when working with spectral tools.  I'll have a look.

 

Best, Brian

violà... bit more organized...

 

a) now you could copy the SUBFUNCTIONS+MAINFUNCTION into:  extensions -> user library. in that way all the functions will be loaded automatically, and it is not necessary to EVALUATE them before using... but it's useful to document it... 

 

b) otherwise... all this functions in your workspace/opmo-file... (like you are donig it wright now)

 

;;; SUBFUNCTIONS ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(defun step-to-pitch (&key steps pitches start)
  (let ((pos (car (position-item start pitches))))
    (append (list (nth pos pitches))
            (loop for i in steps
              ;; setting pos by add the step to pos
              do (setf pos (+ pos i))
              ;; when pitch-range to small then reset to lowest pitch+step
              ;; could be a more intelligent solution
              when (or (>= pos (length pitches))
                       (< pos 0))
              do (setf pos 0);(+ 0 i))
              collect (nth pos pitches)))))

(defun multiple-expand-tonality (&key startpitch octaves tonality)
  (remove-duplicates ;remove is for "cutting" if there are too much pitches (OMN loops last octave!)
   (loop repeat octaves
     with pitch = startpitch
     with cnt = 0 

     when (= cnt (length tonality))
     do (setq cnt 0)

     append (expand-tonality (list pitch (nth cnt tonality)))
     do (incf cnt)
     do (setq pitch (car (pitch-transpose 12 (list pitch)))))))

(defun reset-seq (seq)
  (let ((n (abs (find-min seq))))
    (loop for i in seq
      collect (+ n i))))
        
;;; MAINFUNCTION
                             
(defun map-infinity-series (&key seq start tonality)
  (step-to-pitch :steps (integer-to-interval (reset-seq seq))
                 :pitches (multiple-expand-tonality :startpitch 'c0 
                                                    :octaves 7 
                                                    :tonality tonality)
                 :start start))


;;; EXAMPLES OF USE ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(setf inf-list (infinity-series 128 '(1 0)))

(map-infinity-series :seq inf-list
                     :start 'g4
                     :tonality '(major))

(map-infinity-series :seq inf-list
                     :start 'gs3
                     :tonality '(messiaen-mode6))

 

janusz, is this possible directly via "infinity-series"?

greetings

andré

Thanks André, I am going to have so much exploring this tomorrow.

 

Best wishes

 

Brian

The INFINITY-SERIES returns only the strict series: 0, 1, −1, 2, 1, 0, −2, 3, …

Hi Andre, loving the new function so thank you so much for creating it.  How might I add my own tonality?  Can I do a setf to create a scale and then insert it in TONALITY? Or do I need to add it to the library?  Thanks Brian

 

(setf my-scale (make-scale 'c2 49  :alt '(1 2 1 1)))

hi brian,

 

i modified shortly the code, now you could do what you want...

"step-to-pitch" will test now what the tonality-input is ... if tonality = pitches -> then use this scale, othwerwise -> "expand the scale"

 

(defun map-infinity-series (&key seq start tonality)
  (step-to-pitch :steps (integer-to-interval (reset-seq seq))
                 :pitches (if (pitchp (car tonality))
                            tonality
                            (multiple-expand-tonality :startpitch 'c0 
                                                    :octaves 7 
                                                    :tonality tonality))
                 :start start))


(map-infinity-series :seq '(0 -1 3 2 1 2 -1)
                     :start 'fs4
                     :tonality (make-scale 'c2 49  :alt '(1 2 1 1)))



(map-infinity-series :seq '(0 -1 3 2 1 2 -1 2 2 3 3 1 -1 1 -1 2 2)
                     :start 'g4
                     :tonality '(major))


(map-infinity-series :seq '(0 -1 3 2 1 2 -1 2 2 3 3 1 -1 1 -1 2 2)
                     :start 'fs4
                     :tonality '(messiaen-mode1 messiaen-mode2 messiaen-mode3))

1) do it with library... like '(major) or (messiaen-mode1) or what else

2) do ith with a pitch-sequence like your '(make-scale 'c2 49  :alt '(1 2 1 1))

 

-> just REPLACE map-infinity-series by the new function-version

-> ...the only thing you have to look at it: your start-pitch has to be part of your scale!