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

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

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
>
>

“Random generator based on “brownian movements”. Outputs random
numbers between min and max excluding max.
The distance between two random numbers is determined by the brownian
factor . When this factor is 1, “brownian”
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

http://loibner.cc

jb

Am 23.08.2006 um 19:36 schrieb Gregory Taylor:

> LItter
> Power collection of objects contains a wealth of interesting
> possibilities

> 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….

wes

On 8/23/06, Gregory Taylor wrote:
>
> 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.

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

> 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

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

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

———————
//—————————————————-
// 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]

Still, if Perlin works for you, great.

Is anyone able to confirm that or am I mistaken?

T