/*
Copyright (C) 1999 CERN - European Organization for Nuclear Research.
Permission to use, copy, modify, distribute and sell this software and its documentation for any purpose 
is hereby granted without fee, provided that the above copyright notice appear in all copies and 
that both that copyright notice and this permission notice appear in supporting documentation. 
CERN makes no representations about the suitability of this software for any purpose. 
It is provided "as is" without expressed or implied warranty.
 */
package cern.colt.matrix.tobject.impl;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

import cern.colt.function.tobject.ObjectFunction;
import cern.colt.function.tobject.ObjectObjectFunction;
import cern.colt.function.tobject.ObjectProcedure;
import cern.colt.list.tint.IntArrayList;
import cern.colt.list.tobject.ObjectArrayList;
import cern.colt.matrix.tobject.ObjectMatrix1D;
import cern.colt.matrix.tobject.ObjectMatrix2D;
import edu.emory.utils.ConcurrencyUtils;

/**
 * Dense 2-d matrix holding Object elements. First see the package summary and javadoc tree view to get the broad picture.
 * 

 * Implementation:
 * 

 * Internally holds one single contigous one-dimensional array, addressed in
 * column major. Note that this implementation is not synchronized.
 * 

 * Time complexity:
 * 

 * O(1) (i.e. constant time) for the basic operations get,
 * getQuick, set, setQuick and size,
 * 

 * Cells are internally addressed in column-major. Applications demanding utmost
 * speed can exploit this fact. Setting/getting values in a loop
 * column-by-column is quicker than row-by-row. Thus
 * 
 * 
 * for (int column = 0; column < columns; column++) {
 *     for (int row = 0; row < rows; row++) {
 *         matrix.setQuick(row, column, someValue);
 *     }
 * }
 * 
 * 
 * 
 * is quicker than
 * 
 * 
 * for (int row = 0; row < rows; row++) {
 *     for (int column = 0; column < columns; column++) {
 *         matrix.setQuick(row, column, someValue);
 *     }
 * }
 * 
 * 
 * 
 * @author Piotr Wendykier (piotr.wendykier@gmail.com)
 * 
 */
public class DenseColumnObjectMatrix2D extends ObjectMatrix2D {
    static final long serialVersionUID = 1020177651L;
    protected Object[] elements;

    /**
     * Constructs a matrix with a copy of the given values. values is
     * required to have the form values[row][column] and have exactly
     * the same number of columns in every row.
     * 

     * The values are copied. So subsequent changes in values are not
     * reflected in the matrix, and vice-versa.
     * 
     * @param values
     *            The values to be filled into the new matrix.
     * @throws IllegalArgumentException
     *             if
     *             for any 1 <= row < values.length: values[row].length != values[row-1].length
     *             .
     */
    public DenseColumnObjectMatrix2D(Object[][] values) {
        this(values.length, values.length == 0 ? 0 : values[0].length);
        assign(values);
    }

    /**
     * Constructs a matrix with a given number of rows and columns. All entries
     * are initially 0.
     * 
     * @param rows
     *            the number of rows the matrix shall have.
     * @param columns
     *            the number of columns the matrix shall have.
     * @throws IllegalArgumentException
     *             if
     *             rows<0 || columns<0 || (double)columns*rows > Integer.MAX_VALUE
     *             .
     */
    public DenseColumnObjectMatrix2D(int rows, int columns) {
        setUp(rows, columns, 0, 0, 1, rows);
        this.elements = new Object[rows * columns];
    }

    /**
     * Constructs a matrix with the given parameters.
     * 
     * @param rows
     *            the number of rows the matrix shall have.
     * @param columns
     *            the number of columns the matrix shall have.
     * @param elements
     *            the cells.
     * @param rowZero
     *            the position of the first element.
     * @param columnZero
     *            the position of the first element.
     * @param rowStride
     *            the number of elements between two rows, i.e.
     *            index(i+1,j)-index(i,j).
     * @param columnStride
     *            the number of elements between two columns, i.e.
     *            index(i,j+1)-index(i,j).
     * @param isView
     *            if true then a matrix view is constructed
     * @throws IllegalArgumentException
     *             if
     *             rows<0 || columns<0 || (double)columns*rows > Integer.MAX_VALUE
     *             or flip's are illegal.
     */
    public DenseColumnObjectMatrix2D(int rows, int columns, Object[] elements, int rowZero, int columnZero,
            int rowStride, int columnStride, boolean isView) {
        setUp(rows, columns, rowZero, columnZero, rowStride, columnStride);
        this.elements = elements;
        this.isNoView = !isView;
    }

    public Object aggregate(final ObjectObjectFunction aggr, final ObjectFunction f) {
        if (size() == 0)
            throw new IllegalArgumentException("size() = 0");
        final int zero = (int) index(0, 0);
        Object a = 0;
        int nthreads = ConcurrencyUtils.getNumberOfThreads();
        if ((nthreads > 1) && (size() >= ConcurrencyUtils.getThreadsBeginN_2D())) {
            nthreads = Math.min(nthreads, columns);
            Future[] futures = new Future[nthreads];
            int k = columns / nthreads;
            for (int j = 0; j < nthreads; j++) {
                final int firstColumn = columns - j * k;
                final int lastColumn = (j == (nthreads - 1)) ? 0 : firstColumn - k;
                futures[j] = ConcurrencyUtils.submit(new Callable