Function bodies 149 total

                public float getMultiTouchDiameter() {
                        if (!diameterIsCalculated) {
                                if (!isMultiTouch) {
                                        diameter = 0.0f;
                                } else {
                                        // Get 1/16 pixel's worth of subpixel accuracy, works on screens up to 2048x2048
                                        // before we get overflow (at which point you can reduce or eliminate subpix
                                        // accuracy, or use longs in julery_isqrt())
                                        float diamSq = getMultiTouchDiameterSq();
                                        diameter = (diamSq == 0.0f ? 0.0f : (float) julery_isqrt((int) (256 * diamSq)) / 16.0f);
                                        // Make sure diameter is never less than dx or dy, for trig purposes
                                        if (diameter < dx)
                                       

                public float getMultiTouchAngle() {
                        if (!angleIsCalculated) {
                                if (!isMultiTouch)
                                        angle = 0.0f;
                                else
                                        angle = (float) Math.atan2(ys[1] - ys[0], xs[1] - xs[0]);
                                angleIsCalculated = true;
                        }
                        return angle;
                }

                public int getNumTouchPoints() {
                        return numPoints;
                }

                public float getX() {
                        return xMid;
                }

                public float[] getXs() {
                        return xs;
                }

                public float getY() {
                        return yMid;
                }

                public float[] getYs() {
                        return ys;
                }

                public int[] getPointerIds() {
                        return pointerIds;
                }

                public float getPressure() {
                        return pressureMid;
                }

                public float[] getPressures() {
                        return pressures;
                }

                public boolean isDown() {
                        return isDown;
                }

                public int getAction() {
                        return action;
                }

                public long getEventTime() {
                        return eventTime;
                }

        public static class PositionAndScale {
                private float xOff, yOff, scale, scaleX, scaleY, angle;
                private boolean updateScale, updateScaleXY, updateAngle;

                /**
                 * Set position and optionally scale, anisotropic scale, and/or angle. Where if the corresponding "update" flag is set to false, the field's
                 * value will not be changed during a pinch operation. If the value is not being updated *and* the value is not used by the client
                 * application, then the value can just be zero. However if the value is not being updated but the value *is* being used by the client
                 * application, the value should still be specified and the update flag should be false (e.g. angle of the object being dragged should still
                 * be specified even if the program is in "resize" mode rather than "rotate" mode).
                 */
                public void set(float xOff, float yOff,

                public void set(float xOff, float yOff, boolean updateScale, float scale, boolean updateScaleXY, float scaleX, float scaleY,
                                boolean updateAngle, float angle) {
                        this.xOff = xOff;
                        this.yOff = yOff;
                        this.updateScale = updateScale;
                        this.scale = scale == 0.0f ? 1.0f : scale;
                        this.updateScaleXY = updateScaleXY;
                        this.scaleX = scaleX == 0.0f ? 1.0f : scaleX;
                        this.scaleY = scaleY == 0.0f ? 1.0f : scaleY;
                        this.updateAngle = updateAngle;
                        this.angle = angle;
                }

                protected void set(float xOff, float yOff, float scale, float scaleX, float scaleY, float angle) {
                        this.xOff = xOff;
                        this.yOff = yOff;
                        this.scale = scale == 0.0f ? 1.0f : scale;
                        this.scaleX = scaleX == 0.0f ? 1.0f : scaleX;
                        this.scaleY = scaleY == 0.0f ? 1.0f : scaleY;
                        this.angle = angle;
                }

                public float getXOff() {
                        return xOff;
                }

                public float getYOff() {
                        return yOff;
                }

                public float getScale() {
                        return !updateScale ? 1.0f : scale;
                }

                public float getScaleX() {
                        return !updateScaleXY ? 1.0f : scaleX;
                }

                public float getScaleY() {
                        return !updateScaleXY ? 1.0f : scaleY;
                }

                public float getAngle() {
                        return !updateAngle ? 0.0f : angle;
                }

JNIEXPORT jint JNICALL Java_byrne_fractal_NativeLib_getMin(JNIEnv * env, jobject obj) {
  return minimum;
}

JNIEXPORT jint JNICALL Java_byrne_fractal_NativeLib_getMax(JNIEnv * env, jobject obj) {
  return maximum;
}

JNIEXPORT void JNICALL Java_byrne_fractal_NativeLib_resetValues
(JNIEnv * env, jobject obj) {
  
  minimum = 99999;
  maximum = 0;
  rowsCached = 0; 
  
  if (values == NULL) {
    int r;
    alg = 1;
    bailout = 2;
    bsq = 4;
    equation = 1;
    power = 2;
    values = (int**) malloc(yres * sizeof(int*));
    for (r = 0; r < yres; r++) {
      values[r] = (int*) malloc(xres * sizeof(int));
    }
  }
}

JNIEXPORT void JNICALL Java_byrne_fractal_NativeLib_freeValues
(JNIEnv * env, jobject obj) {
  if (values != NULL) {
    int r;
    for (r = 0; r < yres; r++) {
      free(values[r]);
    }
    free(values);
    values = NULL;
  }
}

JNIEXPORT void JNICALL Java_byrne_fractal_NativeLib_setResolution
(JNIEnv * env, jobject obj, jint jxres, jint jyres) {
  LOG_OF_TWO = log(2);
  SQRT_OF_TWO = sqrt(2);
  xres = jxres;
  yres = jyres;
}

JNIEXPORT void JNICALL Java_byrne_fractal_NativeLib_setEquation
(JNIEnv * env, jobject obj, jint jequation, jint jpower) {
  equation = jequation;
  power = jpower;
  LOG_OF_POWER = log(power);
}

JNIEXPORT void JNICALL Java_byrne_fractal_NativeLib_setMaxIterations
(JNIEnv * env, jobject obj, jint jmax) {
  max = jmax;
}

JNIEXPORT void JNICALL Java_byrne_fractal_NativeLib_resetCurrentRow
(JNIEnv * env, jobject obj) {
  currentRow = 0;
}

JNIEXPORT void JNICALL Java_byrne_fractal_NativeLib_setTrapFactor
(JNIEnv * env, jobject obj, jint jtrapFactor) {
  trapFactor = jtrapFactor;
}

JNIEXPORT void JNICALL Java_byrne_fractal_NativeLib_setFractalType
(JNIEnv * env, jobject obj, jint jfractalType) {
  fractalType = jfractalType;
}

JNIEXPORT void JNICALL Java_byrne_fractal_NativeLib_setAlgorithm
(JNIEnv * env, jobject obj, jint jalg, jint jbailout) {
  alg = jalg;
  bailout = jbailout;
  bsq = bailout*bailout;
}

JNIEXPORT void JNICALL Java_byrne_fractal_NativeLib_setCValue
(JNIEnv * env, jobject obj, jdouble jP, jdouble jQ) {
  P = jP;
  Q = jQ;
}

JNIEXPORT void JNICALL Java_byrne_fractal_NativeLib_setCoords
(JNIEnv * env, jobject obj, jdouble jrealmin, jdouble jrealmax, jdouble jimagmin, jdouble jimagmax) {
  realmin = jrealmin;
  realmax = jrealmax;
  imagmin = jimagmin;
  imagmax = jimagmax;
  deltaP = (realmax - realmin)/xres;
  deltaQ = (imagmax - imagmin)/yres;
}

JNIEXPORT jdouble JNICALL Java_byrne_fractal_NativeLib_getRealMin(JNIEnv * env, jobject obj) {
  return realmin;
}

JNIEXPORT jdouble JNICALL Java_byrne_fractal_NativeLib_getImagMin(JNIEnv * env, jobject obj) {
  return imagmin;
}

JNIEXPORT jdouble JNICALL Java_byrne_fractal_NativeLib_getRealMax(JNIEnv * env, jobject obj) {
  return realmax;
}

JNIEXPORT jdouble JNICALL Java_byrne_fractal_NativeLib_getImagMax(JNIEnv * env, jobject obj) {
  return imagmax;
}

JNIEXPORT jint JNICALL Java_byrne_fractal_NativeLib_getXRes(JNIEnv * env, jobject obj) {
  return xres;
}

JNIEXPORT jint JNICALL Java_byrne_fractal_NativeLib_getYRes(JNIEnv * env, jobject obj) {
  return yres;
}

void iterateZ() {
  switch (equation) {
    case 1: //Mandelbrot
      xtmp = xsq - ysq;
      y = 2*x*y;
      break;
    case 2: //Cubic Mandelbrot
      xtmp = xsq*x - 3*x*ysq;
      y = -ysq*y + 3*xsq*y;
      break;
    case 3: //Quartic Mandelbrot
      xtmp = xsq*xsq - 6*xsq*ysq + ysq*ysq;
      y = 4*xsq*x*y - 4*x*ysq*y;
      break;
    case 4: //Quintic Mandelbrot
      xtmp = xsq*xsq*x-10*xsq*x*ysq+5*x*ysq*ysq;
      y=(5*xsq*xsq*y-10*xsq*ysq*y+ysq*ysq*y);
      break;
    case 5: //Sextic Mandelbrot
      xtmp = xsq*xsq*xsq-15*xsq*xsq*ysq+15*xsq*ysq*ysq-ysq*ysq*ysq;
      y=(6*xsq*xsq*x*y-20*xsq*x*ysq*y+6*x*ysq*ysq*y);
      break;
    case 6: // Z^4 - Z^3 - Z^2 + C
      xtmp = xsq*xsq - 6*xsq*ysq + ysq*ysq - (xsq*x - 3*x*ysq) - (xsq - ysq);
      y = 4*xsq*x*y - 4*x*ysq*y - (-ysq*y + 3*xsq*y) - (2*x*y);
      break;
    case 7: // Z^6 - Z^2 + C
      xtmp = xsq*xsq*xsq-15*xsq*xsq*ysq+15*xsq*ysq*ysq-ysq*ysq*ysq - (xsq - ysq);
      y = (6*xsq*xsq*x*y-20*xsq*x*ysq*y+6*x*ys

double addC() {
  if (equation != 12) { 
    x += P;
    y -= Q;
  } else { //Phoenix Julia
    x += P + Q*prev_x;
    y += Q*prev_y;
  }
}

double gaussianIntDist() {
  double gint_x = round(x*trapFactor)/trapFactor;
  double gint_y = round(y*trapFactor)/trapFactor;
  return sqrt((x - gint_x)*(x-gint_x) + (y-gint_y)*(y-gint_y));
}

double epsilonCrossDist() {
  return minVal(abs(x),abs(y));
}

double stripes() {
  //double rad = sin(5.0 * log(sqrt(x*x+y*y)));
  double ang = sin(4 * atan2(y,x));
  return 0.5 + 0.5*(ang);
}

  
double curve_est() {
  double num_x = x - prev_x;
  double num_y = y - prev_y;
  double den_x = prev_x - prev_x_2;
  double den_y = prev_y - prev_y_2;
  double denom = (den_x*den_x + den_y*den_y);
  double real = (num_x*den_x + num_y*den_y)/denom;
  double imag = (den_x*num_y - den_y*num_x)/denom;
  return (abs(atan2(imag,real))/M_PI);

}

double TIA() {    
  
  double z_mag = sqrt(tia_prev_x*tia_prev_x + tia_prev_y*tia_prev_y);
  double c_mag;
  if (equation != 12) {
    c_mag = sqrt(P*P + Q*Q);
  } else { //Phoenix Julia
    double rt = P + Q*prev_x;
    double it = Q*prev_y;
    c_mag = sqrt(rt*rt + it*it);
  }
  double mn = z_mag - c_mag;
  mn = sqrt(mn*mn);
  double Mn = z_mag + c_mag;
  double num = sqrt(x*x + y*y) - mn;
  double den = Mn - mn;
  
  return num/den;
}

JNIEXPORT jintArray JNICALL Java_byrne_fractal_NativeLib_getFractalRow
(JNIEnv * env, jobject obj, jint row, jint state) {
  
  jintArray result;
  
  result = (*env)->NewIntArray(env, xres);
  if (result == NULL) {
    return NULL; /* out of memory error thrown */
  }
  
  if (fractalType == 1) //Mandelbrot
    Q = imagmax - row*deltaQ;

  int col, step = 1;
  
  currentRow++;
  
  //TODO Find a more elegant way to handle 2x2 and 1x1 rendering
  if (state > 0)
    step = 2;

  if (currentRow > rowsCached) {
    
    for(col=(state%2); col < xres; col = col+step) {
  
      if (fractalType == 1) { //Mandelbrot
    
        P = realmin + col*deltaP;
        x = y = 0.0;
        prev_x = prev_y = prev_x_2 = prev_y_2 = 0.0;
      } else { //Julia
        x = realmin + (double)col * deltaP;
        y = imagmax - (double)row * deltaQ;
        prev_x = prev_x_2 = x;
        prev_y = prev_y_2 = y;
      }
  
      lessThanMax = 0;
      int extraIterations = 0;
      double distance,distance1