private void OnTriggerEnter2D(Collider2D collision)
{
if (collision.CompareTag("Enemy") || collision.CompareTag("Boss"))
{
float damage = Probabilities.RandomNormalVariable(10f, 3f, 5, 20) * 1.5f;
DamagePopup.Create(transform.position, Convert.ToInt32(damage));
if (collision.GetComponent <WalkMonsterController>())
{
collision.GetComponent <WalkMonsterController>().health -= damage;
}
if (collision.GetComponent <ShootingEnemyController>())
{
collision.GetComponent <ShootingEnemyController>().health -= damage;
}
if (collision.GetComponent <BossController>())
{
collision.GetComponent <BossController>().health -= damage;
}
Destroy(gameObject);
}
if (collision.CompareTag("Wall"))
{
Destroy(gameObject);
}
}
static void Main(string[] args)
{
Probabilities[] transitions = new Probabilities[9];
transitions[0] = new Probabilities('a', 'a', 0.9);
transitions[1] = new Probabilities('a', 'b', 0.075);
transitions[2] = new Probabilities('a', 'c', 0.025);
transitions[3] = new Probabilities('b', 'a', 0.15);
transitions[4] = new Probabilities('b', 'b', 0.8);
transitions[5] = new Probabilities('b', 'c', 0.05);
transitions[6] = new Probabilities('c', 'a', 0.25);
transitions[7] = new Probabilities('c', 'b', 0.25);
transitions[8] = new Probabilities('c', 'c', 0.5);
Console.Write("Insert starting state: ");
char startingState = Convert.ToChar(Console.ReadLine());
Console.Write("Insert number of steps: ");
int num_steps = Convert.ToInt32(Console.ReadLine());
var r = MarkovChain(startingState, transitions, num_steps);
Console.WriteLine("\nThis instance of Markov chain produced: ");
foreach (var k in r)
{
Console.WriteLine($"'{k.Key}': {k.Value},");
}
}
/// <summary>
/// Allocating memory for matrices inside <see cref="Probabilities"/>.
/// </summary>
private void AllocateMemoryAndInitialize()
{
QProbabilities = new Dictionary <string, Dictionary <State, double[][]> >();
foreach (var(policyId, v) in policies)
{
var(initialState, initialDuration) = PolicyIdInitialStateDuration[policyId];
var numberOfTimePoints = GetNumberOfTimePoints(v, Time);
var stateProbabilities = new Dictionary <State, double[][]>();
foreach (var state in MarketStateSpace)
{
var arrayOfArray = new double[numberOfTimePoints][];
for (var timeIndex = 0; timeIndex < numberOfTimePoints; timeIndex++)
{
arrayOfArray[timeIndex] =
new double[DurationSupportIndex(initialDuration, timeIndex) + 1];
}
// Default values of array elements are zero, so we only set probability for last duration to one.
arrayOfArray[0][arrayOfArray[0].Length - 1] = state == initialState ? 1 : 0;
stateProbabilities.Add(state, arrayOfArray);
}
Probabilities.Add(policyId, stateProbabilities);
}
}
//Old implementation
public static int PickFromGeometric(int nbPossibilities, float p)
{
float randomValue = Random.Range(0f, 1f);
float previous = 0f;
float next = 0.1f;
List <float> computedProbas = Probabilities.GeometricProbas(nbPossibilities, p);;
for (int i = 0; i < computedProbas.Count; i++)
{
if (i == computedProbas.Count - 1)
{
next = 1;
}
else
{
next = computedProbas[i];
}
if (randomValue > previous && randomValue <= next)
{
return(i);
}
previous = next;
}
return(0);
}
private void OnTriggerEnter2D(Collider2D collision)
{
if (health <= 0)
{
float probability = Probabilities.RandomExponentialVairable(1.0f);
print(probability);
if (probability < 1.2f)
{
Instantiate(GameAssets.i.OneApple, transform.position, Quaternion.Euler(0, 0, 0));
}
else if (probability < 2.2f)
{
Instantiate(GameAssets.i.TwoApples, transform.position, Quaternion.Euler(0, 0, 0));
}
else if (probability < 3.0f)
{
Instantiate(GameAssets.i.TwoApples, transform.position, Quaternion.Euler(0, 0, 0));
}
else
{
Instantiate(GameAssets.i.TwoApples, transform.position, Quaternion.Euler(0, 0, 0));
}
Destroy(gameObject);
}
}
public static int PickFromPoisson(int nbPossibilities, float lambda)
{
float randomValue = Random.Range(0f, 1f);
float previous = 0f;
float next = 0.1f;
List <float> computedProbas = Probabilities.PoissonProbas(nbPossibilities, lambda);
for (int i = 0; i < computedProbas.Count; i++)
{
if (i == computedProbas.Count - 1)
{
next = 1;
}
else
{
next = computedProbas[i];
}
if (randomValue > previous && randomValue <= next)
{
//Debug.Log(i);
return(i);
}
previous = next;
}
return(0);
}
public IViewComponentResult Invoke(decimal preTestProbability, decimal postTestProbability, decimal observed, bool lviReported)
{
Probabilities probabilityData = new Probabilities(preTestProbability, postTestProbability, observed, lviReported);
probabilityData.CalculateConcordance();
return(View(probabilityData));
}
void Start()
{
rb = GetComponent <Rigidbody2D>();
mousePosition = Camera.main.ScreenToWorldPoint(Input.mousePosition);
moveDirection = (mousePosition - transform.position).normalized;
rb.velocity = new Vector2(moveDirection.x * moveSpeed, moveDirection.y * moveSpeed);
probabilities = GetComponent <Probabilities>();
}
/// <summary>
/// Creates a new object that is a copy of the current instance.
/// </summary>
///
/// <returns>
/// A new object that is a copy of this instance.
/// </returns>
///
public object Clone()
{
double[,] A = (double[, ])Transitions.Clone();
double[,] B = (double[, ])Emissions.Clone();
double[] pi = (double[])Probabilities.Clone();
return(new HiddenMarkovModel(A, B, pi, logarithm: true));
}
public List <SummaryInfo> BuildInformationSummary()
{
var result = new List <SummaryInfo>();
var roadsOrderedByProbability = Probabilities.OrderByDescending(x => x.Value).Select(x => x.Key).ToList();
foreach (var road in roadsOrderedByProbability)
{
var info = new SummaryInfo
{
StartEndNodeIds = string.Format("{0} -> {1}", road.Start, road.End),
EmissionProbability = Round(Emissions[road].Probability),
EmissionDistance = Round(Emissions[road].Distance.DistanceInMeters),
Probability = Probabilities[road],
};
// Assign road name
if (road.Name != "")
{
info.RoadName = road.Name;
}
else
{
info.RoadName = "[NoName]";
}
if (PrevProbabilities.ContainsKey(road))
{
info.PrevProbability = Round(PrevProbabilities[road]);
}
else
{
info.PrevProbability = 0;
}
if (Transitions.Count > 0)
{
CandidateInfo roadInfo = this.CandidateDetails[road];
// most probable transition to get to the current road
info.TransitionProbability = Round(roadInfo.P_Transition);
var fromRoad = roadInfo.From;
if (fromRoad.Name != "")
{
info.FromName = fromRoad.Name;
}
else
{
info.FromName = "[NoName]";
}
info.FromStartEndIds = string.Format("{0} -> {1}", fromRoad.Start, fromRoad.End);
info.PrevProbOfFrom = roadInfo.P_From;
}
result.Add(info);
}
return(result);
}
public void InitializeProbabilities()
{
//Probabilities.Clear();
Probabilities.Add(Tier.One, 0);
Probabilities.Add(Tier.Two, 0);
Probabilities.Add(Tier.Three, 0);
Probabilities.Add(Tier.Four, 0);
}
/// <summary>Gets statistic for.</summary>
/// <exception cref="IndexOutOfRangeException">
/// Thrown when the index is outside the required
/// range.
/// </exception>
/// <param name="x">The x coordinate.</param>
/// <returns>The statistic for.</returns>
internal Statistic GetStatisticFor(double x)
{
if (Probabilities == null || Probabilities.Length == 0)
throw new IndexOutOfRangeException("Invalid statistics");
var p = Probabilities.FirstOrDefault(s => s.X.Test(x));
return p;
}
public float GetRawProbability(string statusId)
{
if (Probabilities.ContainsKey(statusId) == false)
{
Debug.LogError(string.Format("{0} status not found. Difficulty : {1}", statusId, difficulty.ToString()));
return(0f);
}
return(Probabilities[statusId]);
}
public void AddItem(T item, float probability)
{
Items
.Add(item);
MaximumProbability += probability;
Probabilities
.Add(MaximumProbability);
}
public bool IsRandomActivated(string statusId)
{
if (Probabilities.ContainsKey(statusId) == false)
{
Debug.LogError(string.Format("{0} status not found. Difficulty : {1}", statusId, difficulty.ToString()));
return(false);
}
return(Probabilities[statusId] > Random.Range(0f, 0.9999f)); // 1f로 하면 1f도 나올 수 있음 : min [inclusive] and max [inclusive]
}
public PokerAgent()
{
myProb = new Probabilities();
opProb = new Probabilities();
unseenCards = new List <Card>();
rnd = new Random();
agressiveRaise = 8; // 0-100 indicate the random for casual raise.
agressiveMoney = 30; // 0-100 indicate the minimum raise fruction.
decieveOponnent = 40;
detector = 0;
}
public void PrepareData()
{
double totalSongsCount = Convert.ToDouble(Clusterizer.ClusterizedSongs.Count);
Probabilities.Clear();
foreach (List <Song> cluster in Clusterizer.Clusters)
{
double clusterCardinality = Convert.ToDouble(cluster.Count);
Probabilities.Add(clusterCardinality / totalSongsCount);
}
}
/// <summary>
/// Creates a new object that is a copy of the current instance.
/// </summary>
///
/// <returns>
/// A new object that is a copy of this instance.
/// </returns>
///
public object Clone()
{
double[,] A = (double[, ])Transitions.Clone();
double[] pi = (double[])Probabilities.Clone();
TDistribution[] B = new TDistribution[Emissions.Length];
for (int i = 0; i < Emissions.Length; i++)
{
B[i] = (TDistribution)Emissions[i].Clone();
}
return(new HiddenMarkovModel <TDistribution>(A, B, pi, logarithm: true));
}
/// <summary>
/// Converts this <see cref="HiddenMarkovModel">Discrete density Hidden Markov Model</see>
/// into a <see cref="HiddenMarkovModel{TDistribution}">arbitrary density model</see>.
/// </summary>
public HiddenMarkovModel <GeneralDiscreteDistribution> ToContinuousModel()
{
var transitions = (double[, ])Transitions.Clone();
var probabilities = (double[])Probabilities.Clone();
var emissions = new GeneralDiscreteDistribution[States];
for (int i = 0; i < emissions.Length; i++)
{
emissions[i] = new GeneralDiscreteDistribution(Accord.Math.Matrix.GetRow(Emissions, i));
}
return(new HiddenMarkovModel <GeneralDiscreteDistribution>(transitions, emissions, probabilities));
}
public void GetProbabilities(ulong pockets, ulong board,
out float ppot, out float npot,
out float hs, out float wp)
{
ulong isoPockets, isoBoard;
Transform(pockets, board, out isoPockets, out isoBoard);
Probabilities prob = probabilities[isoPockets][isoBoard];
ppot = prob.PositivePotential;
npot = prob.NegativePotential;
hs = prob.HandStrength;
wp = prob.WinProbability;
}
public List <S> GetMostLikelySequence()
{
if (Probabilities != null && Probabilities.Count > 0)
{
// get most probable road
S mostLikelyState = Probabilities.GetMostProbableItem();
// trace back most likely sequence
List <S> result = TransitionMemory.TraceBackSequence(mostLikelyState);
return(result);
}
else
{
return(new List <S>());
}
}
private Probabilities CalculateProbabilityNormalization(Particle lbest, Particle gbest)
{
List <MutationSet> sets = d_state.MutationSets;
Probabilities probabilities = new Probabilities();
Particle current = this[0];
// First count the number of possible mutations for each
// mutation set, regarding Pe, Pl and Pg
for (int i = 0; i < sets.Count; ++i)
{
// Counter for Pe
probabilities.Exploration += sets[i].Count - 1;
// Counter for Pl
if (lbest != null && lbest.ActiveSet[i] != current.ActiveSet[i])
{
// Count only when not in the lbest configuration right now
probabilities.Cognitive += 1;
}
// Counter for Pg
if (gbest != null && gbest.ActiveSet[i] != current.ActiveSet[i])
{
// Count only when not in the gbest configuration right now
probabilities.Social += 1;
}
}
// And then normalize it
// P_ret = 1 - (1 - P_val)^(1 / P_count)
if (probabilities.Exploration != 0)
{
probabilities.Exploration = 1 - System.Math.Pow(1 - d_state.MutationProbability, 1 / probabilities.Exploration);
}
if (probabilities.Cognitive != 0)
{
probabilities.Cognitive = 1 - System.Math.Pow(1 - d_state.CognitiveMutationProbability, 1 / probabilities.Cognitive);
}
if (probabilities.Social != 0)
{
probabilities.Social = 1 - System.Math.Pow(1 - d_state.SocialMutationProbability, 1 / probabilities.Social);
}
return(probabilities);
}
public MainWindow()
{
InitializeComponent();
Canvas1.DefaultDrawingAttributes.Width = 20;
Canvas1.DefaultDrawingAttributes.Height = 20;
Canvas1.DefaultDrawingAttributes.Color = Color.FromRgb(255, 255, 255);
// DispatcherTimer setup
dispatcherTimer = new DispatcherTimer();
dispatcherTimer.Tick += new EventHandler(dispatcherTimer_Tick);
dispatcherTimer.Interval = new TimeSpan(0, 0, 0, 0, 100);
dispatcherTimer.Start();
probabilities = (Probabilities)(Resources["probabilities"]);
}
private double[] CalculateMutationProbabilities(int mutationIndex, Probabilities probabilities, MutationSet s, Particle gbest)
{
double[] ret = new double[s.Count];
for (int i = 0; i < ret.Length; ++i)
{
ret[i] = 1;
}
List <uint> activeSet = this[0].ActiveSet;
for (int i = 0; i < s.Count; ++i)
{
// Don't care about non-mutation, since it's just the inverse
// of the mutation probability
if (activeSet[mutationIndex] == i)
{
continue;
}
// Exploration mutation probability
ret[i] *= 1 - probabilities.Exploration;
// Super local best mutation probability
if (d_best != null && d_best.ActiveSet[mutationIndex] == i)
{
ret[i] *= 1 - probabilities.Cognitive;
}
// Super global best mutation probability
if (gbest != null && gbest.ActiveSet[mutationIndex] == i)
{
ret[i] *= 1 - probabilities.Social;
}
}
for (int i = 0; i < ret.Length; ++i)
{
ret[i] = 1 - ret[i];
}
return(ret);
}
private IEnumerator Rotate()
{
stopped = false;
timeInterval = 0.025f;
//Disabling buttons
greenButton.GetComponent <Button>().interactable = false;
blackButton.GetComponent <Button>().interactable = false;
redButton.GetComponent <Button>().interactable = false;
for (int y = 0; y < 15 * 4; y++)
{
RotateAllIncrement();
yield return(new WaitForSeconds(timeInterval));
}
int randomValue = Probabilities.GeometricPick(geoParam) + 1;
UserStats.RouletteSpins += randomValue;
for (int y = 0; y < 15 * 4 * randomValue; y++)
{
RotateAllIncrement();
yield return(new WaitForSeconds(timeInterval));
}
for (int i = 0; i < instanciatedList.Count; i++)
{
if (instanciatedList[i].transform.position.x >= -0.01 && instanciatedList[i].transform.position.x <= 0.01)
{
resultColor = instanciatedList[i].gameObject.GetComponent <SpriteRenderer>().color;
}
}
stopped = true;
//Enabling back buttons
greenButton.GetComponent <Button>().interactable = true;
blackButton.GetComponent <Button>().interactable = true;
redButton.GetComponent <Button>().interactable = true;
}
private void PresentFinalOutcome(Probabilities probs)
{
if (probs.Win > 0.9999)
{
outcome.Text = "PLAYER WON!";
}
else if (probs.Tie > 0.9999)
{
outcome.Text = "IT IS A PUSH!";
}
else
{
outcome.Text = "PLAYER LOST!";
}
hit.Enabled = false;
stand.Enabled = false;
next.Enabled = false;
}
private void InitializeProbabilities()
{
var probabilitiesList = new Probabilities();
foreach (var probabilityElementConfiguration in _configuration.AlgorithmConfiguration.ProbabilitiesConfiguration)
{
var variableType = VariableTypeHelper.ConvertStringToType(probabilityElementConfiguration.VariableType);
var parseTableMethod = ReflectionHelper.GetGenerecMethod(variableType, typeof(ProbabilityTableParser), "Parse");
dynamic table = parseTableMethod.Invoke(null, new object[] { probabilityElementConfiguration.FilePath, probabilityElementConfiguration.WithHeader });
var addToListMethod =
ReflectionHelper.GetGenerecMethod(variableType, typeof(Probabilities), "AddProbabilityTable");
addToListMethod.Invoke(probabilitiesList, new object[] { probabilityElementConfiguration.Variable, table });
}
probabilities = probabilitiesList;
}
public void Mutate(Particle gbest)
{
List <MutationSet> sets = d_state.MutationSets;
bool hasmutated = false;
Probabilities probabilities = CalculateProbabilityNormalization(d_best, gbest);
for (int i = 0; i < sets.Count; ++i)
{
hasmutated |= Mutate(i, probabilities, sets[i], gbest);
}
if (hasmutated)
{
foreach (Particle particle in this)
{
particle.UpdateParameterSet();
}
}
}
private void OnTriggerEnter2D(Collider2D collision)
{
if (collision.CompareTag("Player"))
{
gameObject.GetComponent <SpriteRenderer>().sprite = openedSprite;
float probability = Probabilities.RandomExponentialVairable(.1f);
print(probability);
if (probability < 10f)
{
Instantiate(GameAssets.i.Invincibility, transform.position + new Vector3(2, 0, 0), Quaternion.Euler(0, 0, 0));
}
else if (probability < 15f)
{
Instantiate(GameAssets.i.Level2Powerup, transform.position + new Vector3(2, 0, 0), Quaternion.Euler(0, 0, 0));
}
else
{
Instantiate(GameAssets.i.Level3Powerup, transform.position + new Vector3(2, 0, 0), Quaternion.Euler(0, 0, 0));
}
}
}
/// <summary>
/// Calculates the probability of the list of tokens being in set A
/// </summary>
/// <param name="Items">List of items</param>
/// <returns>The probability that the tokens are from set A</returns>
public virtual double CalculateProbabilityOfTokens(System.Collections.Generic.List <T> Items)
{
if (Items == null)
{
throw new ArgumentNullException("Items");
}
if (Probabilities == null)
{
throw new NullReferenceException("Probabilities has not been initialized");
}
SortedList <string, double> SortedProbabilities = new SortedList <string, double>();
for (int x = 0; x < Items.Count; ++x)
{
double TokenProbability = 0.5;
if (Probabilities.ContainsKey(Items[x]))
{
TokenProbability = Probabilities[Items[x]];
}
string Difference = ((0.5 - System.Math.Abs(0.5 - TokenProbability))).ToString(".0000000") + Items[x] + x;
SortedProbabilities.Add(Difference, TokenProbability);
}
double TotalProbability = 1;
double NegativeTotalProbability = 1;
int Count = 0;
int MaxCount = MathHelper.Min(SortedProbabilities.Count, MaxInterestingTokenCount);
foreach (string Probability in SortedProbabilities.Keys)
{
double TokenProbability = SortedProbabilities[Probability];
TotalProbability *= TokenProbability;
NegativeTotalProbability *= (1 - TokenProbability);
++Count;
if (Count >= MaxCount)
{
break;
}
}
return(TotalProbability / (TotalProbability + NegativeTotalProbability));
}
private void addProbabilities(ulong pockets, string file)
{
if (!probabilities.ContainsKey(pockets))
probabilities.Add(pockets, new Dictionary<ulong, Probabilities>());
using (BinaryReader reader = new BinaryReader(new FileStream(file, FileMode.Open)))
{
while (reader.PeekChar() != -1)
{
ulong board = reader.ReadUInt64();
Probabilities prob = new Probabilities();
prob.PositivePotential = reader.ReadSingle();
prob.NegativePotential = reader.ReadSingle();
prob.HandStrength = reader.ReadSingle();
prob.WinProbability = reader.ReadSingle();
probabilities[pockets].Add(board, prob);
}
}
}
