View Javadoc
1   package org.djunits.value.vdouble.vector;
2   
3   import java.util.List;
4   import java.util.SortedMap;
5   
6   import org.djunits.unit.DimensionlessUnit;
7   import org.djunits.value.StorageType;
8   import org.djunits.value.ValueException;
9   import org.djunits.value.vdouble.scalar.Dimensionless;
10  
11  /**
12   * Immutable Double DimensionlessVector, a vector of values with a DimensionlessUnit.
13   * <p>
14   * Copyright (c) 2013-2018 Delft University of Technology, PO Box 5, 2600 AA, Delft, the Netherlands. All rights reserved. <br>
15   * BSD-style license. See <a href="http://opentrafficsim.org/docs/license.html">OpenTrafficSim License</a>.
16   * </p>
17   * $LastChangedDate: 2015-07-24 02:58:59 +0200 (Fri, 24 Jul 2015) $, @version $Revision: 1147 $, by $Author: averbraeck $,
18   * initial version Oct 9, 2015 <br>
19   * @author <a href="http://www.tbm.tudelft.nl/averbraeck">Alexander Verbraeck</a>
20   * @author <a href="http://www.tudelft.nl/pknoppers">Peter Knoppers</a>
21   */
22  public class DimensionlessVector
23          extends AbstractDoubleVectorRel<DimensionlessUnit, DimensionlessVector, MutableDimensionlessVector, Dimensionless>
24  {
25      /** */
26      private static final long serialVersionUID = 20151109L;
27  
28      /**
29       * Construct a new Relative Immutable Double DimensionlessVector.
30       * @param values double[]; the values of the entries in the new Relative Immutable Double DimensionlessVector
31       * @param unit U; the unit of the new Relative Immutable Double DimensionlessVector
32       * @param storageType the data type to use (e.g., DENSE or SPARSE)
33       * @throws ValueException when values is null
34       */
35      public DimensionlessVector(final double[] values, final DimensionlessUnit unit, final StorageType storageType)
36              throws ValueException
37      {
38          super(values, unit, storageType);
39      }
40  
41      /**
42       * Construct a new Relative Immutable Double DimensionlessVector.
43       * @param values List; the values of the entries in the new Relative Immutable Double DimensionlessVector
44       * @param unit U; the unit of the new Relative Immutable Double DimensionlessVector
45       * @param storageType the data type to use (e.g., DENSE or SPARSE)
46       * @throws ValueException when values is null
47       */
48      public DimensionlessVector(final List<Double> values, final DimensionlessUnit unit, final StorageType storageType)
49              throws ValueException
50      {
51          super(values, unit, storageType);
52      }
53  
54      /**
55       * Construct a new Relative Immutable Double DimensionlessVector.
56       * @param values DoubleScalar.Rel&lt;U&gt;[]; the values of the entries in the new Relative Immutable Double
57       *            DimensionlessVector
58       * @param storageType the data type to use (e.g., DENSE or SPARSE)
59       * @throws ValueException when values has zero entries
60       */
61      public DimensionlessVector(final Dimensionless[] values, final StorageType storageType) throws ValueException
62      {
63          super(values, storageType);
64      }
65  
66      /**
67       * Construct a new Relative Immutable Double DimensionlessVector.
68       * @param values List; the values of the entries in the new Relative Immutable Double DimensionlessVector
69       * @param storageType the data type to use (e.g., DENSE or SPARSE)
70       * @throws ValueException when values has zero entries
71       */
72      public DimensionlessVector(final List<Dimensionless> values, final StorageType storageType) throws ValueException
73      {
74          super(values, storageType);
75      }
76  
77      /**
78       * Construct a new Relative Immutable Double DimensionlessVector.
79       * @param values DoubleScalar.Rel&lt;U&gt;[]; the values of the entries in the new Relative Sparse Mutable Double
80       *            DimensionlessVector
81       * @param length the size of the vector
82       * @param storageType the data type to use (e.g., DENSE or SPARSE)
83       * @throws ValueException when values has zero entries
84       */
85      public DimensionlessVector(final SortedMap<Integer, Dimensionless> values, final int length, final StorageType storageType)
86              throws ValueException
87      {
88          super(values, length, storageType);
89      }
90  
91      /**
92       * Construct a new Relative Immutable Double DimensionlessVector.
93       * @param values Map; the map of indexes to values of the Relative Sparse Mutable Double DimensionlessVector
94       * @param unit U; the unit of the new Relative Sparse Mutable Double DimensionlessVector
95       * @param length the size of the vector
96       * @param storageType the data type to use (e.g., DENSE or SPARSE)
97       * @throws ValueException when values is null
98       */
99      public DimensionlessVector(final SortedMap<Integer, Double> values, final DimensionlessUnit unit, final int length,
100             final StorageType storageType) throws ValueException
101     {
102         super(values, unit, length, storageType);
103     }
104 
105     /**
106      * @param data an internal data object
107      * @param unit the unit
108      */
109     DimensionlessVector(final DoubleVectorData data, final DimensionlessUnit unit)
110     {
111         super(data, unit);
112     }
113 
114     /** {@inheritDoc} */
115     @Override
116     protected final DimensionlessVector instantiateType(final DoubleVectorData dvd, final DimensionlessUnit unit)
117     {
118         return new DimensionlessVector(dvd, unit);
119     }
120 
121     /** {@inheritDoc} */
122     @Override
123     protected final MutableDimensionlessVector instantiateMutableType(final DoubleVectorData dvd, final DimensionlessUnit unit)
124     {
125         return new MutableDimensionlessVector(dvd, unit);
126     }
127 
128     /** {@inheritDoc} */
129     @Override
130     protected final Dimensionless instantiateScalar(final double value, final DimensionlessUnit unit)
131     {
132         return new Dimensionless(value, unit);
133     }
134 
135     /** {@inheritDoc} */
136     @Override
137     public final DimensionlessVector toDense()
138     {
139         return this.data.isDense() ? (DimensionlessVector) this : instantiateType(this.data.toDense(), getUnit());
140     }
141 
142     /** {@inheritDoc} */
143     @Override
144     public final DimensionlessVector toSparse()
145     {
146         return this.data.isSparse() ? (DimensionlessVector) this : instantiateType(this.data.toSparse(), getUnit());
147     }
148 
149     /**
150      * Return an array of Dimensionless Scalars from this vector.
151      * @return Dimensionless[]; an array of Dimensionless Scalars from this vector
152      * @throws RuntimeException wrapping a ValueException on error getting one of the values
153      */
154     public Dimensionless[] toArray()
155     {
156         Dimensionless[] array = new Dimensionless[size()];
157         for (int i = 0; i < size(); i++)
158         {
159             try
160             {
161                 array[i] = get(i);
162             }
163             catch (ValueException exception)
164             {
165                 throw new RuntimeException(exception);
166             }
167         }
168         return array;
169     }
170 
171 }