net.maizegenetics.stats.math

Class OrderEnumerator.Utils

net.maizegenetics.stats.math.OrderEnumerator.Utils

Enclosing interface:

OrderEnumerator

public static class OrderEnumerator.Utils

Method Detail

getConstant

public static OrderEnumerator getConstant(int index)

Parameters:

index - The index to always return

Returns:

org.jetbrains.dokka.NodeRenderContent@c8c7f3b: an OrderEnumerator object that always returns 'index'

getOrdered

public static OrderEnumerator getOrdered(int size)

Parameters:

size - the number of different indexes returned (between 0 and size-1)

Returns:

org.jetbrains.dokka.NodeRenderContent@3e53f111: an OrderEnumerator object returns index in order between a certain range

getShuffled

public static OrderEnumerator getShuffled(int size)

Parameters:

size - the number of different indexes returned (between 0 and size-1)

Returns:

org.jetbrains.dokka.NodeRenderContent@2c2f4148: an OrderEnumerator object returns index in random order between a certain range (order changes with each reset)

getBiasAlternating

public static OrderEnumerator getBiasAlternating(OrderEnumerator primary,
                                                 OrderEnumerator secondary)

Parameters:

primary - The primary OrderEnumerator, one index is taken from this enumertor than an entire sequence of the secondary is taken

Returns:

org.jetbrains.dokka.NodeRenderContent@7c84ab8c: an OrderEnumerator object that combines two sub enumerators

getAlternating

public static OrderEnumerator getAlternating(OrderEnumerator primary,
                                             OrderEnumerator secondary)

Parameters:

primary - The primary OrderEnumerator

Returns:

org.jetbrains.dokka.NodeRenderContent@139e7680: an OrderEnumerator object that combines two sub enumerators, by alternating between outputs

getZero

public static OrderEnumerator getZero()

Returns:

org.jetbrains.dokka.NodeRenderContent@32e4d69b: OrderEnumerator that always returns 0 (zero)

getRestricted

public static OrderEnumerator getRestricted(OrderEnumerator toRestrict,
                                            int minimum,
                                            int range)

Parameters:

minimum - minmim value released

range - range of values released (that is values go between minimum (inclusive) and minimum+range(exclusive)

Returns:

org.jetbrains.dokka.NodeRenderContent@6497e48e: an OrderEnumerator that is restricted in indexes it returns based on base Enumerator

getAdjusted

public static OrderEnumerator getAdjusted(OrderEnumerator toAdjust,
                                          int adjustmentFactor)

Returns:

org.jetbrains.dokka.NodeRenderContent@3d16eb5b: OrderEnumerator that always returns 0 (zero)

getZeroFactory

public static net.maizegenetics.stats.math.OrderEnumerator.OEFactory getZeroFactory()

Returns:

org.jetbrains.dokka.NodeRenderContent@5ddca00f: OrderEnumerator that always returns 0 (zero)

getConstantFactory

public static net.maizegenetics.stats.math.OrderEnumerator.OEFactory getConstantFactory(int index)

Parameters:

index - The index to always return

Returns:

org.jetbrains.dokka.NodeRenderContent@4918f521: an OrderEnumerator object that always returns 'index'

getOrderedFactory

public static net.maizegenetics.stats.math.OrderEnumerator.OEFactory getOrderedFactory()

Returns:

org.jetbrains.dokka.NodeRenderContent@12f0cb18: an OrderEnumerator object returns index in order between a certain range

getShuffledFactory

public static net.maizegenetics.stats.math.OrderEnumerator.OEFactory getShuffledFactory()

Returns:

org.jetbrains.dokka.NodeRenderContent@18b6a62e: an OrderEnumerator object returns index in random order between a certain range (order changes with each reset)

getAdjustedFactory

public static net.maizegenetics.stats.math.OrderEnumerator.OEFactory getAdjustedFactory(net.maizegenetics.stats.math.OrderEnumerator.OEFactory toAdjust,
                                                                                        int adjustmentFactor)

Parameters:

adjustmentFactor - If to adjust returns x, adjusted will return x+adjustmentFactory (it's that simple)

Returns:

org.jetbrains.dokka.NodeRenderContent@20d2b1ef: an OrderEnumerator that returns indexes adjusted from a base enumerator

getRestrictedFactory

public static net.maizegenetics.stats.math.OrderEnumerator.OEFactory getRestrictedFactory(net.maizegenetics.stats.math.OrderEnumerator.OEFactory toRestrict,
                                                                                          int minimum,
                                                                                          int range)

Parameters:

minimum - minmim value released

range - range of values released (that is values go between minimum (inclusive) and minimum+range(exclusive)

Returns:

org.jetbrains.dokka.NodeRenderContent@2e6df929: an OrderEnumerator that is restricted in indexes it returns based on base Enumerator

getAlternatingFactory

public static net.maizegenetics.stats.math.OrderEnumerator.OEFactory getAlternatingFactory(net.maizegenetics.stats.math.OrderEnumerator.OEFactory primary,
                                                                                           net.maizegenetics.stats.math.OrderEnumerator.OEFactory secondary)

Returns:

org.jetbrains.dokka.NodeRenderContent@3ad15ff7: an OrderEnumerator object that alternates outputs between two base enumerator

getBiasAlternatingFactory

public static net.maizegenetics.stats.math.OrderEnumerator.OEFactory getBiasAlternatingFactory(net.maizegenetics.stats.math.OrderEnumerator.OEFactory primary,
                                                                                               net.maizegenetics.stats.math.OrderEnumerator.OEFactory secondary)

Returns:

org.jetbrains.dokka.NodeRenderContent@177b0955: an OrderEnumerator object that alternates outputs between two base enumerator (takes one from primary, than all from secondary, one from primary, all from secondary)