What is an Array and why is it in the Grid? Bitwig Studio 3.2 Beta

[u-u-u]

I just thought whether it might be helpful to get some other output out of an array. Some ideas:
- statistical values like the mean value.
- a search option: outputs the first/last index of a value at the input (if it's in the array, and -1 otherwise)
- the number of array members (can be fed back)
But maybe options like this would make everything over-complicated and less fun

[antic604]

Well, I just want it - substantially - longer, say like 200k slots. Or instead have them add recording to Sampler oscillator

[foosnark]

But I wonder, what practical uses other than mad sound-mangling it can have?

The first thing I thought of was a shift register. These are used a bit in hardware modular -- think of it as a chain of S&H modules that pass values from one to the next. But this is a little different, instead of reading from every S&H in the chain simultaneously it just grabs one position. You could combine it with S&H though for random access reads.

But anyway, it could be used in ways similar to a shift register -- use it to store a random sequence or a performed control gesture, and then loop it. Or you could use it like an audio buffer, play it at different rates or backwards or use phase distortion on either the read or write input. Or use it as a delay by offsetting the phase between play and record.

Maybe it's possible to lengthen the buffer by using multiple arrays and switching between them.

I haven't downloaded the beta but I'm looking forward to experimenting with this

[Echoes in the Attic]

I wish I could say that I understand the array after watching that video, but it's still a bit of a mystery to me (even though I understand an array in python!).

From what I gathered it seems sort of like a sample and hold except that you can read from a different place than the value is getting to from an external signal. But how how could you read from a data pair that hasn't yet been written? This is the logic part I'm struggling with where let's say you have a faster envelope on the read than the write, that seems to me to mean that the read is trying to read from points in the array that come after the write parts have been populated with values. And then I also don't quite understand how the trigger plays into it. So I haven't got a very good grasp yet, but I also haven't checked the documentation of it yet, hopefully that will help.

[antic604]

But how how could you read from a data pair that hasn't yet been written?

The output will simply be zero

[Tj Shredder]

In my test, I managed to record a interpolated Steps into the Array. But that does not have much use, as you could use the Steps directly as well...
I found out though, that each voice will have its own Array, and Arrays are not stored in the patch. Probably for a reason. I could imagine some random fun with filling arrays on the fly.

[Taika-Kim]

Yup with normalize you can give integers starting from 0. Conceptually, just think of it as a Steps module that can have the values externally written.

[Tj Shredder]

Here is an example patch that recreates an old algorithm of mine. I fill an Array with 16 random values on note-on. While holding the note this Array is used to play those as pitches sequenced, accompanied with similar Arrays for timbre and dynamics. But now on each round it will replace one of these notes with a new one! This creates an almost repeating loop. 15 notes are the same, one is different on each round...
This is not possible to create without the Array...
Its also at https://bitwiggers.com/presets/70459508 ... c249a9b59/

have fun...

[stufflin]

Interesthink!

[Pspiralife]

I believe that the array module would be involved in building a TURING MACHINE.

BUT!.... my nerd level unfortunately is not quite as high as I need it to be yet to get my head around how to achieve this! I have tried many times to understand how the read and write phase inputs are actually involved in this task but I still can't understand it.

I've read through all of the posts on this thread too... And tried to understand the previous most recent post that linked a polygrid preset (thank you btw). But also I failed... It doesn't sound to me like it is 15 repeated notes and one new random one each time it loops around.

I just want to be able to send a bar's worth of random values from the output of a sample and hold Random LFO into the array at a rate of 16th notes, and capture 4, 6, 8, 12 or 16 of them within the array, and then playback those captured values in a loop to send to.

Please HELP!

Thanks

[antic604]

...

Sorry to ask instead of helping, but are you the guy who's releasing music on Zenon Rec. or a fan just using the "pspiralife" handle?

Awesome if it's the former!

[Pspiralife]

...

Sorry to ask instead of helping, but are you the guy who's releasing music on Zenon Rec. or a fan just using the "pspiralife" handle?

Awesome if it's the former!

Hey yeah that's me Glad to see a Zenon follower on a bitwig forum!
Have a good one much love <3

[carlca]

...

Sorry to ask instead of helping, but are you the guy who's releasing music on Zenon Rec. or a fan just using the "pspiralife" handle?

Awesome if it's the former!

Hey yeah that's me Glad to see a Zenon follower on a bitwig forum!
Have a good one much love <3

There's a really healthy sized selection of releases at https://pspiralife.bandcamp.com/music

[Hez]

I believe that the array module would be involved in building a TURING MACHINE.

BUT!.... my nerd level unfortunately is not quite as high as I need it to be yet to get my head around how to achieve this! I have tried many times to understand how the read and write phase inputs are actually involved in this task but I still can't understand it.

I've read through all of the posts on this thread too... And tried to understand the previous most recent post that linked a polygrid preset (thank you btw). But also I failed... It doesn't sound to me like it is 15 repeated notes and one new random one each time it loops around.

I just want to be able to send a bar's worth of random values from the output of a sample and hold Random LFO into the array at a rate of 16th notes, and capture 4, 6, 8, 12 or 16 of them within the array, and then playback those captured values in a loop to send to.

Please HELP!

Thanks

Hey Shammie! Big fan of your tunes mate

I've built a lil' something that does roughly what you want. It's not a proper Eurorack style Turing machine (where you can set the probability of each bit mutating on each pass through the buffer), but it allows you to capture a bar's worth of random values and then scan through those values at different rates, all synced to the clock.

Device is here: https://www.dropbox.com/s/p1zi12pjix27s ... reset?dl=0



At the moment it's just hooked up to pitch of an oscillator so you can hear what it's doing.

There's a few different ways to approach this but this one has totally separate things going on for the read and write phase inputs.

The Write input works by triggering a one bar phase ramp (using the LFO) whenever you click the button. It does this by a.) retriggering the LFO and b.) switching on a latch. Once the LFO reaches the top (with a value of ~1), the latch is switched off again via some logic. Unfortunately for some reason we don't have a triggerable Ramp module in the Grid yet, which makes this part uglier than it needs to be.

Simultaneously, a 1/16 rate transport module is triggering a dice to generate random values.

To bring these two things together, the latch output and 1/16 trigger are combined in an AND so that the array only gets written to for a one bar period (quantised to the clock) after you've clicked the button. Then the latch switches off and the 1/16 transport stops pinging the array write trigger, so no new values get written.

On the Read side, I've just got 3 transport modules going into a Merge with different rates (4 x 16th for a 4 step loop, 8 x 16th for 8 steps, 16 x 16th for the full 16). I've attenuated them depending on their rate, so that they only read a subset of the values in the array. E.g. the 4 x 16 transport is attenuated by a factor of 4 (or maybe more intuitively, multiplied by a factor of 4/16) so that it only reads 25% of the full content of the array, which always contains one bar of values (16 values).

Finally, there's phase Shift after the Merge, so that you can scan different parts of what's contained in the array/basically offset the start position of the sequence. I've S+H'd after the offset so that you only get value changes occurring in sync with the clock.

Extending this to read sequences of any other lengths is pretty easy, as long as you want to stick to a 16th note base clock. E.g. add another merge input, add a transport set to 7 / 16ths, multiply it by a factor of 7/16 - you can just type "7/16" into the attenuate module to do this (make sure to delete the % sign though!). If you want to extend it to work in triplets it's also possible but it'd get a bit messy because the transport module doesn't do triplets, so you'd need quite a few phase scalers and phase resets dotted about the place if you wanted to do it properly.

Bitwig devs pls give us grid containers so I don't have to copy-paste this whole monstrosity every time I want to use it...

[Hez]

Ok after that thought experiment, here's a way way way simpler version that functions more like the Eurorack Turing machine:

https://www.dropbox.com/s/4t4xp0smz7eb7 ... reset?dl=0

I'll leave the previous one up though as I think it covers a few interesting 'phase-based sequencing' concepts & approaches.