# Probabilities Revised

In an attempt to learn machine learning, I am revising some previous concepts regarding statistics and probabilities. Here are some of the links I find useful while reading:

For the  understanding of

Conditional, Joint and marginal probability here

Bayes Theorem (Breast Cancer Example) here

# BST reverse in-order traversal for sorting elements in descending order

We all know that there are 3 most popular types of tree traversals namely pre-order, in-order and post-order traversal. Among these three, the in-order traversal of BST gives us the output elements arranged in ascending or increasing order. Now, what if we require the elements to be output in decreasing/descending order??? …. I have found out a very interesting article here covering this technique i-e reverse in-order traversing.

# The Social-Network Illusion That Tricks Your Mind | MIT Technology Review

Network scientists have discovered how social networks can create the illusion that something is common when it is actually rare.

# Internet of Things: Opportunities and Challenges

The IoT has the potential to connect 10X as many (28 billion) “things” to the Internet by 2020. Learn more about it with Ahmed Banafa.

# Generating SSL certificates using openSSL

A pretty good article here to generate SSL certificate for both server and client using openSSL.

P.S: on Windows environment don’t forget to run your command prompt in “Administrator” mode.

# Shamir Secret Splitting code in C++

This is the rough code for Shamir secret splitting and combining written in C++. Kindly change according to your own preferences 🙂 P.S: you have to know the basics of Shamir Secret Sharing and Lagrange’s Interpolation before understanding this code. More details can be found here and a java implementation of Shamir Secret Splitting can be found  here.

``` void split(int number, int available, int needed, int prime){ int coef[10]; int shar[10][2]={0,0}; coef[0] = number; int n = prime - 1; for(int c = 1; c < needed; c++) { coef[c] = rand() % n + 1; // (prime-1)+1 is upper and lower bound respectively } int x, exp, y; double accum; for(x = 1, y = 0; x <= available; x++) { /* * e.g coef = [1234, 166, 94] which is 1234x^0 + 166x^1 + 94x^2 */ for(exp = 1, accum = coef[0]; exp < needed; exp++) { double inn= fmod((pow(double(x), exp)), prime); //pow func always take first argu as float or double double ac = accum + fmod(coef[exp] * inn,prime); accum = fmod(ac,prime);```

//accum = (accum + (coef[exp] * (Math.pow(x, exp) % prime) % prime)) % prime;

} // Modular math
/*
* Store values as (1, 1494), (2, 1942), (3, 2578), (4, 3402), (5, 4414) (6, 5614) in a 2D Array
*/
shar[x – 1][y] = x;
shar[x – 1][y + 1] = accum;
std::cout << “( index = “<< shar[x – 1][y];
std::cout << “, value = “<< shar[x – 1][y + 1] << ” )” << std::endl;
}
}

``` /* This is the recursive method Using Extended Euclidean Algorithm*/ /* This function return the gcd of a and b followed by the pair x and y of equation ax + by = gcd(a,b) */```

pair<int, pair<int, int> > extendedEuclid(int a, int b) {
if(a == 0) return make_pair(b, make_pair(0, 1));
pair<int, pair<int, int> > p;
p = extendedEuclid(b % a, a);
return make_pair(p.first, make_pair(p.second.second – p.second.first*(b/a), p.second.first));
}

int modInverse(int a, int m) {
return (extendedEuclid(a,m).second.first + m) % m;
}

int combine(int shares[10][2], int primeNum, int threshold) {
long double accum = 0, startposition =0, nextposition =0;
for (int i=0 ; i<threshold; i++)
{
cout<< shares[i][0] << “-“<<shares[i][1] << endl;
}
for (int i = 0; i < threshold; i++) {
long double num = 1;
long double den = 1;

for (int j = 0; j < threshold; j++) {
if (i != j) {
startposition = shares[i][0];
nextposition = shares[j][0];
num = fmod((num * (-nextposition)), primeNum);
den = fmod((den * (startposition – nextposition)), primeNum);
}
else if (i==j) {continue;}
}

cout<< “den: ” << den ;
cout<<” num: ” << num ;
cout<<” inv: ” << mi <<endl;
int value = shares[i][1];

long double tmp = value* num * (modInverse(den, primeNum));
long double acc = (accum + primeNum + tmp);