/* ROULETTE MARKOV CHAIN SIMULATION by profinet
In the ethereal realm of Markov chains, we delve into the enchanting world
of probabilities governing the game of Roulette. Before we unveil the magic
woven by this C program, let's unravel the mathematical essence of a Markov chain.
MARKOV CHAIN:
A Markov chain is a stochastic model that describes a sequence of events where
the probability of transitioning to any particular state depends solely on the
current state and time elapsed, not on the sequence of events that preceded it.
This memoryless property is known as the Markov property.
- State Space: Sets A, B, C, and D represent the states in our Roulette Markov
chain. Each state corresponds to a range of numbers on the Roulette wheel.
- Transition Probabilities: The heart of the Markov chain lies in the probabilities
of transitioning from one state to another. These probabilities form a transition
matrix, where each element signifies the likelihood of moving between states.
- Transition Matrix: A square matrix where rows and columns correspond to states,
and each entry represents the probability of transitioning from one state to another.
In our Roulette context, this matrix captures the dynamics of the game over spins.
- Markov Property: The future state of the system depends only on its current state,
adhering to the Markov property. The dynamics of the system are memoryless,
simplifying the modeling of random processes.
Now, armed with the knowledge of Markov chains, let's witness the magic of
probabilities and state transitions as we simulate the dance of fate on the
Roulette wheel with this enchanting C program.
INITIAL STATE VECTOR CALCULATION:
Before embarking on our magical journey through the Roulette Markov chain,
let's decipher the incantation that conjures the initial state vector, v0.
The mystical probabilities for each zone are as follows:
- Zone A: 1/37 = 0.02702702702
- Zone B [1-12]: 1/37 * 12 = 0.32432432432
- Zone C [13-24]: 1/37 * 12 = 0.32432432432
- Zone D [25-36]: 1/37 * 12 = 0.32432432432
Therefore, the initial state vector v0 is crafted with these probabilities:
v0 = { 0.02702702702, 0.32432432432, 0.32432432432, 0.32432432432 }
This vector sets the stage for our journey, representing the initial likelihood
of finding ourselves in each enchanted zone after the first spin of the Roulette wheel.
Now, let the magic unfold as we traverse the Markov chain, weaving the threads
of destiny and revealing the ever-shifting cosmic energies within the enchanted lands.
THE DARK SPIRIT SCRIPT:
Legend has it that sets A, B, C, and D correspond to specific ranges of numbers
on the Roulette wheel. Zone A encompasses the single number 0, while zones B, C,
and D represent ranges [1-12], [13-24], and [25-36], respectively.
Then, the script unfolds as follows:
1. A sample array of mystical symbols is presented, representing the outcome
of a Roulette game.
2. The `countSpecificTransitions` function takes the mystical sample array and
counts transitions between sets A, B, C, and D. The ancient spirits are
summoned to calculate the probabilities of weaving the threads of destiny
from one set to another.
3. The calculated probabilities are then used to build a powerful transition
matrix with the `buildTransitionMatrix` function. Each element of the matrix
represents the likelihood of moving from one enchanted zone to another.
4. The transition matrix is unveiled to mortal eyes through the `printMatrix`
function, revealing the hidden patterns and cosmic energies.
5. A mystical ritual is performed with the `multiplyMatrixVector` function,
combining the powers of the sacred matrix and a humble vector. The result is
a new vector that holds the secrets of transformation, representing the
probabilities of ending up in each enchanted zone after a Roulette spin.
May the ancient spirits guide you through the script, and may the probabilities
revealed here bring fortune and wisdom to those who seek the mystical insights
of the Roulette wheel.
Best of luck on your magical journey! */
#include <math.h>
#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
/**
* @brief Count specific transitions in the sample and calculate transition probabilities.
*
* This magical function takes a mystical sample array and counts the transitions between
* enchanted sets A, B, C, and D. It then summons the ancient spirits to calculate the
* probabilities of weaving the threads of destiny from one set to another.
*
* @param sample The magical sample array containing mystical symbols.
* @param size The size of the sample array (the length of your magical journey).
* @param counters The counters representing the cosmic energies of transitions.
* @param probabilities The probabilities of weaving the threads of destiny between sets.
*/
static void countSpecificTransitions(int sample[], int size, int *counters,
double *probabilities) {
int i, j, k;
// Define the sets
int sets[][12] = { { 0 }, // A
{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 }, // B
{ 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24 }, // C
{ 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36 } // D
};
// Wipe off counters
for (i = 0; i < 16; i++) {
counters[i] = 0;
probabilities[i] = 0.0;
}
// Let's go on a magical journey through the sample array
for (i = 0; i < size - 1; i++) {
int currentSet = -1;
int nextSet = -1;
// Seeking the meaning of life in the current set
for (j = 0; j < 4; j++) {
for (k = 0; k < 12; k++) {
/* If our sample number aligns
* with the mystical symbols in the current set */
if (sample[i] == sets[j][k]) {
// We've found it!
currentSet = j;
break;
}
}
/* If we've already found the meaning of life
* there's no need to keep searching */
if (currentSet != -1) {
break;
}
}
// Gazing into the crystal ball to find the next set
for (j = 0; j < 4; j++) {
for (k = 0; k < 12; k++) {
if (sample[i + 1] == sets[j][k]) {
nextSet = j;
break;
}
}
if (nextSet != -1) {
break;
}
}
// Summoning the ancient spirits to increment the counters
if (currentSet != -1 && nextSet != -1) {
/* We're not just incrementing counters;
* we're weaving the threads of destiny! */
counters[currentSet * 4 + nextSet]++;
}
}
// Let's do some magic math
int totalTransitions = size - 1;
for (i = 0; i < 16; i++) {
probabilities[i] = (double) counters[i] / totalTransitions;
}
}
/**
* @brief Build the transition matrix using mystical probabilities.
*
* This function takes a set of magical probabilities and weaves them into a powerful
* transition matrix. Each element of the matrix represents the likelihood of moving
* from one enchanted zone to another.
*
* @param matrix The matrix that will be imbued with magical probabilities.
* @param probabilities The mystical probabilities, carefully chosen by sorcery.
*/
static void buildTransitionMatrix(double matrix[4][4], double *probabilities) {
/* Fill the matrix with the provided probabilities
* creating a tapestry of transitions */
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
matrix[i][j] = probabilities[i * 4 + j];
}
}
}
/**
* @brief Normalizes a matrix and tries to make it feel like it fits in.
*
* This function takes a matrix and makes each row behave, by subtracting a bit from each element.
* Think of it as matrix therapy - we're helping them get along better with their row-mates.
*
* @param N The size of the matrix.
* @param matrix The matrix to normalize.
*/
static void normalizeMatrix(int N, double matrix[N][N]) {
for (int i = 0; i < N; i++) {
double rowSum = 0.0;
/* Finding the sum of the row
* - because everyone needs to know their worth! */
for (int j = 0; j < N; j++) {
rowSum += matrix[i][j];
}
/* Subtracting (rowSum - 1) / N from every value in this row
* - just a little adjustment therapy */
for (int j = 0; j < N; j++) {
matrix[i][j] -= (rowSum - 1) / N;
}
}
}
/**
* @brief Checks if a matrix is living its best stochastic life.
*
* This function takes a matrix and interrogates its rows to see if they're all adding up to 1.
* It's like a reality show for matrices - if they're not pulling their weight, they're out!
*
* @param N The size of the matrix.
* @param matrix The matrix to investigate.
* @return Returns true if the matrix is living the stochastic dream, false otherwise.
*/
static bool isStochasticMatrix(int N, double matrix[N][N]) {
for (int i = 0; i < N; i++) {
double rowSum = 0.0;
/* Calculating the sum of the current row
* - because each row is a unique individual */
for (int j = 0; j < N; j++) {
rowSum += matrix[i][j];
}
/* Checking if the sum is approximately equal to 1
* - because a row that adds up to 1 is a happy row! */
if (fabs(rowSum
- 1.0) > 1e-6) { return false;
}
}
// The matrix is living its best life!
return true;
}
/**
* @brief Cast a spell to reveal the mystical matrix.
*
* This function is a magical incantation that unleashes the enchanted matrix
* into the mortal realm. It gracefully prints the ethereal values with precision,
* allowing mere mortals to catch a glimpse of the hidden patterns.
*
* @param matrix The mystical matrix to be unveiled.
*/
static void printMatrix(double matrix[4][4]) {
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
// Reveal the magical values with four decimal places
printf("%.4f ", matrix
[i
][j
]); }
// Move to the next line, as the magic unfolds row by row
}
}
/**
* @brief Unleash the magic of matrix-vector multiplication.
*
* This function is a mystical ritual that combines the powers of a sacred matrix
* and a humble vector. It gracefully performs the multiplication, weaving the
* threads of destiny to produce a new vector that holds the secrets of transformation.
*
* @param matrix The sacred matrix, carefully crafted by the wizards of computation.
* @param inputVector The humble vector offering itself to the magic of multiplication.
* @param resultVector The newborn vector, now imbued with the enchanted transformation.
*/
static void multiplyMatrixVector(double matrix[4][4], double *inputVector,
double *resultVector) {
for (int i = 0; i < 4; i++) {
// Prepare the newborn vector, clearing any remnants of previous enchantments
resultVector[i] = 0.0;
for (int j = 0; j < 4; j++) {
// Unleash the magic: combine the powers of matrix and vector
resultVector[i] += matrix[i][j] * inputVector[j];
}
}
}
/**
* @brief Normalizes a vector and makes its elements feel like they're on a diet.
*
* This magical function takes a vector on a sumptuous feast and says, "Enough is enough!"
* It calculates the sum of the elements, scolds them for overindulgence, and puts them on
* a strict diet by dividing each element by the sum. Now, the vector is light, fit, and ready
* for the runway – or any mathematical adventure!
*
* @param vector The vector to be normalized, because even vectors need to watch their weight.
* @param size The size of the vector – because size matters, especially in the world of vectors.
*/
void normalizeVector(double *vector, int size) {
double sum = 0.0;
// Calculate the sum of the elements – a grand feast awaits!
for (int i = 0; i < size; i++) {
sum += vector[i];
}
// Normalize by dividing each element by the sum of the elements
for (int i = 0; i < size; i++) {
vector[i] /= sum;
}
}
/**
* @brief Generates a random list of numbers to keep life exciting.
*
* This function is your go-to party planner for creating a list that's as unpredictable as life itself.
* It seeds the random number generator with the current time, ensuring a unique and lively mix every time.
*
* @param list The list to be filled with random numbers.
* @param size The size of the list - because size matters, especially in random number lists.
*/
static void generateRandomList(int *list, int size) {
// Let's throw a dice and see where the randomness takes us!
// Generating random numbers and filling the list with excitement
for (int i = 0; i < size; i++) {
/* Generating a random number between 0 and 36
* - because variety is the spice of life! */
}
}
/**
* @brief Embark on a magical journey through the enchanted realms of sets A, B, C, and D.
*
* This mystical main function leads a daring expedition into the unseen world of transitions
* and probabilities. A sample array of mystical symbols is presented to the ancient wizards
* who count specific transitions, unveil the secrets of probability, and build a powerful
* transition matrix. The enchanted matrix is then used to transform an initial state vector
* into a new state, revealing the ever-shifting cosmic energies within the enchanted lands.
*
* @return The triumphant return code, signifying the successful completion of the magical journey.
*/
int main() {
// Sample array
int initialData[] = { 0, 1, 1, 2, 3, 5, 8, 13, 21, 34 };
int size = (int)sizeof(initialData) / sizeof(initialData[0]);
// Declare and allocate memory for the sample array
int *sample
= (int *)malloc(size
* sizeof(int));
// Check if memory allocation was successful
if (sample == NULL) {
fprintf(stderr
, "Memory allocation failed :(\n"); return 1; // Return an error code
}
// Initialize sample array with default values
for (int i = 0; i < size; i++) {
sample[i] = i;
}
// Initialize counters and probabilities
int counters[16];
double probabilities[16];
int i = 0;
int winningBet = 0;
do {
// Count specific transitions
countSpecificTransitions(sample, size, counters, probabilities);
// Print the results
for (i = 0; i < 16; i++) {
char currentSet = (char)('A' + i / 4);
char nextSet = (char)('A' + i % 4);
printf("Transition %c->%c: %d, Probability: %.4f\n", currentSet
, nextSet
, counters
[i
], probabilities
[i
]); }
// Build the transition matrix
double transitionMatrix[4][4];
buildTransitionMatrix(transitionMatrix, probabilities);
if (!isStochasticMatrix(4, transitionMatrix)) {
normalizeMatrix(4, transitionMatrix);
}
// Print the transition matrix
printf("\nTransition Matrix:\n"); printMatrix(transitionMatrix);
// Build the new state vector
double initialState[4] = {0.02702702702, 0.32432432432, 0.32432432432, 0.32432432432};
double newState[4];
multiplyMatrixVector(transitionMatrix, initialState, newState);
// Normalize the new state vector
normalizeVector(newState, 4);
// Print the new state vector with corresponding zones and intervals
printf("\nNew state vector:\n"); for (i = 0; i < 4; i++) {
char zoneLabel;
const char *intervalDescription;
// Determine the zone label and interval description
switch (i) {
case 0:
zoneLabel = 'A';
intervalDescription = "Only 0 ";
break;
case 1:
zoneLabel = 'B';
intervalDescription = "[1-12] ";
break;
case 2:
zoneLabel = 'C';
intervalDescription = "[13-24]";
break;
case 3:
zoneLabel = 'D';
intervalDescription = "[25-36]";
break;
default:
// Handle an unexpected index (this should not happen)
zoneLabel = '?';
intervalDescription = "Unknown Interval";
break;
}
// Print the probability along with zone and interval information
printf("Zone %c %s -> %.3f%%\n", zoneLabel
, intervalDescription
, (double)newState
[i
] * 100); }
printf("\nEnter a new winningBet (or any non-integer to exit): "); if (scanf("%d", &winningBet
) != 1) { break;
}
// Update the sample array with the new winningBet
// (For simplicity, just add the winningBet to the end of the array
sample
= realloc(sample
, (size
+ 1) * sizeof(int)); if (sample == NULL) {
fprintf(stderr
, "Memory reallocation failed :(\n"); return 1; // Return an error code
}
sample[size] = winningBet;
size++;
} while (1);
// Free the allocated memory
// The triumphant return code!
return 0;
}
Mostrar Mensajes
