Idea:- Generate Three Phase to give an RGB value to get rainbow fades
A lot of  Rainbow fades use HUE and a Hue2RGB() function.
Could I use N Darwoods's Three Phase method? yes - but you need to clip.

 This is based on a Wireless World article 
  by N Darwood in November 1982.

 Itterate these each time slice:-

 A=A+n*(B-C)
 B=B+n*(C-A)
 C=C+n*(A-B)

If A, B, C map to R, G, B 

If these clip, and go greater than 100% and the colours are pleasing.

The SVG rgb(r%,b%,g%) function clips the values to 0% to 100%.
Graph ' 



// Sine waves using sin() and cos()

period += increment
rad= 2*PI*period
Y=mag*sin(rad)
or
Y=mag*cos(rad)


	


// Sine waves using complex numbers 
// and accumulator.
 A=A*M
 rad = 2.0 * Math.PI * 0.2
 mag = 1.0
 M.re=mag*Math.sin( rad )
 M.im=mag*Math.cos( rad )
 at= mr*ar-mi*ai
 ai= mr*ai+mi*ar
 ar=at 
	



// Sine waves using differential equations
 Itterate these each time slice:-
 x=x+y*n
 y=y-x*n 
 
 This is the solution to d^2 V/dt^2 = -nV 

 dV/dt = j n V
 
 Numerically solve 
 
 re_next = re_now + gradient * step length
 
 re_next=re_now+im_now*n
 im_next=im_now-re_next*n 

 This is a combination of the forward and backward integration and are stable

however the forward Euler integration explodes

 re_next=re_now+im_now*n
 im_next=im_now-re_now*n 

however the backward Euler integration explodes

 re_next=re_now+im_next*n
 im_next=im_now-re_next*n 
 
 




Idea:- Generate Three Phase to give an RGB value

 This is based on a Wireless World article 
  by N Darwood in November 1982.

 Itterate these each time slice:-

 A=A+n*(B-C)
 B=B+n*(C-A)
 C=C+n*(A-B)

If A, B, C are three axis 120 degree relative to each other. 

 A=cos( 2*pi*t/T );
 B=cos( 2*pi*t/T + 2*pi/3 );
 C=cos( 2*pi*t/T + 2*pi/6);
 
 Using complex numbers:-
 
 B= M*A
 C= M*M*A
 A= M*M*M*A
 
 M.re = cos(2*pi/3 )
 M.im = sin(2*pi/3 )



Why is this stable?

Assume it is a solution of a differential equation?

forward Euler uses the gradient at now
backward Euler uses the gradient at now+1

They each have an error which must cancel.

Assume A1 is the next itteration of A0, B1 is B0 + update

These must be executed in the order below without 

 A1=A0+n*(B0-C0)   // forward Euler A1 is based on now values of B and C
 B1=B0+n*(C0-A1)   // Forward and backward Euler integration, based on old and new 	
 C1=C0+n*(A1-B1)   // backward Euler C1 is based on new A and B
 


 
	



 


image