Python Method Index

a | c | e | p


	a
	`Arms`
	`Arms.Arm.Arm.__init__()`
	`Arms.Arm.Arm.__repr__()`
	`Arms.Arm.Arm.__str__()`
	`Arms.Arm.Arm.draw()`
	`Arms.Arm.Arm.draw_nparray()`
	`Arms.Bernoulli.Bernoulli.__init__()`
	`Arms.Bernoulli.Bernoulli.__repr__()`
	`Arms.Bernoulli.Bernoulli.__str__()`
	`Arms.Bernoulli.Bernoulli.draw()`
	`Arms.Bernoulli.Bernoulli.draw_nparray()`
	`Arms.Binomial.Binomial.__init__()`
	`Arms.Binomial.Binomial.__repr__()`
	`Arms.Binomial.Binomial.__str__()`
	`Arms.Binomial.Binomial.draw()`
	`Arms.Binomial.Binomial.draw_nparray()`
	`Arms.Binomial.Binomial.kl()`
	`Arms.Binomial.Binomial.oneLR()`
	`Arms.Constant.Constant.__init__()`
	`Arms.Constant.Constant.__repr__()`
	`Arms.Constant.Constant.__str__()`
	`Arms.Constant.Constant.draw()`
	`Arms.Constant.Constant.draw_nparray()`
	`Arms.DiscreteArm.DiscreteArm.__init__()`
	`Arms.DiscreteArm.DiscreteArm.__repr__()`
	`Arms.DiscreteArm.DiscreteArm.__str__()`
	`Arms.DiscreteArm.DiscreteArm.draw()`
	`Arms.DiscreteArm.DiscreteArm.draw_nparray()`
	`Arms.Exponential.Exponential.__init__()`
	`Arms.Exponential.Exponential.__repr__()`
	`Arms.Exponential.Exponential.__str__()`
	`Arms.Exponential.Exponential.draw()`
	`Arms.Exponential.Exponential.draw_nparray()`
	`Arms.Exponential.Exponential.oneHOI()`
	`Arms.Exponential.ExponentialFromMean.__init__()`
	`Arms.Exponential.UnboundedExponential.__init__()`
	`Arms.Gamma.Gamma.__init__()`
	`Arms.Gamma.Gamma.__repr__()`
	`Arms.Gamma.Gamma.__str__()`
	`Arms.Gamma.Gamma.draw()`
	`Arms.Gamma.Gamma.draw_nparray()`
	`Arms.Gamma.Gamma.kl()`
	`Arms.Gamma.Gamma.oneHOI()`
	`Arms.Gamma.Gamma.oneLR()`
	`Arms.Gamma.GammaFromMean.__init__()`
	`Arms.Gamma.UnboundedGamma.__init__()`
	`Arms.Gaussian.Gaussian.__init__()`
	`Arms.Gaussian.Gaussian.__repr__()`
	`Arms.Gaussian.Gaussian.__str__()`
	`Arms.Gaussian.Gaussian.draw()`
	`Arms.Gaussian.Gaussian.draw_nparray()`
	`Arms.Gaussian.Gaussian.kl()`
	`Arms.Gaussian.Gaussian.oneHOI()`
	`Arms.Gaussian.Gaussian.oneLR()`
	`Arms.Gaussian.Gaussian_0_1.__init__()`
	`Arms.Gaussian.Gaussian_0_10.__init__()`
	`Arms.Gaussian.Gaussian_0_100.__init__()`
	`Arms.Gaussian.Gaussian_0_2.__init__()`
	`Arms.Gaussian.Gaussian_0_5.__init__()`
	`Arms.Gaussian.Gaussian_m100_100.__init__()`
	`Arms.Gaussian.Gaussian_m10_10.__init__()`
	`Arms.Gaussian.Gaussian_m1_1.__init__()`
	`Arms.Gaussian.Gaussian_m2_2.__init__()`
	`Arms.Gaussian.Gaussian_m5_5.__init__()`
	`Arms.Gaussian.UnboundedGaussian.__init__()`
	`Arms.Gaussian.UnboundedGaussian.__repr__()`
	`Arms.Gaussian.UnboundedGaussian.draw()`
	`Arms.Gaussian.UnboundedGaussian.draw_nparray()`
	`Arms.Poisson.Poisson.__init__()`
	`Arms.Poisson.Poisson.__repr__()`
	`Arms.Poisson.Poisson.__str__()`
	`Arms.Poisson.Poisson.draw()`
	`Arms.Poisson.Poisson.draw_nparray()`
	`Arms.Poisson.UnboundedPoisson.__init__()`
	`Arms.UniformArm.UniformArm.__init__()`
	`Arms.UniformArm.UniformArm.__repr__()`
	`Arms.UniformArm.UniformArm.__str__()`
	`Arms.UniformArm.UniformArm.draw()`
	`Arms.UniformArm.UniformArm.draw_nparray()`

	c
	`complete_tree_exploration_for_MP_bandits`
	`complete_tree_exploration_for_MP_bandits.State.__hash__()`
	`complete_tree_exploration_for_MP_bandits.State.__init__()`
	`complete_tree_exploration_for_MP_bandits.State.__str__()`
	`complete_tree_exploration_for_MP_bandits.State.absorbing_states_one_depth()`
	`complete_tree_exploration_for_MP_bandits.State.all_absorbing_states()`
	`complete_tree_exploration_for_MP_bandits.State.all_deltas()`
	`complete_tree_exploration_for_MP_bandits.State.compute_one_depth()`
	`complete_tree_exploration_for_MP_bandits.State.copy()`
	`complete_tree_exploration_for_MP_bandits.State.explore_from_node_to_depth()`
	`complete_tree_exploration_for_MP_bandits.State.find_N_absorbing_states()`
	`complete_tree_exploration_for_MP_bandits.State.get_all_leafs()`
	`complete_tree_exploration_for_MP_bandits.State.get_unique_leafs()`
	`complete_tree_exploration_for_MP_bandits.State.has_absorbing_child_whole_subtree()`
	`complete_tree_exploration_for_MP_bandits.State.is_absorbing()`
	`complete_tree_exploration_for_MP_bandits.State.pretty_print_result_recursively()`
	`complete_tree_exploration_for_MP_bandits.State.proba_reaching_absorbing_state()`
	`complete_tree_exploration_for_MP_bandits.State.saveto()`
	`complete_tree_exploration_for_MP_bandits.State.to_dot()`
	`complete_tree_exploration_for_MP_bandits.State.to_node()`
	`complete_tree_exploration_for_MP_bandits.StateWithMemory.__hash__()`
	`complete_tree_exploration_for_MP_bandits.StateWithMemory.__init__()`
	`complete_tree_exploration_for_MP_bandits.StateWithMemory.__str__()`
	`complete_tree_exploration_for_MP_bandits.StateWithMemory.all_deltas()`
	`complete_tree_exploration_for_MP_bandits.StateWithMemory.copy()`
	`complete_tree_exploration_for_MP_bandits.StateWithMemory.is_absorbing()`
	`complete_tree_exploration_for_MP_bandits.StateWithMemory.to_node()`

	e
	`Environment`
	`Environment.Evaluator.Evaluator.__init__()`
	`Environment.Evaluator.Evaluator.__initEnvironments__()`
	`Environment.Evaluator.Evaluator.__initPolicies__()`
	`Environment.Evaluator.Evaluator._xlabel()`
	`Environment.Evaluator.Evaluator.compute_cache_rewards()`
	`Environment.Evaluator.Evaluator.getAllLastWeightedSelections()`
	`Environment.Evaluator.Evaluator.getAverageRewards()`
	`Environment.Evaluator.Evaluator.getAverageWeightedSelections()`
	`Environment.Evaluator.Evaluator.getBestArmPulls()`
	`Environment.Evaluator.Evaluator.getCumulatedRegret()`
	`Environment.Evaluator.Evaluator.getCumulatedRegret_LessAccurate()`
	`Environment.Evaluator.Evaluator.getCumulatedRegret_MoreAccurate()`
	`Environment.Evaluator.Evaluator.getLastRegrets()`
	`Environment.Evaluator.Evaluator.getLastRegrets_LessAccurate()`
	`Environment.Evaluator.Evaluator.getLastRegrets_MoreAccurate()`
	`Environment.Evaluator.Evaluator.getMaxMinReward()`
	`Environment.Evaluator.Evaluator.getMaxRewards()`
	`Environment.Evaluator.Evaluator.getMemoryConsumption()`
	`Environment.Evaluator.Evaluator.getPulls()`
	`Environment.Evaluator.Evaluator.getRewards()`
	`Environment.Evaluator.Evaluator.getRewardsSquared()`
	`Environment.Evaluator.Evaluator.getRunningTimes()`
	`Environment.Evaluator.Evaluator.getSTDRegret()`
	`Environment.Evaluator.Evaluator.plotBestArmPulls()`
	`Environment.Evaluator.Evaluator.plotHistoryOfMeans()`
	`Environment.Evaluator.Evaluator.plotLastRegrets()`
	`Environment.Evaluator.Evaluator.plotMemoryConsumption()`
	`Environment.Evaluator.Evaluator.plotRegrets()`
	`Environment.Evaluator.Evaluator.plotRunningTimes()`
	`Environment.Evaluator.Evaluator.printFinalRanking()`
	`Environment.Evaluator.Evaluator.printLastRegrets()`
	`Environment.Evaluator.Evaluator.printMemoryConsumption()`
	`Environment.Evaluator.Evaluator.printRunningTimes()`
	`Environment.Evaluator.Evaluator.saveondisk()`
	`Environment.Evaluator.Evaluator.startAllEnv()`
	`Environment.Evaluator.Evaluator.startOneEnv()`
	`Environment.EvaluatorMultiPlayers.EvaluatorMultiPlayers.__init__()`
	`Environment.EvaluatorMultiPlayers.EvaluatorMultiPlayers.__initEnvironments__()`
	`Environment.EvaluatorMultiPlayers.EvaluatorMultiPlayers.__initPlayers__()`
	`Environment.EvaluatorMultiPlayers.EvaluatorMultiPlayers.getAllLastWeightedSelections()`
	`Environment.EvaluatorMultiPlayers.EvaluatorMultiPlayers.getAllPulls()`
	`Environment.EvaluatorMultiPlayers.EvaluatorMultiPlayers.getBestArmPulls()`
	`Environment.EvaluatorMultiPlayers.EvaluatorMultiPlayers.getCentralizedNbSwitchs()`
	`Environment.EvaluatorMultiPlayers.EvaluatorMultiPlayers.getCentralizedRegret()`
	`Environment.EvaluatorMultiPlayers.EvaluatorMultiPlayers.getCentralizedRegret_LessAccurate()`
	`Environment.EvaluatorMultiPlayers.EvaluatorMultiPlayers.getCentralizedRegret_MoreAccurate()`
	`Environment.EvaluatorMultiPlayers.EvaluatorMultiPlayers.getCollisions()`
	`Environment.EvaluatorMultiPlayers.EvaluatorMultiPlayers.getFirstRegretTerm()`
	`Environment.EvaluatorMultiPlayers.EvaluatorMultiPlayers.getfreeTransmissions()`
	`Environment.EvaluatorMultiPlayers.EvaluatorMultiPlayers.getLastRegrets()`
	`Environment.EvaluatorMultiPlayers.EvaluatorMultiPlayers.getLastRegrets_LessAccurate()`
	`Environment.EvaluatorMultiPlayers.EvaluatorMultiPlayers.getLastRegrets_MoreAccurate()`
	`Environment.EvaluatorMultiPlayers.EvaluatorMultiPlayers.getMemoryConsumption()`
	`Environment.EvaluatorMultiPlayers.EvaluatorMultiPlayers.getNbSwitchs()`
	`Environment.EvaluatorMultiPlayers.EvaluatorMultiPlayers.getPulls()`
	`Environment.EvaluatorMultiPlayers.EvaluatorMultiPlayers.getRegretMean()`
	`Environment.EvaluatorMultiPlayers.EvaluatorMultiPlayers.getRewards()`
	`Environment.EvaluatorMultiPlayers.EvaluatorMultiPlayers.getRunningTimes()`
	`Environment.EvaluatorMultiPlayers.EvaluatorMultiPlayers.getSecondRegretTerm()`
	`Environment.EvaluatorMultiPlayers.EvaluatorMultiPlayers.getThirdRegretTerm()`
	`Environment.EvaluatorMultiPlayers.EvaluatorMultiPlayers.loadfromdisk()`
	`Environment.EvaluatorMultiPlayers.EvaluatorMultiPlayers.plotAllPulls()`
	`Environment.EvaluatorMultiPlayers.EvaluatorMultiPlayers.plotBestArmPulls()`
	`Environment.EvaluatorMultiPlayers.EvaluatorMultiPlayers.plotFairness()`
	`Environment.EvaluatorMultiPlayers.EvaluatorMultiPlayers.plotFreeTransmissions()`
	`Environment.EvaluatorMultiPlayers.EvaluatorMultiPlayers.plotFrequencyCollisions()`
	`Environment.EvaluatorMultiPlayers.EvaluatorMultiPlayers.plotLastRegrets()`
	`Environment.EvaluatorMultiPlayers.EvaluatorMultiPlayers.plotMemoryConsumption()`
	`Environment.EvaluatorMultiPlayers.EvaluatorMultiPlayers.plotNbCollisions()`
	`Environment.EvaluatorMultiPlayers.EvaluatorMultiPlayers.plotNbSwitchs()`
	`Environment.EvaluatorMultiPlayers.EvaluatorMultiPlayers.plotNbSwitchsCentralized()`
	`Environment.EvaluatorMultiPlayers.EvaluatorMultiPlayers.plotRegretCentralized()`
	`Environment.EvaluatorMultiPlayers.EvaluatorMultiPlayers.plotRewards()`
	`Environment.EvaluatorMultiPlayers.EvaluatorMultiPlayers.plotRunningTimes()`
	`Environment.EvaluatorMultiPlayers.EvaluatorMultiPlayers.printFinalRanking()`
	`Environment.EvaluatorMultiPlayers.EvaluatorMultiPlayers.printFinalRankingAll()`
	`Environment.EvaluatorMultiPlayers.EvaluatorMultiPlayers.printLastRegrets()`
	`Environment.EvaluatorMultiPlayers.EvaluatorMultiPlayers.printMemoryConsumption()`
	`Environment.EvaluatorMultiPlayers.EvaluatorMultiPlayers.printRunningTimes()`
	`Environment.EvaluatorMultiPlayers.EvaluatorMultiPlayers.saveondisk()`
	`Environment.EvaluatorMultiPlayers.EvaluatorMultiPlayers.startAllEnv()`
	`Environment.EvaluatorMultiPlayers.EvaluatorMultiPlayers.startOneEnv()`
	`Environment.EvaluatorMultiPlayers.EvaluatorMultiPlayers.strPlayers()`
	`Environment.EvaluatorSparseMultiPlayers.EvaluatorSparseMultiPlayers.__init__()`
	`Environment.EvaluatorSparseMultiPlayers.EvaluatorSparseMultiPlayers.getAllLastWeightedSelections()`
	`Environment.EvaluatorSparseMultiPlayers.EvaluatorSparseMultiPlayers.getCentralizedRegret()`
	`Environment.EvaluatorSparseMultiPlayers.EvaluatorSparseMultiPlayers.getCentralizedRegret_LessAccurate()`
	`Environment.EvaluatorSparseMultiPlayers.EvaluatorSparseMultiPlayers.getCentralizedRegret_MoreAccurate()`
	`Environment.EvaluatorSparseMultiPlayers.EvaluatorSparseMultiPlayers.getFirstRegretTerm()`
	`Environment.EvaluatorSparseMultiPlayers.EvaluatorSparseMultiPlayers.getLastRegrets()`
	`Environment.EvaluatorSparseMultiPlayers.EvaluatorSparseMultiPlayers.getLastRegrets_LessAccurate()`
	`Environment.EvaluatorSparseMultiPlayers.EvaluatorSparseMultiPlayers.getLastRegrets_MoreAccurate()`
	`Environment.EvaluatorSparseMultiPlayers.EvaluatorSparseMultiPlayers.getSecondRegretTerm()`
	`Environment.EvaluatorSparseMultiPlayers.EvaluatorSparseMultiPlayers.getThirdRegretTerm()`
	`Environment.EvaluatorSparseMultiPlayers.EvaluatorSparseMultiPlayers.startOneEnv()`
	`Environment.EvaluatorSparseMultiPlayers.EvaluatorSparseMultiPlayers.strPlayers()`
	`Environment.MAB.ChangingAtEachRepMAB.__init__()`
	`Environment.MAB.ChangingAtEachRepMAB.__repr__()`
	`Environment.MAB.ChangingAtEachRepMAB.hoifactor()`
	`Environment.MAB.ChangingAtEachRepMAB.lowerbound()`
	`Environment.MAB.ChangingAtEachRepMAB.lowerbound_multiplayers()`
	`Environment.MAB.ChangingAtEachRepMAB.Mbest()`
	`Environment.MAB.ChangingAtEachRepMAB.Mworst()`
	`Environment.MAB.ChangingAtEachRepMAB.newRandomArms()`
	`Environment.MAB.ChangingAtEachRepMAB.reprarms()`
	`Environment.MAB.IncreasingMAB.__init__()`
	`Environment.MAB.IncreasingMAB.draw()`
	`Environment.MAB.MAB.__init__()`
	`Environment.MAB.MAB.__repr__()`
	`Environment.MAB.MAB.draw()`
	`Environment.MAB.MAB.draw_each()`
	`Environment.MAB.MAB.draw_each_nparray()`
	`Environment.MAB.MAB.draw_nparray()`
	`Environment.MAB.MAB.get_allMeans()`
	`Environment.MAB.MAB.get_maxArm()`
	`Environment.MAB.MAB.get_minArm()`
	`Environment.MAB.MAB.hoifactor()`
	`Environment.MAB.MAB.lowerbound()`
	`Environment.MAB.MAB.lowerbound_multiplayers()`
	`Environment.MAB.MAB.lowerbound_sparse()`
	`Environment.MAB.MAB.Mbest()`
	`Environment.MAB.MAB.Mworst()`
	`Environment.MAB.MAB.new_order_of_arm()`
	`Environment.MAB.MAB.plotComparison_our_anandkumar()`
	`Environment.MAB.MAB.plotHistogram()`
	`Environment.MAB.MAB.reprarms()`
	`Environment.MAB.MAB.str_sparsity()`
	`Environment.MAB.MAB.sumBestMeans()`
	`Environment.MAB.MAB.upperbound_collisions()`
	`Environment.MAB.MarkovianMAB.__init__()`
	`Environment.MAB.MarkovianMAB.__repr__()`
	`Environment.MAB.MarkovianMAB.draw()`
	`Environment.MAB.MarkovianMAB.reprarms()`
	`Environment.MAB.NonStationaryMAB.__init__()`
	`Environment.MAB.NonStationaryMAB.get_allMeans()`
	`Environment.MAB.NonStationaryMAB.get_maxArm()`
	`Environment.MAB.NonStationaryMAB.get_minArm()`
	`Environment.MAB.NonStationaryMAB.newRandomArms()`
	`Environment.MAB.NonStationaryMAB.reprarms()`
	`Environment.MAB.PieceWiseStationaryMAB.__init__()`
	`Environment.MAB.PieceWiseStationaryMAB.__repr__()`
	`Environment.MAB.PieceWiseStationaryMAB.get_allMeans()`
	`Environment.MAB.PieceWiseStationaryMAB.get_maxArm()`
	`Environment.MAB.PieceWiseStationaryMAB.get_minArm()`
	`Environment.MAB.PieceWiseStationaryMAB.newRandomArms()`
	`Environment.MAB.PieceWiseStationaryMAB.plotHistoryOfMeans()`
	`Environment.MAB.PieceWiseStationaryMAB.reprarms()`
	`Environment.pykov.Chain.absorbing_time()`
	`Environment.pykov.Chain.absorbing_tour()`
	`Environment.pykov.Chain.accessibility_matrix()`
	`Environment.pykov.Chain.adjacency()`
	`Environment.pykov.Chain.communicates()`
	`Environment.pykov.Chain.communication_classes()`
	`Environment.pykov.Chain.entropy()`
	`Environment.pykov.Chain.fundamental_matrix()`
	`Environment.pykov.Chain.is_accessible()`
	`Environment.pykov.Chain.kemeny_constant()`
	`Environment.pykov.Chain.mfpt_to()`
	`Environment.pykov.Chain.mixing_time()`
	`Environment.pykov.Chain.move()`
	`Environment.pykov.Chain.pow()`
	`Environment.pykov.Chain.steady()`
	`Environment.pykov.Chain.walk()`
	`Environment.pykov.Chain.walk_probability()`
	`Environment.pykov.Matrix.__add__()`
	`Environment.pykov.Matrix.__delitem__()`
	`Environment.pykov.Matrix.__getitem__()`
	`Environment.pykov.Matrix.__init__()`
	`Environment.pykov.Matrix.__mul__()`
	`Environment.pykov.Matrix.__pow__()`
	`Environment.pykov.Matrix.__reduce__()`
	`Environment.pykov.Matrix.__rmul__()`
	`Environment.pykov.Matrix.__setitem__()`
	`Environment.pykov.Matrix.__sub__()`
	`Environment.pykov.Matrix._dok_()`
	`Environment.pykov.Matrix._el2pos_()`
	`Environment.pykov.Matrix._from_dok_()`
	`Environment.pykov.Matrix._from_numpy_mat()`
	`Environment.pykov.Matrix._numpy_mat()`
	`Environment.pykov.Matrix._UMPFPACKSolve()`
	`Environment.pykov.Matrix.clear()`
	`Environment.pykov.Matrix.copy()`
	`Environment.pykov.Matrix.eye()`
	`Environment.pykov.Matrix.ones()`
	`Environment.pykov.Matrix.pop()`
	`Environment.pykov.Matrix.popitem()`
	`Environment.pykov.Matrix.pow()`
	`Environment.pykov.Matrix.pred()`
	`Environment.pykov.Matrix.remove()`
	`Environment.pykov.Matrix.setdefault()`
	`Environment.pykov.Matrix.states()`
	`Environment.pykov.Matrix.stochastic()`
	`Environment.pykov.Matrix.succ()`
	`Environment.pykov.Matrix.trace()`
	`Environment.pykov.Matrix.transpose()`
	`Environment.pykov.Matrix.update()`
	`Environment.pykov.PykovError.__init__()`
	`Environment.pykov.PykovError.__str__()`
	`Environment.pykov.Vector.__add__()`
	`Environment.pykov.Vector.__getitem__()`
	`Environment.pykov.Vector.__init__()`
	`Environment.pykov.Vector.__mul__()`
	`Environment.pykov.Vector.__rmul__()`
	`Environment.pykov.Vector.__setitem__()`
	`Environment.pykov.Vector.__sub__()`
	`Environment.pykov.Vector._fromarray()`
	`Environment.pykov.Vector._toarray()`
	`Environment.pykov.Vector.choose()`
	`Environment.pykov.Vector.copy()`
	`Environment.pykov.Vector.dist()`
	`Environment.pykov.Vector.entropy()`
	`Environment.pykov.Vector.normalize()`
	`Environment.pykov.Vector.relative_entropy()`
	`Environment.pykov.Vector.sort()`
	`Environment.pykov.Vector.sum()`
	`Environment.Result.Result.__init__()`
	`Environment.Result.Result.change_in_arms()`
	`Environment.Result.Result.store()`
	`Environment.ResultMultiPlayers.ResultMultiPlayers.__init__()`
	`Environment.ResultMultiPlayers.ResultMultiPlayers.store()`
	`Environment.usejoblib.Parallel.__call__()`
	`Environment.usejoblib.Parallel.__enter__()`
	`Environment.usejoblib.Parallel.__exit__()`
	`Environment.usejoblib.Parallel.__init__()`
	`Environment.usejoblib.Parallel.__repr__()`
	`Environment.usejoblib.Parallel._dispatch()`
	`Environment.usejoblib.Parallel._effective_n_jobs()`
	`Environment.usejoblib.Parallel._initialize_backend()`
	`Environment.usejoblib.Parallel._print()`
	`Environment.usejoblib.Parallel._terminate_backend()`
	`Environment.usejoblib.Parallel.dispatch_next()`
	`Environment.usejoblib.Parallel.dispatch_one_batch()`
	`Environment.usejoblib.Parallel.print_progress()`
	`Environment.usejoblib.Parallel.retrieve()`
	`Environment.usetqdm.tqdm.__del__()`
	`Environment.usetqdm.tqdm.__enter__()`
	`Environment.usetqdm.tqdm.__exit__()`
	`Environment.usetqdm.tqdm.__hash__()`
	`Environment.usetqdm.tqdm.__init__()`
	`Environment.usetqdm.tqdm.__iter__()`
	`Environment.usetqdm.tqdm.__len__()`
	`Environment.usetqdm.tqdm.__repr__()`
	`Environment.usetqdm.tqdm.clear()`
	`Environment.usetqdm.tqdm.close()`
	`Environment.usetqdm.tqdm.moveto()`
	`Environment.usetqdm.tqdm.refresh()`
	`Environment.usetqdm.tqdm.set_description()`
	`Environment.usetqdm.tqdm.set_description_str()`
	`Environment.usetqdm.tqdm.set_postfix()`
	`Environment.usetqdm.tqdm.set_postfix_str()`
	`Environment.usetqdm.tqdm.unpause()`
	`Environment.usetqdm.tqdm.update()`

	p
	`Policies`
	`Policies.AdBandits.AdBandits.__init__()`
	`Policies.AdBandits.AdBandits.__str__()`
	`Policies.AdBandits.AdBandits.choice()`
	`Policies.AdBandits.AdBandits.choiceWithRank()`
	`Policies.AdBandits.AdBandits.getReward()`
	`Policies.AdBandits.AdBandits.startGame()`
	`Policies.AdSwitch.AdSwitch.__init__()`
	`Policies.AdSwitch.AdSwitch.__str__()`
	`Policies.AdSwitch.AdSwitch.choice()`
	`Policies.AdSwitch.AdSwitch.compute_di_pi_si()`
	`Policies.AdSwitch.AdSwitch.find_Ik()`
	`Policies.AdSwitch.AdSwitch.getReward()`
	`Policies.AdSwitch.AdSwitch.read_range_of_rewards()`
	`Policies.AdSwitch.AdSwitch.startGame()`
	`Policies.AdSwitch.AdSwitch.statistical_test()`
	`Policies.AdSwitch.Phase.__new__()`
	`Policies.AdSwitch.Phase._generate_next_value_()`
	`Policies.Aggregator.Aggregator.__init__()`
	`Policies.Aggregator.Aggregator.__str__()`
	`Policies.Aggregator.Aggregator._makeChildrenChoose()`
	`Policies.Aggregator.Aggregator.choice()`
	`Policies.Aggregator.Aggregator.choiceFromSubSet()`
	`Policies.Aggregator.Aggregator.choiceIMP()`
	`Policies.Aggregator.Aggregator.choiceMultiple()`
	`Policies.Aggregator.Aggregator.choiceWithRank()`
	`Policies.Aggregator.Aggregator.computeAllIndex()`
	`Policies.Aggregator.Aggregator.computeIndex()`
	`Policies.Aggregator.Aggregator.estimatedBestArms()`
	`Policies.Aggregator.Aggregator.estimatedOrder()`
	`Policies.Aggregator.Aggregator.getReward()`
	`Policies.Aggregator.Aggregator.handleCollision()`
	`Policies.Aggregator.Aggregator.startGame()`
	`Policies.ApproximatedFHGittins.ApproximatedFHGittins.__init__()`
	`Policies.ApproximatedFHGittins.ApproximatedFHGittins.__str__()`
	`Policies.ApproximatedFHGittins.ApproximatedFHGittins.computeAllIndex()`
	`Policies.ApproximatedFHGittins.ApproximatedFHGittins.computeIndex()`
	`Policies.BasePolicy.BasePolicy.__init__()`
	`Policies.BasePolicy.BasePolicy.__str__()`
	`Policies.BasePolicy.BasePolicy.choice()`
	`Policies.BasePolicy.BasePolicy.choiceFromSubSet()`
	`Policies.BasePolicy.BasePolicy.choiceIMP()`
	`Policies.BasePolicy.BasePolicy.choiceMultiple()`
	`Policies.BasePolicy.BasePolicy.choiceWithRank()`
	`Policies.BasePolicy.BasePolicy.estimatedOrder()`
	`Policies.BasePolicy.BasePolicy.getReward()`
	`Policies.BasePolicy.BasePolicy.startGame()`
	`Policies.BaseWrapperPolicy.BaseWrapperPolicy.__init__()`
	`Policies.BaseWrapperPolicy.BaseWrapperPolicy.choice()`
	`Policies.BaseWrapperPolicy.BaseWrapperPolicy.choiceFromSubSet()`
	`Policies.BaseWrapperPolicy.BaseWrapperPolicy.choiceIMP()`
	`Policies.BaseWrapperPolicy.BaseWrapperPolicy.choiceMultiple()`
	`Policies.BaseWrapperPolicy.BaseWrapperPolicy.choiceWithRank()`
	`Policies.BaseWrapperPolicy.BaseWrapperPolicy.computeAllIndex()`
	`Policies.BaseWrapperPolicy.BaseWrapperPolicy.computeIndex()`
	`Policies.BaseWrapperPolicy.BaseWrapperPolicy.estimatedBestArms()`
	`Policies.BaseWrapperPolicy.BaseWrapperPolicy.estimatedOrder()`
	`Policies.BaseWrapperPolicy.BaseWrapperPolicy.getReward()`
	`Policies.BaseWrapperPolicy.BaseWrapperPolicy.startGame()`
	`Policies.BayesianIndexPolicy.BayesianIndexPolicy.__init__()`
	`Policies.BayesianIndexPolicy.BayesianIndexPolicy.__str__()`
	`Policies.BayesianIndexPolicy.BayesianIndexPolicy.computeIndex()`
	`Policies.BayesianIndexPolicy.BayesianIndexPolicy.getReward()`
	`Policies.BayesianIndexPolicy.BayesianIndexPolicy.startGame()`
	`Policies.BayesUCB.BayesUCB.computeIndex()`
	`Policies.BESA.BESA.__init__()`
	`Policies.BESA.BESA.__str__()`
	`Policies.BESA.BESA.choice()`
	`Policies.BESA.BESA.choiceFromSubSet()`
	`Policies.BESA.BESA.choiceMultiple()`
	`Policies.BESA.BESA.choiceWithRank()`
	`Policies.BESA.BESA.computeAllIndex()`
	`Policies.BESA.BESA.computeIndex()`
	`Policies.BESA.BESA.getReward()`
	`Policies.BESA.BESA.handleCollision()`
	`Policies.BoltzmannGumbel.BoltzmannGumbel.__init__()`
	`Policies.BoltzmannGumbel.BoltzmannGumbel.__str__()`
	`Policies.BoltzmannGumbel.BoltzmannGumbel.computeAllIndex()`
	`Policies.BoltzmannGumbel.BoltzmannGumbel.computeIndex()`
	`Policies.CD_UCB.BernoulliGLR_IndexPolicy.__init__()`
	`Policies.CD_UCB.CD_IndexPolicy.__init__()`
	`Policies.CD_UCB.CD_IndexPolicy.__str__()`
	`Policies.CD_UCB.CD_IndexPolicy.choice()`
	`Policies.CD_UCB.CD_IndexPolicy.detect_change()`
	`Policies.CD_UCB.CD_IndexPolicy.getReward()`
	`Policies.CD_UCB.CUSUM_IndexPolicy.__init__()`
	`Policies.CD_UCB.CUSUM_IndexPolicy.__str__()`
	`Policies.CD_UCB.CUSUM_IndexPolicy.detect_change()`
	`Policies.CD_UCB.GaussianGLR_IndexPolicy.__init__()`
	`Policies.CD_UCB.GLR_IndexPolicy.__init__()`
	`Policies.CD_UCB.GLR_IndexPolicy.__str__()`
	`Policies.CD_UCB.GLR_IndexPolicy.compute_threshold_h()`
	`Policies.CD_UCB.GLR_IndexPolicy.detect_change()`
	`Policies.CD_UCB.GLR_IndexPolicy_WithTracking.choice()`
	`Policies.CD_UCB.PHT_IndexPolicy.__str__()`
	`Policies.CD_UCB.PHT_IndexPolicy.detect_change()`
	`Policies.CD_UCB.SlidingWindowRestart_IndexPolicy.detect_change()`
	`Policies.CD_UCB.SubGaussianGLR_IndexPolicy.__init__()`
	`Policies.CD_UCB.SubGaussianGLR_IndexPolicy.__str__()`
	`Policies.CD_UCB.SubGaussianGLR_IndexPolicy.compute_threshold_h()`
	`Policies.CD_UCB.SubGaussianGLR_IndexPolicy.detect_change()`
	`Policies.CORRAL.CORRAL.__init__()`
	`Policies.CORRAL.CORRAL.__setattr__()`
	`Policies.CORRAL.CORRAL.__str__()`
	`Policies.CORRAL.CORRAL.choice()`
	`Policies.CORRAL.CORRAL.choiceFromSubSet()`
	`Policies.CORRAL.CORRAL.choiceIMP()`
	`Policies.CORRAL.CORRAL.choiceMultiple()`
	`Policies.CORRAL.CORRAL.choiceWithRank()`
	`Policies.CORRAL.CORRAL.estimatedBestArms()`
	`Policies.CORRAL.CORRAL.estimatedOrder()`
	`Policies.CORRAL.CORRAL.getReward()`
	`Policies.CORRAL.CORRAL.startGame()`
	`Policies.CPUCB.CPUCB.__init__()`
	`Policies.CPUCB.CPUCB.computeIndex()`
	`Policies.DiscountedBayesianIndexPolicy.DiscountedBayesianIndexPolicy.__init__()`
	`Policies.DiscountedBayesianIndexPolicy.DiscountedBayesianIndexPolicy.__str__()`
	`Policies.DiscountedBayesianIndexPolicy.DiscountedBayesianIndexPolicy.getReward()`
	`Policies.DiscountedThompson.DiscountedThompson.computeIndex()`
	`Policies.DiscountedUCB.DiscountedUCB.__init__()`
	`Policies.DiscountedUCB.DiscountedUCB.__str__()`
	`Policies.DiscountedUCB.DiscountedUCB.computeAllIndex()`
	`Policies.DiscountedUCB.DiscountedUCB.computeIndex()`
	`Policies.DiscountedUCB.DiscountedUCB.getReward()`
	`Policies.DiscountedUCB.DiscountedUCBPlus.__init__()`
	`Policies.DiscountedUCB.DiscountedUCBPlus.__str__()`
	`Policies.DMED.DMED.__init__()`
	`Policies.DMED.DMED.__str__()`
	`Policies.DMED.DMED.choice()`
	`Policies.DMED.DMED.choiceMultiple()`
	`Policies.DMED.DMED.startGame()`
	`Policies.DMED.DMEDPlus.__init__()`
	`Policies.DoublingTrickWrapper.DoublingTrickWrapper.__init__()`
	`Policies.DoublingTrickWrapper.DoublingTrickWrapper.__str__()`
	`Policies.DoublingTrickWrapper.DoublingTrickWrapper.getReward()`
	`Policies.DoublingTrickWrapper.DoublingTrickWrapper.startGame()`
	`Policies.EmpiricalMeans.EmpiricalMeans.computeAllIndex()`
	`Policies.EmpiricalMeans.EmpiricalMeans.computeIndex()`
	`Policies.EpsilonGreedy.EpsilonDecreasing.__init__()`
	`Policies.EpsilonGreedy.EpsilonDecreasing.__str__()`
	`Policies.EpsilonGreedy.EpsilonDecreasingMEGA.__init__()`
	`Policies.EpsilonGreedy.EpsilonDecreasingMEGA.__str__()`
	`Policies.EpsilonGreedy.EpsilonExpDecreasing.__init__()`
	`Policies.EpsilonGreedy.EpsilonExpDecreasing.__str__()`
	`Policies.EpsilonGreedy.EpsilonFirst.__init__()`
	`Policies.EpsilonGreedy.EpsilonFirst.__str__()`
	`Policies.EpsilonGreedy.EpsilonGreedy.__init__()`
	`Policies.EpsilonGreedy.EpsilonGreedy.__str__()`
	`Policies.EpsilonGreedy.EpsilonGreedy.choice()`
	`Policies.EpsilonGreedy.EpsilonGreedy.choiceFromSubSet()`
	`Policies.EpsilonGreedy.EpsilonGreedy.choiceMultiple()`
	`Policies.EpsilonGreedy.EpsilonGreedy.choiceWithRank()`
	`Policies.Exp3.Exp3.__init__()`
	`Policies.Exp3.Exp3.__str__()`
	`Policies.Exp3.Exp3.choice()`
	`Policies.Exp3.Exp3.choiceFromSubSet()`
	`Policies.Exp3.Exp3.choiceMultiple()`
	`Policies.Exp3.Exp3.choiceWithRank()`
	`Policies.Exp3.Exp3.estimatedBestArms()`
	`Policies.Exp3.Exp3.estimatedOrder()`
	`Policies.Exp3.Exp3.getReward()`
	`Policies.Exp3.Exp3.startGame()`
	`Policies.Exp3.Exp3Decreasing.__str__()`
	`Policies.Exp3.Exp3ELM.__init__()`
	`Policies.Exp3.Exp3ELM.__str__()`
	`Policies.Exp3.Exp3ELM.choice()`
	`Policies.Exp3.Exp3ELM.getReward()`
	`Policies.Exp3.Exp3SoftMix.__str__()`
	`Policies.Exp3.Exp3WithHorizon.__init__()`
	`Policies.Exp3.Exp3WithHorizon.__str__()`
	`Policies.Exp3PlusPlus.Exp3PlusPlus.__init__()`
	`Policies.Exp3PlusPlus.Exp3PlusPlus.__str__()`
	`Policies.Exp3PlusPlus.Exp3PlusPlus.choice()`
	`Policies.Exp3PlusPlus.Exp3PlusPlus.choiceFromSubSet()`
	`Policies.Exp3PlusPlus.Exp3PlusPlus.choiceMultiple()`
	`Policies.Exp3PlusPlus.Exp3PlusPlus.choiceWithRank()`
	`Policies.Exp3PlusPlus.Exp3PlusPlus.estimatedBestArms()`
	`Policies.Exp3PlusPlus.Exp3PlusPlus.estimatedOrder()`
	`Policies.Exp3PlusPlus.Exp3PlusPlus.getReward()`
	`Policies.Exp3PlusPlus.Exp3PlusPlus.startGame()`
	`Policies.Exp3R.DriftDetection_IndexPolicy.__init__()`
	`Policies.Exp3R.DriftDetection_IndexPolicy.__str__()`
	`Policies.Exp3R.DriftDetection_IndexPolicy.detect_change()`
	`Policies.Exp3R.Exp3R.__init__()`
	`Policies.Exp3R.Exp3R.__str__()`
	`Policies.Exp3R.Exp3RPlusPlus.__init__()`
	`Policies.Exp3R.Exp3RPlusPlus.__str__()`
	`Policies.Experimentals.BlackBoxOpt.BlackBoxOpt.__init__()`
	`Policies.Experimentals.BlackBoxOpt.BlackBoxOpt.__str__()`
	`Policies.Experimentals.BlackBoxOpt.BlackBoxOpt.choice()`
	`Policies.Experimentals.BlackBoxOpt.BlackBoxOpt.getReward()`
	`Policies.Experimentals.BlackBoxOpt.BlackBoxOpt.startGame()`
	`Policies.Experimentals.KLempUCB.KLempUCB.__init__()`
	`Policies.Experimentals.KLempUCB.KLempUCB.computeIndex()`
	`Policies.Experimentals.KLempUCB.KLempUCB.getReward()`
	`Policies.Experimentals.KLempUCB.KLempUCB.startGame()`
	`Policies.Experimentals.klUCBlog10.klUCBlog10.__str__()`
	`Policies.Experimentals.klUCBlog10.klUCBlog10.computeAllIndex()`
	`Policies.Experimentals.klUCBlog10.klUCBlog10.computeIndex()`
	`Policies.Experimentals.klUCBloglog10.klUCBloglog10.__str__()`
	`Policies.Experimentals.klUCBloglog10.klUCBloglog10.computeAllIndex()`
	`Policies.Experimentals.klUCBloglog10.klUCBloglog10.computeIndex()`
	`Policies.Experimentals.ThompsonRobust.ThompsonRobust.__init__()`
	`Policies.Experimentals.ThompsonRobust.ThompsonRobust.__str__()`
	`Policies.Experimentals.ThompsonRobust.ThompsonRobust.computeIndex()`
	`Policies.Experimentals.UCBjulia.UCBjulia.__init__()`
	`Policies.Experimentals.UCBjulia.UCBjulia.computeIndex()`
	`Policies.Experimentals.UCBlog10.UCBlog10.computeAllIndex()`
	`Policies.Experimentals.UCBlog10.UCBlog10.computeIndex()`
	`Policies.Experimentals.UCBlog10alpha.UCBlog10alpha.__init__()`
	`Policies.Experimentals.UCBlog10alpha.UCBlog10alpha.__str__()`
	`Policies.Experimentals.UCBlog10alpha.UCBlog10alpha.computeAllIndex()`
	`Policies.Experimentals.UCBlog10alpha.UCBlog10alpha.computeIndex()`
	`Policies.Experimentals.UCBoost_faster.UCB_bq.__init__()`
	`Policies.Experimentals.UCBoost_faster.UCB_bq.__str__()`
	`Policies.Experimentals.UCBoost_faster.UCB_bq.computeIndex()`
	`Policies.Experimentals.UCBoost_faster.UCB_h.__init__()`
	`Policies.Experimentals.UCBoost_faster.UCB_h.__str__()`
	`Policies.Experimentals.UCBoost_faster.UCB_h.computeIndex()`
	`Policies.Experimentals.UCBoost_faster.UCB_lb.__init__()`
	`Policies.Experimentals.UCBoost_faster.UCB_lb.__str__()`
	`Policies.Experimentals.UCBoost_faster.UCB_lb.computeIndex()`
	`Policies.Experimentals.UCBoost_faster.UCB_sq.__init__()`
	`Policies.Experimentals.UCBoost_faster.UCB_sq.__str__()`
	`Policies.Experimentals.UCBoost_faster.UCB_sq.computeIndex()`
	`Policies.Experimentals.UCBoost_faster.UCB_t.__init__()`
	`Policies.Experimentals.UCBoost_faster.UCB_t.__str__()`
	`Policies.Experimentals.UCBoost_faster.UCB_t.computeIndex()`
	`Policies.Experimentals.UCBoost_faster.UCBoost.__init__()`
	`Policies.Experimentals.UCBoost_faster.UCBoost.__str__()`
	`Policies.Experimentals.UCBoost_faster.UCBoost.computeIndex()`
	`Policies.Experimentals.UCBoost_faster.UCBoost_bq_h_lb.__init__()`
	`Policies.Experimentals.UCBoost_faster.UCBoost_bq_h_lb.__str__()`
	`Policies.Experimentals.UCBoost_faster.UCBoost_bq_h_lb.computeIndex()`
	`Policies.Experimentals.UCBoost_faster.UCBoost_bq_h_lb_t.__init__()`
	`Policies.Experimentals.UCBoost_faster.UCBoost_bq_h_lb_t.__str__()`
	`Policies.Experimentals.UCBoost_faster.UCBoost_bq_h_lb_t.computeIndex()`
	`Policies.Experimentals.UCBoost_faster.UCBoost_bq_h_lb_t_sq.__init__()`
	`Policies.Experimentals.UCBoost_faster.UCBoost_bq_h_lb_t_sq.__str__()`
	`Policies.Experimentals.UCBoost_faster.UCBoost_bq_h_lb_t_sq.computeIndex()`
	`Policies.Experimentals.UCBoost_faster.UCBoostEpsilon.__init__()`
	`Policies.Experimentals.UCBoost_faster.UCBoostEpsilon.__str__()`
	`Policies.Experimentals.UCBoost_faster.UCBoostEpsilon.computeIndex()`
	`Policies.Experimentals.UCBwrong.UCBwrong.computeAllIndex()`
	`Policies.Experimentals.UCBwrong.UCBwrong.computeIndex()`
	`Policies.Experimentals.UnsupervisedLearning.FittingModel.__init__()`
	`Policies.Experimentals.UnsupervisedLearning.FittingModel.__repr__()`
	`Policies.Experimentals.UnsupervisedLearning.FittingModel.fit()`
	`Policies.Experimentals.UnsupervisedLearning.FittingModel.sample()`
	`Policies.Experimentals.UnsupervisedLearning.FittingModel.score()`
	`Policies.Experimentals.UnsupervisedLearning.FittingModel.score_samples()`
	`Policies.Experimentals.UnsupervisedLearning.SimpleBernoulliKernel.__init__()`
	`Policies.Experimentals.UnsupervisedLearning.SimpleBernoulliKernel.__str__()`
	`Policies.Experimentals.UnsupervisedLearning.SimpleBernoulliKernel.fit()`
	`Policies.Experimentals.UnsupervisedLearning.SimpleBernoulliKernel.sample()`
	`Policies.Experimentals.UnsupervisedLearning.SimpleBernoulliKernel.score_samples()`
	`Policies.Experimentals.UnsupervisedLearning.SimpleGaussianKernel.__init__()`
	`Policies.Experimentals.UnsupervisedLearning.SimpleGaussianKernel.__str__()`
	`Policies.Experimentals.UnsupervisedLearning.SimpleGaussianKernel.fit()`
	`Policies.Experimentals.UnsupervisedLearning.SimpleGaussianKernel.sample()`
	`Policies.Experimentals.UnsupervisedLearning.SimpleGaussianKernel.score_samples()`
	`Policies.Experimentals.UnsupervisedLearning.UnsupervisedLearning.__init__()`
	`Policies.Experimentals.UnsupervisedLearning.UnsupervisedLearning.__str__()`
	`Policies.Experimentals.UnsupervisedLearning.UnsupervisedLearning.choice()`
	`Policies.Experimentals.UnsupervisedLearning.UnsupervisedLearning.estimatedOrder()`
	`Policies.Experimentals.UnsupervisedLearning.UnsupervisedLearning.fit()`
	`Policies.Experimentals.UnsupervisedLearning.UnsupervisedLearning.getReward()`
	`Policies.Experimentals.UnsupervisedLearning.UnsupervisedLearning.sample()`
	`Policies.Experimentals.UnsupervisedLearning.UnsupervisedLearning.sample_with_mean()`
	`Policies.Experimentals.UnsupervisedLearning.UnsupervisedLearning.score()`
	`Policies.Experimentals.UnsupervisedLearning.UnsupervisedLearning.startGame()`
	`Policies.ExploreThenCommit._ETC_RoundRobin_WithStoppingCriteria.__init__()`
	`Policies.ExploreThenCommit._ETC_RoundRobin_WithStoppingCriteria.__str__()`
	`Policies.ExploreThenCommit._ETC_RoundRobin_WithStoppingCriteria.choice()`
	`Policies.ExploreThenCommit._ETC_RoundRobin_WithStoppingCriteria.stopping_criteria()`
	`Policies.ExploreThenCommit.DeltaUCB.__init__()`
	`Policies.ExploreThenCommit.DeltaUCB.__str__()`
	`Policies.ExploreThenCommit.DeltaUCB.choice()`
	`Policies.ExploreThenCommit.ETC_BAI.__init__()`
	`Policies.ExploreThenCommit.ETC_BAI.stopping_criteria()`
	`Policies.ExploreThenCommit.ETC_FixedBudget.__init__()`
	`Policies.ExploreThenCommit.ETC_FixedBudget.__str__()`
	`Policies.ExploreThenCommit.ETC_FixedBudget.choice()`
	`Policies.ExploreThenCommit.ETC_KnownGap.__init__()`
	`Policies.ExploreThenCommit.ETC_KnownGap.__str__()`
	`Policies.ExploreThenCommit.ETC_RandomStop.__init__()`
	`Policies.ExploreThenCommit.ETC_RandomStop.__str__()`
	`Policies.ExploreThenCommit.ETC_SPRT.stopping_criteria()`
	`Policies.GenericAggregation.GenericAggregation.__init__()`
	`Policies.GenericAggregation.GenericAggregation.__str__()`
	`Policies.GenericAggregation.GenericAggregation.choice()`
	`Policies.GenericAggregation.GenericAggregation.choiceFromSubSet()`
	`Policies.GenericAggregation.GenericAggregation.choiceIMP()`
	`Policies.GenericAggregation.GenericAggregation.choiceMultiple()`
	`Policies.GenericAggregation.GenericAggregation.choiceWithRank()`
	`Policies.GenericAggregation.GenericAggregation.estimatedBestArms()`
	`Policies.GenericAggregation.GenericAggregation.estimatedOrder()`
	`Policies.GenericAggregation.GenericAggregation.getReward()`
	`Policies.GenericAggregation.GenericAggregation.startGame()`
	`Policies.Hedge.Hedge.__init__()`
	`Policies.Hedge.Hedge.__str__()`
	`Policies.Hedge.Hedge.choice()`
	`Policies.Hedge.Hedge.choiceFromSubSet()`
	`Policies.Hedge.Hedge.choiceMultiple()`
	`Policies.Hedge.Hedge.choiceWithRank()`
	`Policies.Hedge.Hedge.estimatedBestArms()`
	`Policies.Hedge.Hedge.estimatedOrder()`
	`Policies.Hedge.Hedge.getReward()`
	`Policies.Hedge.Hedge.startGame()`
	`Policies.Hedge.HedgeDecreasing.__str__()`
	`Policies.Hedge.HedgeWithHorizon.__init__()`
	`Policies.Hedge.HedgeWithHorizon.__str__()`
	`Policies.IMED.IMED.__init__()`
	`Policies.IMED.IMED.__str__()`
	`Policies.IMED.IMED.choice()`
	`Policies.IMED.IMED.Dinf()`
	`Policies.IMED.IMED.one_Dinf()`
	`Policies.IndexPolicy.IndexPolicy.__init__()`
	`Policies.IndexPolicy.IndexPolicy.choice()`
	`Policies.IndexPolicy.IndexPolicy.choiceFromSubSet()`
	`Policies.IndexPolicy.IndexPolicy.choiceIMP()`
	`Policies.IndexPolicy.IndexPolicy.choiceMultiple()`
	`Policies.IndexPolicy.IndexPolicy.choiceWithRank()`
	`Policies.IndexPolicy.IndexPolicy.computeAllIndex()`
	`Policies.IndexPolicy.IndexPolicy.computeIndex()`
	`Policies.IndexPolicy.IndexPolicy.estimatedBestArms()`
	`Policies.IndexPolicy.IndexPolicy.estimatedOrder()`
	`Policies.IndexPolicy.IndexPolicy.startGame()`
	`Policies.klUCB.klUCB.__init__()`
	`Policies.klUCB.klUCB.__str__()`
	`Policies.klUCB.klUCB.computeAllIndex()`
	`Policies.klUCB.klUCB.computeIndex()`
	`Policies.klUCBH.klUCBH.__init__()`
	`Policies.klUCBH.klUCBH.__str__()`
	`Policies.klUCBH.klUCBH.computeAllIndex()`
	`Policies.klUCBH.klUCBH.computeIndex()`
	`Policies.klUCBHPlus.klUCBHPlus.__init__()`
	`Policies.klUCBHPlus.klUCBHPlus.__str__()`
	`Policies.klUCBHPlus.klUCBHPlus.computeAllIndex()`
	`Policies.klUCBHPlus.klUCBHPlus.computeIndex()`
	`Policies.klUCBloglog.klUCBloglog.__str__()`
	`Policies.klUCBloglog.klUCBloglog.computeAllIndex()`
	`Policies.klUCBloglog.klUCBloglog.computeIndex()`
	`Policies.klUCBPlus.klUCBPlus.__str__()`
	`Policies.klUCBPlus.klUCBPlus.computeAllIndex()`
	`Policies.klUCBPlus.klUCBPlus.computeIndex()`
	`Policies.klUCBPlusPlus.klUCBPlusPlus.__init__()`
	`Policies.klUCBPlusPlus.klUCBPlusPlus.__str__()`
	`Policies.klUCBPlusPlus.klUCBPlusPlus.computeAllIndex()`
	`Policies.klUCBPlusPlus.klUCBPlusPlus.computeIndex()`
	`Policies.klUCBswitch.klUCBswitch.__init__()`
	`Policies.klUCBswitch.klUCBswitch.__str__()`
	`Policies.klUCBswitch.klUCBswitch.computeIndex()`
	`Policies.klUCBswitch.klUCBswitchAnytime.__init__()`
	`Policies.klUCBswitch.klUCBswitchAnytime.__str__()`
	`Policies.klUCBswitch.klUCBswitchAnytime.computeIndex()`
	`Policies.LearnExp.LearnExp.__init__()`
	`Policies.LearnExp.LearnExp.__str__()`
	`Policies.LearnExp.LearnExp.choice()`
	`Policies.LearnExp.LearnExp.choiceFromSubSet()`
	`Policies.LearnExp.LearnExp.choiceIMP()`
	`Policies.LearnExp.LearnExp.choiceMultiple()`
	`Policies.LearnExp.LearnExp.choiceWithRank()`
	`Policies.LearnExp.LearnExp.estimatedBestArms()`
	`Policies.LearnExp.LearnExp.estimatedOrder()`
	`Policies.LearnExp.LearnExp.getReward()`
	`Policies.LearnExp.LearnExp.startGame()`
	`Policies.LM_DSEE.LM_DSEE.__init__()`
	`Policies.LM_DSEE.LM_DSEE.__str__()`
	`Policies.LM_DSEE.LM_DSEE.choice()`
	`Policies.LM_DSEE.LM_DSEE.getReward()`
	`Policies.LM_DSEE.LM_DSEE.length_exploitation_phase()`
	`Policies.LM_DSEE.LM_DSEE.length_exploration_phase()`
	`Policies.LM_DSEE.LM_DSEE.startGame()`
	`Policies.LM_DSEE.State.__new__()`
	`Policies.LM_DSEE.State._generate_next_value_()`
	`Policies.MEGA.MEGA.__init__()`
	`Policies.MEGA.MEGA.__str__()`
	`Policies.MEGA.MEGA._epsilon_t()`
	`Policies.MEGA.MEGA.choice()`
	`Policies.MEGA.MEGA.getReward()`
	`Policies.MEGA.MEGA.handleCollision()`
	`Policies.MEGA.MEGA.startGame()`
	`Policies.Monitored_UCB.Monitored_IndexPolicy.__init__()`
	`Policies.Monitored_UCB.Monitored_IndexPolicy.__str__()`
	`Policies.Monitored_UCB.Monitored_IndexPolicy.choice()`
	`Policies.Monitored_UCB.Monitored_IndexPolicy.detect_change()`
	`Policies.Monitored_UCB.Monitored_IndexPolicy.getReward()`
	`Policies.MOSS.MOSS.computeAllIndex()`
	`Policies.MOSS.MOSS.computeIndex()`
	`Policies.MOSSAnytime.MOSSAnytime.__init__()`
	`Policies.MOSSAnytime.MOSSAnytime.__str__()`
	`Policies.MOSSAnytime.MOSSAnytime.computeAllIndex()`
	`Policies.MOSSAnytime.MOSSAnytime.computeIndex()`
	`Policies.MOSSExperimental.MOSSExperimental.__str__()`
	`Policies.MOSSExperimental.MOSSExperimental.computeAllIndex()`
	`Policies.MOSSExperimental.MOSSExperimental.computeIndex()`
	`Policies.MOSSH.MOSSH.__init__()`
	`Policies.MOSSH.MOSSH.__str__()`
	`Policies.MOSSH.MOSSH.computeAllIndex()`
	`Policies.MOSSH.MOSSH.computeIndex()`
	`Policies.MusicalChair.MusicalChair.__init__()`
	`Policies.MusicalChair.MusicalChair.__str__()`
	`Policies.MusicalChair.MusicalChair._endInitialPhase()`
	`Policies.MusicalChair.MusicalChair.choice()`
	`Policies.MusicalChair.MusicalChair.getReward()`
	`Policies.MusicalChair.MusicalChair.handleCollision()`
	`Policies.MusicalChair.MusicalChair.startGame()`
	`Policies.MusicalChair.State.__new__()`
	`Policies.MusicalChair.State._generate_next_value_()`
	`Policies.MusicalChairNoSensing.MusicalChairNoSensing.__init__()`
	`Policies.MusicalChairNoSensing.MusicalChairNoSensing.__str__()`
	`Policies.MusicalChairNoSensing.MusicalChairNoSensing._endPhase2()`
	`Policies.MusicalChairNoSensing.MusicalChairNoSensing.choice()`
	`Policies.MusicalChairNoSensing.MusicalChairNoSensing.getReward()`
	`Policies.MusicalChairNoSensing.MusicalChairNoSensing.handleCollision()`
	`Policies.MusicalChairNoSensing.MusicalChairNoSensing.startGame()`
	`Policies.MusicalChairNoSensing.State.__new__()`
	`Policies.MusicalChairNoSensing.State._generate_next_value_()`
	`Policies.OCUCB.OCUCB.__init__()`
	`Policies.OCUCB.OCUCB.__str__()`
	`Policies.OCUCB.OCUCB._Bterm()`
	`Policies.OCUCB.OCUCB._Bterms()`
	`Policies.OCUCB.OCUCB.computeIndex()`
	`Policies.OCUCBH.AOCUCBH.__init__()`
	`Policies.OCUCBH.AOCUCBH.__str__()`
	`Policies.OCUCBH.AOCUCBH.computeIndex()`
	`Policies.OCUCBH.OCUCBH.__init__()`
	`Policies.OCUCBH.OCUCBH.__str__()`
	`Policies.OCUCBH.OCUCBH.computeIndex()`
	`Policies.OracleSequentiallyRestartPolicy.OracleSequentiallyRestartPolicy.__init__()`
	`Policies.OracleSequentiallyRestartPolicy.OracleSequentiallyRestartPolicy.__str__()`
	`Policies.OracleSequentiallyRestartPolicy.OracleSequentiallyRestartPolicy.compute_optimized_changePoints()`
	`Policies.OracleSequentiallyRestartPolicy.OracleSequentiallyRestartPolicy.getReward()`
	`Policies.OSSB.GaussianOSSB.__init__()`
	`Policies.OSSB.OSSB.__init__()`
	`Policies.OSSB.OSSB.__str__()`
	`Policies.OSSB.OSSB.choice()`
	`Policies.OSSB.OSSB.getReward()`
	`Policies.OSSB.OSSB.handleCollision()`
	`Policies.OSSB.OSSB.startGame()`
	`Policies.OSSB.OSSB_AutoDecreasingRate.__init__()`
	`Policies.OSSB.OSSB_AutoDecreasingRate.__str__()`
	`Policies.OSSB.OSSB_DecreasingRate.__init__()`
	`Policies.OSSB.OSSB_DecreasingRate.__str__()`
	`Policies.OSSB.Phase.__new__()`
	`Policies.OSSB.Phase._generate_next_value_()`
	`Policies.OSSB.SparseOSSB.__init__()`
	`Policies.Posterior.Beta.Beta.__init__()`
	`Policies.Posterior.Beta.Beta.__str__()`
	`Policies.Posterior.Beta.Beta.forget()`
	`Policies.Posterior.Beta.Beta.mean()`
	`Policies.Posterior.Beta.Beta.quantile()`
	`Policies.Posterior.Beta.Beta.reset()`
	`Policies.Posterior.Beta.Beta.sample()`
	`Policies.Posterior.Beta.Beta.update()`
	`Policies.Posterior.DiscountedBeta.DiscountedBeta.__init__()`
	`Policies.Posterior.DiscountedBeta.DiscountedBeta.__str__()`
	`Policies.Posterior.DiscountedBeta.DiscountedBeta.discount()`
	`Policies.Posterior.DiscountedBeta.DiscountedBeta.forget()`
	`Policies.Posterior.DiscountedBeta.DiscountedBeta.quantile()`
	`Policies.Posterior.DiscountedBeta.DiscountedBeta.reset()`
	`Policies.Posterior.DiscountedBeta.DiscountedBeta.sample()`
	`Policies.Posterior.DiscountedBeta.DiscountedBeta.undiscount()`
	`Policies.Posterior.DiscountedBeta.DiscountedBeta.update()`
	`Policies.Posterior.Gamma.Gamma.__init__()`
	`Policies.Posterior.Gamma.Gamma.__str__()`
	`Policies.Posterior.Gamma.Gamma.forget()`
	`Policies.Posterior.Gamma.Gamma.mean()`
	`Policies.Posterior.Gamma.Gamma.quantile()`
	`Policies.Posterior.Gamma.Gamma.reset()`
	`Policies.Posterior.Gamma.Gamma.sample()`
	`Policies.Posterior.Gamma.Gamma.update()`
	`Policies.Posterior.Gauss.Gauss.__init__()`
	`Policies.Posterior.Gauss.Gauss.__str__()`
	`Policies.Posterior.Gauss.Gauss.forget()`
	`Policies.Posterior.Gauss.Gauss.mean()`
	`Policies.Posterior.Gauss.Gauss.quantile()`
	`Policies.Posterior.Gauss.Gauss.reset()`
	`Policies.Posterior.Gauss.Gauss.sample()`
	`Policies.Posterior.Gauss.Gauss.update()`
	`Policies.Posterior.Gauss.Gauss.variance()`
	`Policies.Posterior.Posterior.Posterior.__init__()`
	`Policies.Posterior.Posterior.Posterior.forget()`
	`Policies.Posterior.Posterior.Posterior.mean()`
	`Policies.Posterior.Posterior.Posterior.quantile()`
	`Policies.Posterior.Posterior.Posterior.reset()`
	`Policies.Posterior.Posterior.Posterior.sample()`
	`Policies.Posterior.Posterior.Posterior.update()`
	`Policies.ProbabilityPursuit.ProbabilityPursuit.__init__()`
	`Policies.ProbabilityPursuit.ProbabilityPursuit.__str__()`
	`Policies.ProbabilityPursuit.ProbabilityPursuit.choice()`
	`Policies.ProbabilityPursuit.ProbabilityPursuit.choiceFromSubSet()`
	`Policies.ProbabilityPursuit.ProbabilityPursuit.choiceMultiple()`
	`Policies.ProbabilityPursuit.ProbabilityPursuit.choiceWithRank()`
	`Policies.ProbabilityPursuit.ProbabilityPursuit.getReward()`
	`Policies.ProbabilityPursuit.ProbabilityPursuit.startGame()`
	`Policies.SIC_MMAB.SIC_MMAB.__init__()`
	`Policies.SIC_MMAB.SIC_MMAB.__str__()`
	`Policies.SIC_MMAB.SIC_MMAB.choice()`
	`Policies.SIC_MMAB.SIC_MMAB.compute_ucb_lcb()`
	`Policies.SIC_MMAB.SIC_MMAB.getReward()`
	`Policies.SIC_MMAB.SIC_MMAB.handleCollision()`
	`Policies.SIC_MMAB.SIC_MMAB.startGame()`
	`Policies.SIC_MMAB.SIC_MMAB_klUCB.__init__()`
	`Policies.SIC_MMAB.SIC_MMAB_klUCB.__str__()`
	`Policies.SIC_MMAB.SIC_MMAB_klUCB.compute_ucb_lcb()`
	`Policies.SIC_MMAB.SIC_MMAB_UCB.__str__()`
	`Policies.SIC_MMAB.SIC_MMAB_UCB.compute_ucb_lcb()`
	`Policies.SIC_MMAB.State.__new__()`
	`Policies.SIC_MMAB.State._generate_next_value_()`
	`Policies.SlidingWindowRestart.SlidingWindowRestart.__init__()`
	`Policies.SlidingWindowRestart.SlidingWindowRestart.__str__()`
	`Policies.SlidingWindowRestart.SlidingWindowRestart.getReward()`
	`Policies.SlidingWindowRestart.SWR_klUCB.__init__()`
	`Policies.SlidingWindowRestart.SWR_klUCB.__str__()`
	`Policies.SlidingWindowRestart.SWR_klUCB.getReward()`
	`Policies.SlidingWindowRestart.SWR_UCB.__init__()`
	`Policies.SlidingWindowRestart.SWR_UCB.__str__()`
	`Policies.SlidingWindowRestart.SWR_UCB.getReward()`
	`Policies.SlidingWindowRestart.SWR_UCBalpha.__init__()`
	`Policies.SlidingWindowRestart.SWR_UCBalpha.__str__()`
	`Policies.SlidingWindowRestart.SWR_UCBalpha.getReward()`
	`Policies.SlidingWindowUCB.SWUCB.__init__()`
	`Policies.SlidingWindowUCB.SWUCB.__str__()`
	`Policies.SlidingWindowUCB.SWUCB.computeIndex()`
	`Policies.SlidingWindowUCB.SWUCB.getReward()`
	`Policies.SlidingWindowUCB.SWUCBPlus.__init__()`
	`Policies.SlidingWindowUCB.SWUCBPlus.__str__()`
	`Policies.Softmax.Softmax.__init__()`
	`Policies.Softmax.Softmax.__str__()`
	`Policies.Softmax.Softmax.choice()`
	`Policies.Softmax.Softmax.choiceFromSubSet()`
	`Policies.Softmax.Softmax.choiceMultiple()`
	`Policies.Softmax.Softmax.choiceWithRank()`
	`Policies.Softmax.Softmax.estimatedOrder()`
	`Policies.Softmax.Softmax.startGame()`
	`Policies.Softmax.SoftmaxDecreasing.__str__()`
	`Policies.Softmax.SoftmaxWithHorizon.__init__()`
	`Policies.Softmax.SoftmaxWithHorizon.__str__()`
	`Policies.Softmax.SoftMix.__str__()`
	`Policies.SparseklUCB.Phase.__new__()`
	`Policies.SparseklUCB.Phase._generate_next_value_()`
	`Policies.SparseklUCB.SparseklUCB.__init__()`
	`Policies.SparseklUCB.SparseklUCB.__str__()`
	`Policies.SparseklUCB.SparseklUCB.choice()`
	`Policies.SparseklUCB.SparseklUCB.startGame()`
	`Policies.SparseklUCB.SparseklUCB.update_j()`
	`Policies.SparseklUCB.SparseklUCB.update_k()`
	`Policies.SparseUCB.Phase.__new__()`
	`Policies.SparseUCB.Phase._generate_next_value_()`
	`Policies.SparseUCB.SparseUCB.__init__()`
	`Policies.SparseUCB.SparseUCB.__str__()`
	`Policies.SparseUCB.SparseUCB.choice()`
	`Policies.SparseUCB.SparseUCB.startGame()`
	`Policies.SparseUCB.SparseUCB.update_j()`
	`Policies.SparseUCB.SparseUCB.update_k()`
	`Policies.SparseWrapper.Phase.__new__()`
	`Policies.SparseWrapper.Phase._generate_next_value_()`
	`Policies.SparseWrapper.SparseWrapper.__init__()`
	`Policies.SparseWrapper.SparseWrapper.__str__()`
	`Policies.SparseWrapper.SparseWrapper.choice()`
	`Policies.SparseWrapper.SparseWrapper.startGame()`
	`Policies.SparseWrapper.SparseWrapper.update_j()`
	`Policies.SparseWrapper.SparseWrapper.update_k()`
	`Policies.SuccessiveElimination.SuccessiveElimination.choice()`
	`Policies.SWHash_UCB.SWHash_IndexPolicy.__init__()`
	`Policies.SWHash_UCB.SWHash_IndexPolicy.__str__()`
	`Policies.SWHash_UCB.SWHash_IndexPolicy.getReward()`
	`Policies.SWHash_UCB.SWHash_IndexPolicy.startGame()`
	`Policies.TakeFixedArm.TakeFixedArm.__init__()`
	`Policies.TakeFixedArm.TakeFixedArm.__str__()`
	`Policies.TakeFixedArm.TakeFixedArm.choice()`
	`Policies.TakeFixedArm.TakeFixedArm.choiceWithRank()`
	`Policies.TakeFixedArm.TakeFixedArm.getReward()`
	`Policies.TakeFixedArm.TakeFixedArm.startGame()`
	`Policies.TakeRandomFixedArm.TakeRandomFixedArm.__init__()`
	`Policies.TakeRandomFixedArm.TakeRandomFixedArm.__str__()`
	`Policies.TakeRandomFixedArm.TakeRandomFixedArm.choice()`
	`Policies.Thompson.Thompson.computeIndex()`
	`Policies.TrekkingTSN.State.__new__()`
	`Policies.TrekkingTSN.State._generate_next_value_()`
	`Policies.TrekkingTSN.TrekkingTSN.__init__()`
	`Policies.TrekkingTSN.TrekkingTSN.__str__()`
	`Policies.TrekkingTSN.TrekkingTSN._endCCPhase()`
	`Policies.TrekkingTSN.TrekkingTSN.choice()`
	`Policies.TrekkingTSN.TrekkingTSN.getReward()`
	`Policies.TrekkingTSN.TrekkingTSN.handleCollision()`
	`Policies.TrekkingTSN.TrekkingTSN.startGame()`
	`Policies.UCB.UCB.computeAllIndex()`
	`Policies.UCB.UCB.computeIndex()`
	`Policies.UCBalpha.UCBalpha.__init__()`
	`Policies.UCBalpha.UCBalpha.__str__()`
	`Policies.UCBalpha.UCBalpha.computeAllIndex()`
	`Policies.UCBalpha.UCBalpha.computeIndex()`
	`Policies.UCBdagger.UCBdagger.__init__()`
	`Policies.UCBdagger.UCBdagger.__str__()`
	`Policies.UCBdagger.UCBdagger.computeIndex()`
	`Policies.UCBdagger.UCBdagger.getReward()`
	`Policies.UCBH.UCBH.__init__()`
	`Policies.UCBH.UCBH.__str__()`
	`Policies.UCBH.UCBH.computeAllIndex()`
	`Policies.UCBH.UCBH.computeIndex()`
	`Policies.UCBimproved.UCBimproved.__init__()`
	`Policies.UCBimproved.UCBimproved.__str__()`
	`Policies.UCBimproved.UCBimproved.choice()`
	`Policies.UCBimproved.UCBimproved.computeIndex()`
	`Policies.UCBimproved.UCBimproved.update_activeArms()`
	`Policies.UCBmin.UCBmin.computeAllIndex()`
	`Policies.UCBmin.UCBmin.computeIndex()`
	`Policies.UCBoost.UCB_bq.__init__()`
	`Policies.UCBoost.UCB_bq.__str__()`
	`Policies.UCBoost.UCB_bq.computeIndex()`
	`Policies.UCBoost.UCB_h.__init__()`
	`Policies.UCBoost.UCB_h.__str__()`
	`Policies.UCBoost.UCB_h.computeIndex()`
	`Policies.UCBoost.UCB_lb.__init__()`
	`Policies.UCBoost.UCB_lb.__str__()`
	`Policies.UCBoost.UCB_lb.computeIndex()`
	`Policies.UCBoost.UCB_sq.__init__()`
	`Policies.UCBoost.UCB_sq.__str__()`
	`Policies.UCBoost.UCB_sq.computeIndex()`
	`Policies.UCBoost.UCB_t.__init__()`
	`Policies.UCBoost.UCB_t.__str__()`
	`Policies.UCBoost.UCB_t.computeIndex()`
	`Policies.UCBoost.UCBoost.__init__()`
	`Policies.UCBoost.UCBoost.__str__()`
	`Policies.UCBoost.UCBoost.computeIndex()`
	`Policies.UCBoost.UCBoost_bq_h_lb.__init__()`
	`Policies.UCBoost.UCBoost_bq_h_lb.__str__()`
	`Policies.UCBoost.UCBoost_bq_h_lb.computeIndex()`
	`Policies.UCBoost.UCBoost_bq_h_lb_t.__init__()`
	`Policies.UCBoost.UCBoost_bq_h_lb_t.__str__()`
	`Policies.UCBoost.UCBoost_bq_h_lb_t.computeIndex()`
	`Policies.UCBoost.UCBoost_bq_h_lb_t_sq.__init__()`
	`Policies.UCBoost.UCBoost_bq_h_lb_t_sq.__str__()`
	`Policies.UCBoost.UCBoost_bq_h_lb_t_sq.computeIndex()`
	`Policies.UCBoost.UCBoostEpsilon.__init__()`
	`Policies.UCBoost.UCBoostEpsilon.__str__()`
	`Policies.UCBoost.UCBoostEpsilon.computeIndex()`
	`Policies.UCBplus.UCBplus.__str__()`
	`Policies.UCBplus.UCBplus.computeAllIndex()`
	`Policies.UCBplus.UCBplus.computeIndex()`
	`Policies.UCBrandomInit.UCBrandomInit.__init__()`
	`Policies.UCBrandomInit.UCBrandomInit.choice()`
	`Policies.UCBV.UCBV.__init__()`
	`Policies.UCBV.UCBV.__str__()`
	`Policies.UCBV.UCBV.computeAllIndex()`
	`Policies.UCBV.UCBV.computeIndex()`
	`Policies.UCBV.UCBV.getReward()`
	`Policies.UCBV.UCBV.startGame()`
	`Policies.UCBVtuned.UCBVtuned.__str__()`
	`Policies.UCBVtuned.UCBVtuned.computeAllIndex()`
	`Policies.UCBVtuned.UCBVtuned.computeIndex()`
	`Policies.Uniform.Uniform.__init__()`
	`Policies.Uniform.Uniform.__str__()`
	`Policies.Uniform.Uniform.choice()`
	`Policies.Uniform.Uniform.choiceWithRank()`
	`Policies.Uniform.Uniform.getReward()`
	`Policies.Uniform.Uniform.startGame()`
	`Policies.UniformOnSome.UniformOnSome.__init__()`
	`Policies.UniformOnSome.UniformOnSome.__str__()`
	`Policies.UniformOnSome.UniformOnSome.choice()`
	`Policies.WrapRange.WrapRange.__init__()`
	`Policies.WrapRange.WrapRange.__str__()`
	`Policies.WrapRange.WrapRange.choice()`
	`Policies.WrapRange.WrapRange.choiceFromSubSet()`
	`Policies.WrapRange.WrapRange.choiceIMP()`
	`Policies.WrapRange.WrapRange.choiceMultiple()`
	`Policies.WrapRange.WrapRange.choiceWithRank()`
	`Policies.WrapRange.WrapRange.computeAllIndex()`
	`Policies.WrapRange.WrapRange.computeIndex()`
	`Policies.WrapRange.WrapRange.estimatedBestArms()`
	`Policies.WrapRange.WrapRange.estimatedOrder()`
	`Policies.WrapRange.WrapRange.getReward()`
	`Policies.WrapRange.WrapRange.startGame()`
	`PoliciesMultiPlayers`
	`PoliciesMultiPlayers.ALOHA.ALOHA.__init__()`
	`PoliciesMultiPlayers.ALOHA.ALOHA.__str__()`
	`PoliciesMultiPlayers.ALOHA.oneALOHA.__init__()`
	`PoliciesMultiPlayers.ALOHA.oneALOHA.__str__()`
	`PoliciesMultiPlayers.ALOHA.oneALOHA.choice()`
	`PoliciesMultiPlayers.ALOHA.oneALOHA.ftnext()`
	`PoliciesMultiPlayers.ALOHA.oneALOHA.getReward()`
	`PoliciesMultiPlayers.ALOHA.oneALOHA.handleCollision()`
	`PoliciesMultiPlayers.ALOHA.oneALOHA.startGame()`
	`PoliciesMultiPlayers.BaseCentralizedPolicy.BaseCentralizedPolicy.__init__()`
	`PoliciesMultiPlayers.BaseCentralizedPolicy.BaseCentralizedPolicy.__str__()`
	`PoliciesMultiPlayers.BaseCentralizedPolicy.BaseCentralizedPolicy.choice()`
	`PoliciesMultiPlayers.BaseCentralizedPolicy.BaseCentralizedPolicy.getReward()`
	`PoliciesMultiPlayers.BaseCentralizedPolicy.BaseCentralizedPolicy.startGame()`
	`PoliciesMultiPlayers.BaseMPPolicy.BaseMPPolicy.__init__()`
	`PoliciesMultiPlayers.BaseMPPolicy.BaseMPPolicy.__str__()`
	`PoliciesMultiPlayers.BaseMPPolicy.BaseMPPolicy._choice_one()`
	`PoliciesMultiPlayers.BaseMPPolicy.BaseMPPolicy._choiceFromSubSet_one()`
	`PoliciesMultiPlayers.BaseMPPolicy.BaseMPPolicy._choiceIMP_one()`
	`PoliciesMultiPlayers.BaseMPPolicy.BaseMPPolicy._choiceMultiple_one()`
	`PoliciesMultiPlayers.BaseMPPolicy.BaseMPPolicy._choiceWithRank_one()`
	`PoliciesMultiPlayers.BaseMPPolicy.BaseMPPolicy._estimatedBestArms_one()`
	`PoliciesMultiPlayers.BaseMPPolicy.BaseMPPolicy._estimatedOrder_one()`
	`PoliciesMultiPlayers.BaseMPPolicy.BaseMPPolicy._getReward_one()`
	`PoliciesMultiPlayers.BaseMPPolicy.BaseMPPolicy._startGame_one()`
	`PoliciesMultiPlayers.CentralizedCycling.CentralizedCycling.__init__()`
	`PoliciesMultiPlayers.CentralizedCycling.CentralizedCycling.__str__()`
	`PoliciesMultiPlayers.CentralizedCycling.CentralizedCycling._printNbCollisions()`
	`PoliciesMultiPlayers.CentralizedCycling.Cycling.__init__()`
	`PoliciesMultiPlayers.CentralizedCycling.Cycling.__str__()`
	`PoliciesMultiPlayers.CentralizedCycling.Cycling.choice()`
	`PoliciesMultiPlayers.CentralizedCycling.Cycling.getReward()`
	`PoliciesMultiPlayers.CentralizedCycling.Cycling.startGame()`
	`PoliciesMultiPlayers.CentralizedFixed.CentralizedFixed.__init__()`
	`PoliciesMultiPlayers.CentralizedFixed.CentralizedFixed.__str__()`
	`PoliciesMultiPlayers.CentralizedFixed.CentralizedFixed._choice_one()`
	`PoliciesMultiPlayers.CentralizedFixed.CentralizedFixed._getReward_one()`
	`PoliciesMultiPlayers.CentralizedFixed.CentralizedFixed._printNbCollisions()`
	`PoliciesMultiPlayers.CentralizedFixed.CentralizedFixed._startGame_one()`
	`PoliciesMultiPlayers.CentralizedFixed.Fixed.__init__()`
	`PoliciesMultiPlayers.CentralizedFixed.Fixed.__str__()`
	`PoliciesMultiPlayers.CentralizedFixed.Fixed.choice()`
	`PoliciesMultiPlayers.CentralizedFixed.Fixed.getReward()`
	`PoliciesMultiPlayers.CentralizedFixed.Fixed.startGame()`
	`PoliciesMultiPlayers.CentralizedIMP.CentralizedIMP._choice_one()`
	`PoliciesMultiPlayers.CentralizedMultiplePlay.CentralizedChildPointer.__repr__()`
	`PoliciesMultiPlayers.CentralizedMultiplePlay.CentralizedChildPointer.__str__()`
	`PoliciesMultiPlayers.CentralizedMultiplePlay.CentralizedMultiplePlay.__init__()`
	`PoliciesMultiPlayers.CentralizedMultiplePlay.CentralizedMultiplePlay.__str__()`
	`PoliciesMultiPlayers.CentralizedMultiplePlay.CentralizedMultiplePlay._choice_one()`
	`PoliciesMultiPlayers.CentralizedMultiplePlay.CentralizedMultiplePlay._estimatedOrder_one()`
	`PoliciesMultiPlayers.CentralizedMultiplePlay.CentralizedMultiplePlay._getReward_one()`
	`PoliciesMultiPlayers.CentralizedMultiplePlay.CentralizedMultiplePlay._handleCollision_one()`
	`PoliciesMultiPlayers.CentralizedMultiplePlay.CentralizedMultiplePlay._startGame_one()`
	`PoliciesMultiPlayers.ChildPointer.ChildPointer.__init__()`
	`PoliciesMultiPlayers.ChildPointer.ChildPointer.__repr__()`
	`PoliciesMultiPlayers.ChildPointer.ChildPointer.__str__()`
	`PoliciesMultiPlayers.ChildPointer.ChildPointer.choice()`
	`PoliciesMultiPlayers.ChildPointer.ChildPointer.choiceFromSubSet()`
	`PoliciesMultiPlayers.ChildPointer.ChildPointer.choiceIMP()`
	`PoliciesMultiPlayers.ChildPointer.ChildPointer.choiceMultiple()`
	`PoliciesMultiPlayers.ChildPointer.ChildPointer.choiceWithRank()`
	`PoliciesMultiPlayers.ChildPointer.ChildPointer.estimatedBestArms()`
	`PoliciesMultiPlayers.ChildPointer.ChildPointer.estimatedOrder()`
	`PoliciesMultiPlayers.ChildPointer.ChildPointer.getReward()`
	`PoliciesMultiPlayers.ChildPointer.ChildPointer.handleCollision()`
	`PoliciesMultiPlayers.ChildPointer.ChildPointer.startGame()`
	`PoliciesMultiPlayers.EstimateM.EstimateM.__init__()`
	`PoliciesMultiPlayers.EstimateM.EstimateM.__str__()`
	`PoliciesMultiPlayers.EstimateM.oneEstimateM.__init__()`
	`PoliciesMultiPlayers.EstimateM.oneEstimateM.__str__()`
	`PoliciesMultiPlayers.EstimateM.oneEstimateM.choice()`
	`PoliciesMultiPlayers.EstimateM.oneEstimateM.choiceFromSubSet()`
	`PoliciesMultiPlayers.EstimateM.oneEstimateM.choiceIMP()`
	`PoliciesMultiPlayers.EstimateM.oneEstimateM.choiceMultiple()`
	`PoliciesMultiPlayers.EstimateM.oneEstimateM.choiceWithRank()`
	`PoliciesMultiPlayers.EstimateM.oneEstimateM.estimatedBestArms()`
	`PoliciesMultiPlayers.EstimateM.oneEstimateM.estimatedOrder()`
	`PoliciesMultiPlayers.EstimateM.oneEstimateM.getReward()`
	`PoliciesMultiPlayers.EstimateM.oneEstimateM.handleCollision()`
	`PoliciesMultiPlayers.EstimateM.oneEstimateM.startGame()`
	`PoliciesMultiPlayers.EstimateM.oneEstimateM.updateNbPlayers()`
	`PoliciesMultiPlayers.OracleFair.CyclingBest.__init__()`
	`PoliciesMultiPlayers.OracleFair.CyclingBest.__str__()`
	`PoliciesMultiPlayers.OracleFair.CyclingBest.choice()`
	`PoliciesMultiPlayers.OracleFair.CyclingBest.getReward()`
	`PoliciesMultiPlayers.OracleFair.CyclingBest.startGame()`
	`PoliciesMultiPlayers.OracleFair.OracleFair.__init__()`
	`PoliciesMultiPlayers.OracleFair.OracleFair.__str__()`
	`PoliciesMultiPlayers.OracleFair.OracleFair._printNbCollisions()`
	`PoliciesMultiPlayers.OracleNotFair.Fixed.__init__()`
	`PoliciesMultiPlayers.OracleNotFair.Fixed.__str__()`
	`PoliciesMultiPlayers.OracleNotFair.Fixed.choice()`
	`PoliciesMultiPlayers.OracleNotFair.Fixed.getReward()`
	`PoliciesMultiPlayers.OracleNotFair.Fixed.startGame()`
	`PoliciesMultiPlayers.OracleNotFair.OracleNotFair.__init__()`
	`PoliciesMultiPlayers.OracleNotFair.OracleNotFair.__str__()`
	`PoliciesMultiPlayers.OracleNotFair.OracleNotFair._printNbCollisions()`
	`PoliciesMultiPlayers.RandTopM.MCTopM.__init__()`
	`PoliciesMultiPlayers.RandTopM.MCTopM.__str__()`
	`PoliciesMultiPlayers.RandTopM.MCTopMCautious.__init__()`
	`PoliciesMultiPlayers.RandTopM.MCTopMCautious.__str__()`
	`PoliciesMultiPlayers.RandTopM.MCTopMExtraCautious.__init__()`
	`PoliciesMultiPlayers.RandTopM.MCTopMExtraCautious.__str__()`
	`PoliciesMultiPlayers.RandTopM.MCTopMOld.__init__()`
	`PoliciesMultiPlayers.RandTopM.MCTopMOld.__str__()`
	`PoliciesMultiPlayers.RandTopM.oneRandTopM.__init__()`
	`PoliciesMultiPlayers.RandTopM.oneRandTopM.__str__()`
	`PoliciesMultiPlayers.RandTopM.oneRandTopM._index()`
	`PoliciesMultiPlayers.RandTopM.oneRandTopM.choice()`
	`PoliciesMultiPlayers.RandTopM.oneRandTopM.getReward()`
	`PoliciesMultiPlayers.RandTopM.oneRandTopM.handleCollision()`
	`PoliciesMultiPlayers.RandTopM.oneRandTopM.Mbest()`
	`PoliciesMultiPlayers.RandTopM.oneRandTopM.startGame()`
	`PoliciesMultiPlayers.RandTopM.oneRandTopM.worst_Mbest()`
	`PoliciesMultiPlayers.RandTopM.oneRandTopM.worst_previous__and__current_Mbest()`
	`PoliciesMultiPlayers.RandTopM.RandTopM.__init__()`
	`PoliciesMultiPlayers.RandTopM.RandTopM.__str__()`
	`PoliciesMultiPlayers.RandTopM.RandTopMCautious.__init__()`
	`PoliciesMultiPlayers.RandTopM.RandTopMCautious.__str__()`
	`PoliciesMultiPlayers.RandTopM.RandTopMExtraCautious.__init__()`
	`PoliciesMultiPlayers.RandTopM.RandTopMExtraCautious.__str__()`
	`PoliciesMultiPlayers.RandTopM.RandTopMOld.__init__()`
	`PoliciesMultiPlayers.RandTopM.RandTopMOld.__str__()`
	`PoliciesMultiPlayers.RandTopMEst.MCTopMEst.__init__()`
	`PoliciesMultiPlayers.RandTopMEst.MCTopMEst.__str__()`
	`PoliciesMultiPlayers.RandTopMEst.MCTopMEstPlus.__init__()`
	`PoliciesMultiPlayers.RandTopMEst.MCTopMEstPlus.__str__()`
	`PoliciesMultiPlayers.RandTopMEst.oneRandTopMEst.__init__()`
	`PoliciesMultiPlayers.RandTopMEst.oneRandTopMEst.__str__()`
	`PoliciesMultiPlayers.RandTopMEst.oneRandTopMEst.getReward()`
	`PoliciesMultiPlayers.RandTopMEst.oneRandTopMEst.handleCollision()`
	`PoliciesMultiPlayers.RandTopMEst.oneRandTopMEst.startGame()`
	`PoliciesMultiPlayers.RandTopMEst.RandTopMEst.__init__()`
	`PoliciesMultiPlayers.RandTopMEst.RandTopMEst.__str__()`
	`PoliciesMultiPlayers.RandTopMEst.RandTopMEstPlus.__init__()`
	`PoliciesMultiPlayers.RandTopMEst.RandTopMEstPlus.__str__()`
	`PoliciesMultiPlayers.rhoCentralized.oneRhoCentralized.__init__()`
	`PoliciesMultiPlayers.rhoCentralized.oneRhoCentralized.__str__()`
	`PoliciesMultiPlayers.rhoCentralized.oneRhoCentralized.choice()`
	`PoliciesMultiPlayers.rhoCentralized.oneRhoCentralized.handleCollision()`
	`PoliciesMultiPlayers.rhoCentralized.oneRhoCentralized.startGame()`
	`PoliciesMultiPlayers.rhoCentralized.rhoCentralized.__init__()`
	`PoliciesMultiPlayers.rhoCentralized.rhoCentralized.__str__()`
	`PoliciesMultiPlayers.rhoEst.oneRhoEst.__init__()`
	`PoliciesMultiPlayers.rhoEst.oneRhoEst.__str__()`
	`PoliciesMultiPlayers.rhoEst.oneRhoEst.getReward()`
	`PoliciesMultiPlayers.rhoEst.oneRhoEst.handleCollision()`
	`PoliciesMultiPlayers.rhoEst.oneRhoEst.startGame()`
	`PoliciesMultiPlayers.rhoEst.rhoEst.__init__()`
	`PoliciesMultiPlayers.rhoEst.rhoEst.__str__()`
	`PoliciesMultiPlayers.rhoEst.rhoEstPlus.__init__()`
	`PoliciesMultiPlayers.rhoEst.rhoEstPlus.__str__()`
	`PoliciesMultiPlayers.rhoLearn.oneRhoLearn.__init__()`
	`PoliciesMultiPlayers.rhoLearn.oneRhoLearn.__str__()`
	`PoliciesMultiPlayers.rhoLearn.oneRhoLearn.getReward()`
	`PoliciesMultiPlayers.rhoLearn.oneRhoLearn.handleCollision()`
	`PoliciesMultiPlayers.rhoLearn.oneRhoLearn.startGame()`
	`PoliciesMultiPlayers.rhoLearn.rhoLearn.__init__()`
	`PoliciesMultiPlayers.rhoLearn.rhoLearn.__str__()`
	`PoliciesMultiPlayers.rhoLearnEst.oneRhoLearnEst.__str__()`
	`PoliciesMultiPlayers.rhoLearnEst.rhoLearnEst.__init__()`
	`PoliciesMultiPlayers.rhoLearnEst.rhoLearnEst.__str__()`
	`PoliciesMultiPlayers.rhoLearnExp3.oneRhoLearnExp3.__init__()`
	`PoliciesMultiPlayers.rhoLearnExp3.oneRhoLearnExp3.__str__()`
	`PoliciesMultiPlayers.rhoLearnExp3.oneRhoLearnExp3.getReward()`
	`PoliciesMultiPlayers.rhoLearnExp3.oneRhoLearnExp3.handleCollision()`
	`PoliciesMultiPlayers.rhoLearnExp3.oneRhoLearnExp3.startGame()`
	`PoliciesMultiPlayers.rhoLearnExp3.rhoLearnExp3.__init__()`
	`PoliciesMultiPlayers.rhoLearnExp3.rhoLearnExp3.__str__()`
	`PoliciesMultiPlayers.rhoRand.oneRhoRand.__init__()`
	`PoliciesMultiPlayers.rhoRand.oneRhoRand.__str__()`
	`PoliciesMultiPlayers.rhoRand.oneRhoRand.choice()`
	`PoliciesMultiPlayers.rhoRand.oneRhoRand.handleCollision()`
	`PoliciesMultiPlayers.rhoRand.oneRhoRand.startGame()`
	`PoliciesMultiPlayers.rhoRand.rhoRand.__init__()`
	`PoliciesMultiPlayers.rhoRand.rhoRand.__str__()`
	`PoliciesMultiPlayers.rhoRandALOHA.oneRhoRandALOHA.__init__()`
	`PoliciesMultiPlayers.rhoRandALOHA.oneRhoRandALOHA.__str__()`
	`PoliciesMultiPlayers.rhoRandALOHA.oneRhoRandALOHA.getReward()`
	`PoliciesMultiPlayers.rhoRandALOHA.oneRhoRandALOHA.handleCollision()`
	`PoliciesMultiPlayers.rhoRandALOHA.oneRhoRandALOHA.startGame()`
	`PoliciesMultiPlayers.rhoRandALOHA.rhoRandALOHA.__init__()`
	`PoliciesMultiPlayers.rhoRandALOHA.rhoRandALOHA.__str__()`
	`PoliciesMultiPlayers.rhoRandRand.oneRhoRandRand.__init__()`
	`PoliciesMultiPlayers.rhoRandRand.oneRhoRandRand.__str__()`
	`PoliciesMultiPlayers.rhoRandRand.oneRhoRandRand.choice()`
	`PoliciesMultiPlayers.rhoRandRand.oneRhoRandRand.handleCollision()`
	`PoliciesMultiPlayers.rhoRandRand.oneRhoRandRand.startGame()`
	`PoliciesMultiPlayers.rhoRandRand.rhoRandRand.__init__()`
	`PoliciesMultiPlayers.rhoRandRand.rhoRandRand.__str__()`
	`PoliciesMultiPlayers.rhoRandRotating.oneRhoRandRotating.__init__()`
	`PoliciesMultiPlayers.rhoRandRotating.oneRhoRandRotating.__str__()`
	`PoliciesMultiPlayers.rhoRandRotating.oneRhoRandRotating.choice()`
	`PoliciesMultiPlayers.rhoRandRotating.oneRhoRandRotating.handleCollision()`
	`PoliciesMultiPlayers.rhoRandRotating.oneRhoRandRotating.startGame()`
	`PoliciesMultiPlayers.rhoRandRotating.rhoRandRotating.__init__()`
	`PoliciesMultiPlayers.rhoRandRotating.rhoRandRotating.__str__()`
	`PoliciesMultiPlayers.rhoRandSticky.oneRhoRandSticky.__init__()`
	`PoliciesMultiPlayers.rhoRandSticky.oneRhoRandSticky.__str__()`
	`PoliciesMultiPlayers.rhoRandSticky.oneRhoRandSticky.getReward()`
	`PoliciesMultiPlayers.rhoRandSticky.oneRhoRandSticky.handleCollision()`
	`PoliciesMultiPlayers.rhoRandSticky.oneRhoRandSticky.startGame()`
	`PoliciesMultiPlayers.rhoRandSticky.rhoRandSticky.__init__()`
	`PoliciesMultiPlayers.rhoRandSticky.rhoRandSticky.__str__()`
	`PoliciesMultiPlayers.Scenario1.OneScenario1.__init__()`
	`PoliciesMultiPlayers.Scenario1.OneScenario1.__repr__()`
	`PoliciesMultiPlayers.Scenario1.OneScenario1.__str__()`
	`PoliciesMultiPlayers.Scenario1.Scenario1.__init__()`
	`PoliciesMultiPlayers.Scenario1.Scenario1.__str__()`
	`PoliciesMultiPlayers.Scenario1.Scenario1._choice_one()`
	`PoliciesMultiPlayers.Scenario1.Scenario1._getReward_one()`
	`PoliciesMultiPlayers.Scenario1.Scenario1._startGame_one()`
	`PoliciesMultiPlayers.Selfish.Selfish.__init__()`
	`PoliciesMultiPlayers.Selfish.Selfish.__str__()`
	`PoliciesMultiPlayers.Selfish.Selfish._handleCollision_one()`
	`PoliciesMultiPlayers.Selfish.SelfishChildPointer.__str__()`

Python Method Index

All index pages:¶