## org.apache.mahout.math
Class AbstractMatrix.TransposeViewVector

    java.lang.Object
      org.apache.mahout.math.AbstractVector
          org.apache.mahout.math.AbstractMatrix.TransposeViewVector

All Implemented Interfaces:
  Cloneable, Vector

Enclosing class:
  AbstractMatrix

    protected static class AbstractMatrix.TransposeViewVector

extends AbstractVector

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
`protected` `AbstractMatrix.TransposeViewVector(Matrix m, int offset)`
`protected` `AbstractMatrix.TransposeViewVector(Matrix m, int offset, boolean rowToColumn)`

Method Summary
`Vector` `clone()` Return a copy of the recipient
`Vector.Element` `getElement(int i)` Return an object of Vector.Element representing an element of this Vector.
`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()` TODO: currently I don't know of an efficient way to getVector this value correctly.
`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()`
`boolean` `isSequentialAccess()`
`Iterator<Vector.Element>` `iterateNonZero()` Currently delegates to `iterator()`.
`Iterator<Vector.Element>` `iterator()` 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
`Vector` `like()` Return an empty vector of the same underlying class as the receiver
`Vector` `like(int cardinality)`
`protected Matrix` `matrixLike(int rows, int columns)` Subclasses must override to return an appropriately sparse or dense result
`void` `mergeUpdates(OrderedIntDoubleMapping updates)` Used internally by assign() to update multiple indices and values at once.
`protected Vector` `newVector(int cardinality)`
`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, createOptimizedCopy, cross, divide, dot, dotSelf, equals, get, getDistanceSquared, getLengthSquared, getNumNonZeroElements, hashCode, incrementQuick, invalidateCachedLength, logNormalize, logNormalize, logNormalize, maxValue, maxValueIndex, minus, minValue, minValueIndex, nonZeroes, norm, normalize, normalize, plus, plus, set, size, sparseVectorToString, times, times, toString, toString, viewPart, zSum`

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

Constructor Detail

### AbstractMatrix.TransposeViewVector

    protected AbstractMatrix.TransposeViewVector(Matrix m,
                                                 int offset)

### AbstractMatrix.TransposeViewVector

    protected AbstractMatrix.TransposeViewVector(Matrix m,
                                                 int offset,
                                                 boolean rowToColumn)

Method Detail

### clone

    public Vector clone()

  Description copied from interface: `Vector`
  Return a copy of the recipient

  Specified by:
    `clone` in interface `Vector`
  Overrides:
    `clone` in class `AbstractVector`
  Returns:
    a new Vector

### isDense

    public boolean isDense()

  Returns:
    true iff this implementation should be considered dense -- that it explicitly represents every value

### isSequentialAccess

    public boolean isSequentialAccess()

  Returns:
    true iff 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.

### 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

### iterator

    public 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

### iterateNonZero

    public Iterator<Vector.Element> iterateNonZero()

  Currently delegates to `iterator()`. TODO: This could be optimized to at least skip empty rows if there are many of them.

  Specified by:
    `iterateNonZero` in class `AbstractVector`
  Returns:
    an iterator (currently dense).

### getElement

    public Vector.Element getElement(int i)

  Description copied from interface: `Vector`
  Return an object of Vector.Element representing an element of this Vector. Useful when designing new iterator types.

  Specified by:
    `getElement` in interface `Vector`
  Overrides:
    `getElement` in class `AbstractVector`
  Parameters:
    `i` - Index of the Vector.Element required
  Returns:
    The Vector.Element Object

### mergeUpdates

    public void mergeUpdates(OrderedIntDoubleMapping updates)

  Used internally by assign() to update multiple indices and values at once. Only really useful for sparse vectors (especially SequentialAccessSparseVector).

  If someone ever adds a new type of sparse vectors, this method must merge (index, value) pairs into the vector.

  Parameters:
    `updates` - a mapping of indices to values to merge in the vector.

### 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

### 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

### newVector

    protected Vector newVector(int cardinality)

### 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)

### getNumNondefaultElements

    public int getNumNondefaultElements()

  TODO: currently I don't know of an efficient way to getVector this value correctly.

  Returns:
    the number of nonzero entries

### 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.

Copyright © 2008–2014 The Apache Software Foundation. All rights reserved.