## Noise Questions

**category:**code [glöplog]

Your answer rocks =)

haha! didnt await this as an answer! ;)

Was a real offer btw!

Yes, we smoke....shit most likely!

And i am unsocial (asocial) myself, only visiting pouet to annoy the shit out of everyone! ;)

Was a real offer btw!

Yes, we smoke....shit most likely!

And i am unsocial (asocial) myself, only visiting pouet to annoy the shit out of everyone! ;)

this old forum thread is linked to in context of noises on a gpu, which still ranks high on google as of 2019-03, as it nicely describes bluenoise and bayer matrix, with 3 different applications, so this thread is still relevant, and i have something to add:

the [pqfpm] or [qfpm] = [(prime) quadratic field permuting matrix]

a "type of hash/noise" that is

- fast

- parametric

- optionally not c0 continuous OR has infinite differentials (in terms of Fourier analysis)

- optionally not periodic AT ALL (within all practical purposes of ANY address space limitations)

https://www.shadertoy.com/view/Xt3BDB

asks, what if we sum up many different [quadratic fields, who's components share no prime factors], scaled by [x,time], and take the cos() or fract() of that to get it into range[-1..1]

i think a [[quadratic field] matrix with [no coprimes] as parameters for any of its [quadratic field]s]

is pretty useful for a(n aperiodic) hash:

this proposes a LOOKUPTABLE that buffers [quadratic fields] that have unique primes as parameters.

that LUTjust saves us a sqrt(), may not be worth it, unless you want to permute within a VERY large array of [quadratic Field]s.

for simplicity, lets just do a mat4 buffer or smaller, these can bedefined and calculated with little efford.

//when you want to generate a hash, especially with long period and equidistribution

//you likely want to mox and permute different [quadratic field]s

//most famous is Phi= (sqrt(5)+1)/2

//followed by phi= (sqrt(5)-1)/2

//followed by Skewy = (sqrt(3)+0)/2

//to get perios as long as possible, you want a large [leastCommonMultiple] of these.

//-> the parameters of your quadratic fields better not share any primeFactors, no [coprime quadratic field]s allowed

//so, how do we label this [prime quadratic fields] has a cewrtain ring to it, like [prime ribs of fourier analysis]:

//sonmehow opengl has no piecewise matrix sqrt()

mat4 sq(mat4 a){return mat4(sqrt(a[0]),sqrt(a[1]),sqrt(a[2]),sqrt(a[3]));}

mat3 sq(mat3 a){return mat3(sqrt(a[0]),sqrt(a[1]),sqrt(a[2]));}

mat2 sq(mat2 a){return mat2(sqrt(a[0]),sqrt(a[1]));}

//sonmehow opengl has no piecewise matrix fract()

mat4 sq(mat4 a){return mat4(fract(a[0]),fract(a[1]),fract(a[2]),fract(a[3]));}

mat2 sq(mat3 a){return mat3(fract(a[0]),fract(a[1]),fract(a[2]));}

mat2 sq(mat2 a){return mat2(fract(a[0]),fract(a[1]));}

//we define opop() as [permuting matrix] of 2 outerProduct(s):

//an outerProduct(a,b) where either [a] or [b] has all parameters identical, is just a matrix of identical rows/columns

//we sum 2 of these up, to permute row+column:

#define op outerprodct

mat4 opop(vec4,a,vec4 b){return op(a,vec4(1)))

+op( vec4(1),b);}

mat3 opop(vec3,a,vec3 b){return op(a,vec3(1)))

+op( vec3(1),b);}

mat2 opop(vec2,a,vec2 b){return op(a,vec2(1)))

+op( vec2(1),b);}

//opop(sqrt(a),b) returns a matrix of [qudratic field]s

//, of the form sqrt(a)+b

//and it quickly permutes 16 of them, when [a,b] are vec4(), and it returns a mat4 opop()

//if sqrt() is not your (type int), just think of its squared variant;

//where you square both inputs, may defer the summing up the 2 outerProduct(s), and defer any sqrt() as much as you like:

//- that may result in higher precision, but needs 2x as much memory.

//how to we hash/noise this:

#define cosopop(t,a,b) (t*cos (opop(a,b)))

#define fraopop(t,a,b) (t*fract(opop(a,b)))

//returns very long periods, even when a and b are small primes, because quadraticFields tend to not overlap.

//just remember how phi=(sqrt(5)+1)/2 can be used for hashes/noises

mat4 AperiodicFracturedTime=fraopop(iTimeNow,vec4(7,5,3,2),vec4(21,17,13,11))

//multiply AperiodicFracturedTime with any arbitiary matrix, to mix and match them

//, and take any compnent out of that result.

//the components of AperiodicFracturedTime are nice parameters for bilin() trilin() interpolation over anything, including itself.

//AperiodicFracturedTime is fast, but not Continuous

mat4 AperiodicDifferentialTime=cosopop(iTimeNow,vec4(11,7,5,3),vec4(27,21,17,13))

//disadvantage of including trigonometry (lower precision/speed on mobile hardware)

//bias in favor of extrema, being a cos() circle

//advantage of having infinite and continuous differentials over iTimeNow

//the components of AperiodicDifferentialTime are nice parameters for bilin() trilin() interpolation over anything, including itself.

//note, each component of these mat4 is periodic

//, the aperiodicity just implies that your PERMUTED LeastCommonMultiple period is significtntly longer than your runtime/precision

//so by any implication of any [infinity] many permutations may just appear [aperiodic]

//just by using large enough (co) primes as inputs (that share no prime factor)

//a [library of babel] [library of discord] [permuted linear congruential generator]

//...destroys any concept of infinity, to a LeastCommonMultiple of permutations (of primes)

//the 8 input values can be any numbers, but

//- 0 or 1 (each) only appear once within the same vec4()

//- 0 must not appear at the same position of both vec4

//- - actually, having 0 in the first vec4() is pretty [linear], the wuadraticField of [sqrt(0)+b] is a bit trivial.

//- the parameters of any vec4() share no coprime (for a largest possible leastCommonMultiple)

//- all parameters of any vec4() should be close to each other (else you mix large and small periods, which ends up uncanny)

the [pqfpm] or [qfpm] = [(prime) quadratic field permuting matrix]

a "type of hash/noise" that is

- fast

- parametric

- optionally not c0 continuous OR has infinite differentials (in terms of Fourier analysis)

- optionally not periodic AT ALL (within all practical purposes of ANY address space limitations)

https://www.shadertoy.com/view/Xt3BDB

asks, what if we sum up many different [quadratic fields, who's components share no prime factors], scaled by [x,time], and take the cos() or fract() of that to get it into range[-1..1]

i think a [[quadratic field] matrix with [no coprimes] as parameters for any of its [quadratic field]s]

is pretty useful for a(n aperiodic) hash:

this proposes a LOOKUPTABLE that buffers [quadratic fields] that have unique primes as parameters.

that LUTjust saves us a sqrt(), may not be worth it, unless you want to permute within a VERY large array of [quadratic Field]s.

for simplicity, lets just do a mat4 buffer or smaller, these can bedefined and calculated with little efford.

//when you want to generate a hash, especially with long period and equidistribution

//you likely want to mox and permute different [quadratic field]s

//most famous is Phi= (sqrt(5)+1)/2

//followed by phi= (sqrt(5)-1)/2

//followed by Skewy = (sqrt(3)+0)/2

//to get perios as long as possible, you want a large [leastCommonMultiple] of these.

//-> the parameters of your quadratic fields better not share any primeFactors, no [coprime quadratic field]s allowed

//so, how do we label this [prime quadratic fields] has a cewrtain ring to it, like [prime ribs of fourier analysis]:

//sonmehow opengl has no piecewise matrix sqrt()

mat4 sq(mat4 a){return mat4(sqrt(a[0]),sqrt(a[1]),sqrt(a[2]),sqrt(a[3]));}

mat3 sq(mat3 a){return mat3(sqrt(a[0]),sqrt(a[1]),sqrt(a[2]));}

mat2 sq(mat2 a){return mat2(sqrt(a[0]),sqrt(a[1]));}

//sonmehow opengl has no piecewise matrix fract()

mat4 sq(mat4 a){return mat4(fract(a[0]),fract(a[1]),fract(a[2]),fract(a[3]));}

mat2 sq(mat3 a){return mat3(fract(a[0]),fract(a[1]),fract(a[2]));}

mat2 sq(mat2 a){return mat2(fract(a[0]),fract(a[1]));}

//we define opop() as [permuting matrix] of 2 outerProduct(s):

//an outerProduct(a,b) where either [a] or [b] has all parameters identical, is just a matrix of identical rows/columns

//we sum 2 of these up, to permute row+column:

#define op outerprodct

mat4 opop(vec4,a,vec4 b){return op(a,vec4(1)))

+op( vec4(1),b);}

mat3 opop(vec3,a,vec3 b){return op(a,vec3(1)))

+op( vec3(1),b);}

mat2 opop(vec2,a,vec2 b){return op(a,vec2(1)))

+op( vec2(1),b);}

//opop(sqrt(a),b) returns a matrix of [qudratic field]s

//, of the form sqrt(a)+b

//and it quickly permutes 16 of them, when [a,b] are vec4(), and it returns a mat4 opop()

//if sqrt() is not your (type int), just think of its squared variant;

//where you square both inputs, may defer the summing up the 2 outerProduct(s), and defer any sqrt() as much as you like:

//- that may result in higher precision, but needs 2x as much memory.

//how to we hash/noise this:

#define cosopop(t,a,b) (t*cos (opop(a,b)))

#define fraopop(t,a,b) (t*fract(opop(a,b)))

//returns very long periods, even when a and b are small primes, because quadraticFields tend to not overlap.

//just remember how phi=(sqrt(5)+1)/2 can be used for hashes/noises

mat4 AperiodicFracturedTime=fraopop(iTimeNow,vec4(7,5,3,2),vec4(21,17,13,11))

//multiply AperiodicFracturedTime with any arbitiary matrix, to mix and match them

//, and take any compnent out of that result.

//the components of AperiodicFracturedTime are nice parameters for bilin() trilin() interpolation over anything, including itself.

//AperiodicFracturedTime is fast, but not Continuous

mat4 AperiodicDifferentialTime=cosopop(iTimeNow,vec4(11,7,5,3),vec4(27,21,17,13))

//disadvantage of including trigonometry (lower precision/speed on mobile hardware)

//bias in favor of extrema, being a cos() circle

//advantage of having infinite and continuous differentials over iTimeNow

//the components of AperiodicDifferentialTime are nice parameters for bilin() trilin() interpolation over anything, including itself.

//note, each component of these mat4 is periodic

//, the aperiodicity just implies that your PERMUTED LeastCommonMultiple period is significtntly longer than your runtime/precision

//so by any implication of any [infinity] many permutations may just appear [aperiodic]

//just by using large enough (co) primes as inputs (that share no prime factor)

//a [library of babel] [library of discord] [permuted linear congruential generator]

//...destroys any concept of infinity, to a LeastCommonMultiple of permutations (of primes)

//the 8 input values can be any numbers, but

//- 0 or 1 (each) only appear once within the same vec4()

//- 0 must not appear at the same position of both vec4

//- - actually, having 0 in the first vec4() is pretty [linear], the wuadraticField of [sqrt(0)+b] is a bit trivial.

//- the parameters of any vec4() share no coprime (for a largest possible leastCommonMultiple)

//- all parameters of any vec4() should be close to each other (else you mix large and small periods, which ends up uncanny)