1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:

public int mitWhile(int b){ 
int a = 0; 
if (b > 0) { 
a = a+3*b; 
} else { 
a = a-2*b; 
} 
while ( a < b ) 
{ if (b > 0){ 
  a = a+3*b; 
} else { 
  a= a-2*b; 
} 
} 
  return a; 
} 

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:

class Uebung2Test {

		public static void tassert1(String aStr, boolean y){

		if(y) {
		System.out.println("PASS: " + aStr);
		} else {
		System.out.println("FAIL: " + aStr);
		}
		}

		public static void main(String[] args){

		Uebung2 z=new Uebung2();
		Uebung2 w=new Uebung2();
		Uebung2 m=new Uebung2();
		Uebung2 g=new Uebung2();
		Uebung2 h=new Uebung2();

		tassert1("z.theDoWhileMethod(5)", z.theDoWhileMethod(5)==z.aForMethod(5));
		tassert1("w.testWhile(3,7)", w.testWhile(3,7)==w.ifelseAnw(3,7));
		tassert1("m.performActionSwitch(5)", m.performActionSwitch('a')==m.performActionBranch('a'));
		tassert1("g.getWithWhile(5)", g.getWithWhile(5)==g.getWithDoWhile(5));
		tassert1("h.crucialFunction001(-200,50)", h.crucialFunction001(-200,50)==true);

		}

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:

package math;

import Jama.Matrix;
import Jama.QRDecomposition;

public class MatrixTest {
    private final int N;        // number of 
    private final int p;        // number of dependent variables
    private final Matrix beta;  // regression coefficients
    private double SSE;         // sum of squared
    private double SST;         // sum of squared

    public MatrixTest(double[][] x, double[] y) {
        if (x.length != y.length) throw new RuntimeException("dimensions don't agree");
        N = y.length;
        p = x[0].length;

        Matrix X = new Matrix(x);

        // create matrix from vector
        Matrix Y = new Matrix(y, N);

        // find least squares solution
        QRDecomposition qr = new QRDecomposition(X);
        beta = qr.solve(Y);

        // mean of y[] values
        double sum = 0.0;
        for (int i = 0; i < N; i++)
            sum += y[i];
        double mean = sum / N;

        // total variation to be accounted for
        for (int i = 0; i < N; i++) {
            double dev = y[i] - mean;
            SST += dev*dev;
        }

        // variation not accounted for
        Matrix residuals = X.times(beta).minus(Y);
        SSE = residuals.norm2() * residuals.norm2();

    }

    public double beta(int j) {
        return beta.get(j, 0);
    }

    public double R2() {
        return 1.0 - SSE/SST;
    }

    public static void main(String[] args) {
        double[][] x = { {  1,  10,  20 },
                         {  1,  20,  40 },
                         {  1,  40,  15 },
                         {  1,  80, 100 },
                         {  1, 160,  23 },
                         {  1, 200,  18 } };
        double[] y = { 243, 483, 508, 1503, 1764, 2129 };
        MatrixTest regression = new MatrixTest(x, y);

        System.out.printf("%.2f + %.2f beta1 + %.2f beta2  (R^2 = %.2f)\n",
                      regression.beta(0), regression.beta(1), regression.beta(2), regression.R2());
    }
}

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:

/** Schatten norm
   @return    p norms of the vector from the singular values of a matrix
   */

   public double normSchatten (double p) {
      double f = 0;
      SingularValueDecomposition singValDec = new SingularValueDecomposition(this);
      double[] r = singValDec.getSingularValues();
      if(p > 0) {
    	  for(double d : r) {
        	  f += Math.pow(d, p);
          }  
    	  f = Math.pow(f, 1/p);
      }
      return f;
   }

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:

/** Ky-Fan norm
   @return    sum of the first k singular values of a matrix
   */

   public double normKyFan (double k) {
      double f = 0;
      SingularValueDecomposition singValDec = new SingularValueDecomposition(this);
      double[] r = singValDec.getSingularValues();
      if(k > 0) {
    	  for(int i = 0; i < k; i++) {
        	  f += r[i]; 
          }
      }
      return f;
   }

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:

/** Spectral norm
   @return    the largest singular value of a matrix
   */

   public double normSpectralEuclidean () {
      double f = 0;
      SingularValueDecomposition singValDec = new SingularValueDecomposition(this);
      double[] r = singValDec.getSingularValues();
      Arrays.sort(r);
      f = r[r.length - 1];
      return f;
   }

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:

/** Spectral norm
   @return    the largest singular value of a matrix
   */

   public double normSpectralEuclidean () {
      final SingularValueDecomposition singValDec = new SingularValueDecomposition(this);
      final double[] r = singValDec.getSingularValues();
      double norm = 0D;
      for(final double sing : r) {
          if(sing>norm) {
            norm = sing;
          }
      }
      return norm;
   }