Index (vectorz 0.23.0 API)

java.lang.Object
- mikera.indexz.AIndex
- - mikera.indexz.Index

All Implemented Interfaces:

Serializable, Cloneable, Comparable<AIndex>, Iterable<Integer>
```
public final class Index
extends AIndex
```
Class to represent a mutable list of integer indexes, typically used for indexing into vectors or matrices. Backed by an int[] array.

Author:

Mike

See Also:
Serialized Form

Field Summary

Fields
Modifier and Type Field and Description

int[] data

Fields
Modifier and Type	Field and Description
`int[]`	`data`

Constructor Summary

Constructors
Constructor and Description

Index(int length)

Constructors
Constructor and Description
`Index(int length)`

Method Summary

Methods
Modifier and Type	Method and Description
`boolean`	`allInRange(int start, int end)` Checks that all values in this index are within the specified range of start (inclusive) to end (exclusive)
`Index`	`clone()`
`Index`	`compose(AIndex a)` Composes this index with a second index, returning a new index.
`Index`	`compose(Index a)`
`static Index`	`create(AVector v)`
`static Index`	`createLength(int len)`
`boolean`	`equals(Index o)`
`boolean`	`equals(Object o)`
`int`	`find(int value)` Finds a value in this Index and return's it's position, or -1 if not found
`int`	`get(int i)` Gets the index value at position i
`int[]`	`getData()`
`int`	`indexPosition(int i)` Looks up an index value in the index, returning its position or -1 if not found Index must be both sorted and distinct.
`Index`	`invert()` Inverts the permutation represented by this Index
`boolean`	`isDistinctSorted()` Returns true if this index is distinct and sorted (in strictly increasing order)
`boolean`	`isEvenPermutation()`
`boolean`	`isFullyMutable()`
`boolean`	`isOddPermutation()`
`boolean`	`isPermutation()` Returns true if this index represents a permutation of positions 0..length-1
`boolean`	`isSorted()` Returns true if this index is sorted (in increasing order)
`int`	`length()` Returns the length of this index list
`void`	`lookupWith(Index source)`
`static Index`	`of(int... indexes)` Creates a new Index, using the specified index values
`void`	`permute(Index permutationIndex)` Permutes this vector according to a given permutation index
`void`	`reverse()` Reverses an index
`int`	`seekPosition(int i)` Finds the position a value would take assuming a sorted index.
`void`	`set(int i, int value)`
`void`	`sort()` Sorts the Index (in-place)
`void`	`swap(int i, int j)` Swaps (in-place) the indexes at two positions
`int`	`swapCount()` Counts the number of swaps required to create this permutation
`int[]`	`toArray()`
`int`	`unsafeGet(int i)`
`static Index`	`wrap(int[] indexes)` Creates a new Index, wrapping the provided index array

Methods inherited from class mikera.indexz.AIndex
compareTo, contains, contains, copyTo, equals, hashCode, isDistinct, iterator, maxIndex, minIndex, toList, toString

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

- Field Detail
  - data
```
public final int[] data
```
- Constructor Detail
  - Index
```
public Index(int length)
```
- Method Detail
  - swap
```
public void swap(int i,
        int j)
```
    Swaps (in-place) the indexes at two positions
    
    Overrides:
    
    swap in class AIndex
  - reverse
```
public void reverse()
```
    Reverses an index
    
    Overrides:
    
    reverse in class AIndex
  - isDistinctSorted
```
public boolean isDistinctSorted()
```
    Description copied from class: AIndex
    
    Returns true if this index is distinct and sorted (in strictly increasing order)
    
    Overrides:
    
    isDistinctSorted in class AIndex
    
    Returns:
  - isSorted
```
public boolean isSorted()
```
    Description copied from class: AIndex
    
    Returns true if this index is sorted (in increasing order)
    
    Overrides:
    
    isSorted in class AIndex
    
    Returns:
  - isPermutation
```
public boolean isPermutation()
```
    Description copied from class: AIndex
    
    Returns true if this index represents a permutation of positions 0..length-1
    
    Overrides:
    
    isPermutation in class AIndex
    
    Returns:
  - swapCount
```
public int swapCount()
```
    Counts the number of swaps required to create this permutation
    
    Returns:
  - isOddPermutation
```
public boolean isOddPermutation()
```
  - isEvenPermutation
```
public boolean isEvenPermutation()
```
  - wrap
```
public static Index wrap(int[] indexes)
```
    Creates a new Index, wrapping the provided index array
  - of
```
public static Index of(int... indexes)
```
    Creates a new Index, using the specified index values
  - createLength
```
public static Index createLength(int len)
```
  - create
```
public static Index create(AVector v)
```
  - get
```
public int get(int i)
```
    Description copied from class: AIndex
    
    Gets the index value at position i
    
    Specified by:
    
    get in class AIndex
    
    Returns:
  - unsafeGet
```
public int unsafeGet(int i)
```
  - set
```
public void set(int i,
       int value)
```
    Specified by:
    
    set in class AIndex
  - length
```
public int length()
```
    Description copied from class: AIndex
    
    Returns the length of this index list
    
    Specified by:
    
    length in class AIndex
    
    Returns:
  - clone
```
public Index clone()
```
    Overrides:
    
    clone in class AIndex
  - permute
```
public void permute(Index permutationIndex)
```
    Permutes this vector according to a given permutation index
    
    Parameters:
    permutationIndex -
  - sort
```
public void sort()
```
    Sorts the Index (in-place)
    
    Overrides:
    
    sort in class AIndex
  - equals
```
public boolean equals(Object o)
```
    Overrides:
    
    equals in class AIndex
  - equals
```
public boolean equals(Index o)
```
  - getData
```
public int[] getData()
```
  - toArray
```
public int[] toArray()
```
    Overrides:
    
    toArray in class AIndex
  - isFullyMutable
```
public boolean isFullyMutable()
```
    Overrides:
    
    isFullyMutable in class AIndex
  - lookupWith
```
public void lookupWith(Index source)
```
  - compose
```
public Index compose(AIndex a)
```
    Description copied from class: AIndex
    
    Composes this index with a second index, returning a new index. New index satisfies index.get(i) == a.get(this.get(i));
    
    Overrides:
    
    compose in class AIndex
    
    Returns:
  - compose
```
public Index compose(Index a)
```
  - indexPosition
```
public int indexPosition(int i)
```
    Looks up an index value in the index, returning its position or -1 if not found Index must be both sorted and distinct.
    
    Parameters:
    i -
    
    Returns:
  - seekPosition
```
public int seekPosition(int i)
```
    Finds the position a value would take assuming a sorted index. Uses a binary search.
    
    Parameters:
    i - The position of the value - will point to either the value or the next higher value present
    
    Returns:
  - find
```
public int find(int value)
```
    Finds a value in this Index and return's it's position, or -1 if not found
    
    Parameters:
    value -
    
    Returns:
  - invert
```
public Index invert()
```
    Inverts the permutation represented by this Index
    
    Returns:
  - allInRange
```
public boolean allInRange(int start,
                 int end)
```
    Checks that all values in this index are within the specified range of start (inclusive) to end (exclusive)
    
    Parameters:
    start -
    end -
    
    Returns:

Class Index

Field Summary

Constructor Summary

Method Summary

Methods inherited from class mikera.indexz.AIndex

Methods inherited from class java.lang.Object

Field Detail

data

Constructor Detail

Index

Method Detail

swap

reverse

isDistinctSorted

isSorted

isPermutation

swapCount

isOddPermutation

isEvenPermutation

wrap

of

createLength

create

get

unsafeGet

set

length

clone

permute

sort

equals

equals

getData

toArray

isFullyMutable

lookupWith

compose

compose

indexPosition

seekPosition

find

invert

allInRange