/*

     This file is part of Combean.

     Combean is free software; you can redistribute it and/or modify

     it under the terms of the GNU General Public License as published by

     the Free Software Foundation; either version 2 of the License, or

     (at your option) any later version.

     Combean is distributed in the hope that it will be useful,

     but WITHOUT ANY WARRANTY; without even the implied warranty of

     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

     GNU General Public License for more details.

     You should have received a copy of the GNU General Public License

     along with Combean; if not, write to the Free Software

     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

 */

 /*

  * Created on 04.08.2006

  *

  */

 package net.sourceforge.combean.mathprog.linalg;

 import net.sourceforge.combean.interfaces.mathprog.linalg.SparseVector;

 import net.sourceforge.combean.interfaces.mathprog.linalg.VectorIterator;

 import net.sourceforge.combean.interfaces.mathprog.linalg.VectorValue;

 import net.sourceforge.combean.interfaces.mathprog.lp.model.NoLabel;

 import net.sourceforge.combean.util.except.UnsupportedMethodException;

 /**

  * A vector which has a constant non-zero value only in a block with

  * indices that follow a simple arithmetic progression.

  * 

  *  A simple example is a vector with a non-zero consecutive block

  *  like v = [0, ..., 0, 2, 2, ..., 2, 0, ... 0]. A more complex

  *  example would be w =  [0, ..., 0, 3, 0, 3, 0, ..., 3, 0, ... 0],

  *  where we would have an arithmetic progression with length 2.

  * 

  * @author schickin

  *

  */

 public class SparseVectorWithConstantPattern

 implements SparseVector {

     private int dim = -1;

     private double val = 0.0;

     private int from = -1;

     private int to = -1;

     private int incr = 1;

     /**

      * Construct a vector with a constant value everywhere.

      * 

      * @param dim dimension of the vector

      * @param val the constant value of all elements of the vector.

      */

     public SparseVectorWithConstantPattern(int dim, double val) {

         super();

         this.dim = dim;

         this.val = val;

         this.from = 0;

         this.to = dim-1;

         this.incr = 1;

     }

     /**

      * Construct a vector with a constant value in a consecutive block.

      * 

      * @param dim dimension of the vector

      * @param val the constant value of all elements of the vector.

      * @param from the start index of the non-zero block

      * @param to the end index of the non-zero block

      */

     public SparseVectorWithConstantPattern(int dim, double val,

             int from, int to) {

         super();

         this.dim = dim;

         this.val = val;

         this.from = from;

         this.to = to;

         this.incr = 1;

     }

     /**

      * Construct a vector with a constant value in a arithmetic progression.

      * 

      * @param dim dimension of the vector

      * @param val the constant value of all non-elements of the vector.

      * @param from the start index of the non-zero block

      * @param to the end index of the non-zero block

      * @param incr the increment of the arithmetic progression

      */

     public SparseVectorWithConstantPattern(int dim, double val,

             int from, int to, int incr) {

         super();

         this.dim = dim;

         this.val = val;

         this.from = from;

         this.to = to;

         this.incr = incr;

     }

     /* (non-Javadoc)

      * @see net.sourceforge.combean.interfaces.mathprog.linalg.SparseVec#getDimension()

      */

     public int getDimension() {

          return this.dim;

     }

     /* (non-Javadoc)

      * @see net.sourceforge.combean.interfaces.mathprog.linalg.SparseVec#getIterator()

      */

     public VectorIterator<NoLabel> iterator() {

          return new SparseVectorWithConstantPatternIterator();

     }

     /* (non-Javadoc)

      * @see net.sourceforge.combean.interfaces.mathprog.linalg.SparseVec#getNumIterations()

      */

     public int getNumIterations() {

         return (this.to - this.from) / this.incr + 1;

     }

     private class SparseVectorWithConstantPatternIterator

     implements VectorIterator<NoLabel> {

         private int currPos = -1;

         /**

          * @param vec

          */

         public SparseVectorWithConstantPatternIterator() {

             super();

             this.currPos = SparseVectorWithConstantPattern.this.getFrom();

         }

         /* (non-Javadoc)

          * @see net.sourceforge.combean.interfaces.mathprog.linalg.VectorIterator#hasNext()

          */

         public boolean hasNext() {

             return this.currPos <= SparseVectorWithConstantPattern.this.getTo();

         }

         /* (non-Javadoc)

          * @see net.sourceforge.combean.interfaces.mathprog.linalg.VectorIterator#next()

          */

         public VectorValue<NoLabel> next() {

             DoubleVectorValue<NoLabel> result =

                 new DoubleVectorValue<NoLabel>(this.currPos,

                         SparseVectorWithConstantPattern.this.getVal());

             this.currPos += SparseVectorWithConstantPattern.this.getIncrement();

             return result;

         }

         /* (non-Javadoc)

          * @see java.util.Iterator#remove()

          */

         public void remove() {

             throw new UnsupportedMethodException();

         }

     }

     /**

      * @return Returns the from.

      */

     public final int getFrom() {

         return this.from;

     }

     /**

      * @return Returns the to.

      */

     public final int getTo() {

         return this.to;

     }

     /**

      * @return Returns the val.

      */

     public final double getVal() {

         return this.val;

     }

     /**

      * @return Returns the increment.

      */

     public final int getIncrement() {

         return this.incr;

     }

 }