# https://github.com/rfsantacruz/cvx-nb/blob/master/DoublyStochasticApproximation.ipynb

# approximate dh-matrix
import numpy as np
import networkx as nx

from matplotlib import pyplot as plt
%matplotlib inline


def sinkhorn(X, max_it=10):
    Y = np.copy(X)
    for it in range(max_it):
        # Line multipliers normalizer
        D1 = np.diagflat(1. / np.sum(Y, axis=1))
        # Cols multipliers normalizer
        D2 = np.diagflat(1. / np.sum(np.dot(D1, Y), axis=0))
        # Normalize D1 Y D2
        Y = np.dot(np.dot(D1, Y),D2)
    return Y

X = np.random.rand(2,2)
Y = sinkhorn(X)
print("Random input:\n{}".format(X))
print("Sinkhorn Approx. DSM:\n{}".format(Y))



def generate_random_symmetric_doubly_stochastic_matrix(n, max_it = 10):
    # Generate a random matrix of size n x n
    matrix = np.random.rand(n, n)

    # Make the matrix symmetric
    matrix = (matrix + matrix.T) / 2
    # Normalize each column to sum up to 1
    wc = np.sqrt(np.sum(matrix, axis=0))
    matrix = matrix / wc
    matrix = matrix / wc[:, np.newaxis]
    matrix = sinkhorn(matrix,max_it=max_it)
    return matrix
n = 10
x = generate_random_symmetric_doubly_stochastic_matrix(n)
print(np.sum(x-np.transpose(x)))
print('row sum',np.sum(x,axis=0))
print('col sum',np.sum(x,axis=1))


def get_pagerank(matrix):
    graph = nx.from_numpy_array(matrix, create_using=nx.DiGraph)
    pagerank = nx.pagerank(graph)
    pr = np.array(list(pagerank.values()))
    return pr

pr = get_pagerank(matrix)
print('page rank: ', pr)

pr_rank = np.argsort(-pr)
print('rank wrt pagerank', pr_rank)
sim_rank = np.argsort(-np.sum(matrix,axis=0))
print('rank wrt pagerank', sim_rank)


n1 = pr_rank[:k]
n2 = sim_rank[:k]
print('n1, n2',n1,n2)

N = 100
n = 10
k = int(np.min([3,np.round(0.2*n)]))
print('top k is', k)
result = np.zeros((N,n))
for i in range(N):
    X = generate_random_symmetric_doubly_stochastic_matrix(n,max_it=20)
    pr = get_pagerank(X)
    pr_rank = np.argsort(-pr)
    sim_rank = np.argsort(-np.sum(X,axis=0))
    sim_rank = sim_rank.astype(int)
    pr_rank = pr_rank.astype(int)

    #print(sim_rank)
    #print(pr_rank)
    r = np.all(pr_rank == sim_rank)

    for k in range(n):
        n1 = pr_rank[:k]
        n2 = sim_rank[:k]
        r2 = np.all(n2 == n1)
        result[i,k]=r2
    #print(f'iter x: {i}, equal ranks: {r1}, {r}, top-k ranks {r2}')
    #result.append(r2)

#print(100*np.sum(np.array(result))/N)
#print(100*np.sum(np.array(result))/N)

mean_acc_by_k = np.mean(result, axis=0)
print(mean_acc_by_k.shape)
plt.plot(mean_acc_by_k,marker='o', linestyle='-')
plt.plot(pr)
    

pr
def generate_doubly_stochastic_matrix(n):
    # Generate a random matrix of size n x n
    matrix = np.random.rand(n, n)
    matrix = matrix / np.sum(matrix, axis=1)[:, np.newaxis]
    matrix = matrix / np.sum(matrix, axis=0)
    return matrix

new_matrix = generate_doubly_stochastic_matrix(n)
print(new_matrix)
new_matrix = np.ones((n, n)) / n
print(new_matrix)

import numpy as np

def generate_random_symmetric_doubly_stochastic_matrix(n):
    # Generate a random matrix of size n x n
    matrix = np.random.rand(n, n)

    matrix = (matrix + matrix.T) / 2

    row_sums = np.sum(matrix, axis=1)
    col_sums = np.sum(matrix, axis=0)

    matrix /= np.maximum(row_sums, col_sums)[:, np.newaxis]
    matrix = matrix / np.sum(matrix, axis=0)

    return matrix

n = 5  # Size of the matrix
matrix = generate_random_symmetric_doubly_stochastic_matrix(n)
print(matrix)
print(np.sum(matrix,axis=0))
print(np.sum(matrix,axis=1))

import numpy as np

def generate_random_doubly_stochastic_matrix(n):
    # Generate a random matrix of size n x n
    matrix = np.random.rand(n, n)

    # Normalize each row to sum up to 1
    matrix = matrix / np.sum(matrix, axis=1)[:, np.newaxis]

    # Normalize each column to sum up to 1
    matrix = matrix / np.sum(matrix, axis=0)

    return matrix

# Specify the size of the matrix
n = 5

# Generate a random doubly stochastic matrix
matrix = generate_random_doubly_stochastic_matrix(n)

print(matrix)