ProbabilityFunction (Tweety (Math) 1.10 API)

java.lang.Object
- net.sf.tweety.math.probability.ProbabilityFunction<T>

Type Parameters:

T - The class of the objects used.

All Implemented Interfaces:

Map<T,Probability>
```
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 Class Summary
- Nested classes/interfaces inherited from interface java.util.Map
  Map.Entry<K,V>

Constructor Summary

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

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and 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.
`protected static void`	`normalize(List<Double> probabilities)` Normalizes the given list of probabilities, i.e.
`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
clone, finalize, 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 Detail
  - ProbabilityFunction
```
public ProbabilityFunction()
```
    Creates a new probability function.
  - ProbabilityFunction
```
public ProbabilityFunction(ProbabilityFunction<T> other)
```
    Creates a new probability function by copying the given one.
- Method Detail
  - 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
  - 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
  - normalize
```
protected static void normalize(List<Double> probabilities)
```
    Normalizes the given list of probabilities, i.e. divides each probability by the sum of all probabilities.
  - 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 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. 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 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. 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>> ProbabilityFunction<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>> ProbabilityFunction<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 Set<Map.Entry<T,Probability>> 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 Collection<Probability> 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 Vector<Probability> 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 Vector<Double> 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

Class ProbabilityFunction<T extends Comparable<T>>

Nested Class Summary

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

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.Map

Constructor Detail

ProbabilityFunction

ProbabilityFunction

Method Detail

probability

probability

normalize

isNormalized

normalize

convexCombination

linearCombination

convexCombination

getUniformDistribution

sample

sample

toString

clear

containsKey

containsValue

entrySet

get

isEmpty

put

putAll

remove

size

values

keySet

hashCode

getProbabilityVector

getProbabilityVectorAsDoubles

equals