Jump to content

loopyc

Members
  • Posts

    54
  • Joined

  • Last visited

Reputation Activity

  1. Like
    loopyc got a reaction from JulioHerrlein in Inspiring Idea For Rhythm (with Nested Tuplets)   
    Thanks Julio, LOVE realtime tuplets 🙂
  2. Like
    loopyc reacted to JulioHerrlein in Inspiring Idea For Rhythm (with Nested Tuplets)   
    INSPIRING IDEA FOR RHYTHM (Nested Tuplets)
     
    Nestup [[]_[]]
    NESTUP.CUTELAB.NYC Nestup, a Language for Musical Rhythms  
     
     
  3. Like
    loopyc reacted to Stephane Boussuge in Session 4 - 06.06.20 - Bassclarinet   
    Hi,
     
    here's the files from the last session.
     
    Cheers
     
    Stéphane
     
    BclElectrot.opmo Zoom-0606-Midi-to-logic.opmo
  4. Like
    loopyc reacted to opmo in Micropolyphony (coming soon)   
    MICROPOLYPHONY is a polyphonic musical texture developed by György Ligeti which consists of many lines of dense canons moving at different tempos or rhythms, thus resulting in tone clusters vertically. According to David Cope, "micropolyphony resembles cluster chords, but differs in its use of moving rather than static lines"; it is "a simultaneity of different lines, rhythms, and timbres".
     
    Example with two choirs:
     

       
  5. Like
    loopyc reacted to opmo in Opusmodus 2.0.25787   
    2.0.25787
     
    – New functions:
     MICROPOLYPHONY  MICRO-QUANTIZE  MAKE-BINARY  COLLATZ-SEQUENCE  ULAM-SPIRAL-ARRAY  ZIGZAG-ARRAY  
    – Key shortcut changes:
    Utilities Search: control-option-F
    Navigator Search: control-shift-F
     
    At the moment we have two versions of Opusmodus, one for macOS 10.15 (Catalina) and one for macOS 10.9 - 10.14 due to Apple Xcode bug.
    Therefore use the Forums Download link, which you find in the Forums menu.
     
    In the HowTo Score section you will find a few new examples to play with:
    HowTo Score/Polyphony/Micropolyphony 1.opmo
    HowTo Score/Polyphony/Micropolyphony 2.opmo
    HowTo Score/Rhythm/Rhythm.opmo
  6. Thanks
    loopyc reacted to opmo in [SOLVED] Idea for a Rhythmic Set Theory Function   
    pcs-rhythm (pcs &key points invert (rotate 0) (value 1/16) legato omn)
     
    (pcs-rhythm '3-11 :invert t :points 9 :omn t) => (-s = = - = = = - =) (pcs-rhythm '3-11 :invert t :points 9 :rotate 7 :omn t) => (s = - = = = = - =) (pcs-rhythm '3-11 :points 9 :legato t :omn t) => (e. q e) ;; Interval list to prime-form: (pcs-prime-form '(2 5 7 11)) => (0 3 6 8) (pcs-rhythm '(2 5 7 11) :omn t) => (s - - = - - = - = - - -) (pcs-rhythm '(2 5 7 11) :rotate 7 :omn t) => (-s = - = - - - = - - = -) (pcs-rhythm '(3-11 6-5) :points '(8 9) :omn t) => ((s - - = - - - =) (s = = = - - = = -)) (pcs-rhythm '((2 5 7 11) (1 6 3 9 2)) :omn t) => ((s - - = - - = - = - - -) (s = = - - = - - = - - -)) and (pcs-rhythm '(3-11 6-21) :points '(8 9 7 9) :rotate '(0 1 2 3) :legato '(0 1 1 0) :value '(s e s 3q) :omn t) => ((s - - = - - - =) (-e q e = q =) (-e e. e) (-3q - - = - = = = -)) (pcs-rhythm '3-11 :rotate '(0 1 2 3 4 5 6 7 8 9 10 11) :omn t) => (( s - - = - - - = - - - -) (-s = - - = - - - = - - -) (-s - = - - = - - - = - -) (-s - - = - - = - - - = -) (-s - - - = - - = - - - =) ( s - - - - = - - = - - -) (-s = - - - - = - - = - -) (-s - = - - - - = - - = -) (-s - - = - - - - = - - =) ( s - - - = - - - - = - -) (-s = - - - = - - - - = -) (-s - = - - - = - - - - =))  

     
    (pcs-rhythm '(6-z25b 6-z41b) :points '(9 8) :omn t) => ((s - = = - = - = =) (s - = - - = = =))  

    (pcs-rhythm '(6-z39 5-13 4-24 6-9) :rotate '(0 3 9 2) :omn t) => ((s - = = = = - - = - - -) (-s - - = = = - = - - - =) (-s = - - - = - - - = - =) (-s - = = = = - = - = - -)) There is an error in the 3rd bar, it should read: 4-24(s)R9
     
    3rd bar: with 4-24(s)R8

  7. Thanks
    loopyc reacted to opmo in [SOLVED] Idea for a Rhythmic Set Theory Function   
    Example with chord symbols:
    (pcs-rhythm '(7/b9/s11 9/s11 7) :omn t) => ((s - = = - - = - = = - -)     (s - = - = - = - = = - -)     (s - - = - - = - = - - -))  
  8. Thanks
    loopyc reacted to torstenanders in Negative Harmony Function   
    Are you simply looking for an invert function, e.g., pitch-invert? 
     
    (pitch-invert '(c4 d4 e4)) => (c4 bb3 gs3)  
    This function inverts (mirrors) around the first pitch by default. If you are looking for retaining the original ambitus, you might want to instead you my function invert-in-ambitus (https://tanders.github.io/tot/sources/pitch.html#_g251910).
     
    (invert-in-ambitus '(c4 e4 g4))  => (g4 eb4 c4)
    BTW, when you are specifically talking about a harmonic context in which you are "mirroring" chords, there exist extensive music theories based on this idea already. The notion of minor chords as the mirror image of major chords, and its implications on harmonic functions (tonic, dominant, subdominant etc.) was in detail explored under the label of dualism by theorists like Hugo Riemann, Arthur von Öttingen and Sigfrid Karg-Elert. They also already generalised this notion for microtonal music. Likely independently of these theorists exploring the notion of dualism, Harry Partch's concept of otonality and utonality is also based on this idea, now firmly in the field of microtonal music. In microtonal harmonic theory I came across this notion also elsewhere (e.g., discussed by the composers and theorists of ekmelic music like Franz Richter Herf, which may have arrived there independently as well.
     
    Anyway, this harmonic concept in general is so basic and fundamental that I would not be surprised it would have been studied by the likes of Pythagoras already...
     
    Best,
    Torsten
  9. Thanks
    loopyc reacted to torstenanders in Negative Harmony Function   
    Just a brief follow-up. While Partch's book is obviously available in English, the other authors all wrote in German. More recent Neo-Riemannian theory is often pretty math-heavy, so also somewhat hard to digest for us composers. To get a taste of these harmonic theories in a highly developed form (with dualism throughout, but that is only one facet) delivered by a practicing composers, you might want to have a look at the recent English translation and discussion of Sigfrid Karg-Elert's book Acoustic Determination of Pitch, Chord and Function from 1930.
     
    Byrne, D. A. (2018) The Harmonic Theories of Sigfrid Karg-Elert: Acoustics, Function, Transformation, Perception. PhD Thesis thesis. University of Cincinnati. Online available (with a somewhat slow download speed) at https://etd.ohiolink.edu/apexprod/rws_olink/r/1501/10?p10_etd_subid=162928&clear=10   Warning: this is not for the faint of heart 🙂   Best, Torsten
  10. Like
    loopyc reacted to opmo in import pitches/chords from midi-file?   
    The midi system and the conversion to score is very complex indeed.
    There is not an easy solutions to extract individual midi instruments (tracks).
    Anyway, it is done MIDI-TO-OMN and hopefully useful to others.
     
    "What you are doing Janusz is quite bad and unsafe"  - I heard this very often and still I am, it is part of programming 😎
  11. Like
    loopyc reacted to JulioHerrlein in Negative Harmony Function   
    Dear All, 
     
    One interesting thing that could be implemented as a function could be a form of generating Negative Harmony.
    In the video below, there are some explanation of what it is and the origin in the Levy book.
    It was a trendy topic due to the Jacob Collier interview. And there are a lot of fun videos making versions of pop tunes using negative harmony.
     
    The way I understand it, it is simply a kind of mapping notes in relation to an axis, like in the figure below.
     

     
    So we need a function that could map a note in any register to another note in the closest register to the first on.
    So, any  C note will be mapped to G, all Db to F#, all D to F, all, Eb to E, all B to Ab, all Bb to A.
     
    It´s also possible to generate other mappings as well.
     
    I think that replace map or substitute map can do the job, but I´m not sure (I will try), but I find interesting to post it here to explore the idea.
     
    All the best,
     
    Julio
     
    It´s kind of funny to sse in this por versions how every is upside down and how you can generate an entirely new song from exactly the same material.
     
     
     
    POP TUNES with negative harmony:
     
     
     
     
     
  12. Thanks
    loopyc reacted to opmo in Open Recent ... suggestion   
    To reopen the last used windows you need to go to System Preferences/General panel and uncheck the "Close windows when quitting an app".
     

  13. Thanks
    loopyc reacted to opmo in Opusmodus 1.3.24952   
    – Function name changes:
    LENGTH-DIVIDE2 to LENGTH-SUBDIVISION
    LENGTH-DIVIDE3 to LENGTH-SYNCOPATE

    – Function update:
    LENGTH-DIVIDE – changes to arguments.
    LENGTH-SUBDIVISION – changes to arguments.
    LENGTH-SYNCOPATE – changes to arguments.
    POLYGON-RHYTHM – enable fixed sides polygon. 

    – Note:
    If you used any of the functions:
    LENGTH-DIVIDE, LENGTH-DIVIDE2 or LENGTH-DIVIDE3 in your scores,
    please check new documents in order to make the necessary correction.

    – New:
    Enable or disable the DO-VERBOSE macro. 
    (defparameter *do-verbose* nil "Enable or disable traces printed by do-verbose.")  
     
    length-divide
    This function is able to divide number of lengths to a given division value. The :set and :ignore option increases the control for the desired result. When processing the omn-form sequence an optional third value allows you to fill intervalic steps (a root transposition) to new length values derived from the divisions.
     
    (setf rhy '(1/4 1/4 1/4 1/4)) (length-divide '(2 2) rhy) => (1/8 1/8 1/4 1/4 1/8 1/8) (length-divide '(2 4) rhy) => (1/4 1/16 1/16 1/16 1/16 1/16 1/16 1/16 1/16 1/4)  
    Example:
    (length-divide '(1 2) '(1/4 -1/8 1/16 1/16 -1/32 -3/32 1/8 1/1) :seed 34) => (1/4 -1/8 1/16 1/32 1/32 -1/32 -3/32 1/8 1)  
    In the example above only 1 length is divided by 2 - that is the 1/16. In the example below 4 lengths are divided by 2.
    (length-divide '(4 2) '(1/4 -1/8 1/16 1/16 -1/32 -3/32 1/8 1/1) :seed 34) => (1/8 1/8 -1/8 1/16 1/32 1/32 -1/32 -3/32 1/16 1/16 1/2 1/2) (length-divide '(1 2) '(1/4 -1/8 1/16 1/16 -1/32 -3/32 1/8 1/1) :set 'min :seed 34) => (1/4 -1/8 1/32 1/32 1/16 -1/32 -3/32 1/8 1) (length-divide '(1 4) '(1/4 -1/8 1/16 1/16 -1/32 -3/32 1/8 1/1) :set 1/8 :seed 34) => (1/4 -1/8 1/16 1/16 -1/32 -3/32 1/32 1/32 1/32 1/32 1) (length-divide '((2 3) (1 2)) '((1/4 -1/8 1/16 1/16) (1/32 -3/32 1/8 1/1)) :ignore 'max :seed 45) => ((1/4 -1/8 1/48 1/48 1/48 1/48 1/48 1/48) (1/64 1/64 -3/32 1/8 1)) (length-divide '((2 4) (1 2)) '((q -e s s) (s -e. e w)) :set 'max :ignore 1 :seed 65) => ((1/16 1/16 1/16 1/16 -1/8 1/16 1/64 1/64 1/64 1/64) (1/16 -3/16 1/16 1/16 1))
    OMN:
    (setf mat1 '(q c4 d4 e4 f4 g4 a4 b4)) (length-divide '(3 4) mat1 :seed 45) => (s d4 bb3 cs4 b3 cs4 eb4 c4 e4 q s g4 e4 eb4 fs4 q g4 a4 b4)
    Symbol 'r will apply repeat function:
    (length-divide '(3 4 r) mat1 :seed 45) => (s c4 c4 c4 c4 d4 d4 d4 d4 q e4 s f4 f4 f4 f4 q g4 a4 b4)
    Here we use a set of interval values at the end of the division list:
    (length-divide '(3 4 (13 0 1 13)) mat1 :seed 45) => (s cs5 c4 cs4 cs5 eb5 d4 eb4 eb5 q e4 s fs5 f4 fs4 fs5 q g4 a4 b4) (setf mat2 '((e c4 p e4 mp g4 he c5 p) (q c4 f c4 cs4 mp - d5 p d5) (q cs5 mf = - - cs5 p =))) (length-divide '((1 4) (2 4) (2 5)) mat2 :seed 34) => ((e c4 p e4 mp t a4 f4 gs4 fs4 he c5 p) (q c4 f s b3 cs4 bb3 d4 q cs4 mp - d5 p s c5 e5 cs5 eb5) (q cs5 mf cs5 - - 5q eb5 p b4 c5 d5 eb5 c5 eb5 b4 d5 c5))
    In the example below we assign three series of division values to variables s1, s2 and s3:
    (setf s1 '(3 4 (6 12 18 24)) s2 '(3 4 ((13 1 13 0) (13 0 7 1) r)) s3 '(2 5 ((13 0 13 0 13) ?)) ) (length-divide (list s1 s2 s3) mat2 :seed 34) => ((e c4 p t bb4 mp e5 bb5 e6 cs5 g5 cs6 g6 et fs5 p c6 fs6 c7) (q c4 f s cs5 cs4 cs5 c4 q cs4 mp - s eb6 p d5 a5 eb5 d5 d5 d5 d5) (5q d6 mf cs5 d6 cs5 d6 q cs5 - - cs5 p 5q d5 eb5 c5 b4 d5))  
     
    length-subdivision
    This function is able to divide a list of lengths into a number of subdivisions derived from a given length segment value. The :type and :position option increases the control for the desired result. When processing the omn-form sequence an optional third value allows you to fill intervalic steps (a root transposition) to new length values derived from the divisions. This function is a more sophisticated version of LENGTH-DIVIDE. It produces fascinating variants on the simplest of note-lengths, as can be seen below.
     
    (setf rhy '(1/4 1/4 1/4 1/4)) (length-subdivision '(2 1/8) rhy) => (1/8 1/8 1/8 1/8 1/8 1/8 1/8 1/8)
    position 's (start):
    (length-subdivision '(2 1/16) rhy :position 's) => (1/16 1/16 1/8 1/16 1/16 1/8 1/16 1/16 1/8 1/16 1/16 1/8)
    position 'e (end):
    (length-subdivision '(2 1/16) rhy :position 'e) => (1/8 1/16 1/16 1/8 1/16 1/16 1/8 1/16 1/16 1/8 1/16 1/16)
    type 'r (rest), position 'e (end):
    (length-subdivision '(2 1/16) rhy :type 'r :position 'e) => (-1/8 1/16 1/16 -1/8 1/16 1/16 -1/8 1/16 1/16 -1/8 1/16 1/16)
    type 'r (rest), position 's (end):
    (length-subdivision '(2 s) rhy :type 'r :position 's) => (1/16 1/16 -1/8 1/16 1/16 -1/8 1/16 1/16 -1/8 1/16 1/16 -1/8)
    type at random, rest or note :
    (length-subdivision '(2 s) rhy :type '? :position 's) => (1/16 1/16 -1/8 1/16 1/16 -1/8 1/16 1/16 -1/8 1/16 1/16 1/8)
    position and type at random:
    (length-subdivision '(1 e) rhy :type '? :position '? :seed 34) => (1/16 1/8 1/16 1/8 1/8 -1/8 1/8 1/8 1/8) (length-subdivision '((2 5q) (1 3q)) rhy :type '? :position 's :seed 34) => (1/20 1/20 3/20 1/12 -1/6 1/20 1/20 3/20 1/12 -1/6) (length-subdivision '((2 5q) (1 3q) (1 e) (1 s)) rhy :seed 34) => (1/20 1/20 3/20 1/12 1/12 1/12 1/8 1/8 3/16 1/16)  
    Example:
    (setf rhy2 '((1/4 1/4 1/4 1/4) (1/4 1/4 1/4 1/4))) (length-subdivision '(1 e) rhy2 :seed 34) => ((1/8 1/8 1/16 1/8 1/16 1/8 1/8 1/8 1/8) (1/16 1/8 1/16 1/8 1/8 1/8 1/8 1/8 1/8)) (length-subdivision '((1 e) (1 3q)) rhy2 :seed 34) => ((1/8 1/8 1/12 1/12 1/12 1/8 1/8 1/6 1/12) (1/16 1/8 1/16 1/6 1/12 1/8 1/8 1/6 1/12)) (length-subdivision '(((1 e)) ((1 3q))) rhy2 :seed 34) => ((1/8 1/8 1/16 1/8 1/16 1/8 1/8 1/8 1/8) (1/12 1/12 1/12 1/6 1/12 1/12 1/6 1/6 1/12)) (length-subdivision '((3 3q) (1 e)) '((q -e e h) (s e. q h)) :seed 65) => ((1/12 1/12 1/12 -1/8 1/8 1/12 1/12 1/12 1/4) (1/16 3/16 1/8 1/8 1/8 1/12 1/12 1/12 1/8)) (length-subdivision '(((3 3q)) ((1 e))) '((q -e e h) (s e. q h)) :seed 65) => ((1/12 1/12 1/12 -1/8 1/8 1/12 1/12 1/12 1/4) (1/16 1/16 1/8 1/16 1/8 1/16 1/8 3/8)) (length-subdivision '(((2 3q)) ((1 e))) '((q -e e h) (s e. q h)) :type '? :seed 65) => ((1/12 1/12 1/12 -1/8 1/8 1/12 1/12 -1/3) (1/16 -1/16 1/8 1/8 1/8 1/8 3/8))
    OMN:
    (setf mat1 '(q c4 d4 e4 f4 g4 a4 b4)) (length-subdivision '(1 e) mat1 :seed 45) => (s cs4 e b3 s d4 e cs4 e4 s f4 e fs4 s d4 e fs4 eb4 f4 a4 bb4 gs4 bb4 a4)
    The symbol 'r (third value) will apply repeat function:
    (length-subdivision '(1 e r) mat1 :seed 45) => (s c4 e s e d4 d4 s e4 e s e f4 f4 g4 g4 a4 a4 b4 b4)
    Here we define the intervals (third value):
    (length-subdivision '(1 e (13 0 13 0)) mat1 :seed 45) => (s cs5 e c4 s cs5 e eb5 d4 s f5 e e4 s f5 e fs5 f4 gs5 g4 bb5 a4 c6 b4) (length-subdivision '(4 s (13 0 13 0)) mat1 :seed 45) => (s cs5 c4 cs5 c4 eb5 d4 eb5 d4 f5 e4 f5 e4 fs5 f4 fs5 f4 gs5 g4 gs5 g4 bb5 a4 bb5 a4 c6 b4 c6 b4) (length-subdivision '(2 3q (13 0 13 0)) mat1 :type '(r n) :seed 45 :position '(e s s s e s s)) => (-3q cs5 c4 eb5 d4 eb5 f5 e4 - fs5 f4 fs5 - gs5 g4 bb5 a4 bb5 c6 b4 -) (setf mat2 '((e c4 p e4 mp g4 he c5 p) (q c4 f c4 cs4 mp - d5 p d5) (q cs5 mf = - - cs5 p =))) (length-subdivision '((1 e (13 0 13 0)) (2 e (13 0 13 0)) (2 3q (13 0 13 0))) mat2 :type '? :seed 34) => ((e c4 p e4 mp g4 q cs6 p e c5 q cs6) (e cs5 f c4 cs5 c4 -3q d5 mp cs4 -q e eb6 p d5 eb6 d5) (-s e cs5 mf -s e d6 cs5 -q - 3e d6 p 3q cs5 d6 3e cs5 e d6 cs5)) (length-subdivision '(((1 e (13 0 13 0))) ((2 s (13 0 13 0))) ((2 3q r))) mat2 :type '? :seed 34) => ((e c4 p e4 mp g4 q cs6 p e c5 q cs6) (e cs5 f s c4 cs5 -e s cs5 c4 e d5 mp s cs4 d5 -q -s eb6 p d5 - eb6 d5 eb6 d5) (3q cs5 mf cs5 cs5 cs5 cs5 cs5 -q - 3q cs5 p cs5 - - cs5 cs5))  
    In the example below we assign three series of values to variables s1, s2 and s3:
    (setf s1 '(2 e (6 12 18 24)) s2 '(1 3q ((13 1 13 0) (13 0 7 1) r)) s3 '(3 5q ((13 0 13 0 13) ?)) ) (length-subdivision (list s1 s2 s3) mat2 :seed 23) => ((e c4 p 3e bb4 mp 3q e5 e cs6 cs5 p cs6 q.) (e fs4 f c5 3q cs5 cs4 cs5 5h mp 5q c4 g4 c4 -q e c4 p c4 3q d5 3h cs4) (e g5 mf cs6 3q d6 3h d5 -q - 5q d6 p cs5 cs5 5h e d6 cs5))  
     
     
    length-syncopate
    The function LENGTH-SYNCOPATE is a valuable way of bringing more rhythmic interest into a length list. The usual idea of syncopating rhythm is to 'choke' certain attacks so that the attack is delayed or pre-empted.
    (setf rhy '(1/4 1/4 1/4 1/4)) (length-syncopate '(1 4) rhy) => (1/4 3/16 1/16 1/4 1/4) (length-syncopate '(2 4) rhy) => (1/16 3/16 1/4 3/16 1/16 1/4)  
    Example:
    (length-syncopate '(1 4) '(1/4 -1/8 1/16 1/16 -1/8 1/8 1/1) :seed 34) => (1/4 -1/8 1/16 1/64 3/64 -1/8 1/8 1)
    In the example above only 1 length is divided by 4 (1, 3) - that is the 1/16. In the example below 2 values are divided by 3: (1, 2) and (2, 1).
    (length-syncopate '(2 3) '(1/4 -1/8 1/16 1/16 -1/8 1/8 1/1) :seed 34) => (1/4 -1/8 1/48 1/24 1/16 -1/8 1/8 2/3 1/3) (length-syncopate '(1 4) '(1/4 -1/8 1/16 1/16 -1/8 1/8 1/1) :set 1/8 :seed 34) => (1/4 -1/8 1/16 1/16 -1/8 1/32 3/32 1)
    Example with :set for each list:
    (length-syncopate '((2 3) (1 4)) '((1/4 -1/8 1/16 1/16) (1/32 -3/32 1/8 1/1)) :set '(min 1/8) :seed 45) => ((1/4 -1/8 1/24 1/48 1/24 1/48) (1/32 -3/32 3/32 1/32 1)) (length-syncopate '((2 3) (1 5)) '((q -e s s) (s -e. q h)) :set 'max :ignore 'h :seed 65 :omn t) => ((3h 3q -e s 3s 3e) (s -e. 5q 5w h))
    OMN:
    (setf mat '(q c4 d4 e4 f4 g4 a4 b4)) (length-syncopate '(3 4) mat :seed 12) => (s b3 e. cs4 q d4 e. fs4 s d4 q f4 g4 a4 e. bb4 s c5)  
    Here we use a set of interval values:
    (length-syncopate '(3 4 ((13 0) (0 14) (1 13))) mat :seed 23) => (s cs5 e. c4 d4 s e5 q e4 f4 s gs4 e. gs5 q a4 b4) (setf mat2 '((e c4 p e4 mp g4 he c5 p) (q c4 f c4 cs4 mp - d5 p d5) (q cs5 mf = - q cs5 stacc p = =)) (length-syncopate '((1 3 (-3 6)) (2 4 (6 0)) (2 5 (11 13))) mat2 :seed 34) => ((e c4 p e4 mp 3e 3q cs5 he c5 p) (q c4 f s fs4 e. c4 q cs4 mp - e. gs5 p s d5 q) (q cs5 mf cs5 - 5w c6 stacc 5q d6 stacc q cs5 p 5q c6 5w d6 q cs5))
     
     
    polygon-rhythm
    In the next three examples below we use a list of fixed polygon sides (non-symmetrical):
    (circle-rhythm-plot (polygon-rhythm '(1 6 10) 16 1) :points 16) To rotate the polygon we change the starting point value:
    (circle-rhythm-plot (polygon-rhythm '(1 6 10) 16 2) :points 16) (circle-rhythm-plot (polygon-rhythm '(0 2 5 7 10 12 13 15 16 18 19 21 23) 24 0) :points 24 :value 1/24)  
    Best wishes,
    JP
  14. Thanks
    loopyc reacted to torstenanders in Getting precompiled code (e.g., quicklisp, quicklisp libraries, swank, own libraries) running again on recent Opusmodus versions   
    Dear all,
     
    After updating to a recent Opusmodus version 1.3, I ran into some errors when loading code that had been loaded and compiled before, e.g., quicklisp, quicklisp libraries, swank (the interface that allows using Emacs Slime with Opusmodus), and my own Lisp libraries. The errors I saw were rather cryptic, like the following:
     
    Error: The value "CL" is not of the expected type list.
    While executing: (:internal ccl::operation-on-all-specs ccl::%define-package), in process Listener-1(7).
     
    After exchanges with Janusz (thanks a lot for your help!) I learnt that the underlying Common Lisp version of Opusmodus had been upgraded to CCL version 1.12, and the format of compiled files (fasl files or dx64fsl files) of this version had changed.
     
    So, in case you run into similar problems, these can be fixed simply by deleting all previously compiled files (which Lisp stores if they do not change to speed up the load process), so that the Lisp compiler has to compile them again. In the folder  ~/.cache/common-lisp just delete any folders starting with ccl-, so that all compiled files in this directory are compiled again.
     
    Best,
    Torsten
  15. Like
    loopyc reacted to opmo in polygon-rhythm   
  16. Thanks
    loopyc reacted to opmo in polygon-rhythm   
    Second example, this time with code.
    VSL: Soprano Sax, Steinway D, Upright Bass and Jazz DrumSet.
     
       
     
    (progn (init-seed 3578) (setf bd '(c2 cs2)) (setf sd '(d2 ds2 e2 f2 fs2 g2 gs2 a2 bb2 b2)) (setf lt '(c5 cs5 d5 ds5 e5 f5 fs5 g5 gs5 a5 bb5 b5)) (setf cc '(g7 c7)) (setf rc '(c4 cs7 d7 ds7 e7 f7)) (setf hh '(c4 cs4 d4 ds4 e4)) (setf ds-vel '(ff f fff)) (setf bd-gon (gen-eval 33 '(polygon-rhythm 3 16 0 :pitch (rnd-sample 32 bd) :velocity (rnd-sample 32 ds-vel)))) (setf sd-gon (gen-eval 32 '(polygon-rhythm 2 16 '? :pitch (rnd-sample 32 sd) :velocity (rnd-sample 32 ds-vel)))) (setf lt-gon (gen-eval 32 '(polygon-rhythm 2 16 '? :pitch (rnd-sample 32 lt) :velocity (rnd-sample 32 ds-vel)))) (setf cc-gon (gen-eval 32 '(polygon-rhythm 5 24 '? :pitch (rnd-sample 32 cc) :velocity (rnd-sample 32 ds-vel)))) (setf rc-gon (gen-eval 32 '(polygon-rhythm 5 24 '? :pitch (rnd-sample 32 rc) :velocity (rnd-sample 32 ds-vel)))) (setf hh-gon (gen-eval 33 '(polygon-rhythm 5 16 '? :pitch (rnd-sample 32 hh) :velocity (rnd-sample 32 ds-vel)))) (setf hexachord '(d4 eb4 fs4 g4 a4 bb4)) (setf chords (assemble-seq (gen-eval 16 '(polygon-rhythm 3 16 '? :pitch (gen-chord-series hexachord hexachord :type '? :width '(30 24 36 12) :segment t))) (gen-eval 4 '(polygon-rhythm 5 16 '? :pitch (gen-chord-series hexachord hexachord :type '? :width '(30 24 36 12) :segment t))) (gen-eval 7 '(polygon-rhythm 4 16 '? :pitch (gen-chord-series hexachord hexachord :type '? :width '(30 24 36 12) :segment nil) :legato t)) (gen-eval 5 '(polygon-rhythm 3 16 '? :pitch (gen-chord-series hexachord hexachord :type '? :width '(30 24 36 12) :segment t))))) (setf piano (assemble-seq '((-1) (-1) (-1) (-1)) (rnd-octaves '(c2 b6) (subseq chords 4 31)) '(-1))) (setf ssax (make-omn :length (assemble-seq '((-1) (-1) (-1) (-1) (-1) (-1) (-1)) (polygon-rhythm 6 16 '?) (polygon-rhythm 7 16 '?) (polygon-rhythm 9 16 '?) (polygon-rhythm 3 8 '?) (polygon-rhythm 16 16 '?) (polygon-rhythm 24 24 '?) (polygon-rhythm 8 16 '?) (polygon-rhythm 11 16 '?) (polygon-rhythm 5 16 '?) (polygon-rhythm 16 24 '?) (polygon-rhythm 6 8 '?) (polygon-rhythm 4 16 2) (polygon-rhythm 5 16 2) (polygon-rhythm 7 16 2) (polygon-rhythm 9 16 0) (polygon-rhythm 13 16 0) (polygon-rhythm 16 16 0) (polygon-rhythm 21 24 0) (polygon-rhythm 22 24 0) (polygon-rhythm 20 24 0) (polygon-rhythm 20 24 0) (polygon-rhythm 16 24 0) (polygon-rhythm 4 16 2) '((-1) (-1)) ) :pitch (ambitus 'soprano-sax (pitch-transpose (vector-to-pitch '(fs3 fs4) (mod-sine-waves 5 36 4 0.3 :modulation (gen-sine 120 5 0.4))) (pitch-variant (melodize (omn :pitch chords))))) :velocity '(ff))) (setf bass-line (assemble-seq '((-1) (-1)) (gen-eval 31 '(polygon-rhythm 9 16 '? :pitch (ambitus '(e1 g4) (pitch-variant (pitch-transpose -24 (rnd-air :type :pitch)))) :velocity '(fff))))) (ps 'vsl :ssax (list ssax) :grand (list piano) :cb (list bass-line) :ds-bd (list bd-gon) :ds-sd (list sd-gon) :ds-lt (list lt-gon) :ds-cc (list cc-gon) :ds-rc (list cc-gon) :ds-hh (list hh-gon) :tempo 120 :output :live-coding :title "Dada Quartet - EXP.2 (c) 2019 OPMO") (init-seed nil) ) Best wishes,
    Janusz

    P.S. I am almost there with the new release. 😎
  17. Thanks
    loopyc got a reaction from opmo in polygon-rhythm   
    You've got my attention! Amazing example, thanks 🙂
  18. Thanks
    loopyc reacted to opmo in length-weight   
    The additional swallow keyword (default t) will be part of the next release. 🙂
    (length-weight '((q c4 d4 e4 f4 g4 a4 b4)                  (q c4 d4 e4 f4 g4 a4 b4))                :weight '((3 1) (5 2)) :swallow nil                :seed 875) => ((q c4 d4 e4 f4 g4 - a4) (q c4 d4 - e4 f4 g4 -)) ;; With :swallow T (default) (length-weight '((q c4 d4 e4 f4 g4 a4 b4)                  (q c4 d4 e4 f4 g4 a4 b4))                :weight '((3 1) (5 2))                :seed 875) => ((q c4 d4 e4 f4 g4 - b4) (q c4 d4 - f4 g4 a4 -))
  19. Like
    loopyc got a reaction from opmo in Opusmodus Vs. Symbolic Composer   
    oneder, I wrote Peter Stone around that time, and he stated that he was very busy on a project(s) and would update at some time in future but DID take the time to assist me.
     
    He has been at this a long time (my original copy of SCOM I have been upgrading from was purchased for an Atari in the early 90's!), and he has always replied to my emails over that long period...but I imagine SCOM is not necessarily 'in demand' such to be a priority from a marketing standpoint i.e the website.
     
    If you need support, write him directly... he has always presented himself to me as a professional and a gentleman, and has maintained SCOM for decades now... just appears to have other areas of his life he is fully committed to right now ;-)
  20. Thanks
    loopyc reacted to opmo in Opusmodus - second monitor   
    The upcoming release will allow you to open display-midi, display-musicxml, graphs and snippets in a separate window. For any of you using second monitor this will be great addition to your work flow.
     
    Examples:
    (display-midi 'score :display :window) (display-musicxml 'score :display :window)  
    Best,
    Janusz
  21. Like
    loopyc reacted to opmo in Quantization   
    Thank you Yuichi for sharing, great piece, I am very happy to see Opusmodus is able to help you realise your ideas.
  22. Like
    loopyc reacted to opmo in Opusmodus 1.3 release   
    Whats new in version 1.3
     
    Compatibility with macOS Mojave
    
macOS 10.14 Dark Mode
    
CLM added

    OSC added
    
MIDI player improvements
     
    New functions:
    binary-to-attribute
    merge-attributes
    circle-pitch-plot

    circle-rhythm-plot
    xy-plot
    pcs-rhythm

    edit-events
    find-max-span
    fit-to-span

    gen-osc-data

    osc-thread
    
stop-osc-threads
     
    Enhancements and fixes:
    quantizer returns now the count of given length-notes
    single-events returns given type
    don't join dissimilar rests
    fixed rest grouping
    fixed tied 8va or 8vb tuplets
      Installation:
    There are some changes to the Opusmodus user system folder.
    Before opening the new application you need to delete the old Opusmodus folder.
    Make sure you save your personal files (scores, docs etc...) before. A good solution is to rename the Opusmodus folder first and then compress it.
    After you have deleted the Opusmodus user folder you can start the new application.
    At the start Opusmodus will ask you for permission to create a new user folder in your home directory, if you don’t see a window for it, it means the old folder is still on your computer. Make sure the new Opusmodus folder is installed in your home directory.
     
    New Opusmodus folder:
     


    Upgrade:
    Opusmodus 1.3 requires a new serial number to run.
    When purchasing upgrade 1.3 the current user will need to provide an Opusmodus 1.2 serial number.
    After the confirmation which takes a few seconds only, you will be redirected to the purchase page.
    Following the purchase a new serial number will be sent to you by email.
     
    Happy New Year 2019
     
    Yours,
    Janusz Podrazik
  23. Like
    loopyc reacted to AM in chord-contraction/expansion   
    hi julio
     
    it's too complicated to share the code...the FUNCTION is made for a specific idea of the work (not common), so it's made for MY need...
    here is a short sketch of the work... (part of it)
     
    a) generating a pitch-sequence => by using a 12-tone-seq + its expansion by a sorting-algorithm (with GEN-SORT) => an INTERVAL-order mutates to a SCALE (see the list-plot)
    b) pitches are projected on a sequence of symmetrical expanding/compressing FIELDS (with CHORD-CONTR...) => you see how the pitch-seq is contracted/exapnded in "space"
     
    - result is a kind of interference of this processes => at the end you see (in list-plot) that the interference is going more and more to ONE LEVEL - to a SCALE 
    - so its a kind of inside/out. the inherent structure, the inherent process/order is more and more recognizable during the process (start with compr/exp. 12-tone-row to the simple SCALE)
     
     

     
     
    the project is a bit larger. this sequence (which rhythm is based on a binary-event-filter (data of a jpeg of an artist))  is only the structural background (some ideas developed by LACHENMANN) - on this NET (the score you see) there will be other GESTALTS/MOTIFS etc...
    because my needs are such specific to my and my idea - most of the functions i had to code for myself, or modify/enlarge the OPMO functions, great that this is possible on this platform.
     
    sorry a bit complicated and i can't not describe it properly with a few words 🧐
     
     
     
     
  24. Like
    loopyc reacted to AM in chord-contraction/expansion   
    ;;; THIS FUNCTION DOING SYMM TRANSPOSITIONS TO CONRACT (OR EXPAND, depends on INTERVAL) A CHORD or PITCH-SEQ ;;; default setting: it changes in every generation the highest and lowest pitch by an OCTAVE ;;; by changing :position (see examples) you could change which position should be changed/transposed ;;; default interval is 12 ;;; FUNCTION (defun chord-contraction/expansion (n pitchlist &key (position nil) (interval 12) (chord nil)) (let* ((pitchlist (if (chordp (car pitchlist)) (melodize pitchlist) pitchlist)) (position (if (null position) (list 0 (1- (length pitchlist))) (if (listp position) position (list position (- (1- (length pitchlist)) position))))) (pitchlist (cons pitchlist (loop repeat n collect (setf pitchlist (sort-asc (flatten (position-replace position (list (pitch-transpose interval (list (nth (car position) pitchlist))) (pitch-transpose (neg! interval) (list (nth (cadr position) pitchlist)))) pitchlist)))))))) (if (null chord) pitchlist (chordize pitchlist)))) ;;; EXAMPLES: evaluate by cmd3 (setf 12-tone-field '(f3 fs3 gs3 c4 d4 e4 b4 cs5 eb5 g5 a5 bb5)) (chord-contraction/expansion 4 12-tone-field :chord t) => ((f3fs3gs3c4d4e4b4cs5eb5g5a5bb5) (fs3gs3c4d4e4f4bb4b4cs5eb5g5a5) (gs3c4d4e4f4fs4a4bb4b4cs5eb5g5) (c4d4e4f4fs4g4gs4a4bb4b4cs5eb5) (d4eb4e4f4fs4g4gs4a4bb4b4c5cs5)) (chord-contraction/expansion 4 12-tone-field :chord t :interval 48) => ((f3fs3gs3c4d4e4b4cs5eb5g5a5bb5) (bb1fs3gs3c4d4e4b4cs5eb5g5a5f7) (f3fs3gs3c4d4e4b4cs5eb5g5a5bb5) (bb1fs3gs3c4d4e4b4cs5eb5g5a5f7) (f3fs3gs3c4d4e4b4cs5eb5g5a5bb5)) ;;; with spezific positions (inner change) (chord-contraction/expansion 4 12-tone-field :chord t :position 3) => ((f3fs3gs3c4d4e4b4cs5eb5g5a5bb5) (f3fs3gs3d4eb4e4b4c5cs5g5a5bb5) (f3fs3gs3cs4eb4e4b4c5d5g5a5bb5) (f3fs3gs3d4eb4e4b4c5cs5g5a5bb5) (f3fs3gs3cs4eb4e4b4c5d5g5a5bb5)) (chord-contraction/expansion 4 12-tone-field :chord t :position '(0 5)) => ((f3fs3gs3c4d4e4b4cs5eb5g5a5bb5) (e3fs3gs3c4d4f4b4cs5eb5g5a5bb5) (f3fs3gs3c4d4e4b4cs5eb5g5a5bb5) (e3fs3gs3c4d4f4b4cs5eb5g5a5bb5) (f3fs3gs3c4d4e4b4cs5eb5g5a5bb5)) ;;;; with different intervals (chord-contraction/expansion 4 12-tone-field :chord t :interval 11) => ((f3fs3gs3c4d4e4b4cs5eb5g5a5bb5) (fs3gs3c4d4e4e4b4b4cs5eb5g5a5) (gs3c4d4e4e4f4bb4b4b4cs5eb5g5) (c4d4e4e4f4g4gs4bb4b4b4cs5eb5) (d4e4e4e4f4g4gs4bb4b4b4b4cs5)) (chord-contraction/expansion 4 12-tone-field :chord t :interval 7) => ((f3fs3gs3c4d4e4b4cs5eb5g5a5bb5) (fs3gs3c4c4d4e4b4cs5eb5eb5g5a5) (gs3c4c4cs4d4e4b4cs5d5eb5eb5g5) (c4c4cs4d4eb4e4b4c5cs5d5eb5eb5) (c4cs4d4eb4e4g4gs4b4c5cs5d5eb5))  
  25. Thanks
    loopyc reacted to JulioHerrlein in Composing with Piano Reductions   
    Dear All,
     
    I'm trying to find a suitable workflow to make my choices easier.
    One idea was to compose over a piano reduction, for easier manipulation.
    Here's a way of doing that, with comments.
    The MIDI FILE output is like this. I did NO EDITIONS at all in Musescore.This is the video of the MIDI output.
    The XML output is the piano reduction.
    Very convenient !
     
    Best,
    Julio
     

    str_4tet_opusmodus.mov ;;;SEV CHORDS Basic Functions ;;;Harmonic Functions/Sets List (setf Srm7 (pcs-transpose 9 (pcs '4-26) :pitch)) (setf S7M (pcs-transpose 4 (pcs '4-20) :pitch)) (setf Trm7 (pcs-transpose 4 (pcs '4-26) :pitch)) (setf T7M (pcs-transpose -1 (pcs '4-20) :pitch)) (setf Tam7 (pcs-transpose 11 (pcs '4-26) :pitch)) (setf D7 (pcs-transpose 11 (pcs '4-27b) :pitch)) (setf hd (pcs-transpose 9 (pcs '4-27) :pitch)) ;;;Estabilishing a Basic Progressions (setf chordprog (chordize (list Srm7 S7M Trm7 T7M Tam7 S7M))) ;;;Repeating and transposing the progression (setf chordtrp-rpt (pitch-transpose-repeat '((0 3 5 4) (0 2 -2 -1) (0 5 1 -2) (7 12 10 -3)) chordprog)) ;;; Making suitable voicings to the progression (setf chordprogdrop (chordize-list (pitch-transpose-n '(0 -12 0 0) (pitch-melodize chordtrp-rpt)))) ;;;Using these dropped chords as the source (setf chordprgtrp chordprogdrop) ;;;Opcionally with more Voice-Leading, with a smooth transition between the chords ;(setf chordprgtrp (chord-closest-path (car chordprogdrop) (gen-divide 4 chordprogdrop))) ;;;Counting the number of chords to make rhythm repetitions ;(setf times (get-count (get-count chordprgtrp))) ;;;Optionally setting manually the repetitions (setf times 24) ;;;Eachnote assigned to a voice (setf voz1 (flatten (pitch-demix 1 chordprgtrp))) (setf voz2 (flatten (pitch-demix 2 chordprgtrp))) (setf voz3 (flatten (pitch-demix 3 chordprgtrp))) (setf voz4 (flatten (pitch-demix 4 chordprgtrp))) ;;;optionally processing the ambitus of the voices ;(setf vozamb1 (ambitus '(c4 c5) voz1) vozamb2 (ambitus '(f3 c5) voz2) vozamb3 (ambitus '(g3 g4) voz3) vozamb4 (ambitus '(c2 e3) voz4)) ;;; Or setting to instrument's ranges ;(setf vozamb1 (ambitus (ambitus-instrument 'flute) voz1)vozamb2 (ambitus (ambitus-instrument 'oboe) voz2) vozamb3 (ambitus (ambitus-instrument 'clarinet) voz3) vozamb4 (ambitus (ambitus-instrument 'bassoon) voz4)) ;;;or just using the resulting drops as given (setf vozamb1 voz1 vozamb2 voz2 vozamb3 voz3 vozamb4 voz4) ;;;RIT ;;;one rhythm to all (for checking the "chorale" writing) ;(setf r1 (gen-repeat times '(q)) r2 (gen-repeat times '(q)) r3 (gen-repeat times '(q)) r4 (gen-repeat times '(q))) ;;;Doing an homorhythmic section (all instruments play the same rhythms (setf homorhy (gen-repeat times '(q -q e q e h h -s s s s)) r1 homorhy r2 homorhy r3 homorhy r4 homorhy) ;;; Articulation for the homorhytm (setf arthomo '(ten stacc ord stacc ord ord leg leg ord)) ;;;OMN ASSEMBLAGE of the Lines (setf vozomn1 (make-omn :length r1 :pitch vozamb1 :articulation arthomo :velocity (rnd-order'(p)))) (setf vozomn2 (make-omn :length r2 :pitch vozamb2 :articulation arthomo :velocity (rnd-order'(p)))) (setf vozomn3 (make-omn :length r3 :pitch vozamb3 :articulation arthomo :velocity (rnd-order'(pp)))) (setf vozomn4 (make-omn :length r4 :pitch vozamb4 :articulation arthomo :velocity (rnd-order'(pp)))) ;;;--------------------------------------------------------- ;;; SCORE ;;;---------------------------------------------------------- (def-score voices (:title "Piano-Red-4-Voices" :subtitle "Estudos Polifônicos" :composer "Julio-Herrlein" :key-signature 'atonal :time-signature '(4 4) :tempo '("Meditativo" q 60) :layout (piano-solo-layout '(pno-rh1 pno-rh2) '(pno-lh pno-lh2))) (pno-rh1 :omn vozomn1 :channel 1 :sound 'gm :program 'Violin :volume 100) (pno-rh2 :omn vozomn2 :channel 2 :sound 'gm :program 'Violin :volume 70) (pno-lh :omn vozomn3 :channel 3 :sound 'gm :program 'Viola :volume 80) (pno-lh2 :omn vozomn4 :channel 4 :sound 'gm :program 'Cello :volume 80))  
×
×
  • Create New...

Important Information

Terms of Use Privacy Policy