I would like to be able to calculate the density of the air as a function of: pressure, temperature and humidity.

This is the formula.

air density=1/temperature*( pressure- humidity*610.78*10^(7.5* temperature-2048.625/temperature-35.85)/287.05+humidity*610.78*10^(7.5* temperature-2048.625/temperature-35.85)/461.495)

How could I do?

This is what I thought, but it does not work.

 // text(nf(1/(273.15+Temp)*((PAtm+249.08)-Umid*610.78*pow(10,7.5*(273.15+Temp)-2048.625/((273.15+Temp)-35.85))/287.05)
 // +(Umid*610.78*pow(10,7.5*(273.15+Temp)-2048.625/((273.15+Temp)-35.85))/461.495),0,2), width-342,height-539); 

// main setup settings
int dimy = 800;            // screen width 1681
int dimx = 850;            //screen height 1019
int bailout = 2000;         // number of iterations before bail
int plots = 171294;        // number of plots to execute per frame (x30 = plots per second) 171294
//zoom/magnification
float magx = 4.0; // default 3.0, smaller means more zoom
float magy = magx*(dimy/float(dimx));
//pan
float panx = 0.3; //default is 0.5
float pany = 0.0; //default is 0.0
//brightness multiplier
float brt = 1.0; // brightness factor

// 2D array to hold exposure values
int[] exposure = new int[dimx*dimy];

// maximum exposure value
int maxexposure;           

int time = 0;
int exposures = 0;

 float Ex = 2;

 float x, y;
 float x0, y0;

boolean drawing; 

int sgn(float value) {            //if signus is needed sgn(x)=x/abs(x) = 1, 0 or -1
 if (value < 0) {return -1;}
 if (value > 0) {return 1;}
 return 0;
}
float cosh(float value1) {
 return 0.5*(exp(value1)+exp(-value1));
}
float sinh(float value2) {
 return 0.5*(exp(value2)-exp(-value2));
}
float arg(float axis1, float axis2) {
 if (axis2==0) {return PI;}
 else {return -atan(axis1/axis2)+PI*sgn(axis2)*0.5;}
}
float spharg(float axisa, float axisb, float axisc) {
 return acos(axisc/sqrt(sq(axisa)+sq(axisb)+sq(axisc)));
}
void setup() {
 // set up drawing area
 size(800,850,P3D);
}
void draw() {
 plotPlots();
 time++;
 if (time%1==0) { //every second
   findMaxExposure();
   // Infinitely Looping, nested boolean iteration(x0,y0,DrawIt)
   renderBrot();
 }
}
void plotPlots() {

 // iterate through some plots
 for (int n=0;n<plots;n++) {
   // Choose a random point in same range
   x = random(-2.0,2.0);
   y = random(-2.0,2.0);
   x0 = random(-2.0,2.0);
   y0 = random(-2.0,2.0);

   if (iterate(x,y,false)) {
    //Pauses Boolean, (d=pause, D=start)
     if (Ex > 1){
       iterate(x,y,true);
       exposures++;
      }
      if (Ex < 2){
       iterate(x,y,false);
      }
   }

 }
}
void renderBrot() {
 colorMode(RGB,1.0);
 // draw to screen
 for (int i=0;i<dimx;i++) {
   for (int j=0;j<dimy;j++) {
     float ramp = brt * exposure[i*dimy+j] / maxexposure;
     // blow out ultra bright regions
     if (ramp > 1)  {
       ramp = 1;
     }
     //shading formulae
     color c = color(pow(sin(ramp),0.4),pow(ramp,0.75),pow(ramp,2.5)); // sunset
     set(j,i,c);
   }
 }
} 
//   Iterate the Mandelbrot and return TRUE if the point exits
//   Also handle the drawing of the exit points
boolean iterate(float x0, float y0, boolean drawIt) {
 float x = 0.0;
 float y = 0.0;
 //float t = random(0,1);
 //float r = random(0,1);  

 //x0 = 0.0;
 //y0 = 0.0;

 float xnew, ynew;
 int ix,iy;

 for (int i=0;i<bailout;i++) {

   // Display iterations before false DrawIt boolean
   //if (i>0){
   //println(i);
   // }

   //set your costum formula here...
   //example:
   //default Mandelbrot
   xnew = x * x - y * y + x0;
   ynew = 2 * x * y + y0;

// Draws pixel to screen -
// Based on if drawIt boolean is true, and iterations[i] > 3

  // Defines and Draws Pixels in 2D Exposure Array
  // Draws pixel when iteration[i] > 3 within current boolean cycle of xnew, ynew values
  if (drawIt && (i > 3)) {

     ix = int(dimx*(panx+xnew+magx/2.0)/magx);
     iy = int(dimy*(pany+ynew+magy/2.0)/magy);

     //Defines points (ix,iy) within screen ranges
     if (ix >= 0 && iy >= 0 && ix < dimx && iy < dimy) {
       // rotate and expose point
       exposure[ix*dimy+iy]++;
   }
 }

   if ((xnew*xnew + ynew*ynew) > 4) {
     // escapes
     return true;
   }
   x = xnew;
   y = ynew;
 }
 // does not escape
 return false;
}
void findMaxExposure() {
 // assume no exposure
 maxexposure=0;
 // find the largest density value
 for (int i=0;i<dimy;i++) {
   for (int j=0;j<dimx;j++) {
     maxexposure = max(maxexposure,exposure[i*dimx+j]);
   }
 }
} 
 void keyPressed(){

    //Return Iterate(x0,y0,DrawIt) False in Plot  
    if (key == 'r') {
     Ex = 1;
    }
    //Return Iterate(x0,y0,DrawIt) True in Plot  
    if (key == 'R') {
     Ex = 2;
    }
}

I've studied and tested many pixel array programs recently, but don't understand it enough to figure it out the exact method. I know the pixel array exposure[] is a 2D array within the looping, nested boolean iterate(x0,y0,drawIt) and that the pixel array output is derived from the specific code:

    // Draws pixel to screen -
    // Based on if drawIt boolean is true, and iterations[i] > 3

      // Defines and Draws Pixels in 2D Exposure Array
      // Draws pixel when iteration[i] > 3 within current boolean cycle of xnew, ynew values
      if (drawIt && (i > 3)) {

         ix = int(dimx*(panx+xnew+magx/2.0)/magx);
         iy = int(dimy*(pany+ynew+magy/2.0)/magy);

         //Defines points (ix,iy) within screen ranges
         if (ix >= 0 && iy >= 0 && ix < dimx && iy < dimy) {
           // rotate and expose point
           exposure[ix*dimy+iy]++;
       }
     }

It's not a boolean true/false issue as the entire program is written in an infinite loop of nested booleans drawing, iterate(x0,y0,drawIt) and when halted either in the drawing section or the plotPlots() section the pixel array remains intact upon continuation of the program (as demonstrated with Keypressed 'r', 'R'). The program is well threaded into itself with it's booleans and I have no reason to change that fact.

How would I go about updating the entire pixel array in this program to a single color (black) upon key press? Blanking out the canvas and the program continuing it's constant pixel drawing process of exposure points on screen again without the old pixels.

String nufix(float n) { // Numerical Suffix
  String a="";          // String manipulation variable
  float K = 1000.0;     // Kilo
  float M = pow(K, 2);  // Mega
  float G = pow(K, 3);  // Giga
  float T = pow(K, 4);  // Terra
  float P = pow(K, 5);  // Peta
  float E = pow(K, 6);  // Exa
  float Z = pow(K, 7);  // Zeta
  float Y = pow(K, 8);  // Yotta
  float sv=1.0;         // Suffix value
  char  sc=' ';         // Suffix char
  int neg=0; if (n<0){neg=1;} // boolean as int for convenience

  if      (abs(n) < 1) {return '.'+str(int(n*10));}
  else if (abs(n) < K) {return str(int(n));}
  else if (abs(n) < M) {sc='K'; sv=K;}
  else if (abs(n) < G) {sc='M'; sv=M;}
  else if (abs(n) < T) {sc='G'; sv=G;}
  else if (abs(n) < P) {sc='T'; sv=T;}
  else if (abs(n) < E) {sc='P'; sv=P;}
  else if (abs(n) < Z) {sc='E'; sv=E;}
  else if (abs(n) < Y) {sc='Z'; sv=Z;}
  else if (abs(n) < Y*K) {sc='Y'; sv=Y;}
  else {return "yo mama";} // here I give up

  if (abs(n)>=10.0*sv) {
  return str(int(n/sv))+sc;
  }
  else {
    a=str(n/sv);
    if (a.charAt(1+neg)=='.' && a.charAt(2+neg)=='0') {
      return a.substring(0,1+neg)+sc;
      }
    else {return a.substring(0,3+neg)+sc;}
  }
}

Also this shorter but a little worse variant

String nufix(float n) { 
  String scrs="KMGTPEZY";
  if      (abs(n) < 1) {return '.'+str(int(n*10));}
  else if (abs(n) < 1000.0) {return str(int(n));}
  for(int i=0; i<scrs.length();i++)
  {
    if (abs(n) < pow(1000.0,i+2)){
      return str(int(n/pow(K,i+1)))+scrs.charAt(i);
    }
  }
  return "yo mama";
}

Thanks for your tips and help !

E.g. allowing one to "slide" a specific shape without smearing it, via refreshing the buffer.

    PVector nvector(float angle){
      float sinc = (m/8)*sin((m/2)*angle);
      float cosc= ((pow(m,2))/16)*cos((m/2)*angle); 

      float g =(-n2*pow(abs(1/a),n2))*pow(cos((m/4)*angle),n2-2)
        +(n3*pow(abs(1/b),n3))*pow(sin((m/4)*angle),n3-2) ;

      float dg = (n2*pow(abs(1/a),n2))*((n2-2))*sinc*pow(cos((m/4)*angle),n2-4)
        +(n3*pow(abs(1/b),n3))*((n3-2))*sinc*pow(sin((m/4)*angle),n3-4);

      float f = pow(abs((1/a)*cos((m/4)*angle)),n2)+ pow(abs((1/b)*sin((m/4)*angle)),n3);

      float df = sinc*g ;

      float d2f = dg*sinc+g*cosc ; 

      float r =pow(f,(-1/n1)); // this is taken care of by the shape function
      float dr = (-1/n1)*pow(f,((-1/n1)-1))*df;

      float d2r =  (1/n1)*((1/n1)+1)*pow(f,((-1/n1)-2))*pow(df,2)+(-1/n1)*pow(f,(-1/n1)-1)*d2f;

      PVector v1 = new PVector(cos(angle),sin(angle)); 
      PVector v3 = new PVector(cos(angle),sin(angle));
      PVector v2 = new PVector(-sin(angle),cos(angle));

      v1.mult(d2r);
      v2.mult((2*dr));
      v3.mult(r);

      PVector M = v1.add(v2);
      PVector N = M.sub(v3);

       return N;
    } 

I am curious as to the most efficient way to take an integer value and convert it to a floating point so that the whole numbers become fractional numbers.

To illustrate, I want to convert any number from 99999 to 0.99999. So if the value is 7 I want the output to be 0.7. If the value is 8412223, I want the output to be 0.8412223

Is there some "magic" bit-oriented operation that can achieve this or will it take a brute-force method (for example determine the number of digits in the value and then divide by an equivalent power of 10).

Any insights will be greatly appreciated. Thanks

If anyone is curious about the source of the formulas it is here: http://www.ohio.edu/people/williar4/html/pdf/DeltaKin.pdf pages 27 and 28

Code below:

//variables (lengths, etc) (mm)

float sb=432;

float rb=142;

float sp=127;

float lmin=67;

float lmax=479;

float l=264;

float h=44;

float wb=(sqrt(3)/6)*sb;

float ub=(sqrt(3)/3)*sb;

float wp=(sqrt(3)/6)/sp;

float up=(sqrt(3)/3)*sp;

float ox=0;

float oy=0;

float H=686;

//input coordinates (desired position)

float x=0;

float y=0;

float z=-500;

//calculations

float a=wb-up;

float b=(sp/2)-((sqrt(3)/2)*wb);

float c=wp-(.5*wb);

// calculations

float C1=pow(x,2)+pow(y,2)+pow(z,2)+pow(a,2)+(2ya)-pow(l,2);

float C2=pow(x,2)+pow(y,2)+pow(z,2)+pow(b,2)+pow(c,2)+(2xb)+(2yc)-pow(l,2);

float C3=pow(x,2)+pow(y,2)+pow(z,2)+pow(b,2)+pow(c,2)-(2xb)+(2yc)-pow(l,2);

//both solutions for each length (elbow up, and elbow down)

float L11=-z+sqrt(pow(z,2)-C1);

float L12=-z-sqrt(pow(z,2)-C1);

float L21=-z+sqrt(pow(z,2)-C2);

float L22=-z-sqrt(pow(z,2)-C2);

float L31=-z+sqrt(pow(z,2)-C3);

float L32=-z-sqrt(pow(z,2)-C3);

println("elbow up");

println("L1: "+L11);

println("L2: "+L21);

println("L3: "+L31);

println("elbow down");

println("L1: "+L12);

println("L2: "+L22);

println("L3: "+L32);

println("actual answer: 241");

for (int i = 0; i <= 16; i++) {
  println(i, pow(2, i));
}

(Code formatting keeps eating the code...)

         sliderValue= (int)(theEvent.controller().value());
            a = (int) (pow( sliderValue, 2) /100);

But, I want to stretch points along the line at an increasing rate from a to b. I want to do a statement where for each tick, the stretch on the pixels is increased. so say the first point on my slider is 100: a = pow(a, 2) /100 which equals 100. The second increment on the slider is 10, so now the slider value is at 110, but a should be 121 (a = pow(110,2)/100). The next point on the slider is 120, so a should be 144, and so on. So the distanc between the points along the line increases, even though the slider tick mark value stays at increments of 10.

How do I do that in Processing? Thanks