def _estimate_semi_markov(obj, *args, **kargs):
Type = 'v'
#error.CheckType([args[0]], [str])
Type = error.CheckDictKeys(args[0], stochastic_process_type)
NbIteration = kargs.get("NbIteration", I_DEFAULT)
Counting = kargs.get("Counting", True)
Estimator = error.ParseKargs(kargs, "Estimator", "CompleteLikelihood",
estimator_semi_markov_type)
OccupancyMean = error.ParseKargs(kargs, "OccupancyMean",
'Computed', mean_computation_map)
error.CheckType([Counting, NbIteration], [bool, int])
if Type != 'e' or Estimator == PARTIAL_LIKELIHOOD:
if kargs.get(NbIteration):
raise ValueError("Forbidden options Estimate NbIteration")
if kargs.get("OccupancyMean"):
raise ValueError("Forbidden options Estimate OccupancyMean")
return obj.semi_markov_estimation(Type.real , Estimator , Counting,
NbIteration , OccupancyMean)
def ComputeAutoCorrelation(obj, *args, **kargs):
"""
ComputeAutoCorrelation
"""
error.CheckType([obj], [[
_VariableOrderMarkov, _HiddenVariableOrderMarkov,
_VariableOrderMarkovData
]])
error.CheckArgumentsLength(args, 1, 2)
if len(args) == 1:
variable = 1
value = args[0]
elif len(args) == 2:
variable = args[0]
value = args[1]
#_check_nb_variable(obj, variable)
max_lag = error.ParseKargs(kargs, "MaxLag", MAX_LAG)
error.CheckType([variable, value, max_lag], [int, int, int])
if len(args) == 1:
return obj.state_autocorrelation_computation(value, max_lag)
elif len(args) == 2:
return obj.output_autocorrelation_computation(variable, value, max_lag)
def _estimate_hidden_variable_order_markov(obj, *args, **kargs):
"""
Estimate switch hidden_variable_order_markov
"""
from openalea.sequence_analysis._sequence_analysis import \
MIN_NB_STATE_SEQUENCE, \
MAX_NB_STATE_SEQUENCE, \
NB_STATE_SEQUENCE_PARAMETER
from openalea.stat_tool._stat_tool import \
FORWARD, \
FORWARD_BACKWARD_SAMPLING, \
FORWARD_DYNAMIC_PROGRAMMING
GlobalInitialTransition = kargs.get("GlobalInitialTransition", True)
CommonDispersion = kargs.get("CommonDispersion", False)
NbIteration = kargs.get("NbIteration", 80)
Counting = kargs.get("Counting", True)
StateSequence = kargs.get("StateSequence", True)
Parameter = kargs.get("Parameter", NB_STATE_SEQUENCE_PARAMETER)
MinNbSequence = kargs.get("MinNbStateSequence", MIN_NB_STATE_SEQUENCE)
MaxNbSequence = kargs.get("MaxNbStateSequence", MAX_NB_STATE_SEQUENCE)
Algorithm = error.ParseKargs(kargs, "Algorithm", 'EM', \
sub_markovian_algorithms)
error.CheckType([CommonDispersion, Counting, GlobalInitialTransition, NbIteration,
MinNbSequence, MaxNbSequence, Parameter, StateSequence],
[bool, bool, bool, int, int, int, [int, float], bool])
error.CheckType([args[0]], [_HiddenVariableOrderMarkov])
# sanity check on arguments
# this one can be check only when Chain will be public and exported in
# export_variable_order_markov
# if type == 'e' and kargs.get("GlobalInitialTransition")" raise Error
if Algorithm != sub_markovian_algorithms["MCEM"]:
options = ["Parameter", "MaxNbStateSequence", "MinNbStateSequence"]
for option in options:
if kargs.get(option):
raise ValueError("If % is provided, Algorithm cannot be MCEM" %
option)
if Algorithm == FORWARD:
hmarkov = obj.hidden_variable_order_markov_estimation(
args[0], GlobalInitialTransition, CommonDispersion,
Counting, StateSequence, NbIteration)
elif Algorithm == FORWARD_BACKWARD_SAMPLING:
hmarkov = obj.hidden_variable_order_markov_stochastic_estimation(
args[0], GlobalInitialTransition, CommonDispersion,
MinNbSequence, MaxNbSequence, Parameter, Counting,
StateSequence, NbIteration)
else:
print(Algorithm)
return hmarkov
def ComputeCorrelation(obj, *args, **kargs):
"""Computation of sample autocorrelation or cross-correlation functions.
:Examples:
.. doctest::
:options: +SKIP
>>> ComputeCorrelation(seq1, MaxLag=10, Type="Spearman", Normalization="Exact")
>>> ComputeCorrelation(seqn, variable, MaxLag=10, Type="Spearman", Normalization="Exact")
>>> ComputeCorrelation(seqn, variable1, variable2, MaxLag=10, Type="Spearman", Normalization="Exact")
:Arguments:
* seq1 (sequences, discrete_sequences, markov_data, semi-markov_data):
univariate sequences,
* seqn (sequences, discrete_sequences, markov_data, semi-markov_data):
multivariate sequences,
* variable (int): variable index (computation of a sample autocorrelation function).
* variable1, variable2 (int): variable indices (computation of a sample
cross-correlation function).
:Optional Arguments:
* Type (string): type of correlation coefficient: "Pearson" (linear
correlation coefficient - default value), "Spearman" or "Kendall" (rank
correlation coefficients).
* MaxLag (int): maximum lag. A default value is computed from the sequence
length distribution,
* Normalization (STRING): normalization of the correlation coefficients:
"Approximated" (the default - usual convention for time series analysis)
or "Exact", (highly recommended for sample of short sequences). This
optional argument can only be used if the optional argument Type is set
at "Pearson" or "Spearman".
:Returned Object:
If variable, or variable1 and variable2 are valid indices of variables (and
are different if two indices are given) and if 0 <= MaxLag < (maximum length
of sequences), then an object of type correlation is returned, otherwise no
object is returned.
:Background:
In the univariate case or if only variable is given, a sample
autocorrelation function is computed. If variable1 and variable2 are given,
a sample cross-correlation function is computed.
.. seealso::
:func:`~openalea.sequence_analysis.correlation.ComputePartialAutoCorrelation`,
:func:`~openalea.sequence_analysis.correlation.ComputeWhiteNoiseCorrelation`
"""
error.CheckType([obj], [[
_Sequences, _MarkovianSequences, _VariableOrderMarkovData,
_SemiMarkovData, _NonHomogeneousMarkovData
]])
if obj.nb_variable == 1:
variable1 = 1
variable2 = 1
else:
error.CheckType([args[0]], [int])
#todo: check that variable1 <= nb_variable and > 0
variable1 = args[0]
if len(args) == 1:
variable2 = variable1
elif len(args) == 2:
#todo: check that variable1 <= nb_variable and > 0
error.CheckType([args[1]], [int])
variable2 = args[1]
else:
raise TypeError("1 or 2 non-optional arguments required")
max_lag = error.ParseKargs(kargs, "MaxLag", I_DEFAULT)
itype = error.ParseKargs(kargs, "Type", "Pearson", type_dict)
normalization = error.ParseKargs(kargs, "Normalization", "Exact",
norm_type)
IndividualMean = error.ParseKargs(kargs, "IndividualMean", False)
#if normalization_option and ((type == SPEARMAN2) or (type == KENDALL)):
# raise Exception
#if individual_mean_option and (type != PEARSON):
# raise Exception
# check argument validity.
return obj.correlation_computation(variable1, variable2, itype, max_lag,
normalization, IndividualMean)
def ComputePartialAutoCorrelation(obj, *args, **kargs):
"""ComputePartialAutoCorrelation
Computation of sample partial autocorrelation functions.
:Usage:
.. doctest::
:options: +SKIP
>>> ComputePartialAutoCorrelation(seq1, MaxLag=10, Type="Kendall")
>>> ComputePartialAutoCorrelation(seqn, variable, MaxLag=10, Type="Kendall")
:Arguments:
* seq1 (**sequences**, discrete_sequences, markov_data, semi-markov_data):
univariate sequences,
* seqn (sequences, discrete_sequences, markov_data, semi-markov_data):
multivariate sequences,
* variable (int): variable index.
:Optional Arguments:
* MaxLag (int): maximum lag. A default value is computed from the sequence
length distribution,
* Type (string): type of correlation coefficient: "Pearson" (linear
correlation coefficient - the default) or "Kendall" (rank correlation coefficient).
:Returned Object:
If variable is a valid variable index and if 1 <= MaxLag < (maximum length
of sequences), an object of type correlation is returned, otherwise no object
is returned.
:Background:
The partial autocorrelation coefficient at lag k measures the correlation
between :math:`x_i` and :math:`x_{t+k}` not accounted for by
:math:`x_{t+1}, ..., x_{t+k-1}` (or after adjusting for the effects of
:math:`x_{t+1}, ..., x_{t+k-1}`).
.. seealso::
:func:`~openalea.sequence_analysis.correlation.ComputeCorrelation`
"""
error.CheckType([obj], [[
_Sequences, _MarkovianSequences, _VariableOrderMarkovData,
_SemiMarkovData, _NonHomogeneousMarkovData
]])
error.CheckArgumentsLength(args, 0, 1)
if len(args) == 0:
variable = 1
else:
variable = args[0]
max_lag = error.ParseKargs(kargs, "MaxLag", MAX_LAG)
Type = error.ParseKargs(kargs, "Type", "Pearson", type_dict)
error.CheckType([variable, max_lag], [int, int])
_check_nb_variable(obj, variable)
#todo check that Type is Pearson or Kendall
return obj.partial_autocorrelation_computation(variable, Type, max_lag)
def _estimate_variable_order_markov(obj, *args, **kargs):
"""
EStimate on variable order markov
"""
from openalea.sequence_analysis._sequence_analysis import \
LOCAL_BIC_THRESHOLD,\
CTM_KT_THRESHOLD,\
CTM_BIC_THRESHOLD,\
CONTEXT_THRESHOLD,\
CTM_BIC,\
CTM_KT,\
CONTEXT,\
LOCAL_BIC
Order = kargs.get("Order", None)
MaxOrder = kargs.get("MaxOrder", ORDER)
MinOrder = kargs.get("MinOrder", 0)
Threshold = kargs.get("Threshold", LOCAL_BIC_THRESHOLD)
error.CheckType([Threshold, MaxOrder, MinOrder], [[int, float], int, int])
Algorithm = error.ParseKargs(kargs, "Algorithm", "LocalBIC", algorithm)
Estimator = error.ParseKargs(kargs, "Estimator", "Laplace", estimator)
Penalty = error.ParseKargs(kargs, "Penalty", "BIC", likelihood_penalty_type)
GlobalInitialTransition = kargs.get("GlobalInitialTransition", True)
GlobalSample = kargs.get("GlobalSample", True)
Counting = kargs.get("Counting", True)
error.CheckType([Counting, GlobalSample, GlobalInitialTransition],
[bool, bool, bool])
#args0 is a string
if len(args)>0 and isinstance(args[0], str):
Type = 'v'
Type = error.CheckDictKeys(args[0], stochastic_process_type)
# check validity of the input arguments following AML's code
if Algorithm != LOCAL_BIC and not kargs.get("Threshold"):
if Algorithm == CTM_BIC:
Threshold = CTM_BIC_THRESHOLD
elif Algorithm == CTM_KT:
Threshold = CTM_KT_THRESHOLD
elif Algorithm == CONTEXT:
Threshold = CONTEXT_THRESHOLD
if Algorithm == CTM_KT and kargs.get("Estimator"):
raise ValueError("Forbidden combinaison of Algorithm and Estimator")
order_estimation = True
if Order is not None:
order_estimation = False
MaxOrder = Order
if not order_estimation:
options = ["Algorithm", "Estimator", "GlobalSample", "MinOrder",
"Threshold"]
for option in options:
if kargs.get(option):
raise ValueError("Order and %s cannot be used together" %
option)
if Type == 'e' and kargs.get("GlobalInitialTransition"):
raise ValueError("""
Type e and GlobalInitialTransition cannot be used together""")
if order_estimation is True:
markov = obj.variable_order_markov_estimation1(
Type.real, MinOrder, MaxOrder, Algorithm.real, Threshold, Estimator.real ,
GlobalInitialTransition , GlobalSample , Counting)
else:
markov = obj.variable_order_markov_estimation2(
Type, MaxOrder, GlobalInitialTransition, Counting)
#Variable order markov case
elif isinstance(args[0], _VariableOrderMarkov):
vom = args[0]
# can be implemted once Chain class is public and exported
# in export_variable_order_markov
# if vom.type == 'e' and kargs.get("GlobalInitialTransition"):
# raise ValueError("""
# Type e and GlobalInitialTransition cannot be used together""")
markov = obj.variable_order_markov_estimation3(vom,
GlobalInitialTransition, Counting)
# array case
elif isinstance(args[0], list):
symbol = args[0]
markov = obj.lumpability_estimation(symbol, Penalty,
Order, Counting)
else:
raise KeyError("jfjf")
return markov
def _estimate_hidden_semi_markov(obj, *args, **kargs):
"""
.. doctest::
:options: +SKIP
>>> hsmc21 = Estimate(seq21, "HIDDEN_SEMI-MARKOV", hsmc0)
"""
from openalea.sequence_analysis._sequence_analysis import \
MIN_NB_STATE_SEQUENCE, \
MAX_NB_STATE_SEQUENCE, \
NB_STATE_SEQUENCE_PARAMETER
from openalea.stat_tool._stat_tool import \
NO_COMPUTATION, \
FORWARD, \
FORWARD_BACKWARD_SAMPLING, \
KAPLAN_MEIER
# GlobalInitialTransition = kargs.get("GlobalInitialTransition", True)
CommonDispersion = kargs.get("CommonDispersion", False)
NbIteration = kargs.get("NbIteration", I_DEFAULT)
Counting = kargs.get("Counting", True)
StateSequence = kargs.get("StateSequence", True)
Parameter = kargs.get("Parameter", NB_STATE_SEQUENCE_PARAMETER)
MinNbSequence = kargs.get("MinNbStateSequence", MIN_NB_STATE_SEQUENCE)
MaxNbSequence = kargs.get("MaxNbStateSequence", MAX_NB_STATE_SEQUENCE)
Algorithm = error.ParseKargs(kargs, "Algorithm", 'EM', \
sub_markovian_algorithms)
Estimator = error.ParseKargs(kargs, "Estimator", 'CompleteLikelihood',
estimator_semi_markov_type)
InitialOccupancyMean = kargs.get("InitialOccupancyMean", D_DEFAULT)
MeanComputation = error.ParseKargs(kargs, "OccupancyMean", 'Computed',
mean_computation_map)
error.CheckType([CommonDispersion, Counting, NbIteration,
MinNbSequence, MaxNbSequence, Parameter, StateSequence,
InitialOccupancyMean],
[bool, bool, int, int, int, [int, float], bool,
[float, int]])
print(Algorithm)
if Algorithm != sub_markovian_algorithms["MCEM"]:
options = ["Parameter", "MaxNbStateSequence", "MinNbStateSequence"]
for option in options:
if kargs.get(option):
raise ValueError(
"If % is provided, Algorithm cannot be MCEM" % option)
if Algorithm != sub_markovian_algorithms["EM"]:
if Estimator == KAPLAN_MEIER:
raise ValueError(
"Estimator= KaplanMeier and Algorithm = MCEM not possible")
error.CheckType([args[0]], [[str, _HiddenSemiMarkov]])
if isinstance(args[0], str):
Type = 'v'
error.CheckType([args[1]], [int])
NbState = args[1]
if args[0] == "Ordinary":
error.CheckArgumentsLength(args, 3, 3)
error.CheckType([args[2]], [str])
Type = 'o'
if args[2] not in ["LeftRight", "Irreducible"]:
raise ValueError(
"third argument must be LeftRight or Irreducible.")
if args[2] == "LeftRight":
LeftRight = True
else:
LeftRight = False
elif args[0] == "Equilibrium":
error.CheckArgumentsLength(args, 2, 2)
Type = 'e'
LeftRight = False
else:
raise AttributeError("type must be Ordinary or Equilibrium")
if ((Type != 'e') or (Estimator == PARTIAL_LIKELIHOOD) or \
(Algorithm != NO_COMPUTATION)) and \
kargs.get(InitialOccupancyMean):
raise ValueError("Incompatible user arguments")
if Algorithm == NO_COMPUTATION:
hsmarkov = obj.hidden_semi_markov_estimation_model( Type, NbState,
LeftRight, InitialOccupancyMean, CommonDispersion, Estimator,
Counting, StateSequence, NbIteration, MeanComputation)
return hsmarkov
elif Algorithm == FORWARD_BACKWARD_SAMPLING:
hsmarkov = obj.hidden_semi_markov_stochastic_estimation_model(
Type, NbState, LeftRight, InitialOccupancyMean, CommonDispersion,
MinNbSequence, MaxNbSequence, Parameter, Estimator, Counting,
StateSequence, NbIteration)
return hsmarkov
elif isinstance(args[0], _HiddenSemiMarkov):
#todo: add these lines once Chain is public
#if ((( (args[0].type == 'o')) or
# (Estimator == PARTIAL_LIKELIHOOD) or
# (Algorithm != FORWARD_BACKWARD)) and \
# kargs.get("InitialOccupancyMean")):
# raise ValueError("Incompatible arguments")
hsmarkov = args[0]
if Algorithm == NO_COMPUTATION:
output = obj.hidden_semi_markov_estimation(hsmarkov,
CommonDispersion, Estimator, Counting,
StateSequence, NbIteration, MeanComputation)
return output
elif Algorithm == FORWARD_BACKWARD_SAMPLING:
return obj.hidden_semi_markov_stochastic_estimation(hsmarkov,
CommonDispersion, MinNbSequence, MaxNbSequence,
Parameter, Estimator, Counting,
StateSequence, NbIteration)
def _estimate_renewal_count_data(obj, itype, **kargs):
"""
Estimate switch renewal_count_data
"""
Type = 'v'
error.CheckType([obj, itype], [[_TimeEvents, _RenewalData], str])
if isinstance(itype, str):
if itype == "Ordinary":
Type = 'o'
elif itype == "Equilibrium":
Type = 'e'
else:
raise AttributeError("type must be Ordinary or Equilibrium")
else:
raise AttributeError("type must be Ordinary or Equilibrium")
Estimator = error.ParseKargs(kargs, "Estimator",
'Likelihood', estimator_type)
NbIteration = kargs.get("NbIteration", I_DEFAULT)
error.CheckType([NbIteration], [int])
InitialInterEvent = kargs.get("InitialInterEvent", None)
error.CheckType([InitialInterEvent], [[type(None), _DiscreteParametricModel,
_DiscreteMixture, _Convolution, _Compound]])
EquilibriumEstimator = error.ParseKargs(kargs, "EquilibriumEstimator",
'CompleteLikelihood', estimator_semi_markov_type)
InterEventMean = error.ParseKargs(kargs, "InterEventMean",
'Computed', mean_computation_map)
Penalty = error.ParseKargs(kargs, "Penalty", "SecondDifference",
smoothing_penalty_type)
Outside = error.ParseKargs(kargs, "Outside", "Zero", outside_type)
Weight = kargs.get("Weight", -1.)
error.CheckType([Weight], [[int, float]])
if Type != 'e':
if kargs.get("EquilibriumEstimator"):
raise Exception("EquilibriumEstimator cannot be used with type='e'")
if kargs.get("InterEventMean"):
raise Exception("InterEventMean be used with type='e'")
if Estimator == estimator_type['PenalizedLikelihood']:
if kargs.get("InterEventMean") is None:
InterEventMean = ONE_STEP_LATE
elif InterEventMean == COMPUTED:
raise ValueError("""
Incompatible options Estimator and InterEventMean""")
else:
if kargs.get("Penalty"):
raise ValueError("""Incompatible options Penalty with type o""")
if kargs.get("Weight"):
raise ValueError("""Incompatible options Weight with type o""")
if kargs.get("Outside"):
raise ValueError("""Incompatible options Outside with type o""")
if InitialInterEvent:
#cast from InitialInterEvent to Mixture, Compound should be done
if isinstance(InitialInterEvent, _DiscreteParametricModel):
InitialInterEvent = _DiscreteParametric(InitialInterEvent)
else:
InitialInterEvent = _Distribution(InitialInterEvent)
renew = obj.estimation_inter_event_type(Type, InitialInterEvent,
Estimator, NbIteration,
EquilibriumEstimator,
InterEventMean, Weight,
Penalty, Outside)
else:
renew = obj.estimation_type(Type, Estimator, NbIteration,
EquilibriumEstimator, InterEventMean ,
Weight, Penalty, Outside)
return renew
def _estimate_renewal_interval_data(obj, **kargs):
"""
Estimate switch renewal_count_data
.. todo:: to be completed and validated with tests
see stat_func4 in aml
"""
#only LIKELIHOOD and PENALIZED_LIKELIHOOD
Estimator = error.ParseKargs(kargs, "Estimator",
'Likelihood', estimator_type)
NbIteration = kargs.get("NbIteration", I_DEFAULT)
error.CheckType([NbIteration], [int])
# distribution
InitialInterEvent = kargs.get("InitialInterEvent", None)
error.CheckType([InitialInterEvent], [[type(None), _DiscreteParametricModel,
_DiscreteMixture, _Convolution, _Compound]])
if isinstance(InitialInterEvent, _DiscreteParametricModel):
InitialInterEvent = _DiscreteParametric(InitialInterEvent)
else:
InitialInterEvent = _Distribution(InitialInterEvent)
#cast initialInterEvent to parametric ?
Penalty = error.ParseKargs(kargs, "Penalty", "SecondDifference",
smoothing_penalty_type)
Weight = kargs.get("Weight", D_DEFAULT)
error.CheckType([Weight], [[int, float]])
Outside = error.ParseKargs(kargs, "Outside", "Zero", outside_type)
error.CheckType([Weight], [[int, float]])
InterEventMean = error.ParseKargs(kargs, "InterEventMean",
'Computed', mean_computation_map)
if Estimator == estimator_type['PenalizedLikelihood']:
if kargs.get("InterEventMean") is None:
InterEventMean = ONE_STEP_LATE
elif InterEventMean == COMPUTED:
raise ValueError("""
Incompatible options Estimator and InterEventMean""")
else:
if kargs.get("Penalty"):
raise ValueError("""Incompatible options Penalty with type o""")
if kargs.get("Weight"):
raise ValueError("""Incompatible options Weight with type o""")
if kargs.get("Outside"):
raise ValueError("""Incompatible options Outside with type o""")
if isinstance(obj, _FrequencyDistribution):
if InitialInterEvent:
renew = obj.estimation_inter_event(InitialInterEvent,
Estimator, NbIteration,
InterEventMean, Weight,
Penalty, Outside)
else:
renew = obj.estimation(Estimator, NbIteration,
InterEventMean ,
Weight, Penalty, Outside)
else:
if InitialInterEvent:
renew = obj.estimation_inter_event(InitialInterEvent,
Estimator, NbIteration,
InterEventMean, Weight,
Penalty, Outside)
else:
renew = obj.estimation(Estimator, NbIteration,
InterEventMean ,
Weight, Penalty, Outside)
return renew
def Tops(*args, **kargs):
"""Construction of a set of sequences from multidimensional arrays of
integers, from data generated by a renewal process or from an ASCII file.
The data structure of type array(array(array(int))) should be constituted
at the most internal level of arrays of constant size. If the optional
argument IndexParameter is set at "Position" or "Time", the data
structure of type array(array(array(int))) is constituted at the most
internal level of arrays of size 1+n (index parameter, n variables attached
to the explicit index parameter). If the optional argument IndexParameter
is set at "Position", only the index parameter of the last array of size
1+n is considered and the first component of successive elementary arrays
(representing the index parameter) should be increasing. If the optional
argument IndexParameter is set at "Time", the first component of successive
elementary arrays should be strictly increasing.
:Parameters:
* array1 (array(array(int))): input data for univariate sequences
* arrayn (array(array(array(int)))): input data for multivariate sequences,
* timev (renewal_data), file_name (string).
:Optional Parameters:
* Identifiers (array(int)): explicit identifiers of sequences. This optional
argument can only be used if the first argument is of type
array(array(int/array(int))).
* IndexParameter (string): type of the explicit index parameter: "Position"
or "Time" (the default: implicit discrete index parameter starting at 0).
This optional argument can only be used if the first argument is of type
array(array(int/array(int))).
:Returns:
If the construction succeeds, an object of type sequences or
discrete_sequences is returned, otherwise no object is returned. The
returned object is of type discrete_sequences if all the variables are
of type STATE, if the possible values for each variable are consecutive
from 0 and if the number of possible values for each variable is <= 15.
:Examples:
.. doctest::
:options: +SKIP
>>> Tops(array1, Identifiers=[1, 8, 12])
>>> Tops(arrayn, Identifiers=[1, 8, 12], IndexParameter="Position")
>>> Tops(timev)
>>> Tops(file_name)
.. seealso::
:class:`~openalea.stat_tool.output.Save`,
:func:`~openalea.sequence_analysis.data_transform.AddAbsorbingRun`,
:func:`~openalea.stat_tool.cluster.Cluster`,
:func:`~openalea.sequence_analysis.data_transform.Cumulate`,
:func:`~openalea.sequence_analysis.data_transform.Difference`,
:func:`~openalea.sequence_analysis.data_transform.IndexParameterExtract`,
:func:`~openalea.sequence_analysis.data_transform.LengthSelect`,
:func:`~openalea.stat_tool.data_transform.Merge`,
:func:`~openalea.stat_tool.data_transform.MergeVariable`,
:func:`~openalea.sequence_analysis.data_transform.MovingAverage`,
:func:`~openalea.sequence_analysis.data_transform.RecurrenceTimeSequences`,
:func:`~openalea.sequence_analysis.data_transform.RemoveRun`,
:func:`~openalea.sequence_analysis.data_transform.Reverse`,
:func:`~openalea.sequence_analysis.data_transform.SegmentationExtract`,
:func:`~openalea.stat_tool.data_transform.SelectIndividual`,
:func:`~openalea.stat_tool.data_transform.SelectVariable`,
:func:`~openalea.stat_tool.data_transform.Shift`,
:func:`~openalea.stat_tool.cluster.Transcode`,
:func:`~openalea.stat_tool.data_transform.ValueSelect`,
:func:`~openalea.sequence_analysis.data_transform.VariableScaling`.
:func:`~openalea.stat_tool.data_transform.ExtractHistogram`,
:func:`~openalea.sequence_analysis.data_transform.ExtractVectors`,
:func:`~openalea.sequence_analysis.correlation.ComputeCorrelation`,
:func:`~openalea.sequence_analysis.correlation.ComputePartialAutoCorrelation`,
:func:`~openalea.sequence_analysis.data_transform.ComputeSelfTransition`,
:func:`~openalea.sequence_analysis.compare.Compare`,
:func:`~openalea.sequence_analysis.estimate.Estimate`,
:func:`ComputeStateTops`,
:func:`~openalea.sequence_analysis.simulate.Simulate`.
"""
error.CheckArgumentsLength(args, 1, 1)
index_parameter = error.ParseKargs(kargs, "IndexParameter",
"IMPLICIT_TYPE",
index_parameter_type_map)
Identifiers = error.ParseKargs(kargs, "Identifiers", None)
if isinstance(args[0], str):
#todo: add True, False instead or as well as Current, Old
#todo: !!! OldFormat set to True does not work in CPP code
OldFormat = error.ParseKargs(kargs, "Format", "Old", {
"Current": False,
"Old": True
})
filename = args[0]
if os.path.isfile(filename):
return _Tops(filename, OldFormat)
else:
raise IOError("bad file name")
elif isinstance(args[0], _Sequences):
raise NotImplemented
#return _Tops(args[0])
elif isinstance(args[0], list):
error.CheckType([Identifiers], [list])
if kargs.get("IndexParameter"):
if Identifiers:
return _Tops(args[0], Identifiers, index_parameter)
else:
return _Tops(args[0], range(0, len(args[0])), index_parameter)
else:
raise ValueError("wrong arguments ?")
else:
raise TypeError("""Expected a valid filename or a list of
lists (e.g., [[1,0],[0,1]])""")
def Sequences(obj, **kargs):
"""Construction of a set of sequences from multidimensional arrays
of integers, from data generated by a renewal process or from an
ASCII file.
The data structure of type array(array(array(int))) should be
constituted at the most internal level of arrays of constant size. If the
optional argument IndexParameter is set at "Position" or "Time", the data
structure of type array(array(array(int))) is constituted at the most
internal level of arrays of size 1 + n (index parameter, n variables
attached to the explicit index parameter). If the optional argument
IndexParameter is set at "Position", only the index parameter of the
last array of size 1 + n is considered and the first component of successive
elementary arrays (representing the index parameter) should be
ncreasing. If the optional argument IndexParameter is set at "Time", the
first component of successive elementary arrays should be strictly
increasing.
:Parameters:
* array1 (array(array(int))): input data for univariate sequences
* arrayn (array(array(array(int)))): input data for multivariate sequences,
* timev (renewal_data),
* file_name (string).
:Optional Parameters:
* Identifiers (array(int)): explicit identifiers of sequences. This
optional argument can only be used if the first argument is of
type array(array(int / array(int))).
* VertexIdentifiers (array(array(int))): explicit identifiers of vectors.
* IndexParameter (string): type of the explicit index parameter: "Position"
or "Time" (the default: implicit discrete index parameter starting at 0).
This optional argument can only be used if the first argument is of type
array(array(int / array(int))).
.. todo:: IndexParameterType
:Returns:
If the construction succeeds, an object of type sequences or
discrete_sequences is returned, otherwise no object is returned. The
returned object is of type discrete_sequences if all the variables are of
type STATE, if the possible values for each variable are consecutive from 0
and if the number of possible values for each variable is <= 15.
:Examples:
.. doctest::
>>> # Single univariate sequence case (array1).
>>> seq1 = Sequences([1, 2, 3], Identifiers=[8])
>>> seq1.nb_sequence
1
>>> seq1.nb_variable
1
>>> # General case arrayn
>>> seq = Sequences([
... [[1,2],[3,4]],
... [[21,22],[23,24]],
... [[31,32],[33,34], [35,36] ]],
... Identifiers = [1,8,12],
... VertexIdentifiers = [[1,2],[3,4],[5,6,7]])
>>> seq.nb_sequence
3
>>> seq.nb_variable
2
>>> seq.max_length
3
.. doctest::
:options: +SKIP
>>> Sequences(timev)
>>> Sequences(file_name)
.. seealso::
:class:`~openalea.stat_tool.output.Save`,
:func:`~openalea.sequence_analysis.data_transform.AddAbsorbingRun`,
:func:`~openalea.stat_tool.cluster.Cluster`,
:func:`~openalea.sequence_analysis.data_transform.Cumulate`,
:func:`~openalea.sequence_analysis.data_transform.Difference`,
:func:`~openalea.sequence_analysis.data_transform.IndexParameterExtract`,
:func:`~openalea.sequence_analysis.data_transform.LengthSelect`,
:func:`~openalea.stat_tool.data_transform.Merge`,
:func:`~openalea.stat_tool.data_transform.MergeVariable`,
:func:`~openalea.sequence_analysis.data_transform.MovingAverage`,
:func:`~openalea.sequence_analysis.data_transform.RecurrenceTimeSequences`,
:func:`~openalea.sequence_analysis.data_transform.RemoveRun`,
:func:`~openalea.sequence_analysis.data_transform.Reverse`,
:func:`~openalea.sequence_analysis.data_transform.SegmentationExtract`,
:func:`~openalea.stat_tool.data_transform.SelectIndividual`,
:func:`~openalea.stat_tool.data_transform.SelectVariable`,
:func:`~openalea.stat_tool.data_transform.Shift`,
:func:`~openalea.stat_tool.cluster.Transcode`,
:func:`~openalea.stat_tool.data_transform.ValueSelect`,
:func:`~openalea.sequence_analysis.data_transform.VariableScaling`.
:func:`~openalea.stat_tool.data_transform.ExtractHistogram`,
:func:`~openalea.sequence_analysis.data_transform.ExtractVectors`,
:func:`~openalea.sequence_analysis.correlation.ComputeCorrelation`,
:func:`~openalea.sequence_analysis.correlation.ComputePartialAutoCorrelation`,
:func:`~openalea.sequence_analysis.data_transform.ComputeSelfTransition`,
:func:`~openalea.sequence_analysis.compare.Compare`,
:func:`~openalea.sequence_analysis.estimate.Estimate`,
:func:`~openalea.sequence_analysis.data_transform.ComputeStateSequences`,
:func:`~openalea.sequence_analysis.simulate.Simulate`.
"""
import numpy
sequence = None
error.CheckType([obj], [[str, _RenewalData, list]])
if isinstance(obj, str):
filename = obj
if os.path.isfile(filename):
OldFormat = error.ParseKargs(kargs, "OldFormat", False, bool_type)
sequence = _Sequences(filename, OldFormat)
else:
raise IOError("bad file name %s" % filename)
if hasattr(sequence, 'markovian_sequences'):
try:
sequence = sequence.markovian_sequences()
except Exception:
pass
try:
sequence.nb_sequence
except ValueError:
raise ValueError("File read but issue while parsing. Returned sequence is not valid")
return sequence
elif isinstance(obj, _RenewalData):
sequence = _Sequences(obj)
if hasattr(sequence, 'markovian_sequences'):
try:
sequence = sequence.markovian_sequences()
except Exception:
pass
return sequence
# otherwise, we switch to a list constructor that requires a list of seqs
# transform input into array of arrays of arrays
# case 1: general case where input = [[[1,2],[3,4]],[[1,2],[3,4], [5,6]]] nothing to do
# case 2: univariate single sequence, input = [1,2,3,4,5,6] so it is [[[1],[2],[3],...]]
# case 3: univariate sequences input = [[1,2],[3,4],[5,6,7]] (i.e, different vector sizes)
# case 4: multivariate sequence input = [[1,2],[3,4],[5,6]]
Verbose = error.ParseKargs(kargs, "Verbose", False)
Univariate = error.ParseKargs(kargs, "Univariate", False)
if type(obj)==list:
first_sequence = obj[0]
if (type(first_sequence) in [int, float]):
obj = [[[x] for x in obj]]
if Verbose:print 'this is a single univariate sequence'
elif type(first_sequence)==list:
#either a single multivariate sequence ot general case of several sequences multivariates
if type(first_sequence[0]) == list:
if Verbose: print 'this is the general case, nothing to do'
elif type(first_sequence[0]) in [int, float]:
lengths = numpy.array([len(x) for x in obj])
if lengths.var()==0:
if Verbose:print 'this is the ambiguous case'
if lengths[0]<5 and Univariate==False:
if Verbose:print 'this is 1 single multivariate sequence'
obj = [obj]
else:
if Verbose:print 'this is univariate sequences'
res = []
for x in obj:
res.append([[y] for y in x])
obj = res
else:
if Verbose:print 'this is univariate sequences'
res = []
for x in obj:
res.append([[y] for y in x])
obj = res
else:
print SyntaxError('wrong syntax for input object')
# 0 for int, 1 for float. By default all variables are int
#now, we loop over all sequences and sequences and if a variable
# is found to be float, then the type is float.
# once a float is found, there is no need to carry on the current variable
InputTypes = [0] * len(obj[0][0])
nb_variables = len(obj[0][0])
for seq in obj:
for vec in seq:
for index, var in enumerate(vec):
assert type(var) in [int, float], "wrong types var=%s and its type is %s" % (var, type(var))
if type(var)==float:
InputTypes[index]=1
from openalea.sequence_analysis._sequence_analysis import TIME, POSITION, \
IMPLICIT_TYPE
#error.CheckArgumentsLength(args, 1, 1)
IndexParameterType = error.ParseKargs(kargs, "IndexParameterType", "IMPLICIT_TYPE", index_parameter_type_map)
IndexParameter = error.ParseKargs(kargs, "IndexParameter", [])
Identifiers = error.ParseKargs(kargs, "Identifiers", [])
VertexIdentifiers = error.ParseKargs(kargs, "VertexIdentifiers", [])
# build up a list of unique identifiers if none is provided
lengths=[]
for seq in obj:
lengths.append(len(seq))
# all values must be positive strictly
if len(Identifiers)>0:
assert len([x for x in Identifiers if x<=0]) == 0
else:
#create a standard identifiers list [0,1,2,....]
for i, seq in enumerate(obj):
Identifiers.append(i)
# build up a list of unique vertex identifiers if none is provided
if len(VertexIdentifiers)>0:
assert len([x for x in VertexIdentifiers if x<=0]) == 0
else:
#create a standard identifiers list [0,1,2,....] for each sequences ?
index = 0
for i, seq in enumerate(obj):
VertexIdentifiers.append([])
for vec in seq:
VertexIdentifiers[i].append(index)
index+=1
# check unicity of vertex identifiers
idents = []
for seq in VertexIdentifiers:
for ident in seq:
idents.append(ident)
assert len(set(idents)) == len(idents), "ERROR, VertexIdentifiers must be made of unique identifiers (for each vector)"
# check unicity of identifiers
idents = []
for ident in Identifiers:
idents.append(ident)
assert len(set(idents)) == len(idents), "ERROR, Identifiers must be made of unique identifiers (for each sequence)"
if len(IndexParameter)==0:
index = 0
for i, seq in enumerate(obj):
IndexParameter.append([])
for vec in seq:
IndexParameter[i].append(index)
index+=1
if IndexParameterType==POSITION:
IndexParameter[i].append(index)
index+=1
for i, seq in enumerate(obj):
#print len(seq), len(IndexParameter)
if IndexParameterType==POSITION:
assert len(seq)==len(IndexParameter[i])-1, "ERROR, wrong IndexParameterLength. When ParameterType=POSITION, ParameterIndex length must be equla to the sequence length +1"
else:
assert len(seq)==len(IndexParameter[i]), "ERROR, wrong IndexParameterLength. ParameterIndex length must be equal to the sequence length."
#todo check that indesparameter length is correct (length of vectors +1 if position)
valid_param = [POSITION, TIME, IMPLICIT_TYPE]
if IndexParameterType not in valid_param:
raise ValueError("""IndexParameter can be only %s if first
argument is a list""" % valid_param)
sequence = _Sequences(obj, Identifiers, VertexIdentifiers, IndexParameter, InputTypes, IndexParameterType)
if hasattr(sequence, 'markovian_sequences'):
try:
sequence = sequence.markovian_sequences()
except Exception:
pass
return sequence
def Renewal(*args, **kargs):
"""Renewal
Construction of a (either ordinary or equilibrium) renewal process from an inter-event distribution or from an ASCII file.
:Usage:
.. doctest::
:options: +SKIP
>>> Renewal("BINOMIAL", inf_bound, sup_bound, proba, Type="Equilibrium", ObservationTime=40)
>>> Renewal("POISSON", inf_bound, param, Type="Equilibrium", ObservationTime=40)
>>> Renewal("NEGATIVE_BINOMIAL", inf_bound, param, proba, Type="Equilibrium", ObservationTime=40)
>>> Renewal(inter_event, Type="Equilibrium", ObservationTime=40)
>>> Renewal(file_name, Type="Equilibrium", ObservationTime=40)
:Arguments:
* inf_bound (int): lower bound to the range of possible values (shift parameter),
* sup_bound (int): upper bound to the range of possible values (only relevant for binomial or uniform distributions),
* param (int, real): parameter of either the Poisson distribution or the negative binomial distribution.
* proba (int, real): probability of 'success' (only relevant for binomial or negative binomial distributions).
.. note:: the names of the parametric discrete distributions can be summarized by their first letters: "B" ("BINOMIAL"), "P" ("POISSON"), "NB" ("NEGATIVE_BINOMIAL").
* inter_event (distribution, mixture, convolution, compound): inter-event distribution,
* file_name (string).
:Optional Arguments:
* Type (string): type of renewal process: "Ordinary" or "Equilibriun" (the default).
* ObservationTime (int): length of the observation period for the computation of the intensity and counting distributions (default value: 20),
:Returned Object:
If the construction succeeds, an object of type renewal is returned, otherwise no object is returned.
:Background:
A renewal process is built from a discrete distribution termed the inter-event
distribution which represents the time interval between consecutive events. Two types
of renewal processes are available:
* ordinary renewal process where the start of the observation period coincides
with the occurrence time of an event (synchronism assumption),
* equilibrium or stationary renewal process where the start of the observation
period is independent of the process which generates the data (asynchronism
assumption).
In the case where the arguments are the name and the parameters of the inter-event \
distribution, the constraints on parameters described in the definition of the syntactic
form of the type distribution apply (cf. File Syntax).
.. seealso::
:func:`~openalea.stat_tool.output.Save`,
:func:`~openalea.sequence_analysis.simulate.Simulate` (renewal process)
.. todo :: ident should correspond to Binomail,B, NegativeBinomial and so on
"""
#todo: move this enym to enumerate.py
type_map = {
"Equilibrium":'e',
"Ordinary": 'o'
}
Type = error.ParseKargs(kargs, "Type", "Equilibrium", type_map)
ObservationTime = kargs.get("ObservationTime", DEFAULT_TIME)
Scale = kargs.get("Scale", None) #todo check default values !
a = [str]
a.extend(model_distribution_types)
error.CheckType([args[0]], [a])
# a filename constructor. check that only one argument, which is a string
# ------------------ todo ----------- not tested
if len(args)==1 and isinstance(args[0], str):
filename = args[0]
if os.path.isfile(filename):
renewal = _Renewal(filename)
else:
raise IOError("bad file name")
# otherwise, we switch to a constructor from a distribution
elif isinstance(args[0], str):
if args[0] == "BINOMIAL" or args[0] == "B":
error.CheckArgumentsLength(args, 4, 4)
error.CheckType([args[1], args[2], args[3]],
[int, int, [int, float]])
inf_bound = args[1]
sup_bound = args[2]
probability = args[3]
parameter = -1
elif args[0] == "NEGATIVE_BINOMIAL" or args[0] == "NB":
error.CheckArgumentsLength(args, 4, 4)
error.CheckType([args[1], args[2], args[3]],
[int, [int, float], [int, float]])
inf_bound = args[1]
sup_bound = -1
parameter = args[2]
probability = args[3]
elif args[0] == "POISSON" or args[0] == "P":
error.CheckArgumentsLength(args, 4, 4)
error.CheckType([args[1], args[2], args[3]],
[int, [float, int], [int, float]])
inf_bound = args[1]
sup_bound = -1
parameter = args[2]
probability = args[3]
else:
raise NotImplemented("""case not implemented. First arg must be a
valid filename or a "BINOMIAL", "NEGATIVE_BINOMIAL, or "POISSON"
""")
# if all keys in distribution_identifier_type are used, we can move this
# piece of call before the if and remove the NotImplemented above
ident = distribution_identifier_type[args[0]]
RENEWAL_THRESHOLD = 1.
inter_event = _DiscreteParametric(ident , inf_bound , sup_bound , parameter ,
probability , RENEWAL_THRESHOLD)
if Scale:
error.CheckType([Scale], [float])
scaled_inter_event = _DiscreteParametric(inter_event , Scale)
renewal = _Renewal(scaled_inter_event , Type , ObservationTime)
else:
renewal = _Renewal(inter_event , Type , ObservationTime)
# renewal = _Renewal(args[0], range(0,len(args[0])),
# index_parameter_type) or may be provided by the user.
elif type(args[0]) in model_distribution_types:
renewal = _Renewal(_DiscreteParametric(args[0]), Type, ObservationTime)
return renewal
def HiddenSemiMarkov(*args, **kargs):
"""HiddenSemiMarkov
Construction of an object of type hidden_semi-markov from an ASCII file.
:Usage:
.. doctest::
:options: +SKIP
>>> HiddenSemiMarkov(file_name, Length=40, Counting=False)
:Arguments:
file_name (string)
:Optional Arguments:
* Length (int): length of sequences for the computation of the intensity
and counting characteristic distributions (default value: 20),
* Counting (bool): computation of counting characteristic distributions
(default value: True).
:Returned Object:
If the construction succeeds, an object of type hidden_semi-markov is
returned, otherwise no object is returned.
:Background:
A hidden semi-Markov chain is constructed from an underlying semi-Markov
chain (first-order Markov chain representing transition between distinct
states and state occupancy distributions associated to the nonabsorbing
states) and nonparametric observation (or state-dependent) distributions.
The state occupancy distributions are defined as object of type distribution
with the additional constraint that the minimum time spent in a given
state is 1 (inf_bound <= 1).
.. seealso::
:func:`~openalea.sequence_analysis.compare.Compare` (Markovian models for sequences),
:func:`~openalea.sequence_analysis.estimate.Estimate` (Markovian models),
:func:`~openalea.sequence_analysis.data_transform.ComputeStateSequences`,
:func:`~openalea.sequence_analysis.simulate.Simulate` (Markovian models).
"""
Length = kargs.get("Length", DEFAULT_LENGTH)
CountingFlag = kargs.get("Counting", True)
OldFormat = error.ParseKargs(kargs, "Format", "Current", {
"Current": False,
"Old": True
})
error.CheckArgumentsLength(args, 1, 1)
error.CheckType([args[0], Length, CountingFlag, OldFormat],
[str, int, bool, bool])
filename = args[0]
if os.path.isfile(filename):
hsm = _HiddenSemiMarkov(filename, Length, CountingFlag,
OCCUPANCY_THRESHOLD, OldFormat)
else:
raise IOError("bad file name %s" % filename)
return hsm
def Simulate(obj, *args, **kargs):
"""Simulate
* Generation of a random sample from a distribution.
* Generation of a random sample from a renewal process.
* Generation of a sample of sequences from a (hidden) Markovian process.
* Generation of 'tops' from 'top' parameters.
:Usage:
.. doctest::
:options: +SKIP
>>> Simulate(dist, size)
>>> Simulate(mixt, size)
>>> Simulate(convol, size)
>>> Simulate(compound, size)
>>> Simulate(renew, type, time_histo)
>>> Simulate(renew, type, size, time)
>>> Simulate(renew, type, size, timev)
>>> Simulate(markov, length_histo)
>>> Simulate(markov, size, length)
>>> Simulate(markov, size, seq)
>>> Simulate(semi_markov, length_histo, Counting=False)
>>> Simulate(semi_markov, size, length, Counting=False)
>>> Simulate(semi_markov, size, seq, Counting=False)
>>> Simulate(top_param, size, nb_trial, NbAxillary=2)
:Arguments (distribution case):
* dist (distribution),
* mixt (mixture),
* convol (convolution),
* compound (compound),
* size (int): sample size.
:Arguments (renewal case):
* renew (renewal),
* type (string): type of renewal process: "Ordinary" or "Equilibriun",
* time_histo (histogram, mixture_data, convolution_data, compound_data):
frequency distribution of the length of the observation period,
* size (int): sample size,
* time (int): length of the observation period,
* timev (time_events, renewal_data),
:Arguments (markovian case):
* markov (markov, hidden_markov),
* semi_markov (semi-markov, hidden_semi-markov),
* length_histo (histogram, mixture_data, convolution_data, compound_data):
frequency distribution of sequence lengths,
* size (int): sample size,
* length (int): sequence length,
* seq (discrete_sequences, markov_data, semi-markov_data),
:Arguments (top case):
* top_param (top_parameters),
* size (int): sample size,
* nb_trial (int): number of Bernoulli trials for the growth of the parent shoot,
:Optional Arguments:
* Counting (bool): computation of counting distributions (default value: True).
* NbAxillary (int): number of offspring shoots per node (default value: 1,
should be < 4).
:Returned Object:
* If the first argument is of type distribution and if 0 < size < 1000000,
an object of type HISTOGRAM is returned, otherwise no object is returned.
* If the first argument is of type mixture and if 0 < size < 1000000, an
object of type mixture_data is returned, otherwise no object is returned.
* If the first argument is of type convolution and if 0 < size < 1000000,
an object of type convolution_data is returned, otherwise no object is returned.
* If the first argument is of type compound and if 0 < size < 1000000, an
object of type compound_data is returned, otherwise no object is returned.
* The returned object of type HISTOGRAM, mixture_data, convolution_data or
compound_data contains both the simulated sample and the model used for
simulation.
* If 0 < (sample size) < 1000000, if (minimum length of the observation
period) > 2 and if (maximum length of the observation period) XX 1000,
an object of type renewal_data is returned, otherwise no object is
returned. The returned object contains both the simulated sample (not
only count data but also time sequences) and the model used for simulation.
* If the first argument is of type markov or hidden_markov, if 0 < (sample size)
< 100000, if (minimum sequence length) < 2, if (maximum sequence length) <
1000 and if (cumulative sequence length) < 1000000, an object of type
markov_data is returned, otherwise no object is returned.
* If the first argument is of type semi-markov or hidden_semi-markov, if
0 < (sample size) < 100000, if (minimum sequence length) < 2, if (maximum
sequence length) < 1000 and if (cumulative sequence length) < 1000000, an
object of type semi-markov_data is returned, otherwise no object is returned.
* The returned object contains both the simulated sequences and the model
used for simulation.
* If 0 < size < 100000 and if 0 < nb_trial < 1000, an object of type tops
is returned, otherwise no object is returned. The returned object contains
both the simulated 'tops' and the model used for simulation.
:Description:
If the fourth argument is of type time_events or renewal_data, the simulated
sample has the same distribution of length of the observation period than
the original sample given by this fourth argument. This simulation mode is
particularly useful to study the effects of length biasing.
If the third argument is of type discrete_sequences, markov_data or
semi-markov_data, the simulated sequences has the same length distribution
than the original sample given by this third argument. This simulation
mode is particularly useful to study the effects of length biasing.
.. seealso::
:func:`~openalea.stat_tool.distribution.Distribution`,
:func:`~openalea.stat_tool.mixture.Mixture`,
:func:`~openalea.stat_tool.convolution.Convolution`,
:func:`~openalea.stat_tool.compound.Compound`,
:func:`~openalea.stat_tool.data_transform.ExtractHistogram`.
:func:`~openalea.sequence_analysis.semi_markov.SemiMarkov`,
:func:`~openalea.sequence_analysis.hidden_semi_markov.HiddenSemiMarkov`,
:func:`~openalea.sequence_analysis.renewal.Renewal`,
:func:`~openalea.sequence_analysis.top_parameters.TopParameters`,
"""
_valid_dists = [_FrequencyDistribution, _DiscreteMixtureData, \
_ConvolutionData, _CompoundData]
# standard distribution case
if len(args) == 1 and isinstance(args[0], int):
return SimulateDistribution(obj, args[0])
# top parameters case
#elif isinstance(obj, _TopParameters):
#error.CheckArgumentsLength(args, 2, 2)
#NbAxillary = kargs.get("NbAxillary", 1)
#error.CheckType([args[0], args[1], NbAxillary], [int, int, int])
#return obj.simulate(args[0], args[1], NbAxillary)
# Renewal case
elif isinstance(obj, _Renewal):
# check that args[0] is a correct key
Type = error.CheckDictKeys(args[0], stochastic_process_type)
error.CheckType([args[1]], [[_FrequencyDistribution, _DiscreteMixtureData, \
_ConvolutionData, _CompoundData, int]])
if type(args[1]) in _valid_dists:
ret = obj.simulation_histogram(Type, args[1])
elif isinstance(args[1], int):
error.CheckType([args[2]], [[int, _TimeEvents]])
if isinstance(args[2], int):
ret = obj.simulation_nb_elements(Type, args[1], args[2])
else:
ret = obj.simulation_time_events(Type, args[1], args[2])
return ret
# other cases (Markovian, semi_markov, hidden_semi_markov and so on
else:
error.CheckType([obj], [[
_VariableOrderMarkov, _SemiMarkov, _HiddenVariableOrderMarkov,
_NonHomogeneousMarkov, _HiddenSemiMarkov
]])
Counting = error.ParseKargs(kargs, "Counting", True, bool_type)
if type(obj) not in [_SemiMarkov, _HiddenSemiMarkov]:
Counting = True
#order of the if statements is important ! Keep it that way
if isinstance(args[0], int) and isinstance(args[1], int):
ret = obj.simulation_nb_elements(args[0], args[1], Counting)
#here the second arguments is data structure such as Sequences
elif isinstance(args[0], int):
error.CheckType([args[1]], [[
_MarkovianSequences, _VariableOrderMarkovData, _SemiMarkovData,
_NonHomogeneousMarkovData
]])
ret = obj.simulation_markovian_sequences(args[0], args[1],
Counting)
# first argument is a compound_data or equivalent
else:
error.CheckType([args[0]], [_valid_dists])
ret = obj.simulation_histogram(args[0], Counting, False)
return ret
