Method is undefined for the Type

[Dennis Von Valkenburgh]

Hello,
I have a problem with my code with Junit:
"The method infinityNorm(double[) is undefined for the Type Vektor."
This error pops up for both the euclidian norm and the manhattan norm.

Here is the code:

package de.ostfalia.gdp.ss15;

public class Vektor {

	public static void main(String[] args) {
		double[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9};
		System.out.println("Euclidian Norm: " + euclidianNorm(array));
		System.out.println("Manhattan Norm: " + manhattanNorm(array));
		euclidianNorm(array);

	}

	public static boolean isZero(double[] v) {
		boolean truthTest = false;
		for (int i = 0; i < v.length; i++) {

			if (v[i] == 0) {
				truthTest = true;
			}else {
				truthTest = false;
			}

		}
		return truthTest;
	}

	public static double[] add(double[] v, double[] w) {
		double[] result = new double[v.length];
		
			for (int i = 0; i < v.length; i++) {
				result[i] = v[i] + w[i];
		}
		return result;
	}

	public static double[] scale(double c, double[] v) {
		double[] result = new double[v.length];
		
		for (int i = 0; i < v.length; i++) {
			result[i] = c * v[i];
	}
	return result;
	}

	public static double euclidianNorm(double[] v) {
		double result = 0;
		for(int i = 0; i < v.length; i++){
			result += Math.pow(v[i], 2);
		}
		result = Math.sqrt(result);
		return result;
	}

	public static double manhattanNorm(double[] v) {
		double result = 0;
		for(int i = 0; i < v.length; i++){
			result = result + Math.abs(v[i]);
		}
		return result;
	}

//	public static double infinintyNorm(double[] v) {
//		return null;
//	}

}

What is the problem here?

[Carey Brown]

//  public static double infinintyNorm(double[] v) {
//      return null;
//  }

You can't return null for built-in data types. If you change the return type to "Double" it will work but then any caller will have to handle a possible null return.

[Tim Cooke]

You code as it is works as far as I can tell. That is, it compiles and I get some output.

You mention jUnit but include no examples of a jUnit test. Perhaps you've forgotten to post some part of your program that is trying to call 'infinityNorm'?

[Dennis Von Valkenburgh]

Carey Brown wrote:

//  public static double infinintyNorm(double[] v) {
//      return null;
//  }

You can't return null for built-in data types. If you change the return type to "Double" it will work but then any caller will have to handle a possible null return.

That part of the code is commented out and should be ignored as it is not finished yet.
My problem is with the already written methods.

[Carey Brown]

Dennis Von Valkenburgh wrote:

Carey Brown wrote:

//  public static double infinintyNorm(double[] v) {
//      return null;
//  }

You can't return null for built-in data types. If you change the return type to "Double" it will work but then any caller will have to handle a possible null return.

That part of the code is commented out and should be ignored as it is not finished yet.
My problem is with the already written methods.

Well, your error message states that "The method infinityNorm(double[) is undefined for the Type Vektor." . So, if you've commented out this method then you'll get this error -- it's undefined.

[Dennis Von Valkenburgh]

Carey Brown wrote:

Dennis Von Valkenburgh wrote:

Carey Brown wrote:

//  public static double infinintyNorm(double[] v) {
//      return null;
//  }

You can't return null for built-in data types. If you change the return type to "Double" it will work but then any caller will have to handle a possible null return.

That part of the code is commented out and should be ignored as it is not finished yet.
My problem is with the already written methods.

Well, your error message states that "The method infinityNorm(double[) is undefined for the Type Vektor." . So, if you've commented out this method then you'll get this error -- it's undefined.

Ok let me repeat my initial post:
"This error pops up for both the euclidian norm and the manhattan norm."
Forget the infinityNorm, it doesnt exist right now. I get the same error for the already finished methods.

[Carey Brown]

Dennis Von Valkenburgh wrote:

Carey Brown wrote:

Dennis Von Valkenburgh wrote:

Carey Brown wrote:

//  public static double infinintyNorm(double[] v) {
//      return null;
//  }

You can't return null for built-in data types. If you change the return type to "Double" it will work but then any caller will have to handle a possible null return.

That part of the code is commented out and should be ignored as it is not finished yet.
My problem is with the already written methods.

Well, your error message states that "The method infinityNorm(double[) is undefined for the Type Vektor." . So, if you've commented out this method then you'll get this error -- it's undefined.

Ok let me repeat my initial post:
"This error pops up for both the euclidian norm and the manhattan norm."
Forget the infinityNorm, it doesnt exist right now. I get the same error for the already finished methods.

Let's see your JUnit code that calls these methods.

[Dennis Von Valkenburgh]

package de.ostfalia.gdp.ss15.test;


import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;

import java.util.Arrays;

import org.junit.Test;

import de.ostfalia.gdp.ss15.Vektor;


/** Tests the class HelloWorld.
 * @author weimar
 */
public class VektorTest {
	
	@Test(timeout=100)
	public void isZeroTest0(){
		double[] v = {};
		assertTrue("isZero("+Arrays.toString(v)+") sollte wahr sein!", Vektor.isZero(v));
	}

	@Test(timeout=100)
	public void isZeroTest1(){
		double[] v = {0.0};
		assertTrue("isZero("+Arrays.toString(v)+") sollte wahr sein!", Vektor.isZero(v));
	}

	@Test(timeout=100)
	public void isZeroTest2(){
		double[] v = {0.0, 0.0};
		assertTrue("isZero("+Arrays.toString(v)+") sollte wahr sein!", Vektor.isZero(v));
	}

	@Test(timeout=100)
	public void isZeroTest3(){
		double[] v = {0.0, 0.001};
		assertFalse("isZero("+Arrays.toString(v)+") sollte falsch sein!", Vektor.isZero(v));
	}

	@Test(timeout=100)
	public void isZeroTest4(){
		double[] v = {0.0, -0.01};
		assertFalse("isZero("+Arrays.toString(v)+") sollte falsch sein!", Vektor.isZero(v));
	}

	@Test(timeout=100)
	public void addTest0(){
		double[] v = {};
		double[] w = {};
		double[] res = Vektor.add(v, w);
		
		assertEquals("add("+Arrays.toString(v)+", "+Arrays.toString(w)+") falsche Länge!", 0,res.length);
	}

	@Test(timeout=100)
	public void addTest1(){
		double[] v = {0.0};
		double[] w = {1.0};
		double[] res = Vektor.add(v, w);
		
		assertEquals("add("+Arrays.toString(v)+", "+Arrays.toString(w)+") falsche Länge!", 1,res.length);
		assertEquals("add("+Arrays.toString(v)+", "+Arrays.toString(w)+") Wert falsch!", 1.0,res[0],1.0e-7);
	}

	@Test(timeout=100)
	public void addTest2(){
		double[] v = {0.0, 1.0};
		double[] w = {1.0, 2.0};
		double[] res = Vektor.add(v, w);
		
		assertEquals("add("+Arrays.toString(v)+", "+Arrays.toString(w)+") falsche Länge!", 2,res.length);
		assertEquals("add("+Arrays.toString(v)+", "+Arrays.toString(w)+") Wert 0 falsch!", 1.0,res[0],1.0e-7);
		assertEquals("add("+Arrays.toString(v)+", "+Arrays.toString(w)+") Wert 1 falsch!", 3.0,res[1],1.0e-7);
	}

	@Test(timeout=100)
	public void addTest3(){
		double[] v = {0.0, 1.0};
		double[] w = {1.0, 2.0, 4.0};
		double[] res = Vektor.add(v, w);
		
		assertEquals("add("+Arrays.toString(v)+", "+Arrays.toString(w)+") falsche Länge!", 3,res.length);
		assertEquals("add("+Arrays.toString(v)+", "+Arrays.toString(w)+") Wert 0 falsch!", 1.0,res[0],1.0e-7);
		assertEquals("add("+Arrays.toString(v)+", "+Arrays.toString(w)+") Wert 1 falsch!", 3.0,res[1],1.0e-7);
		assertEquals("add("+Arrays.toString(v)+", "+Arrays.toString(w)+") Wert 1 falsch!", 4.0,res[2],1.0e-7);
	}
	
	@Test(timeout=100)
	public void scaleTest0(){
		double[] v = {};
		double[] res = Vektor.scale(2.0, v);
		
		assertEquals("scale(2.0, "+Arrays.toString(v)+") falsche Länge!", 0,res.length);
	}

	@Test(timeout=100)
	public void scaleTest1(){
		double[] v = {1.0};
		double[] res = Vektor.scale(2.0, v);
		
		assertEquals("scale(2.0, "+Arrays.toString(v)+") falsche Länge!", 1, res.length);
		assertEquals("scale(2.0, "+Arrays.toString(v)+") Wert falsch!", 2.0, res[0], 1.0e-7);
	}

	@Test(timeout=100)
	public void scaleTest2(){
		double[] v = {1.0, -0.5};
		double[] res = Vektor.scale(2.0, v);
		
		assertEquals("scale(2.0, "+Arrays.toString(v)+") falsche Länge!", 2, res.length);
		assertEquals("scale(2.0, "+Arrays.toString(v)+") Wert falsch!", 2.0, res[0], 1.0e-7);
		assertEquals("scale(2.0, "+Arrays.toString(v)+") Wert falsch!", -1.0, res[1], 1.0e-7);
	}

	@Test(timeout=100)
	public void euclideanNormTest0(){
		double[] v = {};
		double res = Vektor.euclideanNorm(v);
		assertEquals("euclideanNorm("+Arrays.toString(v)+") falsch.", 0.0, res, 1.0e-7);
	}

	@Test(timeout=100)
	public void euclideanNormTest1(){
		double[] v = {0.5};
		double res = Vektor.euclideanNorm(v);
		assertEquals("euclideanNorm("+Arrays.toString(v)+") falsch.", 0.5, res, 1.0e-7);
	}

	@Test(timeout=100)
	public void euclideanNormTest2(){
		double[] v = {3.0, 4.0};
		double res = Vektor.euclideanNorm(v);
		assertEquals("euclideanNorm("+Arrays.toString(v)+") falsch.", 5.0, res, 1.0e-7);
	}

	@Test(timeout=100)
	public void euclideanNormTest3(){
		double[] v = {-3.0, 4.0};
		double res = Vektor.euclideanNorm(v);
		assertEquals("euclideanNorm("+Arrays.toString(v)+") falsch.", 5.0, res, 1.0e-7);
	}

	@Test(timeout=100)
	public void manhattenNormTest0(){
		double[] v = {};
		double res = Vektor.manhattenNorm(v);
		assertEquals("manhattenNorm("+Arrays.toString(v)+") falsch.", 0.0, res, 1.0e-7);
	}

	@Test(timeout=100)
	public void manhattenNormTest1(){
		double[] v = {0.5};
		double res = Vektor.manhattenNorm(v);
		assertEquals("manhattenNorm("+Arrays.toString(v)+") falsch.", 0.5, res, 1.0e-7);
	}

	@Test(timeout=100)
	public void manhattenNormTest2(){
		double[] v = {3.0, 4.0};
		double res = Vektor.manhattenNorm(v);
		assertEquals("manhattenNorm("+Arrays.toString(v)+") falsch.", 7.0, res, 1.0e-7);
	}

	@Test(timeout=100)
	public void manhattenNormTest3(){
		double[] v = {-3.0, 4.0};
		double res = Vektor.manhattenNorm(v);
		assertEquals("manhattenNorm("+Arrays.toString(v)+") falsch.", 7.0, res, 1.0e-7);
	}

	@Test(timeout=100)
	public void infinityNormTest0(){
		double[] v = {};
		double res = Vektor.infinityNorm(v);
		assertEquals("infinityNorm("+Arrays.toString(v)+") falsch.", 0.0, res, 1.0e-7);
	}

	@Test(timeout=100)
	public void infinityNormTest1(){
		double[] v = {0.5};
		double res = Vektor.infinityNorm(v);
		assertEquals("infinityNorm("+Arrays.toString(v)+") falsch.", 0.5, res, 1.0e-7);
	}

	@Test(timeout=100)
	public void infinityNormTest2(){
		double[] v = {3.0, 4.0};
		double res = Vektor.infinityNorm(v);
		assertEquals("infinityNorm("+Arrays.toString(v)+") falsch.", 4.0, res, 1.0e-7);
	}

	@Test(timeout=100)
	public void infinityNormTest3(){
		double[] v = {-3.0, -4.0};
		double res = Vektor.infinityNorm(v);
		assertEquals("infinityNorm("+Arrays.toString(v)+") falsch.", 4.0, res, 1.0e-7);
	}


}

[Tim Cooke]

You're trying to call infinityNorm from somewhere, and it's not anywhere in the code you've presented thus far.

[Dennis Von Valkenburgh]

Tim Cooke wrote:You're trying to call infinityNorm from somewhere, and it's not anywhere in the code you've presented thus far.

Like I said before: infinityNorm is commented out and is not active as of now because I have not worked on it yet.
Im talking about euclidian and manhattan right now.

[Tim Cooke]

Ok, so you have some unit tests that are calling infinityNorm which is a method that doesn't exist because you have it commented out.

If you don't want to run those particular unit tests then you can add the @Ignore annotation to the test methods and jUnit won't run them.

[Dennis Von Valkenburgh]

Tim Cooke wrote:Ok, so you have some unit tests that are calling infinityNorm which is a method that doesn't exist because you have it commented out.

If you don't want to run those particular unit tests then you can add the @Ignore annotation to the test methods and jUnit won't run them.

Again: I get the same error for manhattan and euclidian. Do you understand?

[Tim Cooke]

I understand perfectly. None of your unit tests will run successfully because you have a compilation error in your test class.

(My previous comment about using @Ignore is nonsense, ignore that)

[Campbell Ritchie]

Yes, Tim does understand. There is no need to repeat yourself. Tim has given you some useful advice; please follow it.

[Dennis Von Valkenburgh]

Ok I apologize for the somewhat rash tone of my reply.
My teacher mispelled euclidian and manhattan in the junit tests so I had to correct for that error.
now all tests work perfectly!
Thanks!

[Dennis Von Valkenburgh]

I have another question:
the isZeroTest0 returns an error for isZero([]) should be true. I assume it means a completely empty array.
How do I accomplish this in the code?

[Campbell Ritchie]

Dennis Von Valkenburgh wrote: . . .
the isZeroTest0 returns an error for isZero([]) should be true. I assume it means a completely empty array.
. . .

Please show us the exact code and the exact error message, but only for the parts of the code you are calling. Maybe your isZero method looks for 0s in an array and an empty array does not contain any 0s.

And … apology accepted

[Dennis Von Valkenburgh]

I already solved the isZero problem.
The test checked whether an array such as array{} would return positive, which it should.

I have one last question for the following code:

public static double[] add(double[] v, double[] w) {
		double[] result = new double[v.length];

		for (int i = 0; i < v.length; i++) {
			result[i] = w[i] + v[i];
		}
		return result;
	}

When I add up two arrays of the same length all is fine.
But when I add up arrays of different lengths, like one array with 2 elements and one array with 3 elements, it cuts off the last element of the logner array. For this I get an error in Junit.
How can I rewrite the method to keep any remaining elements that will not be part of the adding up?

[Carey Brown]

Dennis Von Valkenburgh wrote:I already solved the isZero problem.
The test checked whether an array such as array{} would return positive, which it should.

I have one last question for the following code:

public static double[] add(double[] v, double[] w) {
		double[] result = new double[v.length];

		for (int i = 0; i < v.length; i++) {
			result[i] = w[i] + v[i];
		}
		return result;
	}

When I add up two arrays of the same length all is fine.
But when I add up arrays of different lengths, like one array with 2 elements and one array with 3 elements, it cuts off the last element of the logner array. For this I get an error in Junit.
How can I rewrite the method to keep any remaining elements that will not be part of the adding up?

public static double[] add(double[] v, double[] w) {
        int max = Math.max( v.length, w.length );
        double[] result = new double[max];
        int len = Math.min( v.length, w.length );
        int i=0;
        for ( ; i < len; i++) {
            result[i] = w[i] + v[i];
        }
        for( ; i < w.length ; i++ )
            result[i] = w[i];
        for( ; i < v.length ; i++ )
            result[i] = v[i];
        return result;
    }

[Campbell Ritchie]

What is wrong with
double sum2 = sum(array1) + sum(array2);

Something which is better implemented in a declarative style with Streams than the old imperative style with a for‑each loop.
Remember that doubles occupying a wide range will undergo overflow or underflow or not have the appropriate precision.
System.out.println(12345678901234567890.1234567890 + 99 == 12345678901234567890.1234567890);