;; piece for Corey et. al.

(load "tiling.lisp")
(load "selfsim.lisp")
(load "modes.lisp")
(load "spacegrp.lisp")
(load "nondet.lisp")
(load "tonnetz.lisp")

;; load all these in

(defun mydiff (x)
  (cond ((= x 0) 1)
	((= x 1) 1)
	(t (- (mod (* x x) 5) (* (mydiff (- x 1)) 
				 (mod (mydiff (- x 2)) 3))))))

(defun diffs (start end)
  (loop for y from start to end collect (mydiff y)))

(define difcyc '(1 -1 2 0 4 1))

(define difcyc2
  (flatten (loop for x in difcyc collect (transp difcyc x))))

(define difcyc3
  (flatten (loop for x in difcyc collect (transp difcyc2 x))))

(define difcyc4
  (flatten (loop for x in difcyc collect (transp difcyc3 x))))

(define lin3 (line-from-mels 12 difcyc3))

(define linreg3 (placereg lin3 following-5 12 12))

;;;;; one thing

(define linex 
  (play-mode 
   (melint->line 30 (diffs 0 11)) stravmode))
;; = (50 52 53 58 60 62 60 63 63 70 72 70 73)

(define subx (shuffle (subsequences linex 3)))

(define mt-b
  (process 
    for x in (consmatch (transp linex -12) (consmatch linex (transp linex 12)))
    for dur = (* .25 (pick 1 2)) 
    when (or (numberp x) (listp x));; needed for rests
    output (multievent 'midi :keynum
                       :keynum x
                       :time (now)
                       :duration dur)
    wait dur))

(events mt-b "mt-b.midi")

;; mt-b1a

(define d2ctr (take-contour difcyc2))

(define mtb1pits
  (make-poly  
   (flatten (subsequences (play-mode (transp d2ctr 30) stravmode) 10)) 
   (strums 7 2 2 3 6)))

(define mtb1more
  (consmatch
   (tintab (transp d2ctr 62) stravmode) mtb1pits))

(define mt-b1a
  (process 
    for x in mtb1more
    for dur = (* .25 (if (or (numberp x) (< (length x) 2)) 1 (length x)))
    when (or (numberp x) (listp x));; needed for rests
    output (multievent 'midi :keynum
                       :keynum x
                       :time (now)
                       :duration dur)
    wait dur))

(events mt-b1a "mt-b1a.midi")

;;;; mt-b1b

(define mtb1more2
  (trimatch 
   (play-mode (transp d2ctr 20) ionian)
   (consmatch
    (copylist (tintab (transp d2ctr 74) ionian) 2) mtb1pits)
   '(0 4 7)))

(define mt-b1b
  (process 
    for x in mtb1more2
    for dur = (* .25 (if (or (numberp x) (< (length x) 2)) 1 (length x)))
    when (or (numberp x) (listp x));; needed for rests
    output (multievent 'midi :keynum
                       :keynum x
                       :time (now)
                       :duration dur)
    wait dur))

(events mt-b1b "mt-b1b.midi")


;; mt-b2
(define linex2
  (play-mode 
   (melint->line 30 (diffs 0 11)) hyperphrygian))

(define subx2 (shuffle (subsequences linex2 3)))

(define mt-b2
  (process 
    for x in (consmatch 
              (transp linex2 -12) (consmatch linex (transp linex2 12)))
    for dur = (* .25 (pick 1 2)) 
    when (or (numberp x) (listp x));; needed for rests
    output (multievent 'midi :keynum
                       :keynum x
                       :time (now)
                       :duration dur)
    wait dur))


;; store them in a midi file
(events mt-b2 "mt-b2.midi")


;; mt-b3
(define linex3
  (play-mode 
   (melint->line 30 (diffs 0 11)) hyperphrygian))

(define subx3 (flatten (shuffle (subsequences linex3 5))))

(define b3-matcher (transp subx3 15))

(define b3tin (layout .3 (transp (tintab b3-matcher ionian) -5)))
(define b3tin2 
  (let ((basic (transp (tintab b3-matcher stravmode) -10)))
    (loop for x from 0 to (- (length basic) 1) collect
          (if (= 0 (mod x 7)) (nth x basic) 'r))))

(define b3merg (merge-slots (list b3-matcher b3tin b3tin2)))

(define mt-b3
  (process 
    for x in b3merg
    for dur = (* .25 (if (numberp x) 1 2))
    when (or (numberp x) (listp x));; needed for rests
    output (multievent 'midi :keynum
                       :keynum x
                       :time (now)
                       :duration dur)
    wait dur))


;; store them in a midi file
(events mt-b3 "mt-b3.midi")

;; mt-b4


(define linex4
  (play-mode (transp difcyc3 25) hyperphrygian))

(define subx4 (flatten (shuffle (subsequences linex4 3))))

(define b4-matcher (transp subx4 15))

(define b4tin (layout .3 (transp (tintab b4-matcher ionian) 7)))
(define b4tin2 
  (let ((basic (transp (tintab b4-matcher stravmode) -17)))
    (loop for x from 0 to (- (length basic) 1) collect
          (if (= 0 (mod x 7)) (nth x basic) 'r))))

(define b4merg (merge-slots (list b4-matcher b4tin b4tin2)))

(define mt-b4
  (process 
    for x in (myhand b4merg 3 16)
    for dur = (* .25 (if (numberp x) 1 2))
    when (or (numberp x) (listp x));; needed for rests
    output (multievent 'midi :keynum
                       :keynum x
                       :time (now)
                       :duration dur)
    wait dur))


;; store them in a midi file
(events mt-b4 "mt-b4.midi")

;; mt-c
(define liney
  (play-mode 
   (melint->line 30 (diffs 7 20)) hyperlydian))
(define suby (shuffle (subsequences liney 3)))

(define mtc-pitcyc (makecyc (make-poly (flatten suby) '(1 2 1 1 3))))

(define mtc-durcyc (makecyc (ferney '(1) '(2 2 3) (strums 7 2 3 5 8))))

(define mt-c
  (process 
    repeat 300
    for x = (next mtc-pitcyc)
    for dur = (next mtc-durcyc)
    when (or (numberp x) (listp x));; needed for rests
    output (multievent 'midi :keynum
                       :keynum x
                       :time (now)
                       :duration dur)
    wait dur))

;; store them in a midi file
(events mt-c "mt-c.midi")
;; 

;; mt-c2
;; a variation on "mt-c"
(define mt-poly (make-poly (flatten suby) '(1 1 2 1 1 1 3)))

(define mtc-tt
  (transp (layout .3 (tintab (bottomline mt-poly) stravmode)) -17))

(define liney2 (merge-slots (list mtc-tt mt-poly)))

(define mtc2-pcyc (makecyc liney2))
(define mtc2-dcyc (makecyc (ferney '(1) '(2 2 3) (strums 6 2 3 5 8))))

(define mt-c2
  (process 
    repeat 300
    for x = (next mtc2-pcyc)
    for dur = (next mtc2-dcyc)
    when (or (numberp x) (listp x));; needed for rests
    output (multievent 'midi :keynum
                       :keynum x
                       :time (now)
                       :duration dur)
    wait dur))

;; store them in a midi file
; (events mt-c2 "mt-c2.midi")
;; 

; mt-c3 

(define mtc3-pcyc (makecyc liney2))
(define mtc3-dcyc (makecyc (ferney '(1) '(2 3 3 3 3) (strums 6 2 3 5 8))))

(define mt3strums (strums 6 2 3 5 8))

(define (mt-c3 mens)
  (let ((durcyc (makecyc (ferney mens '(2 2 3) mt3strums))))
    (process 
      repeat 300
      for x = (next mtc3-pcyc)
      for dur = (next durcyc)
      when (or (numberp x) (listp x));; needed for rests
      output (multievent 'midi :keynum
                         :keynum x
                         :time (now)
                         :duration dur)
      wait dur)))


(events (list (mt-c3 1) (mt-c3 2)) "mt-c3.midi")


;; mt-c3b
(define (mt-c3b mens)
  (let ((durcyc (makecyc (ferney mens '(2 3 3 3) mt3strums))))
    (process 
      repeat 300
      for x = (next mtc3-pcyc)
      for dur = (next durcyc)
      when (or (numberp x) (listp x));; needed for rests
      output (multievent 'midi :keynum
                         :keynum x
                         :time (now)
                         :duration dur)
      wait dur)))


(events (list (mt-c3b 1) (mt-c3b 2)) "mt-c3b.midi")


;; mt-c4
(define mt-poly4 (make-poly (flatten suby) '(1 1 2 1 1 1 2 3)))

(define mtc-tt
  (transp (layout .3 (tintab (bottomline mt-poly4) stravmode)) -19))

(define mtc-ttb
  (transp (layout .2 (tintab (topline mt-poly) stravmode)) +7))


(define liney4 (merge-slots (list mtc-tt mt-poly mtc-ttb)))

(define mtc4-pcyc (makecyc liney4))

(define (mt-c4 mens)
  (let ((durcyc (makecyc (ferney mens '(2 3 3 3 3)))))
    (process 
      repeat 300
      for x = (next mtc4-pcyc)
      for dur = (next durcyc)
      when (or (numberp x) (listp x));; needed for rests
      output (multievent 'midi :keynum
                         :keynum x
                         :time (now)
                         :duration dur)
      wait dur)))

(events (list (mt-c4 1) (mt-c4 2)) "mt-c4.midi" '(0 1))

;; somethin' else

(define diffs3 (diffs 15 25))

(define d3strav (transp (stravrot (melint->line 20 diffs3)) 30))

(define d3poly
  (merge-slots (list
                (myhand d3strav 2 10)
                (layout .2 (transp d3strav 31))
                (layout .2 (transp (tintab d3strav ionian) 24)))))

(define mt-d
  (process 
    for x in d3poly
    for dur = .25
    when (or (numberp x) (listp x));; needed for rests
    output (multievent 'midi :keynum
                       :keynum x
                       :time (now)
                       :duration dur)
    wait dur))

;; store them in a midi file
(events mt-d "mt-d.midi")


;; .. and a variation
(define d3stravb (transp (stravrot (melint->line 20 diffs3)) 60))

(define d3poly
  (merge-slots (list
                (myhand d3stravb 2 -10)
                (layout .2 (transp d3stravb -11))
                (layout .2 (transp (tintab d3stravb ionian) -17)))))

(define mt-d2
  (process 
    for x in d3poly
    for dur = .25
    when (or (numberp x) (listp x));; needed for rests
    output (multievent 'midi :keynum
                       :keynum x
                       :time (now)
                       :duration dur)
    wait dur))

;; store them in a midi file
(events mt-d2 "mt-d2.midi")

;; third variation

(define d3s-cont (take-contour d3strav)) ; 10 items

(define d3s-arpegg (transp 
                    (flatten 
                     (loop for x in (transp d3s-cont 2 #'*) collect
                           (chd-inversion 
                            (pick '(0 2 3 5) '(0 2 3)) x 6))) 40))

(define f3cyc (new cycle of (ferney '(1) '(6 6 6 6 4))))

(define mt-d3
  (process 
    for x in d3s-arpegg
    for dur = (next f3cyc)
    when (or (numberp x) (listp x));; needed for rests
    output (multievent 'midi :keynum
                       :keynum x
                       :time (now)
                       :duration dur)
    wait dur))

;; store them in a midi file
(events mt-d3 "mt-d3.midi")


;; 

(define f3cycb (makecyc (ferney '(1) '(6 6 6 6 4) '(4 5 4 6))))

; (subsequences (melint->line 60 (diffs 0 7)) 3)
;  ((60 61 62) (61 62 65) (62 65 66) (65 66 67) 
; (66 67 66) (67 66 68) (66 68 68))

; a = (tzrandchain '(61 62 65) 30)
; b & c = (tzrandchain '(62 65 66) 30)

(define mt-d4
  (process 
    for x in (tzrandchain '(62 65 66) 250)
    for dur = (next f3cycb)
    when (or (numberp x) (listp x));; needed for rests
    output (multievent 'midi :keynum
                       :keynum x
                       :time (now)
                       :duration dur)
    wait dur))

;; store them in a midi file
(events mt-d4 "mt-d4c.midi")

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

; (diffs 0 15) = (1 1 3 1 1 -1 2 0 4 1 -1 2 0 4 1 -1)



;; as chords
(define md-reg
  (process 
    for x in (make-poly linreg3 (transp (randmel 100 3) 1))
    for dur = (* .25 (if (numberp x) 1 (length x)))
    when (or (numberp x) (listp x));; needed for rests
    output (multievent 'midi :keynum
                       :keynum x
                       :time (now)
                       :duration dur)
    wait dur))

;; store them in a midi file
(events md-reg "md-reg.midi")


(define ferndcyc (new cycle of (ferney '(1) '(4 5))))

;; as arpeggiation
(define md-arpeg
  (process 
    for x in (arpegg linreg3 '(2 3) '(4 2))
    for dur = (next ferndcyc)
    when (or (numberp x) (listp x));; needed for rests
    output (multievent 'midi :keynum
                       :keynum x
                       :time (now)
                       :duration dur)
    wait dur))

;; store them in a midi file
(events md-arpeg "md-arpeg.midi")

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

(define mdwig-pits (placereg difcyc2 (new random of '(2 3 4))))
(define mdwig-durs (loop repeat 36 collect (+ 5 (random 8))))
(define mywig (wigline mdwig-pits mdwig-durs '(-1 2)))

(define (mdwig xlist ylist) 
  (process 
    for x in xlist
    for y in ylist
    for dur = (* y .25)
    when (or (numberp x) (listp x));; needed for rests
    output (multievent 'midi :keynum
                       :keynum x
                       :time (now)
                       :duration dur)
    wait dur))

;; store them in a midi file
(events (list
         (mdwig (play-mode (line-from-mels 40 difcyc2) stravmode) mdwig-durs)
         (mdwig (play-mode (line-from-mels 30 difcyc2) ionian) mdwig-durs)
         (mdwig (first mywig) (second mywig)))
        "mdwig.midi")

(events (list
         (mdwig (play-mode (line-from-mels 25 difcyc2) stravmode) mdwig-durs)
         (mdwig (play-mode (line-from-mels 35 difcyc2) ionian) mdwig-durs)
         (mdwig (transp (first mywig) 30) (second mywig)))
        "mdwig2.midi")

;; more mdwig

(define mdwig-pits3 (placereg difcyc2 (new heap of '(2 3 4))))
(define mdwig-durs3 (loop repeat 36 collect (+ 5 (random 8))))
(define mywig3 (wigline mdwig-pits3 mdwig-durs3 '(-5 4)))

(define wigf (ferney '(1) '(4 4 3 4 3) (strums 100 1 1 7 10)))

(define (mdwig3 xlist ylist) 
  (process 
    for x in xlist
    for y in ylist
    for f in wigf
    for dur in (sum-across wigf ylist)
    when (or (numberp x) (listp x));; needed for rests
    output (multievent 'midi :keynum
                       :keynum x
                       :time (now)
                       :duration dur)
    wait dur))

;; store them in a midi file
(events (list
         (mdwig3 (play-mode (line-from-mels 25 difcyc2) stravmode) mdwig-durs3)
         (mdwig3 (play-mode (line-from-mels 35 difcyc2) ionian) mdwig-durs3)
         (mdwig3 (transp (first mywig3) 30) (second mywig3)))
        "mdwig3.midi")

(events (list
         (mdwig3 (play-mode (line-from-mels 25 difcyc2) stravmode) mdwig-durs3)
         (mdwig3 (play-mode (line-from-mels 33 difcyc2) hyperphrygian) mdwig-durs3)
         (mdwig3 (play-mode (line-from-mels 37 difcyc2) hyperphrygian) mdwig-durs3)
         (mdwig3 (transp (first mywig3) 20) (second mywig3)))
        "mdwig3b.midi")

;;;;;;;;;;;

(define mdwig-pits4 (placereg difcyc2 (new heap of '(2 3 4 5))))
(define mdwig-durs4 (loop repeat 36 collect (+ 5 (random 6))))
(define mywig4a (wigline mdwig-pits4 mdwig-durs4 '(-5 4)))
(define mywig4b (wigline mdwig-pits4 mdwig-durs4 '(-3 4)))

(define wigf2 (ferney '(1) '(4 4 4 3 3 4 3) (strums 100 1 1 7 10)))

(define (mdwig4 xlist ylist) 
  (process 
    for x in xlist
    for y in ylist
    for f in wigf2
    for dur in (sum-across wigf ylist)
    when (or (numberp x) (listp x));; needed for rests
    output (multievent 'midi :keynum
                       :keynum x
                       :time (now)
                       :duration dur)
    wait dur))

(events (list
         (mdwig4 (play-mode (line-from-mels 25 difcyc2) stravmode) mdwig-durs4)
         (mdwig4 (play-mode (line-from-mels 33 difcyc2) stravmode) mdwig-durs4)
;         (mdwig4 (play-mode (line-from-mels 37 difcyc2) hyperphrygian) mdwig-durs4)
         (mdwig4 (transp (first mywig4a) 10) (second mywig4a))
         (mdwig4 (transp (first mywig4b) 25) (second mywig4b)))
        "mdwig4.midi")

(events (list
         (mdwig4 (play-mode (line-from-mels 25 difcyc2) stravmode) mdwig-durs4)
         (mdwig4 (play-mode (line-from-mels 33 difcyc2) stravmode) mdwig-durs4)
;         (mdwig4 (play-mode (line-from-mels 37 difcyc2) hyperphrygian) mdwig-durs4)
         (mdwig4 (tintab (transp (first mywig4a) 10) stravmode) (second mywig4a))
         (mdwig4 (transp (first mywig4b) 25) (second mywig4b)))
        "mdwig4b.midi")

;;;;;;;;;;

(define d4mark (markov-analyze difcyc4))


(define (mdmark modename startpit)
      (process 
        for x = (car (play-mode (list (next d4mark)) modename startpit))
        for y in (sum-across (ferney '(1 1.5) '(2 2 3)) (strums 100 1 2 4 5))
        for dur = y
        when (or (numberp x) (listp x));; needed for rests
        output (multievent 'midi :keynum
                           :keynum x
                           :time (now)
                           :duration dur)
        wait dur))

(events (list 
         (mdmark stravmode 21)
         (mdmark stravmode 29)
         (mdmark stravmode 37)
         (mdmark stravmode 41))
        "mdmark1.midi")


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

(define d3mark (markov-analyze (transp-to 0 lin3)))

(define d3markmel (play-mode (next d3mark 100) hyperphrygian 34))

(define mdmarksolo
      (process 
        for x in d3markmel
        for y in (sum-across (ferney '(1 1.5) '(2 2 3)) (strums 100 1 2 4 5))
        for dur = y
        when (or (numberp x) (listp x));; needed for rests
        output (multievent 'midi :keynum
                           :keynum x
                           :time (now)
                           :duration dur)
        wait dur))

(events mdmarksolo "mdmarksolo.midi")


;;; 

(define md2base (ferney '(1 1.5) '(2 2 3)))
(define md2durs1 (sum-across md2base (strums 100 1 2 4 5)))
(define md2durs2 (sum-across md2base (transp (strums 30 1 2 4 5) 3)))
(define md2durs3 (sum-across md2base (strums 100 2 4 3 5)))

(define (mdmark2 modename startpit partdurs)
      (process 
        for x = (car (play-mode (list (next d3mark)) modename startpit))
        for y in partdurs
        for dur = y
        when (or (numberp x) (listp x));; needed for rests
        output (multievent 'midi :keynum
                           :keynum x
                           :time (now)
                           :duration dur)
        wait dur))

(events (list
         (mdmark2 hyperphrygian 37 md2durs1)
         (mdmark2 ionian 26 md2durs2)
         (mdmark2 octatonic 35 md2durs2)
         (mdmark2 octatonic 32 md2durs2))
        "mdmark2.midi")

(events (list
         (mdmark2 hyperphrygian 37 md2durs1)
         (mdmark2 hyperphrygian 30 md2durs3) ; trombone
         (mdmark2 ionian 26 md2durs2)
         (mdmark2 ionian 45 md2durs2)
         (mdmark2 octatonic 52 md2durs2))
        "mdmark3.midi")

;;; mdmark4

(define fracstrums 
  (loop for x in (strums 4 2 2 3 10) collect
        (if (eql x 2) 1.5 1)))

(define divstrums (transp (strums 6 2 2 2 6) 1))

(define md4base (ferney fracstrums divstrums))
(define md4durs1 (sum-across md4base (strums 100 1 2 4 5)))
(define md4durs2 (sum-across md4base (transp (strums 30 1 2 4 5) 3)))
(define md4durs3 (sum-across md4base (strums 100 2 4 3 5)))

(define (mdmark4 modename startpit partdurs)
      (process 
        for x = (car (play-mode (list (next d3mark)) modename startpit))
        for y in partdurs
        for dur = y
        when (or (numberp x) (listp x));; needed for rests
        output (multievent 'midi :keynum
                           :keynum x
                           :time (now)
                           :duration dur)
        wait dur))

(events (list
         (mdmark4 hyperphrygian 37 md4durs1)
         (mdmark4 hyperphrygian 30 md4durs3) ; trombone
         (mdmark4 ionian 26 md4durs2)
         (mdmark4 ionian 45 md4durs2)
         (mdmark4 octatonic 52 md4durs2))
        "mdmark4.midi")

;;;;;;; 

(define md5base (ferney fracstrums divstrums))
(define md5durs1 (sum-across md5base (strums 100 2 2 2 4)))
(define md5durs2 (sum-across md5base (transp (strums 30 2 2 4 5) 2)))
(define md5durs3 (sum-across md5base (strums 100 2 3 3 5)))

(define (mdmark5 modename startpit partdurs tindex)
  (process 
    for x = (transp 
             (car (play-mode (list (next d3mark)) modename startpit))
             tindex)
    for y in partdurs
    for dur = y
    when (or (numberp x) (listp x));; needed for rests
    output (multievent 'midi :keynum
                       :keynum x
                       :time (now)
                       :duration dur)
    wait dur))

(events (list
         (mdmark5 hyperphrygian 37 md5durs1 0)
         (mdmark5 hyperphrygian 40 md5durs1 0)
         (mdmark5 hyperphrygian 30 md5durs3 0) ; trombone
         (mdmark5 ionian 26 md5durs2 0)
         (mdmark5 ionian 45 md5durs2 0)
         (mdmark5 octatonic 52 md5durs2 0))
        "mdmark5.midi")

;;; 
;;; mdmark6

(define fracstrums 
  (loop for x in (strums 4 2 2 3 10) collect
        (if (eql x 2) 1.5 1)))

(define divstrums (transp (strums 6 2 2 2 6) 1))

; (define md6base (copylist (ferney '(1 1 1 1 1 1.5) '(2 2 2 2 3)) 10))
(define md6base (copylist (ferney '(1) '(2 2 3 4 3)) 50))

(define md6durs1 (sum-across md6base (strums 100 1 2 4 5)))
(define md6durs2 (sum-across md6base (transp (strums 30 1 2 4 5) 3)))
(define md6durs3 (sum-across md6base (strums 100 2 4 3 5)))



(define (mdmark6 modename startpit partdurs)
      (process 
        for x = (car (play-mode (list (next d3mark)) modename startpit))
        for y in partdurs
        for dur = y
        when (or (numberp x) (listp x));; needed for rests
        output (multievent 'midi :keynum
                           :keynum x
                           :time (now)
                           :duration dur)
        wait dur))

(events (list
         (mdmark6 hyperphrygian 37 md6durs1)
         (mdmark6 hyperphrygian 30 md6durs3) ; trombone
         (mdmark6 ionian 26 md6durs2)
         (mdmark6 ionian 45 md6durs2)
         (mdmark6 octatonic 52 md6durs2))
        "mdmark6.midi" '(0 1 2 1 0))

(define md6baseb (copylist (ferney '(1) '(3 3 3 3 4)) 50))

(define md6durs1b (sum-across md6baseb (copylist '(2 1) 100)))
(define md6durs2b (sum-across md6baseb (copylist '(3 1) 100)))
(define md6durs3b (sum-across md6baseb (copylist '(3 2) 100)))

(events (list
         (mdmark6 hyperphrygian 37 md6durs1b)
         (mdmark6 hyperphrygian 30 md6durs3b) ; trombone
         (mdmark6 ionian 26 md6durs2b)
         (mdmark6 ionian 45 md6durs2b)
         (mdmark6 octatonic 52 md6durs2b))
        "mdmark6b.midi")

(define md6basec (copylist (ferney '(1 1 2) '(4 4 4 5 5)) 50))

(define md6durs1c (sum-across md6basec (copylist '(2 1) 100)))
(define md6durs2c (sum-across md6basec (copylist '(3 1) 100)))
(define md6durs3c (sum-across md6basec (copylist '(3 2) 100)))

(events (list
         (mdmark6 hyperphrygian 37 md6durs1c)
         (mdmark6 hyperphrygian 30 md6durs3c) ; trombone
         (mdmark6 stravmode 23 md6durs2c)
         (mdmark6 ionian 45 md6durs2c)
         (mdmark6 octatonic 55 md6durs2c))
        "mdmark6c.midi")

;;;;


; difcyc = (1 -1 2 0 4 1)
;; (remove-duplicates (safesort difcyc)) = (-1 0 1 2 4)

; (define cyclops9x13 '(a b c b d c c e e b d e d))
; 5 members

(define ferndcyc (new cycle of (ferney '(1) '(4 5))))


(define ss9x13a
 (selfsimvec cyclops9x13 '(-1 0 1 2 4) '(9 13) '(55 71)))

(define md-ssim
  (process 
    for x in ss9x13a
    for dur = (next ferndcyc)
    when (or (numberp x) (listp x));; needed for rests
    output (multievent 'midi :keynum
                       :keynum x
                       :time (now)
                       :duration dur)
    wait dur))

;; store them in a midi file
(events md-ssim "md-ssim.midi")

(events (list md-ssim md-arpeg) "mdcombo.midi")

(events md-arpeg "md-arpeg.midi")

;;;;;;;

(define up1 (new range to 11))
(define up2a (new range to 11 by 2))
(define up2b (new range from 1 to 11 by 2))
(define up3a 
(define up5 (new range from 0 to 59 by 5))
(next up5 20)
(define down1 (new range from 11 downto 0))

(define cyclix1
  (consmatch (transp (next down1 40) 40) 
             (consmatch (transp (next up5 30) 30) (transp difcyc2 50))))

(define (cycjunk inpits)
  (process 
    for x in inpits
    for dur = .25
    when (or (numberp x) (listp x));; needed for rests
    output (multievent 'midi :keynum
                       :keynum x
                       :time (now)
                       :duration dur)
    wait dur))

;; store them in a midi file
(events (cycjunk cyclix1) "cycjunk1.midi")