# AM

Members

789

## Posts posted by AM

### Number of beats per measure

violà... here's a solution...

but: you have a wrong OMN-structure in your code (-e a3f4d5 q ... => a rest followed by a pitch, i corrected it

```(setf omnlist '((-e q f4d5a5) (q a3e4c5 q e4c5a5) (-e  h g4e5a5)))

(defun countbeats (omnlist &key (denom '1/8))
(loop for i in omnlist
collect (/ (sum (abs! (flatten (omn :length i)))) denom)))

(countbeats omnlist)
=> (3 4 5)

(countbeats omnlist :denom 1/16)
=> (6 8 10)```

### Pairs of digits as sublists?

here is a pure LISP/CCL solution

```(loop for i from 1 to 100
collect (list (1+ (random 2)) i))

=> ((1 1) (2 2) (2 3) (2 4) (1 5) (1 6) (1 7) (2 8) (1 9) (1 10) (1 11) (1 12) (2 13) (2 14) (1 15) (2 16) (2 17) (2 18) (2 19) (2 20) (1 21) (2 22) (2 23) (1 24) (2 25) (2 26) (1 27) (2 28) (2 29) (2 30) (2 31) (2 32) (2 33) (1 34) (2 35) (2 36) (1 37) (1 38) (2 39) (1 40) (1 41) (1 42) (1 43) (2 44) (2 45) (2 46) (2 47) (1 48) (2 49) (1 50) (2 51) (1 52) (2 53) (1 54) (1 55) (1 56) (2 57) (2 58) (1 59) (2 60) (1 61) (1 62) (1 63) (2 64) (1 65) (1 66) (2 67) (1 68) (1 69) (2 70) (2 71) (2 72) (1 73) (1 74) (2 75) (1 76) (1 77) (2 78) (2 79) (1 80) (2 81) (2 82) (1 83) (2 84) (2 85) (1 86) (1 87) (2 88) (2 89) (1 90) (2 91) (1 92) (1 93) (1 94) (2 95) (2 96) (2 97) (1 98) (1 99) (2 100))```

as a function

```(defun pairs (n)
(loop for i from 1 to n
collect (list (1+ (random 2)) i)))

(pairs 200)```

### score-player latency??

if you are interested, i could show you some SOFTWARE to calculate really special tempo curves, in a very handy way. just write me a PM....

### score-player latency??

step by step => every code-line for itself cmd-E!

i have also some LATENCY with conTimbre-player... but that's LISP in realtime

the score player wasn't even intended to play things in parallel (i made a HACK from a HACK :-)). for precise POLYTEMPO things it is best to work via OSC and an external PLAYER (that's how I do it). I only need it in OPMO for sketching

### score-player latency??

i am very thankful for the HACK. lisp is not a language for real-time things, but for me it suits the approximate simulation perfectly!! thanx janusz!!

but: you can try out how it is not to evaluate everything at once, step by step, maybe then there will be less LATENCY?

### play polytempo -> code/examples

unfortunately i have no experience with DAW + polytempo... i always needed it for live-instrumental music

### play polytempo -> code/examples

you will have the same DURATION when the pitch-loop and tempo-loop (tempo-progression = TIME) have the same length. so you have to stop the pitch-seq at the end of your BAR/tempo-seq!!!

process should equal !?

`(gen-integer 110 60) `
`(gen-integer 61 111)`

### pitch-trajectory

great function, stephane!!

little extension/different mapping

```;;; a slightly extended version of stephane's FUNCTION
;;; with integer-output so you could map it on pitchfields/chords

(defun pitch-trajectory* (nbpitch range tendency
&key
(variance 0.5)
(type :around)
(quantize 1/2)
(smooth 1)
filter-repeat
seed
(output 'int)
(int-range '(0 24))
)
(setf seed (rnd-seed seed))
(do-verbose ("pitch-trajectory :seed ~s" seed)
(let* ((values (gen-tendency nbpitch tendency :variance variance :type type
:seed (seed)))
(smoothedval (vector-smooth smooth values))
(out (cond ((equal output 'pitch)
(vector-to-pitch range smoothedval :quantize quantize))
((equal output 'int)
(vector-round (car int-range) (cadr int-range) smoothedval)))))

(if filter-repeat
(filter-repeat filter-repeat out)
out))))

;;; pitch-ouput like in stephane's version

(pitch-list-plot
(pitch-trajectory* 128 '(fs3 g5) '(0.1 1 0.1)
:filter-repeat 1
:variance 0.8
:output 'pitch
))

;;; integer-output for MAPPING

(list-plot
(pitch-trajectory* 128 '(fs3 g5) '(0.1 1 0.1)
:filter-repeat 1
:variance 0.8
:output 'int
:int-range '(0 23)
))

;;; MAPPING the integers on a scale or pitchfield

(loop
for i in (pitch-trajectory* 128 '(fs3 g5) '(0.1 1 0.1)
:filter-repeat 1
:variance 0.8
:output 'int
:int-range '(0 23))
with scale = (make-scale 'c2 24 :alt '(1 2))
collect (nth i scale))

(loop
for i in (pitch-trajectory* 128 '(fs3 g5) '(0.1 3 0.1)
:filter-repeat 1
:variance 0.9
:output 'int
:int-range '(0 23))
with scale = (make-scale 'c2 24 :alt '(2 1 6 5 4))
collect (nth i scale))

;;; an example with MAPPING and SAMPLING

(progn
(setf seq (loop
for i in (pitch-trajectory* 64 '(fs3 g5) '(0.1 3 0.1)
:filter-repeat 1
:variance 0.4
:output 'int
:int-range '(0 23))
with scale = (make-scale 'c2 24 :alt '(2 1 6 5 4))
collect (nth i scale)))

(make-omn :pitch (loop repeat 20 collect (rnd-sample-seq (rnd-pick '(11 17 29)) seq))
:length (pick-norepeat 20 '(t t. s  -t. -t))
:span :pitch))```

### play polytempo -> code/examples

great, that it works fine now!

greetings

andré

### ps & def-instrument-set

halleluja!!!  thanks!!!!

### play polytempo -> code/examples

POLYTEMPO:

here is an easy solution to play POLYTEMPO-textures in OPMO

in every "play-tempo-stream" you can write for 4 instruments... then put it in (progn...  // then choose different tempos and PLAY it

greetings

andré

p.s. if you want to do it like CONLON then write a list with tempos/beats in :tempo-curve

... example: "tempoverlauf per BEAT"

```;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;; damit kannst du einfach dann OMN's eingeben, pro tempo-stream 4 instrumente und dann abspielen,
;; streams überlagernd abspielen

(defun play-tempo-stream (&key (inst1 nil)
(inst2 nil)
(inst3 nil)
(inst4 nil)
(port 0)
(tempo-curve 60))

(def-score stream
(:key-signature 'chromatic
:time-signature (get-time-signature (omn-to-time-signature inst1 '(1 4)))
:tempo tempo-curve
:layout (list
(bracket-group
(treble-layout 'inst1)
(treble-layout 'inst2)
(treble-layout 'inst3)
(treble-layout 'inst4))))

(inst1 :omn inst1
:port port
:channel 1
:pan 20)

(inst2 :omn inst2
:port port
:channel 2
:pan 20)

(inst3 :omn inst3
:port port
:channel 3
:pan 20)

(inst4 :omn inst4
:port port
:channel 4
:pan 20))

(score-player 'stream))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;; some "random omn" to play

(setf p1 '(q d4 pp s eb4 < leg g4 < leg bb4 < leg a4 q. cs5 mf -e
3q gs5 > leg fs5 > leg c5 > b4 > leg f4 leg e4))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;; 3 streams mit je 3 instrumenten
;; konstantes tempo

(progn
(play-tempo-stream :inst1 p1
:inst2 p1
:tempo-curve 30
:port 0)

(play-tempo-stream :inst1 (pitch-transpose 11 p1)
:inst2 (pitch-transpose 12 p1)
:tempo-curve 50
:port 0)

(play-tempo-stream :inst1 (pitch-transpose -11 p1)
:inst2 (pitch-transpose -12 p1)
:tempo-curve 70
:port 0))

;;; tempoverlauf per BEAT

(progn
(play-tempo-stream :inst1 p1
:inst2 p1
:tempo-curve '((100 1) (160 1) (172 1)) ;; tempo per beat
:port 0)

(play-tempo-stream :inst1 (pitch-transpose 11 p1)
:inst2 (pitch-transpose 12 p1)
:tempo-curve '((122 1) (177 1) (201 1)) ;; tempo per beat
:port 0)

(play-tempo-stream :inst1 (pitch-transpose -11 p1)
:inst2 (pitch-transpose -12 p1)
:tempo-curve '((63 1) (62 1) (67 1))  ;; tempo per beat
:port 0))

```

### ps & def-instrument-set

thanx to all, but the problem is not solved, try?!

```

(def-instrument-set group1
:instruments
(:group group1
:trumpet
(:layout trumpet-layout
:port 0
:channel 1
:pan (pan 0)
:volume 92)

:piano
(:layout piano-grand-layout
:port 0
:channel 2
:pan (pan 10)
:volume 92)

:sine
(:layout treble-layout
:port 0
:channel 3
:pan (pan -10)
:volume 92)

:noise
(:layout treble-layout
:port 0
:channel 4
:pan (pan -5)
:volume 92)))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(setf
p1 '(q d4 pp s eb4 < leg g4 < leg bb4 < leg a4 q. cs5 mf -e
3q gs5 > leg fs5 > leg c5 > b4 > leg f4 leg e4))

(ps 'group1
:trumpet p1
:tempo '((88 1) (89 1) (100 1))
:time-signature '(1 4 10))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;```

### ps & def-instrument-set

why does the trumpet and the piano part both "sended" and displayed as "trumpet", played only on channel 1 ?

i do not understand what's my mistake...

thanx for some help

```(def-instrument-set group1
:instruments
(:group group1
:trumpet
(:layout trumpet-layout
:port 0
:channel 1
:sound 'gm-trumpet
:pan (pan 0)
:volume 92)

:piano
(:layout piano-layout
:port 0
:channel 2
:sound 'gm-piano
:pan (pan 10)
:volume 92)

:sine
(:layout treble-layout
:port 0
:channel 2
:sound 'gm
:controllers nil
:pan (pan -10)
:volume 92)

:noise
(:layout treble-layout
:port 0
:channel 2
:sound 'gm
:controllers nil
:pan (pan -5)
:volume 92)))

(midi-destinations)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(setf
p1 '(q d4 pp s eb4 < leg g4 < leg bb4 < leg a4 q. cs5 mf -e
3q gs5 > leg fs5 > leg c5 > b4 > leg f4 leg e4))

(ps 'group1
:trumpet p1

:output :midi
:tempo '((88 1) (89 1) (100 1))
:time-signature '(1 4 10))```

### convert-to-binary

ANTON WEBERN - Variationen für Klavier Op.27, I

converted into BINARY INFORMATION // "Verdoppelung der Welt" //

(inspired by Armin Nassehi's Book  "Muster - Theorie der digitalten Gesellschaft")

### error / merge-voices

but happend again   the solution is to quit/start OPMO - but not a big problem, i'm happy...

### convert-to-binary

this little CONCEPTUAL project goes on:

converting "something" (musical paramters in this case) into a binary form and reconvert it (binary back into musical parameters) => like kind of A/D-D/A-converters and have a look how "the reality is different/changing", experimenting with mapping/resolution etc... i don't think primarily musically with this work but more technically and see what results from that.

```;;; SUB

(defun fill-to-x-bit (listseq &key (bitlength 7))
(loop for i in listseq
when (< (length i) bitlength)
collect (append (gen-repeat (- bitlength (length i)) 0) i)
else collect i))

(defun length/rest-to-binary (alist)
(loop for i in alist
when (length-restp i)
collect 0 else collect 1))

;;;; CONVERTING PITCH/LENGTH or VELOCITY TO BINARY INFORMATION

(defun convert-to-binary (alist &key (parameter 'pitch) (lengthspan '(24 100)) (velocity-resolution 127) (pitch-resolution 127) (bitlength 7))
(let (
(alist (progn
(setf alist (cond ((stringp alist)
(flatten (midi-to-omn alist :instrument 1)))
(t alist)))

(if (omn-formp alist)
(cond ((equal parameter 'pitch)
(setf alist (omn :pitch alist)))
((equal parameter 'length)
(setf alist (omn :length alist)))
((equal parameter 'velocity)
(setf alist (omn :velocity alist))))
alist))))

(cond ((pitchp (car alist))
(progn
(setf alist  (pitch-to-midi (pitch-melodize alist)))
(fill-to-x-bit (decimal-to-binary (vector-round 1 (if (null pitch-resolution)
(- (find-max alist) (find-min alist))
pitch-resolution) alist)) :bitlength bitlength)))

((lengthp (car alist))
(fill-to-x-bit (decimal-to-binary
(vector-round (car lengthspan) (cadr lengthspan) (mapcar 'float (omn :length alist)))) :bitlength bitlength))

((velocityp (car alist))
(fill-to-x-bit (decimal-to-binary
(vector-round 1 velocity-resolution (get-velocity  alist))) :bitlength bitlength)))))

;;;; CONVERTING BINARY INFORMATION BACK TO OMN

(defun convert-to-omn (binlist &key (parameter 'pitch) (lengthspan '4/4) (length/rest nil) (velocityspan '(pppp ffff))
(pitchspan '(c3 c5)) (bitlength 8))
(let ((binlist (gen-divide bitlength (flatten binlist))))

(cond ((equal parameter 'pitch)
(midi-to-pitch (vector-round (car (pitch-to-midi pitchspan)) (cadr (pitch-to-midi pitchspan)) (binary-to-decimal binlist))))
((equal parameter 'length)
(if (null length/rest)
(gen-length-constant (binary-to-decimal binlist) lengthspan)
(loop
for i in (gen-length-constant (binary-to-decimal binlist) lengthspan)
for j in length/rest
when (= j 0) collect (* i -1) else collect i)))

((equal parameter 'velocity)
(vector-to-velocity (car (get-velocity (list (car velocityspan))))
(loop for i in  (binary-to-decimal binlist)
collect (* i (float (/ 1 (sum (binary-to-decimal binlist)))))))))))
```

evaluate here and you see the original and reconverted SAMPLE

```

;;; SOME EXAMPLES OF THE PROCESS SEQ to BINARY, THEN MAPPED BACK TO OMN
;;; IF THE BITLENGTHS ARE DIFFERENT YOU GET DIFFERENT RESulTS
;;; ALSO DIFFERENT RESULTS WITH VELOCITY / LENGTHS => it depends on RESOLUTION etc...

;; cmd-E or cmd-1

(pitch-list-plot
(list
(setf seq '(c4 cs5 fs3 c5 f5) );; original
(convert-to-omn (convert-to-binary seq :bitlength 32) ;; reconverted
:bitlength 32
:pitchspan (get-ambitus seq :type :pitch)))

:join-points t)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(length-list-plot
(list
(setf seq '(-e e -q h e)) ;; original

(convert-to-omn (convert-to-binary seq :bitlength 32) ;; reconverted
:parameter 'length
:length/rest (length/rest-to-binary seq)
:bitlength 32
:lengthspan '4/4))
:join-points t)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(velocity-list-plot
(list
(setf seq '(p p ffff mp )) ;; original
(convert-to-omn (convert-to-binary seq :bitlength 32) ;; reconverted
:parameter 'velocity
:bitlength 32
:velocityspan '(ppp mf)))

:join-points t)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

```

### error / merge-voices

i restarted opusmodus and now it works

### error / merge-voices

also this do not work

```(setf voice1 '(-d_whs s f4 ppp g4 e4 fs4 e4 fs4 fs4 -d_whs s d4 eb4 -e s d4 - e4 -d_whs s d4 eb4 -e s d4 - e4 -d_whs s cs4 g4 - fs4 e4 d4 fs4 -d_whs s fs4 g4 e4 e4 fs4 e4 e4 -d_whs s eb4 eb4 cs4 cs4 eb4 cs4 f4 -d_whs s f4 f4 fs4 fs4 e4 e4 e4 -d_whs s d4 eb4 -e s d4 - e4 -d_whs s f4 f4 g4 g4 f4 f4 f4 -d_whs s d4 d4 -e s d4 - f4 -d_whs s e4 g4 fs4 fs4 fs4 fs4 e4 -d_whs s eb4 eb4 cs4 cs4 eb4 cs4 f4 -d_whs s d4 g4 - e4 fs4 - e4 -d_whs s f4 g4 fs4 fs4 fs4 fs4 e4 -d_whs s d4 eb4 -e s d4 - e4))

(omn-to-time-signature voice1 '(4 4))

> Error: There is no applicable method for the generic function:
>          #<standard-generic-function omn-symbol #x3020009144EF>
>        when called with arguments:
>          (nil)
> While executing: #<ccl::standard-kernel-method no-applicable-method (t)>, in process Listener-2(8).
> Type cmd-/ to continue, cmd-. to abort, cmd-\ for a list of available restarts.
> If continued: Try calling it again
> Type :? for other options.```

### error / merge-voices

it's not working on my system

### error / merge-voices

why does the MERGE-VOICES not work with this two voices? (voices are with  MAKE-OMN, no problem to display as "single voices")

thanx for help

andré

```
(setf voice1 '(-d_whs s f4 ppp g4 e4 fs4 e4 fs4 fs4 -d_whs s d4 eb4 -e s d4 - e4 -d_whs s d4 eb4 -e s d4 - e4 -d_whs s cs4 g4 - fs4 e4 d4 fs4 -d_whs s fs4 g4 e4 e4 fs4 e4 e4 -d_whs s eb4 eb4 cs4 cs4 eb4 cs4 f4 -d_whs s f4 f4 fs4 fs4 e4 e4 e4 -d_whs s d4 eb4 -e s d4 - e4 -d_whs s f4 f4 g4 g4 f4 f4 f4 -d_whs s d4 d4 -e s d4 - f4 -d_whs s e4 g4 fs4 fs4 fs4 fs4 e4 -d_whs s eb4 eb4 cs4 cs4 eb4 cs4 f4 -d_whs s d4 g4 - e4 fs4 - e4 -d_whs s f4 g4 fs4 fs4 fs4 fs4 e4 -d_whs s d4 eb4 -e s d4 - e4))

(setf voice2 '(-d_whs s fs3 ppp e3 g3 f3 g3 f3 f3 -d_whs s a3 gs3 -e s a3 - g3 -d_whs s a3 gs3 -e s a3 - g3 -d_whs s bb3 e3 - f3 g3 a3 f3 -d_whs s f3 e3 g3 g3 f3 g3 g3 -d_whs s gs3 gs3 bb3 bb3 gs3 bb3 fs3 -d_whs s fs3 fs3 f3 f3 g3 g3 g3 -d_whs s a3 gs3 -e s a3 - g3 -d_whs s fs3 fs3 e3 e3 fs3 fs3 fs3 -d_whs s a3 a3 -e s a3 - fs3 -d_whs s g3 e3 f3 f3 f3 f3 g3 -d_whs s gs3 gs3 bb3 bb3 gs3 bb3 fs3 -d_whs s a3 e3 - g3 f3 - g3 -d_whs s fs3 e3 f3 f3 f3 f3 g3 -d_whs s a3 gs3 -e s a3 - g3))

(merge-voices voice2 voice2)

> Error: There is no applicable method for the generic function:
>          #<standard-generic-function omn-symbol #x3020009144EF>
>        when called with arguments:
>          (nil)
> While executing: #<ccl::standard-kernel-method no-applicable-method (t)>, in process Listener-2(8).
> Type cmd-/ to continue, cmd-. to abort, cmd-\ for a list of available restarts.
> If continued: Try calling it again
> Type :? for other options.```

### tempo as FLOAT

it would be very interesting to work with that!

also with the "chromatische Temposkala" by Stockhausen ...as EXTENSION for all your row/serialism-functions

### tempo as FLOAT

i like to simulate parts with individual tempo curves (each instrument has its own tempo progession) and calculated "meeting-points". for that you will need INTEGERS. i wrote some pieces with with tempopolyphonic approaches - but i would like to simulate it with OPMO

---

the software for REALTIME-conducting (PolytempoNetwork) and PolytempoComposer is here:  https://polytempo.zhdk.ch

PolytempoComposer:

"The application PolytempoComposer allows to explore, sketch and organise complex tempo structures. It is a tool to calculate the exact time of every beat in a constant or variable tempo. Furthermore, it enables composers to find or adjust synchronisation points between voices in different tempos. Due to the graphical user interface, composers can manipulate the parameters of a complex tempo polyphony without any in-depth mathematical knowledge."

---

in this video (was for something else: i'm sending new tempo curves data from OPMO to the conductingAPP (still without sheet music - only the conducting)) you can see how to manipulate tempo curves so that the end of the phrase is always at second 15. and how to reach a meeting point (e.g. T2 on 1) within the tempo curve at a different point in time. this can be calculated using the POLYTEMPO-COMPOSER app, output/saved as lisp format and then imported and conducted (by the APP). I would like to hear that and simulate it in advance on OPMO. I've already programmed it appropriately (to generate a SCORE with these tempo curves), but the ERROR is always because of float tempos. without float you won't create any usable polytempo structures on OPMO. if you round, the timepoints are of course no longer correct.

×
• #### Browser

• Video Gallery

• Lessons