# Class ProbabilityFunction<T extends Comparable<T>>

java.lang.Object
org.tweetyproject.math.probability.ProbabilityFunction<T>
Type Parameters:
`T` - The class of the objects used.
All Implemented Interfaces:
`Map<T,Probability>`
Direct Known Subclasses:
`ProbabilisticExtension`, `SubgraphProbabilityFunction`

public class ProbabilityFunction<T extends Comparable<T>> extends Object implements Map<T,Probability>
This class represents a probability distribution over some set of objects
Author:
Matthias Thimm

## Nested classes/interfaces inherited from interface java.util.Map

`Map.Entry<K extends Object,V extends Object>`
• ## Constructor Summary

Constructors
Constructor
Description
`ProbabilityFunction()`
Creates a new probability function.
`ProbabilityFunction(ProbabilityFunction<T> other)`
Creates a new probability function by copying the given one.
• ## Method Summary

Modifier and Type
Method
Description
`void`
`clear()`

`boolean`
`containsKey(Object key)`

`boolean`
`containsValue(Object value)`

`static <S extends Comparable<S>>ProbabilityFunction<S>`
```convexCombination(double[] factors, ProbabilityFunction<S>[] creators)```
Computes the convex combination of the given probability distributions P1,...,PN with parameters factors, i.e.
`ProbabilityFunction<T>`
```convexCombination(double d, ProbabilityFunction<T> other)```
Computes the convex combination of this P1 and the given probability distribution P2 with parameter d, i.e.
`Set<Map.Entry<T,Probability>>`
`entrySet()`

`boolean`
`equals(Object obj)`

`Probability`
`get(Object key)`

`Vector<Probability>`
`getProbabilityVector()`
Returns the vector of probabilities, depending on the order of the domain elements (which can be ordered as they implement Comparable).
`Vector<Double>`
`getProbabilityVectorAsDoubles()`
Returns the vector of probabilities, depending on the order of the domain elements (which can be ordered as they implement Comparable).
`static <S extends Comparable<S>>ProbabilityFunction<S>`
`getUniformDistribution(Set<S> objects)`
Returns the uniform distribution on the given interpretations.
`int`
`hashCode()`

`boolean`
`isEmpty()`

`boolean`
`isNormalized()`
Checks whether this probability function is normalized, i.e.
`Set<T>`
`keySet()`

`ProbabilityFunction<T>`
```linearCombination(double d1, double d2, ProbabilityFunction<T> other)```
Makes a linear combination of this distribution "p1" and the given distribution "other" and the given parameters, i.e.
`void`
`normalize()`
Normalizes this probability function to have mass 1.
`Probability`
`probability(Collection<? extends T> objects)`
Gets the probability of the given object.
`Probability`
`probability(T w)`
Gets the probability of the given object.
`Probability`
```put(T key, Probability value)```

`void`
`putAll(Map<? extends T,? extends Probability> m)`

`Probability`
`remove(Object key)`

`T`
`sample()`
Samples one element from the domain of this probability function, depending on its probability.
`T`
`sample(Random random)`
Samples one element from the domain of this probability function, depending on its probability.
`int`
`size()`

`String`
`toString()`

`Collection<Probability>`
`values()`

### Methods inherited from class java.lang.Object

`getClass, notify, notifyAll, wait, wait, wait`

### Methods inherited from interface java.util.Map

`compute, computeIfAbsent, computeIfPresent, forEach, getOrDefault, merge, putIfAbsent, remove, replace, replace, replaceAll`
• ## Constructor Details

• ### ProbabilityFunction

public ProbabilityFunction()
Creates a new probability function.
• ### ProbabilityFunction

public ProbabilityFunction(ProbabilityFunction<T> other)
Creates a new probability function by copying the given one.
Parameters:
`other` - another probability function
• ## Method Details

• ### probability

public Probability probability(T w) throws IllegalArgumentException
Gets the probability of the given object.
Parameters:
`w` - some object.
Returns:
the probability of the given object.
Throws:
`IllegalArgumentException` - if the given object has no probability
• ### probability

public Probability probability(Collection<? extends T> objects) throws IllegalArgumentException
Gets the probability of the given object.
Parameters:
`objects` - some object.
Returns:
the probability of the given object.
Throws:
`IllegalArgumentException` - if the given object has no probability
• ### isNormalized

public boolean isNormalized()
Checks whether this probability function is normalized, i.e. the sum of all probabilities is 1.
Returns:
"true" if this probability function is normalized.
• ### normalize

public void normalize()
Normalizes this probability function to have mass 1.
• ### convexCombination

public  convexCombination(double d, ProbabilityFunction<T> other)
Computes the convex combination of this P1 and the given probability distribution P2 with parameter d, i.e. it returns a P with P(i)=d P1(i) + (1-d) P2(i) for every interpretation i.
Parameters:
`d` - a double
`other` - a probability distribution
Returns:
the convex combination of this P1 and the given probability distribution P2 with parameter d.
Throws:
`IllegalArgumentException` - if either d is not in [0,1] or this and the given probability distribution are not defined on the same set of interpretations.
• ### linearCombination

public  linearCombination(double d1, double d2, ProbabilityFunction<T> other)
Makes a linear combination of this distribution "p1" and the given distribution "other" and the given parameters, i.e. it returns a P with P(i)=d1 P1(i) + d2 P2(i) for every interpretation i. NOTE: P is normalized after combination.
Parameters:
`d1` - a double.
`d2` - a double.
`other` - a probability distribution.
Returns:
a probability distribution.
• ### convexCombination

public static <S extends Comparable<S>>  convexCombination(double[] factors, ProbabilityFunction<S>[] creators) throws IllegalArgumentException
Computes the convex combination of the given probability distributions P1,...,PN with parameters factors, i.e. it returns a P with P(i)=d1 P1(i) + d2 P2(i)+ ... + dN PN(i) for every object i (with d1,...,dN=factors).
Type Parameters:
`S` - The object class
Parameters:
`factors` - a vector of doubles.
`creators` - a vector of probability distributions.
Returns:
the convex combination of the given distributions with parameters factors.
Throws:
`IllegalArgumentException` - if either the sum of factors d is not in 1, or this and the given probability distributions are not defined on the same set of objects, or the lengths of creators and factors differ.
• ### getUniformDistribution

public static <S extends Comparable<S>>  getUniformDistribution(Set<S> objects)
Returns the uniform distribution on the given interpretations.
Type Parameters:
`S` - The interpretation class
Parameters:
`objects` - set of interpretations of type S.
Returns:
the uniform distribution on the given interpretations.
• ### sample

public T sample()
Samples one element from the domain of this probability function, depending on its probability.
Returns:
a sample from this probability function.
• ### sample

public T sample(Random random)
Samples one element from the domain of this probability function, depending on its probability.
Parameters:
`random` - the number generator used.
Returns:
a sample from this probability function.
• ### toString

public String toString()
Overrides:
`toString` in class `Object`
• ### clear

public void clear()
Specified by:
`clear` in interface `Map<T extends Comparable<T>,Probability>`
• ### containsKey

public boolean containsKey(Object key)
Specified by:
`containsKey` in interface `Map<T extends Comparable<T>,Probability>`
• ### containsValue

public boolean containsValue(Object value)
Specified by:
`containsValue` in interface `Map<T extends Comparable<T>,Probability>`
• ### entrySet

public  entrySet()
Specified by:
`entrySet` in interface `Map<T extends Comparable<T>,Probability>`
• ### get

public Probability get(Object key)
Specified by:
`get` in interface `Map<T extends Comparable<T>,Probability>`
• ### isEmpty

public boolean isEmpty()
Specified by:
`isEmpty` in interface `Map<T extends Comparable<T>,Probability>`
• ### put

public Probability put(T key, Probability value)
Specified by:
`put` in interface `Map<T extends Comparable<T>,Probability>`
• ### putAll

public void putAll(Map<? extends T,? extends Probability> m)
Specified by:
`putAll` in interface `Map<T extends Comparable<T>,Probability>`
• ### remove

public Probability remove(Object key)
Specified by:
`remove` in interface `Map<T extends Comparable<T>,Probability>`
• ### size

public int size()
Specified by:
`size` in interface `Map<T extends Comparable<T>,Probability>`
• ### values

public  values()
Specified by:
`values` in interface `Map<T extends Comparable<T>,Probability>`
• ### keySet

public Set<T> keySet()
Specified by:
`keySet` in interface `Map<T extends Comparable<T>,Probability>`
• ### hashCode

public int hashCode()
Specified by:
`hashCode` in interface `Map<T extends Comparable<T>,Probability>`
Overrides:
`hashCode` in class `Object`
• ### getProbabilityVector

public  getProbabilityVector()
Returns the vector of probabilities, depending on the order of the domain elements (which can be ordered as they implement Comparable).
Returns:
the vector of probabilities
• ### getProbabilityVectorAsDoubles

public  getProbabilityVectorAsDoubles()
Returns the vector of probabilities, depending on the order of the domain elements (which can be ordered as they implement Comparable).
Returns:
the vector of probabilities as doubles
• ### equals

public boolean equals(Object obj)
Specified by:
`equals` in interface `Map<T extends Comparable<T>,Probability>`
Overrides:
`equals` in class `Object`