org.deeplearning4j.berkeley

Class Pair<F,S>

java.lang.Object

org.deeplearning4j.berkeley.Pair<F,S>

All Implemented Interfaces:

Serializable, Comparable<Pair<F,S>>

public class Pair<F,S>
extends Object
implements Serializable, Comparable<Pair<F,S>>

A generic-typed pair of objects.

Author:

Dan Klein

See Also:

Serialized Form

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	Pair.DefaultLexicographicPairComparator<F extends Comparable<F>,S extends Comparable<S>>
static class	Pair.FirstComparator<S extends Comparable<? super S>,T>
static class	Pair.LexicographicPairComparator<F,S>
static class	Pair.ReverseFirstComparator<S extends Comparable<? super S>,T>
static class	Pair.ReverseSecondComparator<S,T extends Comparable<? super T>>
static class	Pair.SecondComparator<S,T extends Comparable<? super T>>

Constructor Summary

Constructors

Constructor and Description
Pair(F first, S second)

Method Summary

Modifier and Type	Method and Description
int	compareTo(Pair<F,S> o) Compares this object with the specified object for order.
boolean	equals(Object o)
F	getFirst()
S	getSecond()
int	hashCode()
static <S,T> Pair<S,T>	makePair(S first, T second)
static <S,T> Pair<S,T>	newPair(S first, T second)
Pair<S,F>	reverse()
void	setFirst(F pFirst)
void	setSecond(S pSecond)
String	toString()

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Constructor Detail

Pair

public Pair(F first,
            S second)

Method Detail

getFirst

public F getFirst()

getSecond

public S getSecond()

setFirst

public void setFirst(F pFirst)

setSecond

public void setSecond(S pSecond)

reverse

public Pair<S,F> reverse()

equals

public boolean equals(Object o)

Overrides:

equals in class Object

hashCode

public int hashCode()

Overrides:

hashCode in class Object

toString

public String toString()

Overrides:

toString in class Object

compareTo

public int compareTo(Pair<F,S> o)

Compares this object with the specified object for order. Returns a negative integer, zero, or a positive integer as this object is less than, equal to, or greater than the specified object.

The implementor must ensure sgn(x.compareTo(y)) == -sgn(y.compareTo(x)) for all x and y. (This implies that x.compareTo(y) must throw an exception iff y.compareTo(x) throws an exception.)

The implementor must also ensure that the relation is transitive: (x.compareTo(y)>0 && y.compareTo(z)>0) implies x.compareTo(z)>0.

Finally, the implementor must ensure that x.compareTo(y)==0 implies that sgn(x.compareTo(z)) == sgn(y.compareTo(z)), for all z.

It is strongly recommended, but not strictly required that (x.compareTo(y)==0) == (x.equals(y)). Generally speaking, any class that implements the Comparable interface and violates this condition should clearly indicate this fact. The recommended language is "Note: this class has a natural ordering that is inconsistent with equals."

In the foregoing description, the notation sgn(expression) designates the mathematical signum function, which is defined to return one of -1, 0, or 1 according to whether the value of expression is negative, zero or positive.

Specified by:

compareTo in interface Comparable<Pair<F,S>>

Parameters:

o - the object to be compared.

Returns:

a negative integer, zero, or a positive integer as this object is less than, equal to, or greater than the specified object.

Throws:

NullPointerException - if the specified object is null

ClassCastException - if the specified object's type prevents it from being compared to this object.

newPair

public static <S,T> Pair<S,T> newPair(S first,
                                      T second)

makePair

public static <S,T> Pair<S,T> makePair(S first,
                                       T second)