DiagonalMatrix.SingleElementVector (Mahout Math 0.13.0 API)

java.lang.Object
- org.apache.mahout.math.AbstractVector
- - org.apache.mahout.math.DiagonalMatrix.SingleElementVector

All Implemented Interfaces:

Cloneable, Vector

Enclosing class:

DiagonalMatrix
```
public class DiagonalMatrix.SingleElementVector
extends AbstractVector
```
Special class to implement views of rows and columns of a diagonal matrix.

Nested Class Summary
- Nested classes/interfaces inherited from class org.apache.mahout.math.AbstractVector
  AbstractVector.LocalElement
- Nested classes/interfaces inherited from interface org.apache.mahout.math.Vector
  Vector.Element

Field Summary
- Fields inherited from class org.apache.mahout.math.AbstractVector
  lengthSquared

Constructor Summary

Constructors
Constructor and Description

SingleElementVector(int index)

Constructors
Constructor and Description
`SingleElementVector(int index)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`double`	`getIteratorAdvanceCost()` Gets an estimate of the cost (in number of operations) it takes to advance an iterator through the nonzero elements of this vector.
`double`	`getLookupCost()` Gets an estimate of the cost (in number of operations) it takes to lookup a random element in this vector.
`int`	`getNumNondefaultElements()` Return the number of values in the recipient which are not the default value.
`double`	`getQuick(int index)` Return the value at the given index, without checking bounds
`boolean`	`isAddConstantTime()` Return true iff adding a new (nonzero) element takes constant time for this vector.
`boolean`	`isDense()` true if this implementation should be considered dense -- that it explicitly represents every value
`boolean`	`isSequentialAccess()` true if this implementation should be considered to be iterable in index order in an efficient way.
`protected Iterator<Vector.Element>`	`iterateNonZero()` Iterates over all non-zero elements.
`protected Iterator<Vector.Element>`	`iterator()` Iterates over all elements
`Vector`	`like()` Return an empty vector of the same underlying class as the receiver
`Vector`	`like(int cardinality)` Return a new empty vector of the same underlying class as the receiver with given cardinality
`protected Matrix`	`matrixLike(int rows, int columns)` Subclasses must override to return an appropriately sparse or dense result
`void`	`mergeUpdates(OrderedIntDoubleMapping updates)` Merge a set of (index, value) pairs into the vector.
`void`	`set(int index, double value)` Set the value at the given index
`void`	`setQuick(int index, double value)` Set the value at the given index, without checking bounds

Methods inherited from class org.apache.mahout.math.AbstractVector
aggregate, aggregate, all, asFormatString, assign, assign, assign, assign, assign, assign, clone, createOptimizedCopy, cross, divide, dot, dotSelf, equals, get, getDistanceSquared, getElement, getLengthSquared, getNumNonZeroElements, hashCode, incrementQuick, invalidateCachedLength, logNormalize, logNormalize, logNormalize, maxValue, maxValueIndex, minus, minValue, minValueIndex, nonZeroes, norm, normalize, normalize, plus, plus, size, sparseVectorToString, times, times, toString, toString, viewPart, zSum

Methods inherited from class java.lang.Object
finalize, getClass, notify, notifyAll, wait, wait, wait

- Constructor Detail
  - SingleElementVector
```
public SingleElementVector(int index)
```
- Method Detail
  - getQuick
```
public double getQuick(int index)
```
    Description copied from interface: Vector
    
    Return the value at the given index, without checking bounds
    
    Parameters:
    
    index - an int index
    
    Returns:
    
    the double at the index
  - set
```
public void set(int index,
                double value)
```
    Description copied from interface: Vector
    
    Set the value at the given index
    
    Specified by:
    
    set in interface Vector
    
    Overrides:
    
    set in class AbstractVector
    
    Parameters:
    
    index - an int index into the receiver
    
    value - a double value to set
  - iterateNonZero
```
protected Iterator<Vector.Element> iterateNonZero()
```
    Description copied from class: AbstractVector
    
    Iterates over all non-zero elements.
    NOTE: Implementations may choose to reuse the Element returned for performance reasons, so if you need a copy of it, you should call AbstractVector.getElement(int) for the given index
    
    Specified by:
    
    iterateNonZero in class AbstractVector
    
    Returns:
    
    An Iterator over all non-zero elements
  - iterator
```
protected Iterator<Vector.Element> iterator()
```
    Description copied from class: AbstractVector
    
    Iterates over all elements
    NOTE: Implementations may choose to reuse the Element returned for performance reasons, so if you need a copy of it, you should call AbstractVector.getElement(int) for the given index
    
    Specified by:
    
    iterator in class AbstractVector
    
    Returns:
    
    An Iterator over all elements
  - matrixLike
```
protected Matrix matrixLike(int rows,
                            int columns)
```
    Description copied from class: AbstractVector
    
    Subclasses must override to return an appropriately sparse or dense result
    
    Specified by:
    
    matrixLike in class AbstractVector
    
    Parameters:
    
    rows - the row cardinality
    
    columns - the column cardinality
    
    Returns:
    
    a Matrix
  - isDense
```
public boolean isDense()
```
    Description copied from interface: Vector
    
    true if this implementation should be considered dense -- that it explicitly represents every value
    
    Returns:
    
    true or false
  - isSequentialAccess
```
public boolean isSequentialAccess()
```
    Description copied from interface: Vector
    
    true if this implementation should be considered to be iterable in index order in an efficient way. In particular this implies that Vector.all() and Vector.nonZeroes() ()} return elements in ascending order by index.
    
    Returns:
    
    true iff this implementation should be considered to be iterable in index order in an efficient way.
  - mergeUpdates
```
public void mergeUpdates(OrderedIntDoubleMapping updates)
```
    Description copied from interface: Vector
    
    Merge a set of (index, value) pairs into the vector.
    
    Parameters:
    
    updates - an ordered mapping of indices to values to be merged in.
  - like
```
public Vector like()
```
    Description copied from interface: Vector
    
    Return an empty vector of the same underlying class as the receiver
    
    Returns:
    
    a Vector
  - like
```
public Vector like(int cardinality)
```
    Description copied from interface: Vector
    
    Return a new empty vector of the same underlying class as the receiver with given cardinality
    
    Parameters:
    
    cardinality - - size of vector
    
    Returns:
    
    Vector
  - setQuick
```
public void setQuick(int index,
                     double value)
```
    Description copied from interface: Vector
    
    Set the value at the given index, without checking bounds
    
    Parameters:
    
    index - an int index into the receiver
    
    value - a double value to set
  - getNumNondefaultElements
```
public int getNumNondefaultElements()
```
    Description copied from interface: Vector
    
    Return the number of values in the recipient which are not the default value. For instance, for a sparse vector, this would be the number of non-zero values.
    
    Returns:
    
    an int
  - getLookupCost
```
public double getLookupCost()
```
    Description copied from interface: Vector
    
    Gets an estimate of the cost (in number of operations) it takes to lookup a random element in this vector.
  - getIteratorAdvanceCost
```
public double getIteratorAdvanceCost()
```
    Description copied from interface: Vector
    
    Gets an estimate of the cost (in number of operations) it takes to advance an iterator through the nonzero elements of this vector.
  - isAddConstantTime
```
public boolean isAddConstantTime()
```
    Description copied from interface: Vector
    
    Return true iff adding a new (nonzero) element takes constant time for this vector.

Class DiagonalMatrix.SingleElementVector

Nested Class Summary

Nested classes/interfaces inherited from class org.apache.mahout.math.AbstractVector

Nested classes/interfaces inherited from interface org.apache.mahout.math.Vector

Field Summary

Fields inherited from class org.apache.mahout.math.AbstractVector

Constructor Summary

Method Summary

Methods inherited from class org.apache.mahout.math.AbstractVector

Methods inherited from class java.lang.Object

Constructor Detail

SingleElementVector

Method Detail

getQuick

set

iterateNonZero

iterator

matrixLike

isDense

isSequentialAccess

mergeUpdates

like

like

setQuick

getNumNondefaultElements

getLookupCost

getIteratorAdvanceCost

isAddConstantTime