/**
* Calculates equation 1 variables
*
* @param d
* @param v0
* @param t
* @param a
* @param varNum
* @return res
*/
private static String calc1(double d, double v0, double t, double a, int varNum) {
double res = 0;
// Solve for appropriate variable
if (varNum == 1) {
res = v0 * t + .5 * a * Math.pow(t, 2);
units = "meters";
} else if (varNum == 2) {
res = (d / t) - (.5 * a * t);
units = "m/s";
} else if (varNum == 3) {
double quadA =
((-1 * v0) + Math.sqrt(Math.pow(v0, 2) - (4 * .5 * a * (-1 * d)))) / (2 * .5 * a);
double quadB =
((-1 * v0) - Math.sqrt(Math.pow(v0, 2) - (4 * .5 * a * (-1 * d)))) / (2 * .5 * a);
if (quadA >= 0) res = quadA;
else res = quadB;
units = "seconds";
} else if (varNum == 4) {
res = ((d / t) - v0) / .5 * t;
units = "m/s^2";
}
return df.format(res);
}
@Test
public void GetUnitVectorInSameDirectionTest_LegalCase() {
Vector v = new Vector(Math.sqrt(2) / 2, Math.sqrt(2) / 2);
Vector result = testVector1.getUnitVectorInDirection();
assertTrue(Util.fuzzyEquals(v._X(), result._X()));
assertTrue(Util.fuzzyEquals(v._Y(), result._Y()));
}
@Override
public void reduce(
Text moviePair, Iterator<Text> ratings, OutputCollector<Text, Text> output, Reporter reporter)
throws IOException {
ArrayList<Double> ratings1 = new ArrayList<Double>();
ArrayList<Double> ratings2 = new ArrayList<Double>();
double numRatings = 0;
double totRating1 = 0, totrating2 = 0;
while (ratings.hasNext()) {
String[] rating = ratings.next().toString().split(",");
ratings1.add(Double.parseDouble(rating[0]));
ratings2.add(Double.parseDouble(rating[1]));
totRating1 += Double.parseDouble(rating[0]);
totrating2 += Double.parseDouble(rating[1]);
numRatings += 1;
}
double avgRating1 = totRating1 / numRatings;
double avgRating2 = totrating2 / numRatings;
double sum1 = 0.0, sum2 = 0.0, sumProduct = 0.0;
for (int i = 0; i < numRatings; i++) {
sum1 += Math.pow((ratings1.get(i) - avgRating1), 2);
sum2 += Math.pow((ratings2.get(i) - avgRating2), 2);
sumProduct += (ratings1.get(i) - avgRating1) * (ratings2.get(i) - avgRating2);
}
double corr = sumProduct / (Math.sqrt(sum1) * Math.sqrt(sum2));
System.out.println(sum1 + "," + sum2 + "," + sumProduct + "," + corr);
if (Double.isNaN(corr)) {
corr = 0;
}
output.collect(moviePair, new Text(corr + ""));
}
private double modelLevyAsian(double S, double K, double r, double div, double sig, double T) {
double valueLevy = 0.0;
double se = 0.0;
double m = 0.0;
double d = 0.0;
double sv = 0.0;
double xStar = 0.0;
double d1, d2 = 0.0;
double b = r - div; // cost of carry rate
double t2 = T; // remaining time to maturity
double sa = S; // Arithmetic Average price
se = S / (T * b) * (Math.exp((b - r) * t2) - Math.exp(-r * t2));
m =
2
* Math.pow(S, 2)
/ (b + Math.pow(sig, 2))
* ((Math.exp((2 * b + Math.pow(sig, 2)) * t2) - 1) / (2 * b + Math.pow(sig, 2))
- (Math.exp(b * t2) - 1) / b);
d = m / Math.pow(T, 2);
sv = Math.log(d) - 2 * (r * t2 + Math.log(se));
xStar = K - ((T - t2) / T) * sa;
d1 = 1 / Math.sqrt(sv) * (Math.log(d) / 2 - Math.log(xStar));
d2 = d1 - Math.sqrt(sv);
valueLevy = se * CND(d1) - xStar * Math.exp(-r * t2) * CND(d2);
return valueLevy;
}
private static void getRectangleSidesWithSquareAndPerimeter(
Rectangle rectangle, double perimeter, double square) {
double x;
double y;
double discriminant;
double halfPerimeter = perimeter / 2;
discriminant = (Math.pow(halfPerimeter, 2)) - (4 * 1 * square);
if (discriminant > 0) {
x = (halfPerimeter - Math.sqrt(discriminant)) / 2;
rectangle.sideA = x;
y = (halfPerimeter + Math.sqrt(discriminant)) / 2;
rectangle.sideB = y;
} else if (discriminant == 0) {
x = (halfPerimeter + Math.sqrt(discriminant)) / 2;
rectangle.sideA = x;
y = (halfPerimeter + Math.sqrt(discriminant)) / 2;
rectangle.sideB = y;
} else {
System.out.println("Maybe wrong data entered!");
}
}
static void initBiasLFM(
List<ArrayList<Double>> matrix,
List<Double> biList,
List<Double> bfList,
List<ArrayList<Double>> pMatrix,
List<ArrayList<Double>> qMatrix,
int F) {
for (int i = 0; i < matrix.size(); i++) {
biList.add(0.0);
}
for (int j = 0; j < matrix.get(0).size(); j++) {
bfList.add(0.0);
}
for (int i = 0; i < matrix.size(); i++) {
ArrayList<Double> tempList = new ArrayList<Double>();
for (int f = 0; f < F; f++) {
tempList.add((double) (Math.random() / Math.sqrt((double) F)));
}
pMatrix.add(tempList);
}
for (int j = 0; j < matrix.get(0).size(); j++) {
ArrayList<Double> tempList = new ArrayList<Double>();
for (int f = 0; f < F; f++) {
tempList.add((double) (Math.random() / Math.sqrt((double) F)));
}
qMatrix.add(tempList);
}
}
/**
* Apply the optimized MelCosine filter used in pocketsphinx to the given melspectrum.
*
* @param melspectrum the MelSpectrum data
* @return MelCepstrum data produced by apply the MelCosine filter to the MelSpectrum data
*/
@Override
protected double[] applyMelCosine(double[] melspectrum) {
// create the cepstrum
double[] cepstrum = new double[cepstrumSize];
double sqrt_inv_n = Math.sqrt(1.0 / numberMelFilters);
double sqrt_inv_2n = Math.sqrt(2.0 / numberMelFilters);
cepstrum[0] = melspectrum[0];
for (int j = 1; j < numberMelFilters; j++) {
cepstrum[0] += melspectrum[j];
}
cepstrum[0] *= sqrt_inv_n;
if (numberMelFilters <= 0) {
return cepstrum;
}
for (int i = 1; i < cepstrum.length; i++) {
double[] melcosine_i = melcosine[i];
int j = 0;
cepstrum[i] = 0;
for (j = 0; j < numberMelFilters; j++) {
cepstrum[i] += (melspectrum[j] * melcosine_i[j]);
}
cepstrum[i] *= sqrt_inv_2n;
}
return cepstrum;
}
/** Return baselineparameters */
private static void compute_B_Bpar_Bperp_Theta(
BaselineComponents BBparBperptheta,
final Point point,
final Point master,
final Point slave) {
logger.trace("BBparBperpTheta method");
BBparBperptheta.b =
master.distance(slave); // baseline. abs. value (in plane master,point,slave)
final double range1 = master.distance(point);
final double range2 = slave.distance(point);
BBparBperptheta.bpar = range1 - range2; // parallel baseline, sign ok
final Point r1 = master.min(point); // points from P to M
final Point r2 = slave.min(point);
BBparBperptheta.theta = master.angle(r1); // viewing angle
BBparBperptheta.bperp = sqr(BBparBperptheta.b) - sqr(BBparBperptheta.bpar);
// check for the sign of Bperp
if (BBparBperptheta.bperp < 0.0) {
BBparBperptheta.bperp = 0.0;
} else if (BBparBperptheta.theta > master.angle(r2)) { // perpendicular baseline, sign ok
BBparBperptheta.bperp = Math.sqrt(BBparBperptheta.bperp);
} else {
BBparBperptheta.bperp = -Math.sqrt(BBparBperptheta.bperp);
}
}
public void EMpar(Database db, double prior) {
int j, np;
double x, y, tmp, tmpx, tmpy, tmpsx, tmpsy, tmpsxy;
np = db.nPoints();
tmpsx = tmpsy = tmpsxy = kmx = kmy = 0;
for (j = 0; j < np; j++) {
x = db.xVal(j);
y = db.yVal(j);
kmx += probs[j] * x;
kmy += probs[j] * y;
tmpsx += probs[j] * x * x;
tmpsy += probs[j] * y * y;
tmpsxy += probs[j] * x * y;
}
tmp = np * weight;
kmx /= tmp;
kmy /= tmp;
ksx = Math.sqrt(tmpsx / tmp - kmx * kmx);
ksy = Math.sqrt(tmpsy / tmp - kmy * kmy);
ksxy = tmpsxy / tmp - kmx * kmy;
if (ksx < mins) ksx = mins;
if (ksy < mins) ksy = mins;
weight = 0.9 * weight + 0.1 * prior;
}
public void inputMovement(Point2D.Float acceleration) {
oldPosition = this.getPosition();
if (acceleration.x == 0 && acceleration.y == 0) {
velocity.x *= slowDown;
velocity.y *= slowDown;
} else {
float accelerationAbs =
(float) Math.sqrt(acceleration.x * acceleration.x + acceleration.y * acceleration.y);
velocity.x += acceleration.x * accelerationScale / accelerationAbs;
velocity.y += acceleration.y * accelerationScale / accelerationAbs;
float speed = (float) Math.sqrt(velocity.x * velocity.x + velocity.y * velocity.y);
if (speed > maxSpeed) {
velocity.x = velocity.x * maxSpeed / speed;
velocity.y = velocity.y * maxSpeed / speed;
}
}
if (collision == null) {
} else {
// revert the position and bounce a little bit
position.x += (position.x - collision.x) / 2;
position.y += (position.y - collision.y) / 2;
Point2D.Float proj = new Point2D.Float();
float collisionDirection = getRadiansTo(collision);
float movementDirection = (float) Math.atan2(velocity.y, velocity.x);
float angleBetween = movementDirection - collisionDirection;
float velocityAbs = (float) Math.sqrt(velocity.x * velocity.x + velocity.y * velocity.y);
float cosAB = (float) Math.cos(angleBetween); // angle between
velocity.x -= velocityAbs * cosAB * (float) Math.cos(collisionDirection) * 1.1;
velocity.y -= velocityAbs * cosAB * (float) Math.sin(collisionDirection) * 1.1;
resetCollision();
}
incrementPosition(velocity.x, velocity.y);
}
private static void calculateRegressionCoefficients(
double[] x, double meanx, double[] y, double meany, Result r, int d, int p) {
double beta;
double alpha;
double sxx = 0;
double sxy = 0;
double b = 0;
for (int i = 0; i < y.length; i++) {
sxx += ((x[i] - meanx) * (x[i] - meanx));
sxy += ((y[i] - meany) * (x[i] - meanx));
}
beta = sxy / sxx;
alpha = meany - beta * meanx;
double ssxy = 0;
for (int i = 0; i < y.length; i++) {
double yexp = alpha + (beta * x[i]);
ssxy += ((y[i] - yexp) * (y[i] - yexp));
}
double se = (Math.sqrt((ssxy) / (y.length - 2))) / Math.sqrt(sxx);
r.beta[d][p] = beta;
r.se[d][p] = se;
}
public void initialize() {
super.initialize();
if (Math.abs(Math.abs(projectionLatitude) - MapMath.HALFPI) < EPS10) {
mode = projectionLatitude < 0. ? SOUTH_POLE : NORTH_POLE;
sinphi0 = projectionLatitude < 0. ? -1. : 1.;
cosphi0 = 0.;
} else if (Math.abs(projectionLatitude) < EPS10) {
mode = EQUATOR;
sinphi0 = 0.;
cosphi0 = 1.;
} else {
mode = OBLIQUE;
sinphi0 = Math.sin(projectionLatitude);
cosphi0 = Math.cos(projectionLatitude);
}
if (!spherical) {
en = MapMath.enfn(es);
switch (mode) {
case NORTH_POLE:
Mp = MapMath.mlfn(MapMath.HALFPI, 1., 0., en);
break;
case SOUTH_POLE:
Mp = MapMath.mlfn(-MapMath.HALFPI, -1., 0., en);
break;
case EQUATOR:
case OBLIQUE:
N1 = 1. / Math.sqrt(1. - es * sinphi0 * sinphi0);
G = sinphi0 * (He = e / Math.sqrt(one_es));
He *= cosphi0;
break;
}
}
}
// Berechnung der Distanzen zwischen den Informationspunkten; Berechnung der Distanzen zwischen
// den Informationspunkten und dem Interpolationspunkt
public void calculateDistances() {
numOfPoints = points.size();
distanceData = new double[numOfPoints][numOfPoints];
calcPointDistance = new double[numOfPoints];
// Berechnung der Distanzen zwischen den Informationspunkten
for (int i = 0; i < numOfPoints; i++) {
for (int j = 0; j < numOfPoints; j++) {
distanceData[i][j] =
Math.sqrt(
Math.pow(points.get(i).xCoordinate - points.get(j).xCoordinate, 2)
+ Math.pow(points.get(i).yCoordinate - points.get(j).yCoordinate, 2));
}
}
// Berechnung der Distanzen zwischen den Informationspunkten und dem Interpolationspunkt
for (int i = 0; i < numOfPoints; i++) {
calcPointDistance[i] =
Math.sqrt(
Math.pow(calcPoint.xCoordinate - points.get(i).xCoordinate, 2)
+ Math.pow(calcPoint.yCoordinate - points.get(i).yCoordinate, 2));
}
}
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int a, b, c;
a = in.nextInt();
b = in.nextInt();
c = in.nextInt();
int tmp;
if (a < b) {
tmp = a;
a = b;
b = tmp;
}
if (a < c) {
tmp = a;
a = c;
c = tmp;
}
if (a >= b + c) {
System.out.println("n");
} else if (a == Math.sqrt(b * b + c * c)) {
System.out.println("r");
} else if (a > Math.sqrt(b * b + c * c)) {
System.out.println("o");
} else {
System.out.println("a");
}
System.out.println();
}
/**
* Uses the Haversine formula to calculate the distnace between to lat-long coordinates
*
* @param latitude1 The first point's latitude
* @param longitude1 The first point's longitude
* @param latitude2 The second point's latitude
* @param longitude2 The second point's longitude
* @return The distance between the two points in meters
*/
public static double CalculateDistance(
double latitude1, double longitude1, double latitude2, double longitude2) {
/*
Haversine formula:
A = sin²(Δlat/2) + cos(lat1).cos(lat2).sin²(Δlong/2)
C = 2.atan2(√a, √(1−a))
D = R.c
R = radius of earth, 6371 km.
All angles are in radians
*/
double deltaLatitude = Math.toRadians(Math.abs(latitude1 - latitude2));
double deltaLongitude = Math.toRadians(Math.abs(longitude1 - longitude2));
double latitude1Rad = Math.toRadians(latitude1);
double latitude2Rad = Math.toRadians(latitude2);
double a =
Math.pow(Math.sin(deltaLatitude / 2), 2)
+ (Math.cos(latitude1Rad)
* Math.cos(latitude2Rad)
* Math.pow(Math.sin(deltaLongitude / 2), 2));
double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
return 6371 * c * 1000; // Distance in meters
}
public static double getAngleToTarget(BaseModel t1, BaseModel t2) {
Vec2 forVec =
Vec2.getVector(
t1.getPosX(),
t1.getPosY(),
t1.getPosX() + Math.cos(Math.toRadians(t1.getRotation())) * 10,
t1.getPosY() + Math.sin(Math.toRadians(t1.getRotation())) * 10);
Vec2 tarVec = Vec2.getVector(t1.getPosX(), t1.getPosY(), t2.getPosX(), t2.getPosY());
double scalar = Vec2.getScalarMultip(forVec, tarVec);
double modFV = Math.sqrt(forVec.vX * forVec.vX + forVec.vY * forVec.vY);
double modTV = Math.sqrt(tarVec.vX * tarVec.vX + tarVec.vY * tarVec.vY);
double cosa = scalar / (modFV * modTV);
double ang = Math.toDegrees(Math.acos(cosa));
double znak = getRelativePositionTarget(t1, t2);
znak = znak / Math.abs(znak);
if (Double.isNaN(znak)) {
znak = 0;
}
if (Double.isNaN(ang)) {
ang = 0;
}
return ang * znak;
}
public void animateCircularClip(int x, int y, boolean in, AnimatorListener listener) {
if (mAnimator != null) {
mAnimator.cancel();
}
final int w = mDetail.getWidth() - x;
final int h = mDetail.getHeight() - y;
int innerR = 0;
if (x < 0 || w < 0 || y < 0 || h < 0) {
innerR = Math.abs(x);
innerR = Math.min(innerR, Math.abs(y));
innerR = Math.min(innerR, Math.abs(w));
innerR = Math.min(innerR, Math.abs(h));
}
int r = (int) Math.ceil(Math.sqrt(x * x + y * y));
r = (int) Math.max(r, Math.ceil(Math.sqrt(w * w + y * y)));
r = (int) Math.max(r, Math.ceil(Math.sqrt(w * w + h * h)));
r = (int) Math.max(r, Math.ceil(Math.sqrt(x * x + h * h)));
if (in) {
mAnimator = ViewAnimationUtils.createCircularReveal(mDetail, x, y, innerR, r);
} else {
mAnimator = ViewAnimationUtils.createCircularReveal(mDetail, x, y, r, innerR);
}
mAnimator.setDuration((long) (mAnimator.getDuration() * 1.5));
if (listener != null) {
mAnimator.addListener(listener);
}
if (in) {
mBackground.startTransition((int) (mAnimator.getDuration() * 0.6));
mAnimator.addListener(mVisibleOnStart);
} else {
mDetail.postDelayed(mReverseBackground, (long) (mAnimator.getDuration() * 0.65));
mAnimator.addListener(mGoneOnEnd);
}
mAnimator.start();
}
/**
* Returns a {@linkplain Stats Stats} object containing statistics of this series.
*
* @return Statistics.
*/
public Stats stats() {
int n = length();
double sumX = 0.0;
double sumY = 0.0;
for (int i = 0; i < n; ++i) {
sumX += x(i);
sumY += y(i);
}
double meanX = sumX / n;
double sumdevX = 0.0;
double sumdevsqrX = 0.0;
double meanY = sumY / n;
double sumdevY = 0.0;
double sumdevsqrY = 0.0;
for (int i = 0; i < n; ++i) {
double devX = x(i) - meanX;
double devsqrX = devX * devX;
sumdevX += devX;
sumdevsqrX += devsqrX;
double devY = y(i) - meanY;
double devsqrY = devY * devY;
sumdevY += devY;
sumdevsqrY += devsqrY;
}
double varX = (sumdevsqrX - sumdevX * sumdevX / n) / (n - 1);
double stddevX = Math.sqrt(varX);
double varY = (sumdevsqrY - sumdevY * sumdevY / n) / (n - 1);
double stddevY = Math.sqrt(varY);
return new Stats(meanX, varX, stddevX, meanY, varY, stddevY);
}
public void mouseReleased(MouseEvent e) {
left_mouse_pressed = false;
double kvadrat = Math.sqrt(angleX * angleX + angleY * angleY);
double tempx = angleX / kvadrat;
double tempy = Math.sqrt(1 - tempx * tempx);
if (angleY < 0) tempy = -tempy;
Bullet b = new Bullet();
boolean next = false;
if (type_bullet1 == true && count_sphere > 0) {
b = new Sphere();
count_sphere--;
next = true;
}
if (type_bullet2 == true && count_fireball > 0) {
b = new FireBall();
count_fireball--;
next = true;
}
if (type_bullet3 == true && count_rocket > 0) {
b = new Rocket();
count_rocket--;
next = true;
}
if (next == true) {
b.bullet_x = player.getX() + 52 + 5 * Math.cos(angle); // + 50; //koef;
b.bullet_y = player.getY() + 49 + 5 * Math.sin(angle); // player.getY() + 35; //25;
b.current_direction_x = tempx;
b.current_direction_y = tempy;
bullet.addElement(b);
allow_shoot = false;
}
}
public static double calcDistFromLonmLatm(
double lonm1, double latm1, double lonm2, double latm2) {
double lon1R = lonm1 * .000001 / 180 * Math.PI;
double lat1R = latm1 * .000001 / 180 * Math.PI;
double lon2R = lonm2 * .000001 / 180 * Math.PI;
double lat2R = latm2 * .000001 / 180 * Math.PI;
// from http://www.movable-type.co.uk/scripts/latlong.html
// var R = 6371; // km
// var dLat = (lat2-lat1).toRad();
// var dLon = (lon2-lon1).toRad();
// var lat1 = lat1.toRad();
// var lat2 = lat2.toRad();
//
// var a = Math.sin(dLat/2) * Math.sin(dLat/2) +
// Math.sin(dLon/2) * Math.sin(dLon/2) * Math.cos(lat1) * Math.cos(lat2);
// var c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a));
// var d = R * c;
double dLatR = lat2R - lat1R;
double dLonR = lon2R - lon1R;
double a =
Math.sin(dLatR / 2) * Math.sin(dLatR / 2)
+ Math.sin(dLonR / 2) * Math.sin(dLonR / 2) * Math.cos(lat1R) * Math.cos(lat2R);
double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
return EARTH_RADIUS_M * c;
}
public double getT(Ray r, RenderObject o) {
Matrix m = new Matrix();
double[][] u = r.u3;
double[][] ut = m.tMatrix(u);
double[][] p = r.p0C.subtract(r.p0C, o.getOrigin()).toArray3D();
double[][] pt = m.tMatrix(p);
double[][] aa = m.multiplyMatrix(ut, u);
double a = aa[0][0];
double bb[][] = m.multiplyMatrix(ut, p);
double b = bb[0][0] * 2;
double cc[][] = m.multiplyMatrix(pt, p);
double cee = cc[0][0] - (o.getRadius() * o.getRadius());
double existance = (b * b) - (4 * a * cee);
if (existance < 0) {
return -1;
} else {
double t1 = ((-1 * b) + Math.sqrt(existance)) / (2 * a);
double t2 = ((-1 * b) - Math.sqrt(existance)) / (2 * a);
if (t1 < 0 && t2 < 0) {
return -1;
} else if (t1 < 0) {
return t2;
} else if (t2 < 0) {
return t1;
} else {
return Math.min(t1, t2);
}
}
}
@Override
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
final float ratio = calculateRatio();
float radius;
// Darkening background
canvas.drawColor(Color.argb((int) (200 * calculateRatio()), 0, 0, 0));
if (mRadiusAimed) {
// Indicate that target radius is aimed.
mPaint.setAlpha(35);
radius = (float) Math.sqrt(mRadius / 70) * 70;
canvas.drawCircle(mPoint[0], mPoint[1], radius, mPaint);
}
// Draw unlock circle
mPaint.setAlpha((int) (255 * Math.pow(ratio, 0.33f)));
radius = (float) Math.sqrt(mRadius / 50) * 50;
canvas.drawCircle(mPoint[0], mPoint[1], radius, mPaint);
// Draw unlock icon at the center of circle
float scale = 0.5f + 0.5f * ratio;
canvas.save();
canvas.translate(
mPoint[0] - mDrawable.getMinimumWidth() / 2 * scale,
mPoint[1] - mDrawable.getMinimumHeight() / 2 * scale);
canvas.scale(scale, scale);
mDrawable.draw(canvas);
canvas.restore();
}
/**
* Input W must be initialized to a nonzero vector, output is {U,V,W}, an orthonormal basis. A
* hint is provided about whether or not W is already unit length.
*
* @param kU DOCUMENT ME!
* @param kV DOCUMENT ME!
* @param kW DOCUMENT ME!
* @param bUnitLengthW DOCUMENT ME!
*/
static void generateOrthonormalBasis(
MjVector3f kU, MjVector3f kV, MjVector3f kW, boolean bUnitLengthW) {
if (!bUnitLengthW) {
kW.normalizeSafe();
}
float fInvLength;
if (Math.abs(kW.x) >= Math.abs(kW.y)) {
// W.x or W.z is the largest magnitude component, swap them
fInvLength = 1.0f / (float) Math.sqrt((kW.x * kW.x) + (kW.z * kW.z));
kU.x = -kW.z * fInvLength;
kU.y = 0.0f;
kU.z = +kW.x * fInvLength;
} else {
// W.y or W.z is the largest magnitude component, swap them
fInvLength = 1.0f / (float) Math.sqrt((kW.y * kW.y) + (kW.z * kW.z));
kU.x = 0.0f;
kU.y = +kW.z * fInvLength;
kU.z = -kW.y * fInvLength;
}
kV.cross(kW, kU);
}
public static String calc_distance(Context context, String start_longlat, String end_longlat) {
double sLat = Double.parseDouble(start_longlat.substring(0, start_longlat.indexOf(",") - 1));
double sLng = Double.parseDouble(start_longlat.substring(start_longlat.indexOf(",") + 1));
double eLat = Double.parseDouble(end_longlat.substring(0, end_longlat.indexOf(",") - 1));
double eLng = Double.parseDouble(end_longlat.substring(end_longlat.indexOf(",") + 1));
double dis;
double jrk;
String distance = null;
double d2r = (Math.PI / 180);
double dLat = (eLat - sLat) * d2r;
double dLon = (eLng - sLng) * d2r;
double a =
Math.sin(dLat / 2) * Math.sin(dLat / 2)
+ Math.cos(sLat * d2r) * Math.cos(eLat * d2r) * Math.sin(dLon / 2) * Math.sin(dLon / 2);
double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
dis = EARTH_RADIUS_KM * c * 1000;
if (dis > 10000) {
jrk = Double.valueOf(Math.round(dis / 1000));
distance = Double.toString(jrk) + " Km";
} else if (dis > 0 && dis < 100) {
jrk = Double.valueOf(Math.round(dis));
distance = Double.toString(jrk) + " m";
} else if (dis > 200 && dis < 1000) {
jrk = Double.valueOf(Math.round(dis / 10));
distance = Double.toString(jrk) + " Km";
} else {
jrk = Double.valueOf(Math.round(dis / 1000));
distance = Double.toString(jrk) + " Km";
}
return distance;
}
private double vegaArithmetic(double S, double K, double T, double r, double div, double sig) {
double vegaAr = 0.0;
double m1 = 0.0;
double m2 = 0.0;
double ba = 0.0;
double b = r - div;
double tau = 0.0;
double va = 0.0;
double d1, d2 = 0.0;
m1 = (Math.exp(b * T) - Math.exp(b * tau)) / (b * (T - tau));
m2 =
2
* Math.exp((2 * b + Math.pow(sig, 2)) * T)
/ ((b + Math.pow(sig, 2)) * (2 * b + Math.pow(sig, 2)) * Math.pow((T - tau), 2))
+ 2
* Math.exp((2 * b + Math.pow(sig, 2)) * tau)
/ (b * Math.pow((T - tau), 2))
* (1 / (2 * b + Math.pow(sig, 2))
- Math.exp(b * (T - tau)) / (b + Math.pow(sig, 2)));
System.out.println("M:" + m2);
ba = Math.log(m1) / T;
va = Math.sqrt(Math.log(m2) / T - 2 * ba);
d1 = (Math.log(S / K) + (ba + Math.pow(va, 2) / 2) * T) / (va * Math.sqrt(T));
// d2 = d1 - (sig*Math.sqrt(T));
vegaAr = S * Math.exp((ba - r) * T) * ND(d1) * Math.sqrt(T);
return vegaAr;
}
private float calcXLocationInWheel(float x, float cos, float radius) {
if (x > (getMeasuredWidth() / 2)) {
return (float) (getWidth() / 2 + Math.sqrt(1 - cos * cos) * radius);
} else {
return (float) (getWidth() / 2 - Math.sqrt(1 - cos * cos) * radius);
}
}
@Override
public boolean onTouchEvent(MotionEvent event) {
int action = event.getActionMasked();
int P = event.getPointerCount();
// int N = event.getHistorySize();
if (action != MotionEvent.ACTION_MOVE) {
if (action == MotionEvent.ACTION_DOWN) {
// startX = mCurX * mScale; // event.getX();
// startY = mCurY * mScale; // event.getY();
sX1 = mCurX * mScale - event.getX(0);
sY1 = mCurY * mScale - event.getY(0);
return true;
}
if (action == MotionEvent.ACTION_POINTER_DOWN) {
// Toast.makeText(mContext,
// Float.toString(sX1)+"apd",
// Toast.LENGTH_SHORT).show();
if (P == 2) {
float sX2 = event.getX(0) - event.getX(1);
float sY2 = event.getY(0) - event.getY(1);
sD = (float) Math.sqrt(sX2 * sX2 + sY2 * sY2);
mBitmapViewWidthInitial = mBitmapViewWidth;
return true;
} else if (P == 3) {
sMx = (float) mCenterX - event.getX(2);
sMy = (float) mCenterY - event.getY(2);
return true;
}
return false;
}
} else {
if (P == 1) {
float a = Math.abs(sX1 + event.getX()) % mX;
float b = Math.abs(sY1 + event.getY()) % mY;
mCurX = (int) (a / mScale); // *(int)(event.getHistoricalX(0)-event.getHistoricalX(1));
mCurY = (int) (b / mScale); // *(int)(event.getHistoricalY(0)-event.getHistoricalY(1));
} else if (P == 2) {
float sX2 = event.getX(0) - event.getX(1);
float sY2 = event.getY(0) - event.getY(1);
float sD2 = (float) Math.sqrt(sX2 * sX2 + sY2 * sY2);
int r = mBitmapViewWidthInitial + Math.round(sD2 - sD);
if (r < mScreenRadius) r = mScreenRadius;
setViewBitmapSizes(r);
} else if (P == 3) {
mCenterX = (int) (sMx + event.getX(2));
mCenterY = (int) (sMy + event.getY(2));
} else {
return false;
}
drawIntoBitmap();
invalidate();
if (use3D) {
updateTexture();
}
}
return true;
}
private static double Correlationlogppl1(ArrayList<Double> sent, ArrayList<Double> word) {
// TODO Auto-generated method stub
double result = 0, SumScr_x = 0, SumScr_y = 0;
double sum_sq_x = 0;
double sum_sq_y = 0;
double sum_coproduct = 0;
double mean_x = 0;
double mean_y = 0;
for (int i = 0; i < sent.size(); i++) {
SumScr_x += sent.get(i);
SumScr_y += word.get(i);
}
mean_x = SumScr_x / sent.size();
mean_y = SumScr_y / sent.size();
for (int i = 0; i < sent.size(); i++) {
double delta_x = sent.get(i) - mean_x;
double delta_y = word.get(i) - mean_y;
sum_sq_x += delta_x * delta_x;
sum_sq_y += delta_y * delta_y;
sum_coproduct += delta_x * delta_y;
}
double pop_sd_x = (double) Math.sqrt(sum_sq_x);
double pop_sd_y = (double) Math.sqrt(sum_sq_y);
result = sum_coproduct / (pop_sd_x * pop_sd_y);
return result;
}
@Override
public Component getVisualizationComponent(Object renderable, IOContainer ioContainer) {
TTestSignificanceTestResult result = (TTestSignificanceTestResult) renderable;
PerformanceVector[] allVectors = result.getAllVectors();
StringBuffer buffer = new StringBuffer();
Color bgColor = SwingTools.LIGHTEST_YELLOW;
String bgColorString =
Integer.toHexString(bgColor.getRed())
+ Integer.toHexString(bgColor.getGreen())
+ Integer.toHexString(bgColor.getBlue());
buffer.append("<table bgcolor=\"" + bgColorString + "\" border=\"1\">");
buffer.append("<tr><td></td>");
for (int i = 0; i < result.getAllVectors().length; i++) {
buffer.append(
"<td>"
+ Tools.formatNumber(allVectors[i].getMainCriterion().getAverage())
+ " +/- "
+ Tools.formatNumber(Math.sqrt(allVectors[i].getMainCriterion().getVariance()))
+ "</td>");
}
buffer.append("</tr>");
for (int i = 0; i < allVectors.length; i++) {
buffer.append(
"<tr><td>"
+ Tools.formatNumber(allVectors[i].getMainCriterion().getAverage())
+ " +/- "
+ Tools.formatNumber(Math.sqrt(allVectors[i].getMainCriterion().getVariance()))
+ "</td>");
for (int j = 0; j < allVectors.length; j++) {
buffer.append("<td>");
if (!Double.isNaN(result.getProbMatrix()[i][j])) {
double prob = result.getProbMatrix()[i][j];
if (prob < result.getAlpha()) {
buffer.append("<b>");
}
buffer.append(Tools.formatNumber(prob));
if (prob < result.getAlpha()) {
buffer.append("</b>");
}
}
buffer.append("</td>");
}
buffer.append("</tr>");
}
buffer.append("</table>");
buffer.append(
"<br>Probabilities for random values with the same result.<br>Bold values are smaller than alpha="
+ Tools.formatNumber(result.getAlpha())
+ " which indicates a probably significant difference between the actual mean values!");
JEditorPane textPane =
new ExtendedHTMLJEditorPane(
"text/html", "<html><h1>" + getName() + "</h1>" + buffer.toString() + "</html>");
textPane.setBackground((new JLabel()).getBackground());
textPane.setBorder(javax.swing.BorderFactory.createEmptyBorder(11, 11, 11, 11));
textPane.setEditable(false);
return new ExtendedJScrollPane(textPane);
}
/**
* Gradient
*
* @param x a <code>double[]</code> input vector
* @return
*/
@Override
public double[] gradient(double[] x) {
double[] sqrtPsi = new double[nVariables];
double[] invSqrtPsi = new double[nVariables];
for (int i = 0; i < nVariables; i++) {
x[i] = Math.max(0.005, x[i]); // ensure that no parameters are negative
sqrtPsi[i] = Math.sqrt(x[i]);
invSqrtPsi[i] = 1.0 / Math.sqrt(x[i]);
}
DiagonalMatrix diagPsi = new DiagonalMatrix(x);
DiagonalMatrix diagSqtPsi = new DiagonalMatrix(sqrtPsi);
DiagonalMatrix SC = new DiagonalMatrix(invSqrtPsi);
RealMatrix Sstar = SC.multiply(R2).multiply(SC);
EigenDecomposition E = new EigenDecomposition(Sstar);
RealMatrix L = E.getV().getSubMatrix(0, nVariables - 1, 0, nFactors - 1);
double[] ev = new double[nFactors];
for (int i = 0; i < nFactors; i++) {
ev[i] = Math.sqrt(Math.max(E.getRealEigenvalue(i) - 1, 0));
}
DiagonalMatrix M = new DiagonalMatrix(ev);
RealMatrix LOAD = L.multiply(M);
RealMatrix LL = diagSqtPsi.multiply(LOAD);
RealMatrix G = LL.multiply(LL.transpose()).add(diagPsi).subtract(R2);
double[] gradient = new double[nVariables];
for (int i = 0; i < nVariables; i++) {
gradient[i] = G.getEntry(i, i) / (x[i] * x[i]);
}
return gradient;
}