Adding up the elements of two arrays and putting the resulting sum in another array

[Johnathan Beck]

I am working on how to add the contents of two arrays and putting the results on another array. The problem is that I am not too sure on how to do it properly.

The first array I called ary1. It is a double type with unknown length. This length is determined by my JUnit test class.
The second array I labeled as ary2. ary2 is a copy of ary1. Therfore I casted it as the following in my adding arrays method.

public NVectorADT plus(NVectorADT y) {
        DVector ary2 = (DVector)y;
	//...
    }

Where y is a parameter passed from the NVectorADT interface. There isn't a return statement yet because I haven't determined what needs to be returned. I am thinking the result array.

Lastly the result array is a double where it's size is determined by the size of ary1. I created size field and in the constructor assigned size as ary1.length.

Here is the code of what I have done thus far.

/**
 * The DVector class will create a object to be used by the NVector interface
 * to implement its methods
 * 
 * @author Johnathan Beck
 */
public class DVector implements NVectorADT
{
    private double[] ary1; 
    //private double[] ary2;
    private double[] aryResult;
    private int size;
    
    /**
     * Constructs the first array and the results array. 
     * Will throw an unchecked exception if the length of the first array is 
     * either 0 or array is null.
     * 
     * @param ary1  parameter of the first array
     */
    public DVector(double[] ary1)
    {
        size = ary1.length;
        if (ary1.length == 0 || ary1 == null) {
            throw new IllegalArgumentException ("Illegal Array");
        }
        else {
            //ary2 = ary1;
            aryResult = new double[size];
        }
    }

    @Override
    public NVectorADT plus(NVectorADT y) {
        DVector ary2 = (DVector)y;
        //more code
    }

Here are my thoughts of how to do this.

I know I am going to need a while loop that will terminate at the end of the length of ary1. I know in this loop I will need three for loops, in the first two for loops I need to mull through ary1 and ary2 and store each number in local variables. The last for loop will store the result of my caculation in the result array.

I am thinking the looping structure might look something like this.

While
for loop - ary1
for loop - ary2
for loop - store sum of ary1[i] and ary2[i] in aryResult[i]
end

However I don't know how to get a element in ary1, adding it to it's corresponding element in ary2 and putting the result in it's corresponding aryResult (ex. ary1[1] + ary2[1] = aryResult[1]). Also the thought has crossed my mind if I even will need three for loops. Couldn't I just use one for loop to mull through ary1 and ary2, do the operation, and store the result in aryResult?

Any thoughts would be appreciated.

[Unnar Björnsson]

If I understand you correctly you are overthinking the problem, you only need one loop, the loop index maps each element of ary1 to ary2 and stores it in result array in the same iteration.

and store each number in local variables.

No you don't need any extra variables for the task.

However if ary1 and ary2 are of different lengths, special care needs to be taken to either catch IndexOutOfBoundsException or perform checks each iteration.

[Johnathan Beck]

Unnar Björnsson wrote:If I understand you correctly you are overthinking the problem, you only need one loop, the loop index maps each element of ary1 to ary2 and stores it in result array in the same iteration.

Yeah it's something I tend to do, overthinking a problem. I know it's a bad habit when it comes to programming and believe me I am working on it. I do appreciate your honesty.

Unnar Björnsson wrote:However if ary1 and ary2 are of different lengths, special care needs to be taken to either catch IndexOutOfBoundsException or perform checks each iteration.

You know I didn't even think of that. I would figure my constructor would check that however it only checks to see if ary1 is null or empty.

So I took your idea and going with something like this.

initialize i to 0;
if ( length of array1 != size of array2 ) {
     throw error;
}
else {
     while ( i < length of array1 && < size of array2) {
          assign array1[i] + array2[size] to arrayResult[i]
          i++
          size++
     }
}

I think it will work. So I'm gonna try it out.

edit: It didn't work. my IDE is saying array is required but DVector was found.

        if (ary2.size != ary1.length) {
            throw new IndexOutOfBoundsException("Array indices are of different length");
        }
        else {
            while ( i < ary1.length && i < ary2.size) {
                aryResult[size] = ary1[i] + ary2[size]; //here is where the error is throwing
                ++i;
                ++size;
            }
        }

I'm thinking I might have to make an ary2 a true array. But honestly I don't know. It makes sense though if that's it.

[Unnar Björnsson]

I'm thinking I might have to make an ary2 a true array. But honestly I don't know. It makes sense though if that's it.

ary2 is not an array but an object therefore you can't use bracket operations to access its values, you'll need to define getters and setters as well as size() methods to manipulate its values. You might consider extending ArrayList for that purpose.

aryResult[size] = ary1[i] + ary2[size];

Yes java is throwing IndexOutOfBoundsException because an array of size N contains elements in places from 0 to N-1, you are asking for an element in the (last+1)th place
You want to add together elements ary1[0]+ary2[0] ary1[1]+ary2[1] ... right?

while ( i < ary1.length && i < ary2.size) {  
                 aryResult[size] = ary1[i] + ary2[i]; 
}

[Johnathan Beck]

Unnar Björnsson wrote:You want to add together elements ary1[0]+ary2[0] ary1[1]+ary2[1] ... right?

Essentially yes. It should go something like this ary1[i] + ary2[i] and store the caculation in aryResult[i] and keep going through the array.

Here is some more information hopefully to clarify it some more.

The DVector needs to have one constructor, that takes an array as a parameter. I then need to make a copy of that array. The constructor should throw an exception if there's anything wrong with the array parameter. Which in this case the only thing I can think of is either a null or empty array. I think I got that part covered in the constructor.

public DVector(double[] ary1)
    {
        size = ary1.length;
        if (ary1.length == 0 || ary1 == null) {
            throw new IllegalArgumentException ("Illegal Array");
        }
        else {
            

        }

It then goes on when it passes the check then I need to make a copy. My instructor drew this diagram. The ( ) represents arrays.



So I am wondering does the casting DVector ary2 = (DVector) y make a copy of the array object?

[Johnathan Beck]

Unnar I am going to post the ADT interface and the DVector classes. Maybe it will help you out in helping me figuring this out.

NVectorADT as given by my instructor.

/** Specification for a numerical vector.  This is a fixed size column vector. */
public interface NVectorADT
{

/* ----------- Arithmetic operations --------------- */
	
	/**
	 * Addition.  Perform the element-by-element addition of the two vectors.  The resulting vector
	 * has the same dimensions as the two operands.
	 *	@param y The vector to use as the second operand.  The dimensions of this vector must be identical to the first operand
	 *	@return A new vector that is the addition of this vector and the argument y.  Returns null if the addition cannot be performed.
	 */
	public NVectorADT plus( NVectorADT y );
	
	/**
	 * Subtraction.  Perform the element-by-element subtraction of the two vectors.  The resulting vector
	 * has the same dimensions as the two operands.
	 *	@param y The vector to use as the second operand.  The dimensions of this vector must be identical to the first operand
	 *	@return A new vector that is the result of subtracting the elements in y from the elements in this vector, element-wise.  
	 *  		Returns null if the subtraction cannot be performed.
	 */
	public NVectorADT minus( NVectorADT y );
	
	/**
	 * Multiplication.  Perform the element-by-element multiplication of the two vectors.  The resulting vector
	 * has the same dimensions as the two operands.
	 *	@param y The vector to use as the second operand.  The dimensions of this vector must be identical to the first operand
	 *	@return A new vector that is the result of multiplying the elements in this vector by the elements in y, element-wise.  
	 *  		Returns null if the multiplication cannot be performed.
	 */
	public NVectorADT mult( NVectorADT y );
	
	/**
	 * Division.  Perform the element-by-element division of the two vectors.  The resulting vector
	 * has the same dimensions as the two operands.
	 *	@param y The vector to use as the second operand.  The dimensions of this vector must be identical to the first operand
	 *	@return A new vector that is the result of dividing the elements in this vector by the elements in y, element-wise.  
	 *  		Returns null if the division cannot be performed.
	 */
	public NVectorADT divby( NVectorADT y );
	
	/**
	 * Determine the sum of all the elements in the vector
	 *	@return The sum, a scalar
	 */
	public double sum( );
	
	/** 
	 * Perform the element-wise square root operation on this vector.
	 * @return A new vector that contains the square root of the elements in this vector.  
	 *			Returns null if the operation cannot be performed.
	 */
	public NVectorADT sqrt( );
	
/* ---------------- Other useful operations --------------------- */

	/** 
	 * Get the number of elements in this vector.
	 * @return The number of rows n in this n x 1 matrix.
	 */
	public int size( );
	
	/**
	 * Get an array representation of this vector.
	 * @return The elements of the vector as an array.  The length of the array is the same as the size of the vector.
	 */
	public double[] getAsArray();
	
	/**
	 * Determine if this vector is equal to, i.e. the same as, the given vector argument.
	 *	@param y The vector to use as the second operand
	 *	@return True if the two vectors are equivalent in every way, False otherwise.
	 */
	public boolean equals( NVectorADT y );	

}

DVector Class

/**
 * The DVector class will create a object to be used by the NVector interface
 * to implement its methods
 * 
 * @author Johnathan Beck
 */
public class DVector implements NVectorADT
{
    private double[] ary1;
    private double[] aryResult;
    private int size;
    
    /**
     * Constructs the first array and the results array. 
     * Will throw an unchecked exception if the length of the first array is 
     * either 0 or array is null.
     * 
     * @param ary1  parameter of the first array
     */
    public DVector(double[] ary1)
    {
        size = ary1.length;
        if (ary1.length == 0 || ary1 == null) {
            throw new IllegalArgumentException ("Illegal Array");
        }
        else {
            aryResult = new double[ary1.length];
        }
    }
    
    /**
     * Adds the elements of the first array and the second array and stores the
     * result in the result array. Therfore ary1[i] + ary2[i] = aryResult[i].
     * @param y
     * @return
     */
    @Override
    public NVectorADT plus(NVectorADT y) {
       DVector ary2 = (DVector) y;
        throw new IndexOutOfBoundsException("Array indices are of different length");
    }

    @Override
    public NVectorADT minus(NVectorADT y) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    @Override
    public NVectorADT mult(NVectorADT y) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    @Override
    public NVectorADT divby(NVectorADT y) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    @Override
    public double sum() {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    @Override
    public NVectorADT sqrt() {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    @Override
    public int size() {
        return size;
    }

    @Override
    public double[] getAsArray() {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    @Override
    public boolean equals(NVectorADT y) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    @Override
    public String toString()
    {
        throw new UnsupportedOperationException("Not supported yet.");
    }
    
}

[Jesper de Jong]

Johnathan Beck wrote:So I am wondering does the casting DVector ary2 = (DVector) y make a copy of the array object?

No, casting does not copy objects or do any "magical" conversions. A cast is nothing more than you telling the compiler "I have an object here, and I want you to treat it as if it is a DVector".

[Unnar Björnsson]

You are on the right track, you just need to add getElement() and getSize() functions in DVector class and use that to access elements of ary2

Another thing aryResult is not an instance variable, it should be a local variable in the implemented functions