/*
    * Licensed to the Apache Software Foundation (ASF) under one or more
    * contributor license agreements.  See the NOTICE file distributed with
    * this work for additional information regarding copyright ownership.
    * The ASF licenses this file to You under the Apache License, Version 2.0
    * (the "License"); you may not use this file except in compliance with
    * the License.  You may obtain a copy of the License at
    *
    *      https://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  /*
   * This is not the original file distributed by the Apache Software Foundation
   * It has been modified by the Hipparchus project
   */
  package org.hipparchus.linear;
  
  import org.hipparchus.Field;
  import org.hipparchus.FieldElement;
  import org.hipparchus.exception.MathIllegalArgumentException;
  import org.hipparchus.util.OpenIntToFieldHashMap;
  
  /**
   * Sparse matrix implementation based on an open addressed map.
   *
   * <p>
   *  Caveat: This implementation assumes that, for any {@code x},
   *  the equality {@code x * 0d == 0d} holds. But it is is not true for
   *  {@code NaN}. Moreover, zero entries will lose their sign.
   *  Some operations (that involve {@code NaN} and/or infinities) may
   *  thus give incorrect results.
   * </p>
   * @param <T> the type of the field elements
   */
  public class SparseFieldMatrix<T extends FieldElement<T>> extends AbstractFieldMatrix<T> {
  
      /** Storage for (sparse) matrix elements. */
      private final OpenIntToFieldHashMap<T> entries;
      /** Row dimension. */
      private final int rows;
      /** Column dimension. */
      private final int columns;
  
      /**
       * Create a matrix with no data.
       *
       * @param field Field to which the elements belong.
       */
      public SparseFieldMatrix(final Field<T> field) {
          super(field);
          rows = 0;
          columns= 0;
          entries = new OpenIntToFieldHashMap<>(field);
      }
  
      /**
       * Create a new {@link SparseFieldMatrix} with the supplied row and column
       * dimensions.
       *
       * @param field Field to which the elements belong.
       * @param rowDimension Number of rows in the new matrix.
       * @param columnDimension Number of columns in the new matrix.
       * @throws org.hipparchus.exception.MathIllegalArgumentException
       * if row or column dimension is not positive.
       */
      public SparseFieldMatrix(final Field<T> field,
                               final int rowDimension, final int columnDimension) {
          super(field, rowDimension, columnDimension);
          this.rows = rowDimension;
          this.columns = columnDimension;
          entries = new OpenIntToFieldHashMap<>(field);
      }
  
      /**
       * Copy constructor.
       *
       * @param other Instance to copy.
       */
      public SparseFieldMatrix(SparseFieldMatrix<T> other) {
          super(other.getField(), other.getRowDimension(), other.getColumnDimension());
          rows = other.getRowDimension();
          columns = other.getColumnDimension();
          entries = new OpenIntToFieldHashMap<>(other.entries);
      }
  
      /**
       * Generic copy constructor.
       *
       * @param other Instance to copy.
       */
      public SparseFieldMatrix(FieldMatrix<T> other){
          super(other.getField(), other.getRowDimension(), other.getColumnDimension());
          rows = other.getRowDimension();
         columns = other.getColumnDimension();
         entries = new OpenIntToFieldHashMap<>(getField());
         for (int i = 0; i < rows; i++) {
             for (int j = 0; j < columns; j++) {
                 setEntry(i, j, other.getEntry(i, j));
             }
         }
     }
 
     /** {@inheritDoc} */
     @Override
     public void addToEntry(int row, int column, T increment) {
         checkRowIndex(row);
         checkColumnIndex(column);
         final int key = computeKey(row, column);
         final T value = entries.get(key).add(increment);
         if (getField().getZero().equals(value)) {
             entries.remove(key);
         } else {
             entries.put(key, value);
         }
     }
 
     /** {@inheritDoc} */
     @Override
     public FieldMatrix<T> copy() {
         return new SparseFieldMatrix<T>(this);
     }
 
     /** {@inheritDoc} */
     @Override
     public FieldMatrix<T> createMatrix(int rowDimension, int columnDimension) {
         return new SparseFieldMatrix<T>(getField(), rowDimension, columnDimension);
     }
 
     /** {@inheritDoc} */
     @Override
     public int getColumnDimension() {
         return columns;
     }
 
     /** {@inheritDoc} */
     @Override
     public T getEntry(int row, int column) {
         checkRowIndex(row);
         checkColumnIndex(column);
         return entries.get(computeKey(row, column));
     }
 
     /** {@inheritDoc} */
     @Override
     public int getRowDimension() {
         return rows;
     }
 
     /** {@inheritDoc} */
     @Override
     public void multiplyEntry(int row, int column, T factor) {
         checkRowIndex(row);
         checkColumnIndex(column);
         final int key = computeKey(row, column);
         final T value = entries.get(key).multiply(factor);
         if (getField().getZero().equals(value)) {
             entries.remove(key);
         } else {
             entries.put(key, value);
         }
 
     }
 
     /** {@inheritDoc} */
     @Override
     public void setEntry(int row, int column, T value) {
         checkRowIndex(row);
         checkColumnIndex(column);
         if (getField().getZero().equals(value)) {
             entries.remove(computeKey(row, column));
         } else {
             entries.put(computeKey(row, column), value);
         }
     }
 
     /**
      * {@inheritDoc}
      *
      * @throws MathIllegalArgumentException if {@code m} is an
      * {@code OpenMapRealMatrix}, and the total number of entries of the product
      * is larger than {@code Integer.MAX_VALUE}.
      */
     @Override
     public FieldMatrix<T> multiplyTransposed(final FieldMatrix<T> m)
         throws MathIllegalArgumentException {
 
         MatrixUtils.checkSameColumnDimension(this, m);
 
         final int outCols = m.getRowDimension();
         final FieldMatrix<T> out = m.createMatrix(rows, outCols);
         for (OpenIntToFieldHashMap<T>.Iterator iterator = entries.iterator(); iterator.hasNext();) {
             iterator.advance();
             final T   value    = iterator.value();
             final int key      = iterator.key();
             final int i        = key / columns;
             final int k        = key % columns;
             for (int j = 0; j < outCols; ++j) {
                 out.addToEntry(i, j, value.multiply(m.getEntry(j, k)));
             }
         }
 
         return out;
 
     }
 
     /**
      * {@inheritDoc}
      *
      * @throws MathIllegalArgumentException if {@code m} is an
      * {@code OpenMapRealMatrix}, and the total number of entries of the product
      * is larger than {@code Integer.MAX_VALUE}.
      */
     @Override
     public FieldMatrix<T> transposeMultiply(final FieldMatrix<T> m)
         throws MathIllegalArgumentException {
 
         MatrixUtils.checkSameRowDimension(this, m);
 
         final int outCols = m.getColumnDimension();
         final FieldMatrix<T> out = m.createMatrix(columns, outCols);
         for (OpenIntToFieldHashMap<T>.Iterator iterator = entries.iterator(); iterator.hasNext();) {
             iterator.advance();
             final T   value = iterator.value();
             final int key   = iterator.key();
             final int k     = key / columns;
             final int i     = key % columns;
             for (int j = 0; j < outCols; ++j) {
                 out.addToEntry(i, j, value.multiply(m.getEntry(k, j)));
             }
         }
 
         return out;
 
     }
 
     /**
      * Compute the key to access a matrix element.
      *
      * @param row Row index of the matrix element.
      * @param column Column index of the matrix element.
      * @return the key within the map to access the matrix element.
      */
     private int computeKey(int row, int column) {
         return row * columns + column;
     }
 }