List of usage examples for java.lang Math cos
@HotSpotIntrinsicCandidate public static double cos(double a)
From source file:com.kircherelectronics.accelerationexplorer.filter.ImuLaCfQuaternion.java
public float[] getLinearAcceleration() { // values[0]: azimuth, rotation around the Z axis. // values[1]: pitch, rotation around the X axis. // values[2]: roll, rotation around the Y axis. // Find the gravity component of the X-axis // = g*-cos(pitch)*sin(roll); components[0] = (float) (SensorManager.GRAVITY_EARTH * -Math.cos(fusedOrientation[1]) * Math.sin(fusedOrientation[2])); // Find the gravity component of the Y-axis // = g*-sin(pitch); components[1] = (float) (SensorManager.GRAVITY_EARTH * -Math.sin(fusedOrientation[1])); // Find the gravity component of the Z-axis // = g*cos(pitch)*cos(roll); components[2] = (float) (SensorManager.GRAVITY_EARTH * Math.cos(fusedOrientation[1]) * Math.cos(fusedOrientation[2])); // Subtract the gravity component of the signal // from the input acceleration signal to get the // tilt compensated output. linearAcceleration[0] = (this.acceleration[0] - components[0]); linearAcceleration[1] = (this.acceleration[1] - components[1]); linearAcceleration[2] = (this.acceleration[2] - components[2]); return linearAcceleration; }
From source file:Rotation.java
/** Build a rotation from an axis and an angle. * <p>We use the convention that angles are oriented according to * the effect of the rotation on vectors around the axis. That means * that if (i, j, k) is a direct frame and if we first provide +k as * the axis and PI/2 as the angle to this constructor, and then * {@link #applyTo(Vector3D) apply} the instance to +i, we will get * +j.</p>/* w w w . j a v a 2s .c om*/ * @param axis axis around which to rotate * @param angle rotation angle. * @exception ArithmeticException if the axis norm is zero */ public Rotation(Vector3D axis, double angle) { double norm = axis.getNorm(); if (norm == 0) { throw new ArithmeticException("zero norm for rotation axis"); } double halfAngle = -0.5 * angle; double coeff = Math.sin(halfAngle) / norm; q0 = Math.cos(halfAngle); q1 = coeff * axis.getX(); q2 = coeff * axis.getY(); q3 = coeff * axis.getZ(); }
From source file:com.alvermont.terraj.fracplanet.geom.Matrix33.java
/** * Get a matrix that represents a rotation around the X axis * * @param angle The angle of rotation desired (in radians) * @return The corresponding rotation matrix *//*from ww w .ja v a 2s . co m*/ public static Matrix33 getRotateAboutX(float angle) { final Matrix33 mat = new Matrix33(); final float ca = (float) Math.cos(angle); final float sa = (float) Math.sin(angle); mat.basis[0] = new SimpleXYZ(1.0f, 0.0f, 0.0f); mat.basis[1] = new SimpleXYZ(0.0f, ca, sa); mat.basis[2] = new SimpleXYZ(0.0f, -sa, ca); return mat; }
From source file:imagingbook.pub.fd.FourierDescriptor.java
/** * Returns the spatial point reconstructed from a single * DFT coefficient 'Gm' with frequency 'm' at * position 't' in [0,1].// w ww. jav a 2 s. co m */ private Complex getReconstructionPoint(Complex Gm, int m, double t) { double wm = 2 * Math.PI * m; double Am = Gm.re; double Bm = Gm.im; double cost = Math.cos(wm * t); double sint = Math.sin(wm * t); double xt = Am * cost - Bm * sint; double yt = Bm * cost + Am * sint; return new Complex(xt, yt); }
From source file:com.docdoku.server.rest.InstanceMessageBodyWriter.java
private double getRelativeTxAfterParentRotation(double rx, double ry, double rz, double tx, double ty, double tz) { double a = Math.cos(ry) * Math.cos(rz); double b = -Math.cos(rx) * Math.sin(rz) + Math.sin(rx) * Math.sin(ry) * Math.cos(rz); double c = Math.sin(rx) * Math.sin(rz) + Math.cos(rx) * Math.sin(ry) * Math.cos(rz); return a * tx + b * ty + c * tz; }
From source file:es.emergya.geo.util.Lambert.java
/** * Initializes from geographic coordinates. Note that reference ellipsoid * used by Lambert is the Clark ellipsoid. * * @param lat latitude in grad/*from w ww . j a va 2 s. com*/ * @param lon longitude in grad * @param Xs false east (coordinate system origin) in meters * @param Ys false north (coordinate system origin) in meters * @param c projection constant * @param n projection exponent * @return EastNorth projected coordinates in meter */ private EastNorth ConicProjection(double lat, double lon, double Xs, double Ys, double c, double n) { double eslt = Ellipsoid.clarke.e * Math.sin(lat); double l = Math.log(Math.tan(Math.PI / 4.0 + (lat / 2.0)) * Math.pow((1.0 - eslt) / (1.0 + eslt), Ellipsoid.clarke.e / 2.0)); double east = Xs + c * Math.exp(-n * l) * Math.sin(n * (lon - lg0)); double north = Ys - c * Math.exp(-n * l) * Math.cos(n * (lon - lg0)); return new EastNorth(east, north); }
From source file:fr.certu.chouette.validation.checkpoint.AbstractValidation.java
/** * @see http://mathforum.org/library/drmath/view/51879.html *///from w ww . ja v a 2s.c o m private double computeHaversineFormula(NeptuneLocalizedObject obj1, NeptuneLocalizedObject obj2) { double lon1 = Math.toRadians(obj1.getLongitude().doubleValue()); double lat1 = Math.toRadians(obj1.getLatitude().doubleValue()); double lon2 = Math.toRadians(obj2.getLongitude().doubleValue()); double lat2 = Math.toRadians(obj2.getLatitude().doubleValue()); final double R = 6371008.8; double dlon = lon2 - lon1; double dlat = lat2 - lat1; double a = Math.pow((Math.sin(dlat / 2)), 2) + Math.cos(lat1) * Math.cos(lat2) * Math.pow(Math.sin(dlon / 2), 2); double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a)); double d = R * c; return d; }
From source file:edu.stanford.slac.archiverappliance.PB.data.StatusSeverityTest.java
private DBR getJCASampleValue(ArchDBRTypes type, int value, int severity, int status) { switch (type) { case DBR_SCALAR_STRING: DBR_TIME_String retvalss = new DBR_TIME_String(new String[] { Integer.toString(value) }); retvalss.setTimeStamp(convertSecondsIntoYear2JCATimeStamp(value)); retvalss.setSeverity(severity);// w ww .j av a2 s . c o m retvalss.setStatus(status); return retvalss; case DBR_SCALAR_SHORT: DBR_TIME_Short retvalsh; if (0 <= value && value < 1000) { // Check for some numbers around the minimum value retvalsh = new DBR_TIME_Short(new short[] { (short) (Short.MIN_VALUE + value) }); } else if (1000 <= value && value < 2000) { // Check for some numbers around the maximum value retvalsh = new DBR_TIME_Short(new short[] { (short) (Short.MAX_VALUE - (value - 1000)) }); } else { // Check for some numbers around 0 retvalsh = new DBR_TIME_Short(new short[] { (short) (value - 2000) }); } retvalsh.setTimeStamp(convertSecondsIntoYear2JCATimeStamp(value)); retvalsh.setSeverity(severity); retvalsh.setStatus(status); return retvalsh; case DBR_SCALAR_FLOAT: DBR_TIME_Float retvalfl; if (0 <= value && value < 1000) { // Check for some numbers around the minimum value retvalfl = new DBR_TIME_Float(new float[] { Float.MIN_VALUE + value }); } else if (1000 <= value && value < 2000) { // Check for some numbers around the maximum value retvalfl = new DBR_TIME_Float(new float[] { Float.MAX_VALUE - (value - 1000) }); } else { // Check for some numbers around 0. Divide by a large number to make sure we cater to the number of precision digits retvalfl = new DBR_TIME_Float(new float[] { (value - 2000.0f) / value }); } retvalfl.setTimeStamp(convertSecondsIntoYear2JCATimeStamp(value)); retvalfl.setSeverity(severity); retvalfl.setStatus(status); return retvalfl; case DBR_SCALAR_ENUM: DBR_TIME_Enum retvalen; retvalen = new DBR_TIME_Enum(new short[] { (short) (value) }); retvalen.setTimeStamp(convertSecondsIntoYear2JCATimeStamp(value)); retvalen.setSeverity(severity); retvalen.setStatus(status); return retvalen; case DBR_SCALAR_BYTE: DBR_TIME_Byte retvalby; retvalby = new DBR_TIME_Byte(new byte[] { ((byte) (value % 255)) }); retvalby.setTimeStamp(convertSecondsIntoYear2JCATimeStamp(value)); retvalby.setSeverity(severity); retvalby.setStatus(status); return retvalby; case DBR_SCALAR_INT: DBR_TIME_Int retvalint; if (0 <= value && value < 1000) { // Check for some numbers around the minimum value retvalint = new DBR_TIME_Int(new int[] { Integer.MIN_VALUE + value }); } else if (1000 <= value && value < 2000) { // Check for some numbers around the maximum value retvalint = new DBR_TIME_Int(new int[] { Integer.MAX_VALUE - (value - 1000) }); } else { // Check for some numbers around 0 retvalint = new DBR_TIME_Int(new int[] { (value - 2000) }); } retvalint.setTimeStamp(convertSecondsIntoYear2JCATimeStamp(value)); retvalint.setSeverity(severity); retvalint.setStatus(status); return retvalint; case DBR_SCALAR_DOUBLE: DBR_TIME_Double retvaldb; if (0 <= value && value < 1000) { // Check for some numbers around the minimum value retvaldb = new DBR_TIME_Double(new double[] { (Double.MIN_VALUE + value) }); } else if (1000 <= value && value < 2000) { // Check for some numbers around the maximum value retvaldb = new DBR_TIME_Double(new double[] { (Double.MAX_VALUE - (value - 1000)) }); } else { // Check for some numbers around 0. Divide by a large number to make sure we cater to the number of precision digits retvaldb = new DBR_TIME_Double(new double[] { ((value - 2000.0) / (value * 1000000)) }); } retvaldb.setTimeStamp(convertSecondsIntoYear2JCATimeStamp(value)); retvaldb.setSeverity(severity); retvaldb.setStatus(status); return retvaldb; case DBR_WAVEFORM_STRING: DBR_TIME_String retvst; // Varying number of copies of a typical value retvst = new DBR_TIME_String( Collections.nCopies(value, Integer.toString(value)).toArray(new String[0])); retvst.setTimeStamp(convertSecondsIntoYear2JCATimeStamp(value)); retvst.setSeverity(severity); retvst.setStatus(status); return retvst; case DBR_WAVEFORM_SHORT: DBR_TIME_Short retvsh; retvsh = new DBR_TIME_Short( ArrayUtils.toPrimitive(Collections.nCopies(1, (short) value).toArray(new Short[0]))); retvsh.setTimeStamp(convertSecondsIntoYear2JCATimeStamp(value)); retvsh.setSeverity(severity); retvsh.setStatus(status); return retvsh; case DBR_WAVEFORM_FLOAT: DBR_TIME_Float retvf; // Varying number of copies of a typical value retvf = new DBR_TIME_Float(ArrayUtils.toPrimitive( Collections.nCopies(value, (float) Math.cos(value * Math.PI / 3600)).toArray(new Float[0]))); retvf.setTimeStamp(convertSecondsIntoYear2JCATimeStamp(value)); retvf.setSeverity(severity); retvf.setStatus(status); return retvf; case DBR_WAVEFORM_ENUM: DBR_TIME_Enum retven; retven = new DBR_TIME_Enum( ArrayUtils.toPrimitive(Collections.nCopies(1024, (short) value).toArray(new Short[0]))); retven.setTimeStamp(convertSecondsIntoYear2JCATimeStamp(value)); retven.setSeverity(severity); retven.setStatus(status); return retven; case DBR_WAVEFORM_BYTE: DBR_TIME_Byte retvb; // Large number of elements in the array retvb = new DBR_TIME_Byte(ArrayUtils .toPrimitive(Collections.nCopies(65536 * value, ((byte) (value % 255))).toArray(new Byte[0]))); retvb.setTimeStamp(convertSecondsIntoYear2JCATimeStamp(value)); retvb.setSeverity(severity); retvb.setStatus(status); return retvb; case DBR_WAVEFORM_INT: DBR_TIME_Int retvint; // Varying number of copies of a typical value retvint = new DBR_TIME_Int( ArrayUtils.toPrimitive(Collections.nCopies(value, value * value).toArray(new Integer[0]))); retvint.setTimeStamp(convertSecondsIntoYear2JCATimeStamp(value)); retvint.setSeverity(severity); retvint.setStatus(status); return retvint; case DBR_WAVEFORM_DOUBLE: DBR_TIME_Double retvd; // Varying number of copies of a typical value retvd = new DBR_TIME_Double(ArrayUtils.toPrimitive( Collections.nCopies(value, Math.sin(value * Math.PI / 3600)).toArray(new Double[0]))); retvd.setTimeStamp(convertSecondsIntoYear2JCATimeStamp(value)); retvd.setSeverity(severity); retvd.setStatus(status); return retvd; case DBR_V4_GENERIC_BYTES: throw new RuntimeException("Currently don't support " + type + " when generating sample data"); default: throw new RuntimeException("We seemed to have missed a DBR type when generating sample data"); } }
From source file:com.georgeme.Act_Circle.java
public double CalculationByDistance(LatLng StartP, LatLng EndP) { int Radius = 6371;// radius of earth in Km double lat1 = StartP.latitude; double lat2 = EndP.latitude; double lon1 = StartP.longitude; double lon2 = EndP.longitude; double dLat = Math.toRadians(lat2 - lat1); double dLon = Math.toRadians(lon2 - lon1); double a = Math.sin(dLat / 2) * Math.sin(dLat / 2) + Math.cos(Math.toRadians(lat1)) * Math.cos(Math.toRadians(lat2)) * Math.sin(dLon / 2) * Math.sin(dLon / 2); double c = 2 * Math.asin(Math.sqrt(a)); return Radius * c * 1000; }