I just realized this thing was going to overflow the variables after a long time as they keep adding up. To prevent that I added a noLoop() to stop the program after 50 000 Pluto's revolutions (50000*2*PI).

 

int W=1350;
int H=700;
PVector v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21;
float i=0;
float j=0;
float k=0;
float p=0;
float q=0;
float t=0;
float m=0;
float s=0;
float d=0;
float n=0;

void setup()
{
  size(W, H);
  frameRate(80);
 
  v1 = new PVector();
  v2 = new PVector(W/2-200, H/2);
  v3 = new PVector();
  v4 = new PVector(W/2-200, H/2);

  v5 = new PVector();
  v6 = new PVector(W/2-200, H/2);
  v7 = new PVector();
  v8 = new PVector(W/2-200, H/2);
 
  v9 = new PVector();
  v10 = new PVector(W/2-200, H/2);
  v11 = new PVector();
  v12 = new PVector(W/2-200, H/2);
 
  v13 = new PVector();
  v14 = new PVector(W/2-200, H/2);
  v15 = new PVector();
  v16 = new PVector(W/2-200, H/2);
 
  v17 = new PVector();
  v18 = new PVector(W/2-200, H/2);
  v19 = new PVector();
  v20 = new PVector(W/2-200, H/2);
}

void draw()
{
  background(0);
  if(n>100000*PI)  //50 000 Pluto's revolutions (50000*2*PI).
  {
  noLoop();
  }
  n=n+0.003;   //Pluto
  d=d+0.0035;  //Neptune
  s=s+0.004;   //Uranus
  m=m+0.0045;  //Saturn
  t=t+0.005;   //Jupiter
  q=q+0.0055;  //Mars
  i=i+0.006;   //Earth
  j=j+0.003;   //Comet
  p=p+0.010;   //Venus
  k=k+0.013;   //Mercury
  v1.x=sin(i);
  v1.y=cos(i);
  v3.x=1.3*sin(j);
  v3.y=0.7*cos(j);
  v5.x=1.2*sin(k);
  v5.y=1.2*cos(k);
  v7.x=1.2*sin(p);
  v7.y=1.2*cos(p);
  v9.x=1.2*sin(q);
  v9.y=1.2*cos(q);
  v11.x=1.6*sin(t);
  v11.y=1.6*cos(t);
  v13.x=1.8*sin(m);
  v13.y=1.8*cos(m);
  v15.x=1.8*sin(s);
  v15.y=1.8*cos(s);
  v17.x=1.8*sin(d);
  v17.y=1.8*cos(d);
  v19.x=1.8*sin(n);
  v19.y=1.8*cos(n);
  v2.add(v1); 
  v4.add(v3);
  v6.add(v5);
  v8.add(v7);
  v10.add(v9);
  v12.add(v11);
  v14.add(v13);
  v16.add(v15);
  v18.add(v17);
  v20.add(v19);
  fill(255, 255, 0);
  ellipse(W/2, H/2, 40, 40);
 
  fill(0, 0, 255);
  ellipse(v2.x+30, v2.y, 6, 6);
 
  float f=dist(v4.x,v4.y,W/2,H/2);
  fill(255);
  ellipse(v4.x, v4.y, 50/sqrt(f), 300/sqrt(f));
 
  fill(255);
  ellipse(v6.x+100, v6.y, 3, 3); // Mercury
  ellipse(v8.x+75, v8.y, 5, 5); // Venus
 
  fill(255, 0, 0);
  ellipse(v10.x-25, v10.y, 4, 4);//Mars
 
  fill(255, 255, 0);
  ellipse(v12.x-125, v12.y, 13, 13);//Jupiter
 
  fill(255, 255, 0);
  ellipse(v14.x-200, v14.y, 10, 10);//Saturn
 
  fill(255);
  ellipse(v14.x-200, v14.y, 22, 3);//Saturn Ring
 
  fill(0, 255, 255);
  ellipse(v16.x-250, v16.y, 8, 8);//Uranus
 
  fill(0,200,255);
  ellipse(v18.x-300, v18.y, 8, 8);//Neptune
 
  fill(255);
  ellipse(v20.x-375, v20.y, 2, 2);//Pluto
}

 

This ensures that p is always in the range 0 - TWO_PI which is what you need for your position calculations.

The % is called the modulo operator.

Good help quarks. I tried the module and woks perfectly.

 

Thanks,

 

 fix 1 thanks to quarks:

 

  n=(n+0.003)% TWO_PI;   //Pluto
  d=(d+0.0035)% TWO_PI;  //Neptune
  s=(s+0.004)% TWO_PI;   //Uranus
  m=(m+0.0045)% TWO_PI;  //Saturn
  t=(t+0.005)% TWO_PI;   //Jupiter
  q=(q+0.0055)% TWO_PI;  //Mars
  i=(i+0.006)% TWO_PI;   //Earth
  j=(j+0.003)% TWO_PI;   //Comet
  p=(p+0.010)% TWO_PI;   //Venus
  k=(k+0.013)% TWO_PI;   //Mercury