public void testViewPart() throws Exception {
Vector part = test.viewPart(1, 2);
assertEquals("part size", 2, part.getNumNondefaultElements());
for (int i = 0; i < part.size(); i++) {
assertEquals("part[" + i + ']', test.get(i + 1), part.get(i));
}
}
public void toAt(Vector cam, Vector obj) {
if (cam == null || obj == null) throw new NullPointerException();
dir.set(0, 0, 0);
dir.set(obj);
dir.sub(cam);
dir.mult(-1f);
dir.norm();
dir.get(dirArray);
right.set(0, 0, 0);
right.cross(worldUp, dir);
right.norm();
right.get(rightArray);
up.set(0, 0, 0);
up.cross(dir, right);
up.norm();
up.get(upArray);
set(
rightArray[0],
rightArray[1],
rightArray[2],
upArray[0],
upArray[1],
upArray[2],
dirArray[0],
dirArray[1],
dirArray[2]);
}
public void testMinus() throws Exception {
Vector val = test.minus(test);
assertEquals("size", test.size(), val.size());
for (int i = 0; i < test.size(); i++) {
assertEquals("get [" + i + ']', 0.0, val.get(i));
}
val = test.minus(test).minus(test);
assertEquals("cardinality", test.size(), val.size());
for (int i = 0; i < test.size(); i++) {
assertEquals("get [" + i + ']', 0.0, val.get(i) + test.get(i));
}
Vector val1 = test.plus(1);
val = val1.minus(test);
for (int i = 0; i < test.size(); i++) {
assertEquals("get [" + i + ']', 1.0, val.get(i));
}
val1 = test.plus(-1);
val = val1.minus(test);
for (int i = 0; i < test.size(); i++) {
assertEquals("get [" + i + ']', -1.0, val.get(i));
}
}
private Vector addAnchorString(Vector list, String field, double diff) {
Vector topIndex = new Vector();
Hashtable topIndexParms, currEntry;
double lastValue, currValue;
if (list.size() == 0) return null;
currEntry = (Hashtable) list.get(0);
lastValue = Common.parseDouble((String) currEntry.get(field)) + diff;
for (int i = 1; i < list.size(); i++) {
currEntry = (Hashtable) list.get(i);
currValue = Common.parseDouble((String) currEntry.get(field));
if (currValue >= lastValue) {
// Values for navigation line
topIndexParms = new Hashtable();
topIndexParms.put("HREF", Convert.toString(i));
topIndexParms.put("TEXT", Convert.toString(lastValue));
topIndex.add(topIndexParms);
// add anchor entry to list
currEntry.put("ANCHORNAME", Convert.toString(i));
currEntry.put("ANCHORTEXT", Convert.toString(lastValue));
lastValue = currValue + diff;
} else {
// clear value from previous run
currEntry.put("ANCHORNAME", "");
currEntry.put("ANCHORTEXT", "");
}
list.set(i, currEntry);
}
return topIndex;
}
public void train() {
for (int i = 0; i < weights.getM(); ++i) {
for (int j = 0; j < weights.getN(); ++j) {
weights.set(i, j, weights.get(i, j) + (learning * inputs.get(i) * errors.get(j)));
}
}
}
public void testGet() throws Exception {
for (int i = 0; i < test.size(); i++) {
if (i % 2 == 0) {
assertEquals("get [" + i + ']', 0.0, test.get(i));
} else {
assertEquals("get [" + i + ']', values[i / 2], test.get(i));
}
}
}
private Vector addAnchorString(Vector list, String field, boolean fullCompare) {
Vector topIndex = new Vector();
Hashtable topIndexParms, currEntry;
String lastValue, currValue;
if (list.size() == 0) return null;
currEntry = (Hashtable) list.get(0);
lastValue = (String) currEntry.get(field);
if (lastValue == null || lastValue.length() == 0) lastValue = " ";
lastValue = lastValue.toUpperCase();
for (int i = 1; i < list.size(); i++) {
currEntry = (Hashtable) list.get(i);
currValue = (String) currEntry.get(field);
currValue = currValue.toUpperCase();
if (currValue == null || currValue == "") continue;
try {
if (fullCompare) {
if (lastValue.compareTo(currValue) != 0) {
// Values for navigation line
topIndexParms = new Hashtable();
topIndexParms.put("HREF", Convert.toString(i));
topIndexParms.put("TEXT", currValue);
topIndex.add(topIndexParms);
// add anchor entry to list
currEntry.put("ANCHORNAME", Convert.toString(i));
currEntry.put("ANCHORTEXT", currValue);
} else {
// clear value from previous run
currEntry.put("ANCHORNAME", "");
currEntry.put("ANCHORTEXT", "");
}
} else {
if (lastValue.charAt(0) != currValue.charAt(0)) {
// Values for navigation line
topIndexParms = new Hashtable();
topIndexParms.put("HREF", Convert.toString(i));
topIndexParms.put("TEXT", currValue.charAt(0) + " ");
topIndex.add(topIndexParms);
// add anchor entry to list
currEntry.put("ANCHORNAME", Convert.toString(i));
currEntry.put("ANCHORTEXT", currValue.charAt(0) + " ");
} else {
// clear value from previous run
currEntry.put("ANCHORNAME", "");
currEntry.put("ANCHORTEXT", "");
}
}
list.set(i, currEntry);
lastValue = currValue;
} catch (Exception e) {
continue;
}
}
return topIndex;
}
public void testPlusDouble() throws Exception {
Vector val = test.plus(1);
assertEquals("size", test.size(), val.size());
for (int i = 0; i < test.size(); i++) {
if (i % 2 == 0) {
assertEquals("get [" + i + ']', 1.0, val.get(i));
} else {
assertEquals("get [" + i + ']', values[i / 2] + 1.0, val.get(i));
}
}
}
public void testDivideDouble() throws Exception {
Vector val = test.divide(3);
assertEquals("size", test.size(), val.size());
for (int i = 0; i < test.size(); i++) {
if (i % 2 == 0) {
assertEquals("get [" + i + ']', 0.0, val.get(i));
} else {
assertEquals("get [" + i + ']', values[i / 2] / 3.0, val.get(i), EPSILON);
}
}
}
public void testTimesVector() throws Exception {
Vector val = test.times(test);
assertEquals("size", test.size(), val.size());
for (int i = 0; i < test.size(); i++) {
if (i % 2 == 0) {
assertEquals("get [" + i + ']', 0.0, val.get(i));
} else {
assertEquals("get [" + i + ']', values[i / 2] * values[i / 2], val.get(i));
}
}
}
public void testNormalize() throws Exception {
Vector val = test.normalize();
double mag = Math.sqrt(1.1 * 1.1 + 2.2 * 2.2 + 3.3 * 3.3);
for (int i = 0; i < test.size(); i++) {
if (i % 2 == 0) {
assertEquals("get [" + i + ']', 0.0, val.get(i));
} else {
assertEquals("dot", values[i / 2] / mag, val.get(i));
}
}
}
public void testSet() throws Exception {
test.set(3, 4.5);
for (int i = 0; i < test.size(); i++) {
if (i % 2 == 0) {
assertEquals("get [" + i + ']', 0.0, test.get(i));
} else if (i == 3) {
assertEquals("set [" + i + ']', 4.5, test.get(i));
} else {
assertEquals("set [" + i + ']', values[i / 2], test.get(i));
}
}
}
public void getHash() {
for (Vector v : vectors) {
for (int i = 1; i < v.size(); i++) {
if (sets.containsKey(v.get(i))) {
((ArrayList<Integer>) sets.get(v.get(i))).add(v.get(0));
} else {
ArrayList<Integer> firstElement = new ArrayList<Integer>();
firstElement.add(v.get(0));
sets.put(v.get(i), firstElement);
}
}
}
}
public void testGetOver() {
try {
test.get(test.size());
fail("expected exception");
} catch (IndexException e) {
}
}
public void testGetUnder() {
try {
test.get(-1);
fail("expected exception");
} catch (IndexException e) {
}
}
public double dot(Vector y) {
checkSize(y);
double ret = 0;
for (VectorEntry e : this) ret += e.get() * y.get(e.index());
return ret;
}
public void testSparseDoubleVectorInt() throws Exception {
Vector val = new RandomAccessSparseVector(4);
assertEquals("size", 4, val.size());
for (int i = 0; i < 4; i++) {
assertEquals("get [" + i + ']', 0.0, val.get(i));
}
}
/**
* Multiply with a vector
*
* @param vector the vector to multiply by
* @return the result
*/
public Vector times(Vector vector) {
double[] result = new double[m()];
for (int row = 0; row < result.length; row++) {
for (int i = 0; i < n(); i++) {
result[row] += get(row, i) * vector.get(i);
}
}
return new DenseVector(result);
}
public Vector multiply(Vector vector) {
Vector result = new Vector(dim1);
for (int i = 0; i < dim1; i++) {
for (int j = 0; j < dim2; j++) {
result.add(i, get(i, j) * vector.get(j));
}
}
return result;
}
/**
* Calculate and populate the Azimuth, Pitch, and Roll.
*
* @param rotationMatrix Rotation matrix used in calculations.
*/
public static synchronized void calcPitchBearing(Matrix rotationMatrix) {
if (rotationMatrix == null) return;
tempMatrix.set(rotationMatrix);
tempMatrix.transpose();
if (AugmentedReality.portrait) {
looking.set(0, 1, 0);
} else {
looking.set(1, 0, 0);
}
looking.prod(tempMatrix);
looking.get(lookingArray);
Calculator.azimuth = ((getAngle(0, 0, lookingArray[0], lookingArray[2]) + 360) % 360);
Calculator.roll = -(90 - Math.abs(getAngle(0, 0, lookingArray[1], lookingArray[2])));
looking.set(0, 0, 1);
looking.prod(tempMatrix);
looking.get(lookingArray);
Calculator.pitch = -(90 - Math.abs(getAngle(0, 0, lookingArray[1], lookingArray[2])));
}
public void testAssignBinaryFunction3() throws Exception {
test.assign(mult(4));
for (int i = 0; i < values.length; i++) {
if (i % 2 == 0) {
assertEquals("get [" + i + ']', 0.0, test.get(i));
} else {
assertEquals("value[" + i + ']', values[i - 1] * 4, test.getQuick(i));
}
}
}
public Domain[] split(int attribute, int numattr) {
Domain[] splitDomain = new Domain[numattr];
for (int i = 0; i < numattr; i++) splitDomain[i] = new Domain();
for (Vector v : attributesAndCategory) {
int index = (int) v.get(attribute);
Domain d = splitDomain[index - 1];
d.addVector(v);
}
return splitDomain;
}
/**
* Calculate and populate the Azimuth, Pitch, and Roll.
*
* @param rotationMatrix Rotation matrix used in calculations.
*/
public static void calcPitchBearing(Matrix rotationMatrix) {
if (rotationMatrix == null) return;
tempMatrix.set(rotationMatrix);
tempMatrix.transpose();
float x = 0;
float y = 0;
int angle = ARData.getDeviceOrientationAngle();
if (angle >= 0 && angle < 90) {
x = (angle * unitPerDegree) - 1;
y = 1 - (angle * unitPerDegree);
} else if (angle >= 90 && angle < 180) {
angle -= 90;
x = (angle * unitPerDegree) - 1;
y = (angle * unitPerDegree) - 1;
} else if (angle >= 180 && angle < 270) {
angle -= 180;
x = 1 - (angle * unitPerDegree);
y = (angle * unitPerDegree) - 1;
} else {
// >= 270 && < 360
angle -= 270;
x = 1 - (angle * unitPerDegree);
y = 1 - (angle * unitPerDegree);
}
looking.set(x, y, 0);
looking.prod(tempMatrix);
looking.get(lookingArray);
azimuth = ((getAngle(0, 0, lookingArray[0], lookingArray[2]) + 360) % 360);
roll = -(90 - Math.abs(getAngle(0, 0, lookingArray[1], lookingArray[2])));
looking.set(0, 0, 1);
looking.prod(tempMatrix);
looking.get(lookingArray);
pitch = -(90 - Math.abs(getAngle(0, 0, lookingArray[1], lookingArray[2])));
}
public static HashMap<Vector, Integer> trainClassifier(ArrayList<Vector> data, int K) {
HashMap<Vector, Integer> means = new HashMap<Vector, Integer>();
int dimension = data.get(0).getDimension();
ArrayList<Vector> mus = new ArrayList<Vector>();
Random rand = new Random();
for (int i = 0; i < data.size(); i++) {
means.put(data.get(i), 0);
}
for (int i = 0; i < K; i++) {
double[] build = new double[dimension];
for (int j = 0; j < dimension; j++) {
build[j] = rand.nextDouble();
}
mus.add(new Vector(build, 0));
}
for (int epoch = 0; epoch < 10000; epoch++) {
for (Vector x : data) {
means.replace(x, argmin(x, mus));
}
double[][] new_mu = new double[mus.size()][mus.get(0).getDimension()];
double[] mu_counter = new double[mus.size()];
Iterator it = means.entrySet().iterator();
while (it.hasNext()) {
Map.Entry<Vector, Integer> pair = (Entry<Vector, Integer>) it.next();
Vector temp = pair.getKey();
for (int i = 0; i < temp.getDimension(); i++) {
new_mu[pair.getValue()][i] += temp.get(i);
}
mu_counter[pair.getValue()]++;
}
for (int i = 0; i < new_mu.length; i++) {
for (int j = 0; j < new_mu[i].length; j++) {
if (mu_counter[i] == 0) new_mu[i][j] = mus.get(i).get(j);
else new_mu[i][j] /= mu_counter[i];
}
}
for (int i = 0; i < mus.size(); i++) {
mus.set(i, new Vector(new_mu[i], 0));
}
}
return means;
}
public void testIteratorSet() throws CloneNotSupportedException {
Vector clone = test.clone();
Iterator<Vector.Element> it = clone.iterateNonZero();
while (it.hasNext()) {
Vector.Element e = it.next();
e.set(e.get() * 2.0);
}
it = clone.iterateNonZero();
while (it.hasNext()) {
Vector.Element e = it.next();
assertEquals(test.get(e.index()) * 2.0, e.get());
}
clone = test.clone();
it = clone.iterator();
while (it.hasNext()) {
Vector.Element e = it.next();
e.set(e.get() * 2.0);
}
it = clone.iterator();
while (it.hasNext()) {
Vector.Element e = it.next();
assertEquals(test.get(e.index()) * 2.0, e.get());
}
}
private Vector input(final Vector x, final boolean update) {
final Vector result = x.copy();
for (int i = 0; i < this.avgInputs.size(); i++) {
final SignalSmoother avgInput = this.avgInputs.get(i);
if (avgInput != null) {
if (update) {
final double oldAvgInput = avgInput.getSmoothedValue();
avgInput.addValue(x.get(i));
this.offset += this.coefficients.get(i) * (avgInput.getSmoothedValue() - oldAvgInput);
}
result.add(i, -avgInput.getSmoothedValue());
}
}
return result;
}
public static int argmin(Vector x, ArrayList<Vector> mu) {
double min = -Math.log(0);
int arg = -1;
for (int i = 0; i < mu.size(); i++) {
double distance = 0;
for (int j = 0; j < mu.get(i).getDimension(); j++) {
distance += Math.pow(x.get(j) - mu.get(i).get(j), 2);
}
if (distance < min) {
min = distance;
arg = i;
}
}
return arg;
}
@Override
public void intersect(Vector vector, VectorVectorMapper callback) {
if (vector instanceof DenseVector) {
vector.intersect(this, new VectorVectorReverseOrderMapper(callback));
return;
}
if (vector instanceof SparseVector) {
for (int i = 0; i < fillLevel; i++) {
int ip1 = index(i);
float v2 = vector.get(ip1);
if (!NumberUtils.isZero(v2)) {
float v1 = value(i);
if (!NumberUtils.isZero(v1)) {
if (!callback.map(ip1, value(i), v2)) {
return;
}
}
}
}
return;
}
OffHeapVector v = (OffHeapVector) vector;
int p1 = 0;
int p2 = 0;
for (; p1 < fillLevel && p2 < v.fillLevel; ) {
int ip1 = index(p1);
int ip2 = v.index(p2);
if (ip1 == ip2) {
float v1 = value(p1);
float v2 = v.value(p2);
if (!NumberUtils.isZero(v1) && !NumberUtils.isZero(v2)) {
if (!callback.map(ip1, v1, v2)) {
return;
}
}
p1++;
p2++;
} else if (ip1 < ip2) {
p1++;
} else {
p2++;
}
}
}
@Override
public double product(Vector vector) {
if (vector == null) {
throw new IllegalArgumentException("Vector can't be null.");
}
if (length != vector.length()) {
throw new IllegalArgumentException("Wrong vector length: " + vector.length());
}
double result = 0.0;
for (int i = 0; i < length; i++) {
result += get(i) * vector.get(i);
}
return result;
}
@Override
public Vector add(Vector vector, Factory factory) {
ensureFactoryIsNotNull(factory);
if (vector == null) {
throw new IllegalArgumentException("Vector can't be null.");
}
if (length != vector.length()) {
throw new IllegalArgumentException("Worong vector length: " + vector.length());
}
Vector result = blank(factory);
for (int i = 0; i < length; i++) {
result.set(i, get(i) + vector.get(i));
}
return result;
}
