### Smooth random?

Hi

i am sure this is relatively a newbie question but is there a way to

smoothout random number generation? I would like a random to generate

random numbers from 1 to 100 but move smoothly around certain areas. A

line perhaps? A tutorial # or an object reference would be greatly

appreciated.

pp

>content-class: urn:content-classes:message

>Content-Type: multipart/alternative;

> boundary="—-_=_NextPart_001_01C6C6C9.9BD20634"

>

>

>

>Hi

>

>i am sure this is relatively a newbie question but is there a way to

>smoothout random number generation? I would like a random to

>generate random numbers from 1 to 100 but move smoothly around

>certain areas. A line perhaps? A tutorial # or an object reference

>would be greatly appreciated.

kind of drunk perhaps???

or rebuild a drunk-like patch using some of the LITTER objects..

of cours eline is a possibility for smoothing, but will not necessary

move AROUND certain areas

best

kasper

–

Kasper T. Toeplitz

noise, composition, bass, computer

I believe you want Perlin noise?

You can search the web for the algorithm, or the list archives.

v a d e //

http://www.vade.info

abstrakt.vade.info

On Aug 23, 2006, at 11:39 AM, Kasper T Toeplitz wrote:

>> content-class: urn:content-classes:message

>> Content-Type: multipart/alternative;

>> boundary="—-_=_NextPart_001_01C6C6C9.9BD20634"

>>

>>

>> Hi

>>

>> i am sure this is relatively a newbie question but is there a way

>> to smoothout random number generation? I would like a random to

>> generate random numbers from 1 to 100 but move smoothly around

>> certain areas. A line perhaps? A tutorial # or an object reference

>> would be greatly appreciated.

>

> kind of drunk perhaps???

>

> or rebuild a drunk-like patch using some of the LITTER objects..

>

> of cours eline is a possibility for smoothing, but will not

> necessary move AROUND certain areas

>

> best

>

> kasper

> —

> Kasper T. Toeplitz

> noise, composition, bass, computer

> http://www.sleazeArt.com

>

>

Karlheinz Essl’s RTC-Lib does contain a number of abstractions for

random number generation. e.g. "brownian":

"Random generator based on "brownian movements". Outputs random

numbers between min

The distance between two random numbers is determined by the brownian

factor

behaves like an ordinary random generator. When the factor is O,

always the same number is repeated."

And of course there’s the Litter Library for all sorts of smart

random number operations.

b.

On Aug/23/2006/, at 17/34, Patrick Pagano wrote:

> Hi

>

> i am sure this is relatively a newbie question but is there a way

> to smoothout random number generation? I would like a random to

> generate random numbers from 1 to 100 but move smoothly around

> certain areas. A line perhaps? A tutorial # or an object reference

> would be greatly appreciated.

—

Bernhard Loibner

sound & media artist

And I would also point out that Peter Castine’s LItter

Power collection of objects contains a wealth of interesting

possibilities.

I think you meant to say "a mess" of interesting possibilities.

jb

Am 23.08.2006 um 19:36 schrieb Gregory Taylor:

> LItter

> Power collection of objects contains a wealth of interesting

> possibilities

On Aug 23, 2006, at 7:39 PM, Jeremy Bernstein wrote:

> I think you meant to say "a mess" of interesting possibilities.

"a Messe" of interesting possibilities. Coming from

someone who has been so assiduous in correcting

my nonexistent German, I’m shocked. Shocked….

Don’t forget the Big Friendly Giant! jit.bfg has nice noise functions.

wes

On 8/23/06, Gregory Taylor

>

> On Aug 23, 2006, at 7:39 PM, Jeremy Bernstein wrote:

>

> > I think you meant to say "a mess" of interesting possibilities.

>

> "a Messe" of interesting possibilities. Coming from

> someone who has been so assiduous in correcting

> my nonexistent German, I’m shocked. Shocked….

>

>

On Aug 23, 2006, at 7:51 PM, Wesley Smith wrote:

> Don’t forget the Big Friendly Giant! jit.bfg has nice noise functions.

Oh. *THAT’s* what the acronym means. :-)

On Aug 23, 2006, at 8:34 AM, Patrick Pagano wrote:

> i am sure this is relatively a newbie question but is there a way

> to smoothout random number generation? I would like a random to

> generate random numbers from 1 to 100 but move smoothly around

> certain areas. A line perhaps? A tutorial # or an object reference

> would be greatly appreciated.

While all the suggestions are good ones (especially walking around a

volume of perlin noise (jit.bfg @basis noise.gradient)), it sounds

like you just want temporal filtering. You could use line, or curve,

or slide, etc. to perform low pass filtering of continuous data.

There’s an example of using jit.slide with a volume of noise to

generate smooth transitions in jit.matrix-3d-render.pat.

If you don’t want to use a whole matrix, just replace jit.noise with

random and jit.slide with slide.

-Joshua

Thanks to all for the suggestions, will try tonight

Much thanks!

Patrick Pagano, B.S., M.F.A

Digital Media Specialist

Digital Worlds Institute

University of Florida

(352) 294-2082

—–Original Message—–

From: jitter-bounces@cycling74.com [mailto:jitter-bounces@cycling74.com]

On Behalf Of Joshua Kit Clayton

Sent: Wednesday, August 23, 2006 5:02 PM

Subject: Re: [jitter] Smooth random?

On Aug 23, 2006, at 8:34 AM, Patrick Pagano wrote:

> i am sure this is relatively a newbie question but is there a way to

> smoothout random number generation? I would like a random to generate

> random numbers from 1 to 100 but move smoothly around certain areas. A

> line perhaps? A tutorial # or an object reference would be greatly

> appreciated.

While all the suggestions are good ones (especially walking around a

volume of perlin noise (jit.bfg @basis noise.gradient)), it sounds like

you just want temporal filtering. You could use line, or curve, or

slide, etc. to perform low pass filtering of continuous data.

There’s an example of using jit.slide with a volume of noise to generate

smooth transitions in jit.matrix-3d-render.pat.

If you don’t want to use a whole matrix, just replace jit.noise with

random and jit.slide with slide.

-Joshua

On 23-Aug-2006, at 17:34, Patrick Pagano wrote:

> i am sure this is relatively a newbie question but is there a way

> to smoothout random number generation? I would like a random to

> generate random numbers from 1 to 100 but move smoothly around

> certain areas. A line perhaps? A tutorial # or an object reference

> would be greatly appreciated.

A few people have mentioned Litter Power, since this is the Jitter

list I’d just like to add that Litter Bundle for Jitter has recently

had some updates on the random number/noise front, together with the

UB update.

More information, as always, at the URI in the .sig

Best — Peter

PS to JB & GT: We prefer to describe it as "eine Masse von

Zufallsgeneratoren"… Messen gibt’s in der Kirche.

————– http://www.bek.no/~pcastine/Litter/ ————-

Peter Castine +–> Litter Power & Litter Bundle for Jitter

Universal Binaries on the way

iCE: Sequencing, Recording &

Interface Building for |home | chez nous|

Max/MSP Extremely cool |bei uns | i nostri|

http://www.dspaudio.com/ http://www.castine.de

Hello. It seems that 1-dimensional Perlin Noise is suitable for Smooth Random needed.

Here is implementation of it using "js".

It's based on http://asserttrue.blogspot.com/2011/12/perlin-noise-in-javascript_31.html

———————

//—————————————————-

// Perlin Noise implementation for Max/MSP javascript.

// by Denis Perevalov

//—————————————————-

// Based on Kas Thomas code:

// http://asserttrue.blogspot.com/2011/12/perlin-noise-in-javascript_31.html

// This is a port of Ken Perlin's Java code. The

// original Java code is at http://cs.nyu.edu/%7Eperlin/noise/.

// Note that in this version, a number from 0 to 1 is returned.

//—————————————————-

//Usage:

//send to first inlet input – x.

//then ferst outlet returns perlin(x).

// inlets and outlets

inlets = 1; //x, for 1-dim perlin noise

outlets = 1; //output = perlin(x)

// global variables

var p = new Array(512);

var permutation = [ 151,160,137,91,90,15,

131,13,201,95,96,53,194,233,7,225,140,36,103,30,69,142,8,99,37,240,21,10,23,

190, 6,148,247,120,234,75,0,26,197,62,94,252,219,203,117,35,11,32,57,177,33,

88,237,149,56,87,174,20,125,136,171,168, 68,175,74,165,71,134,139,48,27,166,

77,146,158,231,83,111,229,122,60,211,133,230,220,105,92,41,55,46,245,40,244,

102,143,54, 65,25,63,161, 1,216,80,73,209,76,132,187,208, 89,18,169,200,196,

135,130,116,188,159,86,164,100,109,198,173,186, 3,64,52,217,226,250,124,123,

5,202,38,147,118,126,255,82,85,212,207,206,59,227,47,16,58,17,182,189,28,42,

223,183,170,213,119,248,152, 2,44,154,163, 70,221,153,101,155,167, 43,172,9,

129,22,39,253, 19,98,108,110,79,113,224,232,178,185, 112,104,218,246,97,228,

251,34,242,193,238,210,144,12,191,179,162,241, 81,51,145,235,249,14,239,107,

49,192,214, 31,181,199,106,157,184, 84,204,176,115,121,50,45,127, 4,150,254,

138,236,205,93,222,114,67,29,24,72,243,141,128,195,78,66,215,61,156,180

];

var _inited = false;

//——————————————-

// float — run the equation once

function msg_float(x)

{

var out = perlin( x, Math.sin(x), Math.cos(x) );

//post(out);

outlet(0, out);

}

//——————————————-

function init()

{

post("Perlin inited");

for (var i=0; i < 256 ; i++) {

p[256+i] = p[i] = permutation[i];

}

}

//——————————————-

function perlin( x, y, z ) {

if ( !_inited ) {

_inited = true;

init();

}

var X = Math.floor(x) & 255, // FIND UNIT CUBE THAT

Y = Math.floor(y) & 255, // CONTAINS POINT.

Z = Math.floor(z) & 255;

x -= Math.floor(x); // FIND RELATIVE X,Y,Z

y -= Math.floor(y); // OF POINT IN CUBE.

z -= Math.floor(z);

var u = fade(x), // COMPUTE FADE CURVES

v = fade(y), // FOR EACH OF X,Y,Z.

w = fade(z);

var A = p[X ]+Y, AA = p[A]+Z, AB = p[A+1]+Z, // HASH COORDINATES OF

B = p[X+1]+Y, BA = p[B]+Z, BB = p[B+1]+Z; // THE 8 CUBE CORNERS,

return scale(lerp(w, lerp(v, lerp(u, grad(p[AA ], x , y , z ), // AND ADD

grad(p[BA ], x-1, y , z )), // BLENDED

lerp(u, grad(p[AB ], x , y-1, z ), // RESULTS

grad(p[BB ], x-1, y-1, z ))),// FROM 8

lerp(v, lerp(u, grad(p[AA+1], x , y , z-1 ), // CORNERS

grad(p[BA+1], x-1, y , z-1 )), // OF CUBE

lerp(u, grad(p[AB+1], x , y-1, z-1 ),

grad(p[BB+1], x-1, y-1, z-1 )))));

}

//——————————————-

function fade(t) { return t * t * t * (t * (t * 6 – 15) + 10); }

function lerp( t, a, b) { return a + t * (b – a); }

function grad(hash, x, y, z) {

var h = hash & 15; // CONVERT LO 4 BITS OF HASH CODE

var u = h<8 ? x : y, // INTO 12 GRADIENT DIRECTIONS.

v = h<4 ? y : h==12||h==14 ? x : z;

return ((h&1) == 0 ? u : -u) + ((h&2) == 0 ? v : -v);

}

function scale(n) { return (1 + n)/2; }

//——————————————-

[attachment=203815,4408]

Interesting. Perlin’s been on my to-do list for a long time. But it basically looks like pink noise. You could drop in lp.zzz for your [js perlin] and get the same image by tweaking the multiplication factor. And adding an offsetâ€¦ lp.zzz works in the range [-1 .. 1].

Still, if Perlin works for you, great.

I’m under the impression that Perlin noise is only useful in more than 1 dimension. If it is generated in only 1 dimension it is the same as brownian motion, 1/f noise (if the layering is done so the sample rate is done in octaves and the amplitudes are done as 2^-i).

Is anyone able to confirm that or am I mistaken?

T

Interesting paper on Wavelet Noise http://graphics.pixar.com/library/WaveletNoise/paper.pdf