Project Guidance

Hi everyone,
I would like to try to do something that I didn’t see yet in here.
I’m working on an Installation and I would love to find a place to share and discuss this project from the beginning till the end.
If someone is intersted in help me out I just opened a repo on Github:


For now there is just a sketch file that I’m using to write some scenes.

The Installation is made of 3 elements:

  • Dimmered Lights
  • Loudspeakers Used like actuators
  • Mechanical Laser Oscilloscopes

I’m exploring this 3 media, asking to myself:
What could I do with 6 lights controlled over time?
How to fully use speakers like actuators?
How to write sounds that looks nice ?
and first of all…
How to Structure everything?

Project Guidance

I found myself quite often looking for solutions of technical problems or ideas, implementations and explenations on this forum,in the mailing list or at https://sccode.org/
I used to play with a friend that helped me a lot with the programming thing.
Here an extract of one of our projects:
https://youtu.be/BBi-QUU0x0I
Now it’s not possible anymore to play togheter, but, to have the possibility of ask here, make me feel enough confidence to start my first project alone.
I’m feeling quite a newbie.

To be explicitly honest I would love to find someone interested in help me out, even sporadically or just when he/she wants/can.
If for you make sense I can open compleatly all the processes of the making including the “ownership” of the Installation, live or whatever will be…

Don’t get me wrong, I don’t think to have the best Ideas of the world, I just copy, or better I take inspiration from other artists that with their works give me a solid starting point.

Said that, I would like to do it collectively and I think that the work belongs to whoever does it.

Like I said I usually take inspirations or I copy:

  • ideas from other artists, musicians or creatves.
  • quite often the code is copied from solutions or implementations made by others.
  • the workflow is taken step by step from some tutorials…and so on…

For example I copied the way to think/structure a performance from here:

or from here a bunch of synths:

A nice thing that I learnt when I studied eletroacustic music from one of my teacher was : “music is sharing” I know that could sounds a bit of a rethoric sentence but I like to think that could be true.
Now, flying down to the planet earth, I kindly ask you your support hoping that this could become a nice moment to confront eachother, bringing out a lean and solid approach to tackle a performative project.

I also hope that, this moment of sharing, if it will be so, could become an interesting “place” to discuss how a project can be structured in its entirety, from the development of the idea, which constantly requires to be modified according to the real possibilities and to the limits, up to the physical realization or the technicalities of programming.

Let’s try to see what will happen :slight_smile:

About the Performative-Installation

My first multimedia performance installation is based on three elements: Light, Sound and Mechanical Laser oscilloscopes.
Currently being in a preliminary phase I have mounted 6 circular equidistant bulbs attached to the ceiling of a room that is dedicated to the development of this installation.


(the light in the center is NOT controlled by the dimmer, is just the light of the room)

The dimmer I use is this one:

I’m in Italy, anyway I’m not recommending to buy stuff from where I bought them, it’s just for for illustrative purposes and as far as I know, there are cheaper places to buy these items, just in case you are interested.

I found this cheap solution, that it works quite well, and I’m happy to share because I guess It could be used in a lot of contexts where a maximum of 8 loudspeakers is needed.

cheap 8-channel sound card:

Amplifier:

Power supply:

Loudspeaker:

cables:

1 LIGHTS/DIMMER

At the moment I’m working with lights only, writing some obvious/foundamental pattern beheviours.

Video snippet of constant circular motion:

2 SOUND /LOUDSPEAKERS

Video snippet using PanAz with the loudspeakers:

This Idea was taken from:

Marcus Fisher

http://mapmap.ch/index.php/ongoing/multiples/

I hypothesized an approach to sound design, where I physically go to put on and off objects that want to vibrate inside the loudspeakers.

The objects that I have identified as interesting are:

  • rattles
  • plastic caps
  • glass eroded by the sea
  • hunting-fishing sinkers
  • leaves and seeds

and casekeeper … beer bottle caps :slight_smile:

Here an example with the lights too.
One to one approach(for light one correspond spaeker one… and so on…)

3 MECHANICAL LASER OSCILLOSCOPE

Another thing that fascinated me a lot was this “experiment” that I saw on youtube:

Laser + mirror + sound

I then decided to try it and I bought the Balloons, lasers and mirrors.

I then looked for information about the generation of Lissajous figures and how an Oscilloscope works.

There are fundamental differences between this way of viewing sound and a real oscilloscope, first of all it is not possible to view the high frequencies, this approach works well only in the low and medium range and I have to build a way to make the system solid and have the certainty that the figure produced will be replicable. I think this will be done with 3d printing techniques, in order to decide the angle and distance between laser and mirror, and it would be essential to find a way to stretch the balloon membrane homogeneously.

For this approach, however, I based myself on additive synthesis and then I found Phase Modulation extremely interesting.

Just a couple of video snippets taken for memo purposes.
complex waveforms additive synthesis:

Phase Modulation:

and I found some intersting ideas to compose waveforms from this book:
https://www.packtpub.com/application-development/mapping-and-visualization-supercollider#tab-label-table.of.contents

These are the first 3 elements that I am interested to explore for now.

1 What and how is it possible to do with 6 lights (search and structuring of a phrasebook)
2 Speakers like Actuator (From punctual to continuous) (Low and Infrasonic music).
3 Draw with sound. waveform composition.

In the end the first thing I’m working on is copying from this teaser the different lights movements.

Takami Nakamoto - Opacity EP Teaser Medley


I’m just intersted in having a musical work like a reference

The artists or the Ideas I would love to copy from are :

Sound inspirations

1 Pattern and Signal Based approach

Marcus Fisher

http://mapmap.ch/index.php/ongoing/multiples/
video extract: https://youtu.be/9tW34OvHs24

Mark Fell |Multistability

http://www.markfell.com/wiki/index.php?n=Mf.Multistability

Gavin-Harrison-Rhythmic-Illusions

http://www.gavharrison.com/
From this book it’s possible to read/study and listen to
a really nice examples of Rhythmic modulations, polymeters My goal in this regard is just to create polimeters in between from sounds Pattern and light Patterns.

Nik Bärtsch


http://www.nikbaertsch.com/

2 Controllerism Like approach

**Pallavi e Ritmi **

I’m very fascinated by this piece,
that is rich of rhythmic Ideas and could let me expand in this direction.

Hip-hop/afro/dub/funk/fusion drums Grooves
will be added …

Lighting Inspirations

I found some difficulties to find artists that work
with lightsbulbs in a musical context.

Takami Nakamoto - Opacity EP Teaser Medley


I’m just intersted in having a musical work like a reference

Daito Manabe

Jeff Carey - Ende Tymes

Marije Baalman
https://marijebaalman.eu/projects/n-polytope.html

4 Likes

This looks fascinating, and I think sharing your process and code is a fantastic idea.
I’m looking forward to following your progress.

1 Like

Thanks for sharing this. Very interesting!

1 Like

Tour of Array.methods

http://doc.sccode.org/Classes/Array.html

I’m moving the first steps to see how and what I could do with 6 lights.
If you want to join us, @elgiano is guiding me/ helping me .
you are welcome :partying_face:

  1. Run the file that load the others
 (
 s.waitForBoot{
     [
         "synthdefs.scd",
         "utils.scd",
         "setup_lights.scd",
         "metro.scd",
     ]
     .do(_.loadRelative);

 	s.plotTree;
 	s.meter;
 }
 )

 // start-stop processing osc responder
 OSCdef(\processing).disable // pause
 OSCdef(\processing).enable // resume

Processing
If you like to try by yourself you could run the processingOSCnodimmer.pde to visualize the envelopes/animations.

If you know some nice concatenations of methods it would be a plasure to try them out :slight_smile:

import oscP5.*;
import netP5.*;

OscP5 osc;
NetAddress sc;

float amp1,amp2,amp3,amp4,amp5,amp6;

void setup(){
  size(420, 66);

  osc = new OscP5(this, 12321);
  sc = new NetAddress("127.0.0.1", 57120);

  // PLUGS
  osc.plug(this, "newamps", "/amps");

 
}


void draw(){
  background(0);

  //ask data at frameRate with .send
  OscMessage msg = new OscMessage("/getAmps");
  osc.send(msg, sc);

 // UI
 noStroke();

 // channel 1
  fill(153, 255*amp1, 0);
  rect(0, 0, width/6, height*amp1);

  // channel 2
  
  fill(153, 255*amp2, 0);
  rect(70, 0, width/6, height*amp2);

  // channel 3
  fill(153, 255*amp3, 0);
  rect(140, 0, width/6, height*amp3);

  // channel 4
  fill(153, 255*amp4, 0);
  rect(210, 0, width/6, height*amp4);

  // channel 5
  fill(153, 255*amp5, 0);
  rect(280, 0, width/6, height*amp5);

  // channel 6
  fill(153, 255*amp6, 0);
  rect(350, 0, width/6, height*amp6);

}

// funcction  to get the data and send them to the proper place.
void newamps(float rms1, float rms2, float rms3, float rms4, float rms5, float rms6){
   amp1 = rms1; amp2 = rms2; amp3 = rms3; amp4 = rms4; amp5 = rms5; amp6 = rms6;
   println("[",amp1,amp2,amp3,amp4,amp5,amp6,"]");
}

Then if you need to use it with a dimmer just go on github https://github.com/RandColors/project-guidance/tree/master/ProcessingOSC and run the “ProcessingOSC.pde” file in Processing
https://processing.org/

in SC:
Run

  • setup.scd
  • sketches.scd

if you like to make .gif files from your pattern, here the code:

import gifAnimation.*;
import oscP5.*;
import netP5.*;

GifMaker gifExport;
int frames = 0;

OscP5 osc;
NetAddress sc;

float amp1, amp2, amp3, amp4, amp5, amp6;

public void setup() {
frameRate(60);
  smooth();
  size(420, 66);
 
  osc = new OscP5(this, 12321);
  sc = new NetAddress("127.0.0.1", 57120);
  osc.plug(this, "newamps", "/amps");
  osc.plug(this, "startrec", "/startrec");
  osc.plug(this, "stoprec", "/stoprec");
 

  noFill();
  stroke(0);
  strokeWeight(20);
 
  gifExport = new GifMaker(this, "export.gif", 100);
}

void draw() {

  background(255);

  background(0);

  //ask data at frameRate using .send
  OscMessage msg = new OscMessage("/getAmps");
  osc.send(msg, sc);

  // UI
  noStroke();

  // channel 1
  fill(153, 255*amp1, 0);
  rect(0, 0, width/6, height*amp1);

  // channel 2
  
  fill(153, 255*amp2, 0);
  rect(70, 0, width/6, height*amp2);

  // channel 3
  fill(153, 255*amp3, 0);
  rect(140, 0, width/6, height*amp3);

  // channel 4
  fill(153, 255*amp4, 0);
  rect(210, 0, width/6, height*amp4);

  // channel 5
  fill(153, 255*amp5, 0);
  rect(280, 0, width/6, height*amp5);

  // channel 6
  fill(153, 255*amp6, 0);
  rect(350, 0, width/6, height*amp6);

  if (gifExport != null) {
gifExport.setDelay(20);
gifExport.addFrame();
frames++;
  }
}

void newamps(float rms1, float rms2, float rms3, float rms4, float rms5, float rms6) {
  amp1 = rms1;
  amp2 = rms2;
  amp3 = rms3;
  amp4 = rms4;
  amp5 = rms5;
  amp6 = rms6;
  println("[", amp1, amp2, amp3, amp4, amp5, amp6, "]");
}

void startrec(String s) {
  gifExport = new GifMaker(this, "export.gif", 100);
  gifExport.setRepeat(0); // make it an "endless" animation
  println("----------- start " + s);
}

void stoprec(String s) {
  gifExport.finish();
  exit();
  println("----------- stop " + s);
}

// replace the pattern in p

(
p = Pbindef(\forward,
    \instrument, \DcOuts,
	\stretch,4,
	\legato,1,
	\bus,Pseq((0..5).stutter(4),1) + ~lightsBus.index,
    \amp,1,
    \env, Pseq([
		[Env.perc(0.001,0.999,1,4)]
    ],inf),
	\dur, Pseq([1/8],inf),
    \finish, ~beatsToSeconds
);
)

(
var lightsAddr = ~lightsAddr;

Pfset(
	func:{lightsAddr.sendMsg('/startrec',"startrec".postln)},
	pattern:p ,
	cleanupFunc:{lightsAddr.sendMsg('/stoprec',"stoprec".postln)}
).play(~metro.base ,quant:~metro.base.beatsPerBar);
)

p.play(~metro.base ,quant:~metro.base.beatsPerBar);

first things first, default words:

forward

Pbindef(\forward,
\instrument, \DcOuts,
	\stretch,4,
	\legato,1,
\bus,Pseq((0..5),inf) + ~lightsBus.index,
\amp,1,
\env, Pseq([
		[Env.perc(0.001,0.999,1,4)]
],inf),
	\dur, Pseq([1/4],inf),
\finish, ~beatsToSeconds
).play(~metro.base ,quant:~metro.base.beatsPerBar);
)
 
Pbindef(\forward).stop;
Pbindef(\forward).clear;

reverse

(
Pbindef(\reverse,
\instrument, \DcOuts,
	\stretch,4,
	\legato,1,![palindromo|420x66, 75%](upload://gAk4AFhPF92f3KlpdTOdtwgGSkS.gif) 
\bus,Pseq((0..5).reverse,inf) + ~lightsBus.index,
\amp,1,
\env, Pseq([
		[Env.perc(0.001,0.999,1,4)]
],inf),
	\dur, Pseq([1/4],inf),
\finish, ~beatsToSeconds
).play(~metro.base ,quant:~metro.base.beatsPerBar);
)


Pbindef(\reverse).stop;
Pbindef(\reverse).clear;

palindromo

(
Pbindef(\palindromo,
\instrument, \DcOuts,
	\stretch,4,
	\legato,1,
\bus,Pseq((0..5).mirror1,inf) + ~lightsBus.index,
\amp,1,
\env, Pseq([
		[Env.perc(0.001,0.999,1,4)]
],inf),
	\dur, Pseq([1/4],inf),
\finish, ~beatsToSeconds
).play(~metro.base ,quant:~metro.base.beatsPerBar);
)

Pbindef(\palindromo).stop;
Pbindef(\palindromo).clear;

// a scrambled array sequenced, repeted over and over
scramble

(
Pbindef(\scramble,
\instrument, \DcOuts,
	\legato,1,
	\stretch,4,
\bus,Pseq((0..5).scramble,inf) + ~lightsBus.index,
\amp,1,
\env, Pseq([
		[Env.perc(0.001,0.999,1,4)]
],inf),
	\dur, Pseq([1/4],inf),
\finish, ~beatsToSeconds
).play(~metro.base ,quant:~metro.base.beatsPerBar);
)


Pbindef(\scramble).stop;
Pbindef(\scramble).clear;


// all togheter 

tutti

(
Pbindef(\tutti,
\instrument, \DcOuts,
   \legato,1,
\stretch,4,
\bus,Pseq([(0..5)],inf) + ~lightsBus.index,
\amp,1,
\env, Pseq([
 [Env.perc(0.999,0.001,1,4)]
],inf),
  \dur, Pseq([1/4],inf),
\finish, ~beatsToSeconds
).play(~metro.base ,quant:~metro.base.beatsPerBar);
)

Pbindef(\tutti).stop
Pbindef(\tutti).clear

more methods

.powerset
Returns all possible combinations of the array’s elements.

powerset

(0..5).powerset.postln;
[ [ ], [ 0 ], [ 1 ], [ 0, 1 ], [ 2 ], [ 0, 2 ], [ 1, 2 ], [ 0, 1, 2 ], [ 3 ], [ 0, 3 ], [ 1, 3 ], [ 0, 1, 3 ], [ 2, 3 ], [ 0, 2, 3 ], [ 1, 2, 3 ], [ 0, 1, 2, 3 ], [ 4 ], [ 0, 4 ], [ 1, 4 ], [ 0, 1, 4 ], [ 2, 4 ], [ 0, 2, 4 ], [ 1, 2, 4 ], [ 0, 1, 2, 4 ], [ 3, 4 ], [ 0, 3, 4 ], [ 1, 3, 4 ], [ 0, 1, 3, 4 ], [ 2, 3, 4 ], [ 0, 2, 3, 4 ], [ 1, 2, 3, 4 ], [ 0, 1, 2, 3, 4 ], [ 5 ], [ 0, 5 ], [ 1, 5 ], [ 0, 1, 5 ], [ 2, 5 ], [ 0, 2, 5 ], [ 1, 2, 5 ], [ 0, 1, 2, 5 ], [ 3, 5 ], [ 0, 3, 5 ], [ 1, 3, 5 ], [ 0, 1, 3, 5...etc...

powerset_sort_by_size_ big_first
(0..5).powerset.sort({ |a, b| a.size > b.size }); // sort by size, big first
[ [ 0, 1, 2, 3, 4, 5 ], [ 1, 2, 3, 4, 5 ], [ 0, 2, 3, 4, 5 ], [ 0, 1, 3, 4, 5 ], [ 0, 1, 2, 4, 5 ], [ 0, 1, 2, 3, 5 ], [ 0, 1, 2, 3, 4 ], [ 2, 3, 4, 5 ], [ 1, 3, 4, 5 ], [ 0, 3, 4, 5 ], [ 1, 2, 4, 5 ], [ 0, 2, 4, 5 ], [ 0, 1, 4, 5 ], [ 1, 2, 3, 5 ], [ 0, 2, 3, 5 ], [ 0, 1, 3, 5 ], [ 0, 1, 2, 5 ], [ 1, 2, 3, 4 ], [ 0, 2, 3, 4 ], [ 0, 1, 3, 4 ], [ 0, 1, 2, 4 ], [ 0, 1, 2, 3 ], [ 3, 4, 5 ], [ 2, 4, 5 ], [ 1, 4, 5 ], [ 0, 4, 5 ], [ 2, 3, 5 ], [ 1, 3, 5 ], [ 0, 3, 5 ], [ 1, 2, 5 ], [ 0, 2, 5 ], [ 0, 1, 5 ], [ 2,...etc...

powerset_small_first
(0..5).powerset.sort({ |a, b| a.size > b.size }).reverse; // by size, small first
[ [ ], [ 0 ], [ 1 ], [ 2 ], [ 3 ], [ 4 ], [ 5 ], [ 0, 1 ], [ 0, 2 ], [ 1, 2 ], [ 0, 3 ], [ 1, 3 ], [ 2, 3 ], [ 0, 4 ], [ 1, 4 ], [ 2, 4 ], [ 3, 4 ], [ 0, 5 ], [ 1, 5 ], [ 2, 5 ], [ 3, 5 ], [ 4, 5 ], [ 0, 1, 2 ], [ 0, 1, 3 ], [ 0, 2, 3 ], [ 1, 2, 3 ], [ 0, 1, 4 ], [ 0, 2, 4 ], [ 1, 2, 4 ], [ 0, 3, 4 ], [ 1, 3, 4 ], [ 2, 3, 4 ], [ 0, 1, 5 ], [ 0, 2, 5 ], [ 1, 2, 5 ], [ 0, 3, 5 ], [ 1, 3, 5 ], [ 2, 3, 5 ], [ 0, 4, 5 ], [ 1, 4, 5 ], [ 2, 4, 5 ], [ 3, 4, 5 ], [ 0, 1, 2, 3 ], [ 0, 1, 2, 4 ], [ 0, 1, 3, 4 ], [ 0,...etc...

.pyramid(patternType: 1)
Return a new Array whose elements have been reordered via one of 10 “counting” algorithms. Run the examples to see the algorithms.

    (
    10.do({ arg i;
    	(0..5).pyramid(i + 1).postcs;
    });
    )

// 21 elemets .pyramid(1)
pyramid(1)
[ 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5 ]
pyramid(1)

// 21 elemets .pyramid(2)
pyramid(2)
[ 5, 4, 5, 3, 4, 5, 2, 3, 4, 5, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5 ]
pyramid(2)

// 21 elemets .pyramid(3)
pyramid(3)
[ 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 0, 1, 2, 3, 0, 1, 2, 0, 1, 0 ]
pyramid(3)

// 21 elemets .pyramid(4)
pyramid(4)
[ 0, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 2, 3, 4, 5, 3, 4, 5, 4, 5, 5 ]
pyramid(4)

// 36 elemets .pyramid(5)
pyramid(5)
[ 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 0, 1, 2, 3, 0, 1, 2, 0, 1, 0 ]
pyramid(5)

// 36 elemets .pyramid(6)
pyramid(6)
[ 5, 4, 5, 3, 4, 5, 2, 3, 4, 5, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 2, 3, 4, 5, 3, 4, 5, 4, 5, 5 ]
pyramid(6)

/ 41 elements .pyramid(7)
pyramid(7)
[ 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 0, 1, 2, 3, 0, 1, 2, 0, 1, 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5 ]
pyramid(7)

// 41 elements .pyramid(8)
pyramid(8)
[ 0, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 2, 3, 4, 5, 3, 4, 5, 4, 5, 5, 4, 5, 3, 4, 5, 2, 3, 4, 5, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5 ]
pyramid(8)

// 36 elements .pyramid(9)
pyramid(9)
[ 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 2, 3, 4, 5, 3, 4, 5, 4, 5, 5 ]
pyramid(9)

// 36 elements .pyramid(10)
pyramid(10)
[ 5, 4, 5, 3, 4, 5, 2, 3, 4, 5, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 0, 1, 2, 3, 0, 1, 2, 0, 1, 0 ]
pyramid(10)

.pyramidg(patternType: 1)
Like pyramid, but keep the resulting values grouped in subarrays

(
  10.do({ arg i;
(0..5).pyramidg(i + 1).postcs;
  });
)

// .pyramidg(1) 6 arrays
pyramidg(1)
[ [ 0 ], [ 0, 1 ], [ 0, 1, 2 ], [ 0, 1, 2, 3 ], [ 0, 1, 2, 3, 4 ], [ 0, 1, 2, 3, 4, 5 ] ]
pyramidg(1)
pyramidg(1)plotB

// .pyramidg(2) 6 arrays
pyramidg(2)
[ [ 5 ], [ 4, 5 ], [ 3, 4, 5 ], [ 2, 3, 4, 5 ], [ 1, 2, 3, 4, 5 ], [ 0, 1, 2, 3, 4, 5 ] ]
pyramidg(2) pyramidg(2)plotB

// .pyramidg(3) 6 arrays
pyramidg(3)
[ [ 0, 1, 2, 3, 4, 5 ], [ 0, 1, 2, 3, 4 ], [ 0, 1, 2, 3 ], [ 0, 1, 2 ], [ 0, 1 ], [ 0 ] ]
pyramidg(3) pyramidg(3)plotB

// .pyramidg(4) 6 arrays
pyramidg(4)
[ [ 0, 1, 2, 3, 4, 5 ], [ 1, 2, 3, 4, 5 ], [ 2, 3, 4, 5 ], [ 3, 4, 5 ], [ 4, 5 ], [ 5 ] ]
pyramidg(4) pyramidg(4)plotB

// .pyramidg(5) 11 arrays
arrayspyramidg(5)
[ [ 0 ], [ 0, 1 ], [ 0, 1, 2 ], [ 0, 1, 2, 3 ], [ 0, 1, 2, 3, 4 ], [ 0, 1, 2, 3, 4, 5 ], [ 0, 1, 2, 3, 4 ], [ 0, 1, 2, 3 ], [ 0, 1, 2 ], [ 0, 1 ], [ 0 ] ]
pyramidg(5) pyramidg(5)plotB

// .pyramidg(6) 11 arrays
pyramidg(6) !!
[ [ 5 ], [ 4, 5 ], [ 3, 4, 5 ], [ 2, 3, 4, 5 ], [ 1, 2, 3, 4, 5 ], [ 0, 1, 2, 3, 4, 5 ], [ 1, 2, 3, 4, 5 ], [ 2, 3, 4, 5 ], [ 3, 4, 5 ], [ 4, 5 ], [ 5 ] ]
pyramidg(6) pyramidg(6)plotB

// .pyramidg(7) 11 arrays
pyramidg(7)
[ [ 0, 1, 2, 3, 4, 5 ], [ 0, 1, 2, 3, 4 ], [ 0, 1, 2, 3 ], [ 0, 1, 2 ], [ 0, 1 ], [ 0 ], [ 0, 1 ], [ 0, 1, 2 ], [ 0, 1, 2, 3 ], [ 0, 1, 2, 3, 4 ], [ 0, 1, 2, 3, 4, 5 ] ]
pyramidg(7) pyramidg(7)plotB

// .pyramidg(8) 11 arrays
pyramidg(8)
[ [ 0, 1, 2, 3, 4, 5 ], [ 1, 2, 3, 4, 5 ], [ 2, 3, 4, 5 ], [ 3, 4, 5 ], [ 4, 5 ], [ 5 ], [ 4, 5 ], [ 3, 4, 5 ], [ 2, 3, 4, 5 ], [ 1, 2, 3, 4, 5 ], [ 0, 1, 2, 3, 4, 5 ] ]
pyramidg(8) pyramidg(8)plotB

// .pyramidg(9) 11 arrays
pyramidg(9)
[ [ 0 ], [ 0, 1 ], [ 0, 1, 2 ], [ 0, 1, 2, 3 ], [ 0, 1, 2, 3, 4 ], [ 0, 1, 2, 3, 4, 5 ], [ 1, 2, 3, 4, 5 ], [ 2, 3, 4, 5 ], [ 3, 4, 5 ], [ 4, 5 ], [ 5 ] ]
pyramidg(9) pyramidg(9)plotB

// .pyramidg(10) 11 arrays
pyramidg(10)
[ [ 5 ], [ 4, 5 ], [ 3, 4, 5 ], [ 2, 3, 4, 5 ], [ 1, 2, 3, 4, 5 ], [ 0, 1, 2, 3, 4, 5 ], [ 0, 1, 2, 3, 4 ], [ 0, 1, 2, 3 ], [ 0, 1, 2 ], [ 0, 1 ], [ 0 ] ]
pyramidg(10) pyramidg(10)plotB

.slide(windowLength: 3, stepSize: 1)
Return a new Array whose elements are repeated subsequences from the receiver. Easier to demonstrate than explain.

// 10 elements
(0..5).slide(2, 1).asCompileString.postln;
slide(2, 1)
[ 0, 1, 1, 2, 2, 3, 3, 4, 4, 5 ]
slide(2,1)

// 12 elements
(0..5).slide(3, 1).asCompileString.postln;
slide(3, 1)
[ 0, 1, 2, 1, 2, 3, 2, 3, 4, 3, 4, 5 ]
slide(3,1)

// 12 elements
(0..5).slide(4, 1).asCompileString.postln;
slide(4, 1)
[ 0, 1, 2, 3, 1, 2, 3, 4, 2, 3, 4, 5 ]
slide(4,1)

// 10 elements
(0..5).slide(5, 1).asCompileString.postln;
slide(5, 1)
[ 0, 1, 2, 3, 4, 1, 2, 3, 4, 5 ]
slide(5,1)

// 3 elements
(0..5).slide(1, 2).asCompileString.postln;
slide(1, 2)
[ 0, 2, 4 ]
slide(1,2)

// 2 elements
(0..5).slide(1, 3).asCompileString.postln;
slide(1, 3)
[ 0, 3 ]
slide(1,3)

// 6 elements
(0..5).slide(3, 2).asCompileString.postln;
slide(3, 2)
[ 0, 1, 2, 2, 3, 4 ]
slide(3,2)

// 8 elements
(0..5).slide(4, 2).asCompileString.postln;
slide(4, 2)
[ 0, 1, 2, 3, 2, 3, 4, 5 ]
slide(4,2)

// 2 elements
(0..5).slide(1, 4).asCompileString.postln;
slide(1, 4)
[ 0, 4 ]
slide(1,4)

.mirror2
Return a new Array which is the receiver concatenated with a reversal of itself. The center element is duplicated. The receiver is unchanged.

mirror2

(0..5).mirror2

[ 0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0 ]

**
.stutter(n: 2)
Return a new Array whose elements are repeated n times. The receiver is unchanged.**

(0..5).stutter(2).postln;
stutter(2)
[ 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5 ]

(0..5).stutter(3).postln;
stutter(3)
[ 0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5 ]

(0..5).stutter(4).postln;
stutter(4)
[ 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5 ]

.sputter(probability: 0.25, maxlen: 100)
Return a new Array of length maxlen with the items partly repeated (random choice of given probability).
here it’s possible to see 10 different postln for each .sputter()

// sputter(0.1, 6)

  10.do{(0..5).sputter(0.1, 6).postln;};
            [ 0, 1, 2, 3, 4, 5 ]
            [ 0, 1, 2, 3, 4, 5 ]
            [ 0, 1, 2, 3, 3, 4 ]
            [ 0, 1, 2, 3, 4, 5 ]
            [ 0, 1, 2, 3, 4, 5 ]
            [ 0, 1, 2, 3, 4, 5 ]
            [ 0, 1, 2, 3, 4, 5 ]
            [ 0, 1, 2, 3, 4, 5 ]
            [ 0, 1, 2, 3, 3, 4 ]
            [ 0, 1, 2, 3, 3, 4 ]

// sputter(0.1, 100)

sputter(0.1, 100)

    10.do{(0..5).sputter(0.1, 100).postln;};
    [ 0, 1, 2, 3, 4, 5 ]
    [ 0, 1, 2, 3, 3, 3, 3, 4, 5, 5 ]
    [ 0, 0, 1, 2, 2, 3, 4, 5 ]
    [ 0, 1, 2, 2, 3, 4, 5 ]
    [ 0, 1, 2, 3, 4, 5 ]
    [ 0, 1, 2, 3, 4, 5 ]
    [ 0, 1, 2, 3, 4, 5 ]
    [ 0, 1, 2, 2, 3, 4, 5 ]
    [ 0, 1, 1, 2, 2, 3, 4, 5 ]
    [ 0, 1, 1, 2, 3, 4, 5 ]

// sputter(0.2, 6)

    10.do{(0..5).sputter(0.2, 6).postln;};
    [ 0, 1, 2, 3, 4, 4 ]
    [ 0, 1, 2, 3, 4, 5 ]
    [ 0, 1, 2, 3, 4, 5 ]
    [ 0, 1, 2, 3, 3, 3 ]
    [ 0, 1, 2, 3, 4, 5 ]
    [ 0, 1, 2, 3, 3, 3 ]
    [ 0, 1, 2, 3, 4, 5 ]
    [ 0, 1, 2, 3, 4, 5 ]
    [ 0, 1, 2, 3, 3, 4 ]
    [ 0, 1, 2, 2, 3, 4 ]

// sputter(0.2, 100)

sputter(0.2, 100)

    10.do{(0..5).sputter(0.2, 100).postln;};
    [ 0, 1, 2, 3, 4, 5 ]
    [ 0, 1, 2, 2, 3, 4, 5 ]
    [ 0, 0, 1, 2, 3, 4, 5 ]
    [ 0, 1, 1, 2, 3, 4, 5 ]
    [ 0, 1, 2, 3, 3, 4, 5 ]
    [ 0, 1, 1, 2, 3, 3, 4, 4, 5 ]
    [ 0, 1, 1, 2, 3, 3, 4, 5 ]
    [ 0, 0, 1, 2, 3, 3, 4, 5, 5 ]
    [ 0, 1, 2, 3, 4, 5 ]
    [ 0, 1, 2, 3, 4, 5 ]

// sputter(0.3, 6)

    10.do{(0..5).sputter(0.3, 6).postln;};
    [ 0, 1, 2, 3, 3, 4 ]
    [ 0, 1, 2, 3, 4, 5 ]
    [ 0, 0, 1, 1, 2, 3 ]
    [ 0, 1, 2, 3, 3, 3 ]
    [ 0, 0, 1, 2, 2, 3 ]
    [ 0, 0, 1, 2, 3, 4 ]
    [ 0, 1, 2, 3, 4, 5 ]
    [ 0, 0, 0, 0, 0, 0 ]
    [ 0, 1, 1, 1, 2, 3 ]
    [ 0, 1, 1, 2, 2, 3 ]

// sputter(0.3, 100)

sputter(0.3, 100)

10.do{(0..5).sputter(0.3, 100).postln;};
[ 0, 1, 2, 2, 3, 4, 4, 5 ]
[ 0, 1, 2, 2, 3, 4, 5, 5 ]
[ 0, 0, 1, 2, 3, 3, 4, 4, 5 ]
[ 0, 0, 1, 1, 1, 2, 3, 3, 4, 5 ]
[ 0, 1, 2, 2, 3, 4, 4, 5, 5, 5, 5, 5, 5 ]
[ 0, 1, 1, 2, 3, 4, 5, 5 ]
[ 0, 1, 2, 3, 3, 4, 5, 5, 5 ]
[ 0, 0, 1, 1, 2, 3, 4, 5, 5, 5 ]
[ 0, 0, 1, 2, 3, 3, 4, 4, 5 ]
[ 0, 0, 1, 2, 3, 4, 5 ]

// sputter(0.4, 6)

10.do{(0..5).sputter(0.4, 6).postln;};
[ 0, 0, 1, 1, 1, 1 ]
[ 0, 0, 1, 2, 2, 2 ]
[ 0, 0, 0, 0, 1, 2 ]
[ 0, 1, 2, 3, 3, 3 ]
[ 0, 0, 0, 0, 1, 2 ]
[ 0, 1, 2, 2, 3, 4 ]
[ 0, 1, 2, 3, 3, 4 ]
[ 0, 0, 1, 1, 2, 3 ]
[ 0, 0, 1, 1, 2, 3 ]
[ 0, 1, 1, 2, 2, 3 ]

// sputter(0.4, 100)

sputter(0.4, 100)

    10.do{(0..5).sputter(0.4, 100).postln;};
    [ 0, 0, 1, 2, 2, 3, 4, 5 ]
    [ 0, 0, 0, 1, 2, 2, 3, 4, 4, 5, 5 ]
    [ 0, 1, 2, 3, 3, 4, 5 ]
    [ 0, 1, 1, 2, 3, 3, 4, 5, 5 ]
    [ 0, 1, 2, 3, 3, 4, 4, 5, 5 ]
    [ 0, 0, 0, 0, 1, 2, 3, 3, 4, 5, 5 ]
    [ 0, 0, 0, 0, 0, 1, 1, 2, 3, 4, 5, 5, 5, 5, 5 ]
    [ 0, 0, 0, 0, 0, 0, 1, 2, 2, 3, 3, 4, 5, 5, 5, 5, 5 ]
    [ 0, 0, 0, 0, 0, 1, 2, 2, 3, 3, 3, 4, 5 ]
    [ 0, 1, 2, 2, 3, 4, 5 ]

// sputter(0.5, 6)

    10.do{(0..5).sputter(0.5, 6).postln;};
    [ 0, 0, 0, 1, 1, 2 ]
    [ 0, 1, 2, 2, 3, 3 ]
    [ 0, 0, 0, 0, 0, 0 ]
    [ 0, 0, 1, 1, 1, 1 ]
    [ 0, 0, 0, 1, 1, 2 ]
    [ 0, 1, 2, 2, 3, 3 ]
    [ 0, 1, 2, 2, 2, 2 ]
    [ 0, 0, 0, 0, 0, 0 ]
    [ 0, 0, 1, 2, 3, 4 ]
    [ 0, 1, 1, 2, 3, 4 ]

// sputter(0.5, 100)

sputter(0.5, 100)

    10.do{(0..5).sputter(0.5, 100).postln;};
    [ 0, 1, 2, 2, 2, 2, 2, 2, 3, 4, 5 ]
    [ 0, 1, 2, 2, 3, 3, 4, 4, 5 ]
    [ 0, 0, 0, 1, 2, 3, 4, 4, 5, 5, 5 ]
    [ 0, 0, 1, 1, 1, 1, 2, 3, 3, 3, 3, 4, 5 ]
    [ 0, 0, 0, 0, 1, 2, 3, 4, 4, 5 ]
    [ 0, 0, 1, 1, 2, 2, 2, 2, 2, 3, 3, 4, 5, 5, 5 ]
    [ 0, 0, 1, 1, 2, 3, 4, 5, 5, 5, 5 ]
    [ 0, 0, 0, 0, 0, 1, 1, 1, 2, 3, 3, 4, 5 ]
    [ 0, 0, 1, 2, 2, 3, 3, 3, 4, 5, 5 ]
    [ 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 2, 3, 3, 3, 4, 5, 5 ]

// sputter(0.6, 6)

10.do{(0..5).sputter(0.6, 6).postln;};
[ 0, 1, 1, 2, 2, 2 ]
[ 0, 0, 0, 0, 0, 0 ]
[ 0, 0, 1, 1, 2, 3 ]
[ 0, 0, 0, 1, 2, 3 ]
[ 0, 1, 1, 1, 1, 2 ]
[ 0, 1, 1, 2, 3, 3 ]
[ 0, 1, 1, 1, 1, 2 ]
[ 0, 0, 0, 1, 1, 2 ]
[ 0, 0, 1, 2, 2, 3 ]
[ 0, 0, 0, 0, 0, 0 ]

// sputter(0.6, 100)

sputter(0.6, 100)

10.do{(0..5).sputter(0.6, 100).postln;};
[ 0, 0, 1, 1, 1, 2, 3, 3, 3, 3, 3, 4, 5, 5, 5 ]
[ 0, 0, 1, 2, 2, 3, 3, 3, 3, 3, 3, 4, 5, 5, 5, 5, 5 ]
[ 0, 0, 1, 2, 3, 3, 3, 3, 4, 4, 4, 5 ]
[ 0, 0, 1, 1, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 4, 5 ]
[ 0, 1, 1, 2, 2, 2, 2, 2, 2, 3, 4, 4, 4, 5, 5 ]
[ 0, 1, 2, 3, 3, 4, 5 ]
[ 0, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 5, 5, 5 ]
[ 0, 1, 1, 2, 2, 2, 2, 3, 3, 4, 5 ]
[ 0, 0, 0, 1, 2, 3, 3, 3, 4, 4, 5, 5 ]
[ 0, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 4, 4, 4, 5 ]

// sputter(0.7, 6)

10.do{(0..5).sputter(0.7, 6).postln;};
[ 0, 0, 0, 0, 1, 1 ]
[ 0, 0, 0, 0, 0, 0 ]
[ 0, 1, 2, 3, 3, 3 ]
[ 0, 0, 0, 0, 0, 0 ]
[ 0, 0, 1, 1, 2, 2 ]
[ 0, 0, 0, 0, 1, 1 ]
[ 0, 0, 0, 1, 2, 3 ]
[ 0, 0, 0, 0, 1, 2 ]
[ 0, 1, 1, 2, 2, 3 ]
[ 0, 1, 1, 2, 2, 3 ]

// sputter(0.7, 100)

sputter(0.7, 100)

10.do{(0..5).sputter(0.7, 100).postln;};
[ 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 5, 5 ]
[ 0, 0, 0, 0, 1, 2, 2, 2, 2, 3, 3, 3, 4, 4, 5 ]
[ 0, 0, 0, 0, 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 5, 5 ]
[ 0, 0, 1, 1, 2, 2, 3, 4, 5, 5, 5, 5, 5 ]
[ 0, 0, 1, 1, 2, 2, 2, 3, 4, 5, 5, 5, 5 ]
[ 0, 0, 0, 0, 0, 0, 0, 1, 2, 2, 2, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5 ]
[ 0, 1, 1, 1, 2, 2, 2, 3, 4, 4, 5, 5, 5, 5 ]
[ 0, 0, 0, 0, 0, 1, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5 ]
[ 0, 1, 1, 1, 1, 1, 1, 2, 3, 4, 5, 5, 5, 5, 5 ]
[ 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 3, 3, 4, 5, 5, 5, 5 ]

// sputter(0.8, 6)

10.do{(0..5).sputter(0.8, 6).postln;};
[ 0, 0, 0, 0, 0, 0 ]
[ 0, 1, 1, 1, 2, 2 ]
[ 0, 0, 1, 2, 2, 2 ]
[ 0, 0, 0, 0, 0, 0 ]
[ 0, 0, 0, 0, 0, 0 ]
[ 0, 0, 0, 0, 0, 0 ]
[ 0, 0, 0, 1, 1, 1 ]
[ 0, 0, 1, 1, 1, 1 ]
[ 0, 0, 0, 0, 0, 0 ]
[ 0, 0, 0, 1, 1, 1 ]

// sputter(0.8, 100)

sputter(0.8, 100)

10.do{(0..5).sputter(0.8, 100).postln;};
[ 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 3, 3, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5 ]
[ 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 4, 5 ]
[ 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 5 ]
[ 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5 ]
[ 0, 0, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 4, 5, 5, 5, 5 ]
[ 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 3, 3, 3, 3, 3, 3, 4, 5, 5 ]
[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 2, 3, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5 ]
[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5 ]
[ 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5 ]
[ 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 5, 5 ]

// sputter(0.9, 6)

10.do{(0..5).sputter(0.9, 6).postln;};
[ 0, 0, 0, 0, 0, 0 ]
[ 0, 0, 0, 0, 0, 0 ]
[ 0, 0, 0, 0, 0, 0 ]
[ 0, 0, 0, 1, 1, 1 ]
[ 0, 0, 0, 1, 1, 1 ]
[ 0, 0, 0, 0, 0, 0 ]
[ 0, 1, 1, 1, 1, 1 ]
[ 0, 0, 0, 0, 0, 1 ]
[ 0, 0, 0, 0, 0, 0 ]
[ 0, 1, 1, 1, 1, 2 ]

// sputter(0.9, 100)

sputter(0.9, 100)

10.do{(0..5).sputter(0.9, 100).postln;};
[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5 ]
[ 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5 ]
[ 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5 ]
[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 2, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5 ]
[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5 ]
[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5 ]
[ 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 5, 5, 5, 5, 5 ]
[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5 ]
[ 0, 0, 0, 0, 1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5 ]
[ 0, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 5, 5, 5, 5, 5, 5 ]

// .sputter(1.0, 6)

    10.do{(0..5).sputter(1.0, 6).postln;};
    [ 0, 0, 0, 0, 0, 0 ]
    [ 0, 0, 0, 0, 0, 0 ]
    [ 0, 0, 0, 0, 0, 0 ]
    [ 0, 0, 0, 0, 0, 0 ]
    [ 0, 0, 0, 0, 0, 0 ]
    [ 0, 0, 0, 0, 0, 0 ]
    [ 0, 0, 0, 0, 0, 0 ]
    [ 0, 0, 0, 0, 0, 0 ]
    [ 0, 0, 0, 0, 0, 0 ]
    [ 0, 0, 0, 0, 0, 0 ]

// .sputter(1.0, 100)

sputter(1.0, 100)

    10.do{(0..5).sputter(1.0, 100).postln;};
[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]
... 

.allTuples(maxTuples: 16384)
Returns a new Array whose elements contain all possible combinations of the receiver’s subcollections.

allTuples

[(0..5), (0..5)].allTuples;

[ [ 0, 0 ], [ 0, 1 ], [ 0, 2 ], [ 0, 3 ], [ 0, 4 ], [ 0, 5 ], [ 1, 0 ], [ 1, 1 ], [ 1, 2 ], [ 1, 3 ], [ 1, 4 ], [ 1, 5 ], [ 2, 0 ], [ 2, 1 ], [ 2, 2 ], [ 2, 3 ], [ 2, 4 ], [ 2, 5 ], [ 3, 0 ], [ 3, 1 ], [ 3, 2 ], [ 3, 3 ], [ 3, 4 ], [ 3, 5 ], [ 4, 0 ], [ 4, 1 ], [ 4, 2 ], [ 4, 3 ], [ 4, 4 ], [ 4, 5 ], [ 5, 0 ], [ 5, 1 ], [ 5, 2 ], [ 5, 3 ], [ 5, 4 ], [ 5, 5 ] ]

1 Like