Sometimes my composition process is very related to harmony and voice-leading.

For example starting with a sequence of chords in 4-part writing as a foundation

for a string quartet or saxophone quartet.

So, I have some questions regarding this:

1) How to make ornaments and developing the texture in each voice individually but keeping the harmonic movement based on the first "chorale", the fundation of the composition. Maybe harmonic path ? But do you have other hints ?

2) How to repeat the notes of a given chord within that foundational 4-part structure

Something like this...

I have my ideas, but I´d like to hear more from you (especially in ways to be more flexible).

Some of my ideas are here

]]>

When I evaluate:

(interval-to-pitch '(2 2 1 2 2 2 1) :start 'c7) => (c7 d7 e7 f7 g7 a7 b7 c8)

This is expected.

But when I evaluate:

(interval-to-pitch '(2 2 1 2 2 2 1) :start 'c8) => (c8 bb7 gs7 g7 f7 eb7 cs7 c7)

Is this expected?

- Rangarajan

]]>I was looking at the documentation of "gen-walk" function and have a doubt. It is my understanding that the probability of "forward" and probability of "backward" can each range from 0 to 1, but the sum cannot be greater than 1. However, the sum could be less than 1.

So, I think it is not correct to have forward probability as 1 and backward probability as 0.7. This would make the total exceed 1. However, it is OK to have forward probability as 0.3 and backward probability as 0.4. In this case the stationary probability would be 1 - 0.3 - 0.4 = 0.3

Am I correct in my understanding? If this is correct, then there is a mistake in the documentation of the function. There is an example with forward probability as 0.9 and backward probability as 0.3.

Kindly clarify.

Regards,

Rangarajan

]]>
I am trying to understand the **polygon-rhythm** function, but having some difficulty with the finer details.

The expression (polygon-rhythm 5 8 4) returns 8 points (randomly generated) like this: => (-1/8 -1/8 1/8 1/8 1/8 1/8 1/8 -1/8)

Likewise, (polygon-rhythm 5 16 4) returns 16 points: => (1/16 -1/16 -1/16 -1/16 1/16 -1/16 -1/16 -1/16 1/16 1/16 -1/16 -1/16 -1/16 -1/16 -1/16 1/16)

This: (polygon-rhythm 3 16 8) also returns 16 points: => (-1/16 -1/16 -1/16 -1/16 -1/16 1/16 -1/16 -1/16 1/16 -1/16 -1/16 1/16 -1/16 -1/16 -1/16 -1/16)

What is the role of the first and 3rd arguments to this function?

Next: What does the keyword argument :legato achieve?

The expression (polygon-rhythm 5 8 4 :legato t) returns: => (-1/8 1/8 1/4 1/4 1/8 1/8)

I can see that the result has only 6 elements, instead of 8. What is going on?

I went through the documentation, but still couldn't understand these points.

Regards,

Rangarajan

]]>

here's an example (from my current work)...

this little video shows how i generate/display SCORE (instrumental parts) on a screen + virtual conductor (piano part). the example is "nonsense", but shows how it looks/works... you see the bars (generating), the cue, beat... and the arrow (that shows you where to read/play) ...also you hear some bad (sry) sound-simulation of the setup.

in this way i can generate** a whole piece in realtime on STAGE** (all musicians will read their part from their own screen). this one will be for 5 instruments, ePlayer and modular synthesizer. during the performance an algorithm (or some data-streams) will generate the piece in OPMO. with OSC i can send all datas (score, beat, tempo..) **from OPMO to POLYTEMPO-NETWORK ** (https://polytempo.zhdk.ch) and work and coordinate different independent tempo layers, conducting etc...

for more POLYTEMPO informations... have a look here: https://polytempo.zhdk.ch

greetings

andré

]]>

Is it possible to change the offset from find-everyother somehow?

```
(find-everyother 2 '(1 2 3 4 5 6))
--> (1 3 5)
like this:
(find-everyother 2 '(1 2 3 4 5 6) :offset 1)
--> (2 4 6)
```

thanks!

]]>

So, I rolled by own version of unfold that addresses this shortcoming. This new function works as follows: you can use the names of arbitrary Opusmodus functions, as long as they expect an OMN sequence as first argument. The following example applies first the function gen-retrograde and then quantum to the material mat.

(setf mat '((q c4 d4 e4) (h f4 q b3)))

(fn-unfold '((gen-retrograde) (quantum :fraction -0.2)) mat)

=> ((7W B3 7H._QT F4 -E..) (E E4 D4 S. C4 -ET))

If you would like to have functions with more concise names (as unfold does), just define functions with shorter names. Here are some examples.

(defun tr (sequence transpose &key (section NIL) (exclude NIL) (ambitus 'piano) (omn NIL))

"Like pitch-transpose, but sequence as first param."

(pitch-transpose transpose sequence :section section :exclude exclude :ambitus ambitus :omn omn))

(defun ld (sequence values &key set ignore seed (section NIL) (exclude NIL) (omn NIL))

"Like length-divide, but sequence as first param."

(length-divide values sequence :set set :ignore ignore :section section :exclude exclude :omn omn :seed seed))

With the definitions above, we can now use fn-unfold as follows for computing an octave transposition of mat and then applying length-divide to the second bar with the given settings.

(fn-unfold '((tr 12) (ld (2 3) :section 1)) mat)

=> ((Q C5 D5 E5) (3H E5 FS5 G5 3Q A4 BB4 CS5))

BTW: The definition of fn-unfold is pretty short. By far the longest part of this definition is the doc string

(defun fn-unfold (fns sequence) "Much like the buildin Opusmodus `unfold`, but instead works with functions and additional arguments can be given to the functions. Apply to `sequence` all fns in order. * Arguments: - fns (list of lists): Each sublist has the form (<omn-fn> &rest <args>), where <omn-fn> is a function expecting an OMN sequence as first argument and arbitrary further argments, and <args> are the further arguments beyond the OMN sequence given to the function. - sequence: OMN sequence * Examples: Some material to use ;;; (setf mat '((q c4 d4 e4) (h f4 q b3))) Remember: all functions used must expect a OMN sequence as *first* argument. ;;; (fn-unfold '((gen-retrograde) (quantum :fraction -0.2)) mat) Some short-hand versions of common functions are defined for conciseness. ;;; (fn-unfold '((tr 12) (ld (2 3) :section 1)) mat) " (reduce (lambda (seq fn) (apply (if (functionp (first fn)) (first fn) (fdefinition (first fn))) seq (rest fn))) fns :initial-value sequence))

]]>

I´m creating some permutations and I´d like to assign a text under each note to make clear the use of certain intervals.

`substitute-map '(T 2M 3M 4J 5J 6M 7M) '(c3 d3 e3 f3 g3 a3 b3) '(c3 d3 e3 f3 g3 c3 c3 c3 g3 c3 c3 d3))`

But in the evaluation, I get this:

`(t 2m 3m 4j 5j t t t 5j t t 2m)`

With lowercase letters, I get 2m , 3m and 5J instead of 2M, 3M and 5J (uppercase names of intervals).

Since I want it for pedagogical reasons, can it be generated with the corresponding UPPERCASE letters ?

Thanks in advance.

All the best,

Julio

]]>

In the docs it says that arp-adlib makes an arpeggio up or down randomly, but there are only arps upward, what am I missing?

thanks!

```
(setf arp '(c4d4e4g4a4b4d5fs5 arp-adlib c4d4e4g4a4b4d5fs5 arp-adlib
c4d4e4g4a4b4d5fs5 arp-adlib c4d4e4g4a4b4d5fs5 arp-adlib
c4d4e4g4a4b4d5fs5 arp-adlib c4d4e4g4a4b4d5fs5 arp-adlib
c4d4e4g4a4b4d5fs5 arp-adlib c4d4e4g4a4b4d5fs5 arp-adlib
c4d4e4g4a4b4d5fs5 arp-adlib))
```

]]>

(setf chords '(c3g3c4ds4 gs2f3c4d4 c3g3c4ds4 gs2f3c4d4 c3g3c4ds4 d3g3b3f4 c3g3c4g4 d3f3c4gs4 ds3g3c4g4 cs3g3as3f4 ds3a3c4fs4 fs3a3c4ds4 c3g3c4ds4 g2g3b3d4 gs2f3c4d4 b2d3f4 c3g3c4ds4 f3gs3c4d4 g2g3b3d4 c3ds3g3ds4 as2e3g3g4 f2f3c4gs4 g2g3b3d4 cs3g3as3f4 b2g3d4g4 c3g3c4ds4 f3gs3c4f4 g2g3b3d4 gs2ds3c4gs4 gs2ds3c4gs4 as2as3d4f4 ds3as3ds4g4 d3f3b3f4 c3g3c4e4 f3gs3c4f4 g2g3c4ds4 g2g3b3d4 c3ds3g3c4 c3ds3g3c4)) (setf instrument1 (gen-repeat (length chords) '(s g4c4 c4 g4e4 g4 d4 c4 g4f4 g4))) (setf instrument1.map1 (harmonic-path chords instrument1 :type '> :octave 'path))

It seems that instrument1 needs to have the melody nested one level in order to make the result work, like this:

(setf instrument1 (gen-repeat (length chords) '((s g4c4 c4 g4e4 g4 d4 c4 g4f4 g4))))

It looks like something changes in gen-repeat, or possibly harmonic-path since December, or am I missing something? Thanks for any insights!

]]>

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:

]]>

I don't understand the result of harmonic-path, as I understand it, it should be (something like):

`(eb4 g4 bb4 d4 gs4 c4 eb4 fs5 b5 bb5 ds5 fs5 b5 d5 g4 b4 eb4 g4 bb4 g4)`

below is the evaluation and I don't understand it, what am I missing..?

```
(harmonic-path '(eb3g3bb3d4 gs3c4ds4fs4 b3ds4fs4bb4 g3b3d4fs4)
'(c4 d4 e4 f4 g4 a4 b4 c5 d5 e5 f5 e5 d5 c5 b4 a4 g4 f4 e4 d4))
==>(eb4 g4 bb4 d4 gs4 c4 eb4 fs5 b5 bb5 eb5 g5 bb5 d5 gs4 c4 eb4 fs4 b4 bb4)
```

It seems that I am overlooking something obvious, so I'am greatful for some help!

Thanks!

]]>

I´m interested in the 4-note combinations of the diatonic scale without repeating elements.

`(combination2 4 '(c3 d3 e3 f3 g3 a3 b3))`

The filter-repeat and the remove-duplicates are not giving the right result.

```
PARTIAL RESULT,,,
combination2, size: 4
((b3 b3 b3 b3) (a3 b3 b3 b3) (g3 b3 b3 b3) (f3 b3 b3 b3) (e3 b3 b3 b3) (d3 b3 b3 b3) (c3 b3 b3 b3) (b3 a3 b3 b3) (a3 a3 b3 b3) (g3 a3 b3 b3) (f3 a3 b3 b3) (e3 a3 b3 b3) (d3 a3 b3 b3) (c3 a3 b3 b3) (b3 g3 b3 b3) (a3 g3 b3 b3) (g3 g3 b3 b3) (f3 g3 b3 b3) (e3 g3 b3 b3) (d3 g3 b3 b3) (c3 g3 b3 b3) (b3 f3 b3 b3) (a3 f3 b3 b3) (g3 f3 b3 b3) (f3 f3 b3 b3) (e3 f3 b3 b3) (d3 f3 b3 b3) (c3 f3 b3 b3) (b3 e3 b3 b3) (a3 e3 b3 b3) (g3 e3 b3 b3) (f3 e3 b3 b3) (e3 e3 b3 b3) (d3 e3 b3 b3) (c3 e3 b3 b3) (b3 d3 b3 b3) (a3 d3 b3 b3) (g3 d3 b3 b3) (f3 d3 b3 b3) (e3 d3 b3 b3) (d3 d3 b3 b3) (c3 d3 b3 b3) (b3 c3 b3 b3) (a3 c3 b3 b3) (g3 c3 b3 b3) (f3 c3 b3 b3) (e3 c3 b3 b3) (d3 c3 b3 b3) (c3 c3 b3 b3) (b3 b3 a3 b3) (a3 b3 a3 b3) (g3 b3 a3 b3) (f3 b3 a3 b3) (e3 b3 a3 b3) (d3 b3 a3 b3) (c3 b3 a3 b3) (b3 a3 a3 b3) (a3 a3 a3 b3) (g3 a3 a3 b3) (f3 a3 a3 b3) (e3 a3 a3 b3) (d3 a3 a3 b3) (c3 a3 a3 b3) (b3 g3 a3 b3) (a3 g3 a3 b3) (g3 g3 a3 b3) (f3 g3 a3 b3) (e3 g3 a3 b3) (d3 g3 a3 b3) (c3 g3 a3 b3) (b3 f3 a3 b3) (a3 f3 a3 b3)
```

I want to filter OUT the sets like

((b3 b3 b3 b3) (a3 b3 b3 b3) (g3 b3 b3 b3) (f3 b3 b3 b3) (e3 b3 b3 b3) (d3 b3 b3 b3)

With one or more repeating notes.

Best,

Julio

]]>

For training purposes I'am rebuilding the examples that Stéphane demonstrates in the Karajan Music Tech Conference Video, but the second example throws me an error and I can't find out what I'am missing..thanks for assistance..

```
(setf thema '(s c4 leg d4 leg e4 leg f4 q g4 ff stacc))
(setf thema.repeat (gen-repeat 24 thema))
(setf scales '((c4 d4 e4 fs4 gs4 a4 b4)(c4 d4 eb4 f4 g4 ab4 bb4)))
(setf path (tonality-series (chordize scales) :closest '(down)))
(setf thema.harm (tonality-map
path
thema.repeat))
```

```
> Error: Incorrect keyword arguments in (:scale ((c4d4e4fs4gs4a4b4) :closest down :ambitus piano) ((c4d4eb4f4g4ab4bb4) :closest down :ambitus piano)) .
> While executing: (:internal scale-map-l tonality-map), in process Listener-1(7).
> Type cmd-. to abort, cmd-\ for a list of available restarts.
> Type :? for other options.
```

Maybe it has to do that I'am still on 1.3??

]]>Newcomer here, please point me to resources if I'm missing something obvious.

Here is a function that substitutes attributes when they are combined. Is there an easier way of doing this? Thanks!

```
(defun attribute-substitution (new old list-of-attributes)
(mapcar (lambda (list) (join-attributes list))
(substitute-map new old (mapcar (lambda (attr)
(disjoin-attributes attr)) list-of-attributes))))
(attribute-substitution 'pizz 'arco '(ten+arco pizz arco))
=> (ten+pizz pizz pizz)
```

]]>

`(ambitus-chord '(14 6) '((eb4c6 c4fs4 b4) (c4b4 b3eb5b3)))`

]]>

function example below, would someone be willing to explain why the ambitus function is not producing all diatonic pitches included in list_? I understand that I may want to use harmonic-path or similar instead, but I just wanted to ask for the learning experience. I feel like I might be missing something so I welcome the feedback!

```
(setf range_ (gen-ambitus-series '(-10 30)
(vector-smooth 0.2 (gen-white-noise 6 :seed 23))
(vector-smooth 0.2 (gen-white-noise 8 :seed 24))))
(integer-to-pitch range_)
(setf list_ '((c4 d4 e4 f4 g4 a4 b4 c5)
(c4 d4 e4 f4 g4 a4 b4 c5)
(c4 d4 e4 f4 g4 a4 b4 c5)
(c4 d4 e4 f4 g4 a4 b4 c5)
(c4 d4 e4 f4 g4 a4 b4 c5)
(c4 d4 e4 f4 g4 a4 b4 c5)
(c4 d4 e4 f4 g4 a4 b4 c5)
(c4 d4 e4 f4 g4 a4 b4 c5)
))
(ambitus range_ list_)
```

Perhaps a different example may illustrate my question better. Below we have a series of transformation of the given harmonic sequence. The pitches (pitch classes) of the harmonic sequence are retained with each individual ambitus transformation, but not when gen-ambitus-series is used (see below). Thanks!

```
(setf omn
'((h e4f5 p c5a4) (h b3d3 gs4eb2fs3) (h bb2g5cs5 gs4d4eb2)
(w bb2 mp) (h g3f4cs5 p c5) (h fs5a5b3 e4b3) (h bb2)
(w e2eb4) (h c5cs6 a5) (h f4g3 gs4d3) (h fs5 bb2fs5g3)
(h d3e5eb4 gs4) (h a2c6 f2) (h b0 cs6c5) (h gs4d3)))
(ambitus '(-6 12) omn)
(setf range
(gen-ambitus-series
'(-30 42)
(vector-smooth 0.2 (gen-white-noise 15 :seed 23))
(vector-smooth 0.2 (gen-white-noise 15 :seed 24))))
(ambitus range omn)
```

]]>

I'am examine 'harmonic-path more closly and have some hard time to understand, if someone could please explain some things to me..

```
(setf chord '(c3 g3 c4 e4 f3 c4 f4 a4))
(setf melodytest '( c4 cs4 d4 e4 f4 fs4 g4 gs4))
(harmonic-path chordtest2 melodytest :octave 'path )
==>(c3 g3 c4 e4 f3 f4 a4 c3)
```

in the example above harmonic-path is obviously swallowing the recurring notes (and is looping the path although the doc says the default is looping nil),

why, I don't get the logic behind it? And can I change this?

In the example below there is no difference in the output between :loop t or :loop nil, I assumed that the looping parameter concerns both, the path and the sequence..?

What am I missing? Thanks!

```
(setf chord '(c3 g3 c4 e4 f3 c4 f4 a4))
(setf melody '(c4 cs4 d4 e4))
(harmonic-path chord melody :octave 'path :loop t )
==>(c3 g3 c4 e4)
(setf melody '(c4 cs4 d4 e4))
(harmonic-path chord melody :octave 'path :loop nil )
==>(c3 g3 c4 e4)
```

]]>

Happy New Year

I´m back to a lot of work with sets, subsets and supersets and I have an idea/suggestion:

When evaluating this

`(pcs-super-sets 7 (pcs '3-1) :forte)`

I get this result

`(7-1 7-2 7-2b 7-3 7-3b 7-4 7-4b 7-5 7-5b 7-6 7-6b 7-7 7-7b 7-8 7-9 7-9b 7-10 7-10b 7-11 7-11b 7-z12 7-13 7-13b 7-14 7-14b 7-15 7-16 7-16b 7-z17 7-z18 7-z18b 7-19 7-19b 7-20 7-20b 7-21 7-21b 7-22 7-23 7-23b 7-24 7-24b 7-25 7-25b 7-26 7-26b 7-27 7-27b 7-28 7-28b 7-29 7-29b 7-30 7-30b 7-33 7-z36 7-z36b 7-z37 7-z38 7-z38b)`

These are all the supersets of cardinality 7 of the 3-1 set.

Would be very nice in this context to have a keyword to invert the result, i.e., actually showing the excluded sets, like all the sets that ARE NOT supersets of the 3-1 set.

Like inverting, like a (pcs-non-super-sets) function. I think that maybe it´s not so difficult, because the algorythm of the function already give the result, the only thing necessary is that the function return exactly the opposite result.

Best,

Julio

]]>

so the entire catalog of FORTE are converted to rhythms, following the steps of Babitt:

As a hardcore serialist, Babbitt was interested in converting 12-tone rows to rhythms, in a kind of 12-tone rhythm theory.

Below, Wuorinen show one example of a typical Babbitt idea:

For the sake of explaining my idea of function, it's important to have in mind that for Babbitt, the order of the

row is very important and lead to different results in the pitch to rhythm conversion. Take a look in the example

below:

In the preceeding figure, the order of the C major triad generate different rhythms. In the example (0 4 7) have a

different result from (4 0 7) or (7 0 4).

In the system I developed in my Dissertation, the order does NOT matter, since (0 4 7), (7 0 4) or (4 0 7) will result

in exactly the same rhythm, as you can see below:

In my system, the transposition equals rotation (as well as in Babbitt)

And every chord symbol can be transformed in a rhythm:

Even voicings can be converted in longer Rhythms (the more spread the voicing, the longer the rhythm):

So I did every FORTE SET in the catalog, in this way:

Below, you can see the example of the rhythm of the major triad (Forte number 3-11b).

In the 1st bar there is the prime form (0 4 7).

In each subsequent bar there is a rotation of the first set by 16th note increments.

**HERE IS THE POINT, for the sake of the new function !**

**The note C (that I call Rhythmic Fundamental, the "root" of the rhythm) is being displaced, as**

** you can see in the circled notes. **

**THE SET WRAP AROUND ITSELF, always forming 12 time-points (always twelve 16th notes), **

**in a different way from Babbit, where the order of the sets generates longer rhythms.**

**THIS WAY IS MORE INTERESTING For Popular and Minimalist Repetition Music, as**

** well as 12 tone music.**

In the bottom staff, there are the complementary rhythm of the 3-11b set, i.e., the 9-11a

set. In the catalog, every set is presented alongside its complementary set and every set is

presented in 3/4 (16th notes) and in 12-8 (with the 8th note as the base value for the increments

and rotations).

So the function needed would be the one that mirror exacty this kind of conversion, not the tradicional time-point-system conversion,

so I could use my catolog inside Opusmodus, connecting the diferent sets, like this:

Or even using portions of the Rhythmic Sets, by truncating some of them, like this:

In the preceeding example, only parts of the 2 sets are used (9 time points out of 12 in the

first and 8 time points out of 12 in the second).

So, I hope someone could help me to find a way of implementing this.

Maybe Janusz or Stephane could find interesting to develop this kind of idea inside

the software.

All the best !

Julio Herrlein

]]>

Does Opusmodus have functions for this (implicitly or explicitly) or does anyone know of a Common Lisp library that is already specialized in Neo-Riemannian transformation? Basically the ability to do P R and L motions using elegant functions and calculating the shortest modulation (shortest Tonnetz steps) from any triad to any other triad.

One of the many explanations on youtube:

]]>

i'm a excited beginner with OM!

Just exploring and modifying the turotials.

One Question:

What would be a good approach to sort the notes which are generated from the snippet below to, say, a scale.

In other words: The outoot below is chromatic. How can i turn it into a scale, eg. d-phrygian)

Thank you!

(setf size 60) (setf vector (gen-sine size 1 '(0.5 0.4 0.3 0.6) :modulation (gen-sine size 1 0.3 :phase 180))) (setf pitchvec (vector-to-pitch '(g1 g6) vector))

]]>

THIS CRASHES

```
(setf padrao '(7 -1 -5 4 -3 2 12 -16))
(setf pitches (gen-sieve '(c4 e6) padrao :type :pitch))
```

THIS DON´T CRASH

```
(setf padrao '(7 -1 -5 4 -3 2 12 -15))
(setf pitches (gen-sieve '(c4 e6) padrao :type :pitch))
```

]]>

In my Doctoral Dissertation, I converted every FORTE number in a modulo 12 Rhythm via time-point-system.

There is a complete catalog included (see the link below). It's in portuguese.

After Janusz adjusted the Forte numbers to have the inversion, using "a" and "b" to differentiate the

prime forms from the inversions, it was easy to convert using codes like this:

```
(setf ch0 (time-point-system (pcs '5-11b :pitch)'s :start 0))
(setf ch1 (time-point-system (pcs '6-33 :pitch)'s :start 1))
(setf ch2 (time-point-system (pcs '7-11b :pitch)'s :start 2))
(setf ch3 (time-point-system (pcs '3-11b :pitch)'s :start 3))
(setf ch4 (time-point-system (pcs '3-11b :pitch)'s :start 0))
```

**The dissertation (in portuguese) can be downloaded HERE:**

Das alturas ao ritmo : teoria dos conjuntos rítmicos como ferramenta composicional

From pitches to rhythm: rhythmic set theory as a compositional tool.

http://hdl.handle.net/10183/179457

This doctoral dissertation is divided into two parts: the first deals a rhythmic set theory, and the second contains the portfolio of compositions developed during this period of studies. This dissertation presents a system of rhythmic organization parallel to the musical set theory pitch class organization FORTE (1973), as well as an adaptation of the time-point-system (BABBITT, 1962). From the standpoint of the traditional set theory, and also from the diatonic set theory, this unified approach allows to estabilish a connecting tissue of basic aspects: from the harmony and chords symbols to the rhythmic organization. At one time, in a complete catalog, the families of pitch class sets and chord symbols are related to their respective rhythmic counterparts. The musical motivation for this research came from my interest in the swinging and groovy repetitive rhythms called timelines (TOUSSAINT, 2013), commonly used in popular music. These dancing timelines have properties similar to those of the diatonic sets, and for this reason, this dissertation presents some properties of the diatonic pitch class sets, drawing a parallel with their rhythmic counterparts. These relationships also appear in the portfolio of compositions, characterizing some procedures used. The portfolio of compositions, which includes a composition for symphony orchestra, is presented form the standpoint of a duality between transparency and opacity. This duality address the essential differences in the audibility of the results from various composition techniques. This study of Rhythmic Set Theory will serve as an analytical approach of my compositional output in popular music, with a systematic way to understant and to extrapolate some aspects already used in my practice as composer and improviser.