import matplotlib.pyplot as plt
import numpy as np
import cascade_creation
import convex_optimization
import algorithms
import rip_condition


def compare_greedy_and_lagrange_cs284r():
    """
    Compares the performance of the greedy algorithm on the
    lagrangian sparse recovery objective on the Facebook dataset
    for the CS284r project
    """
    G = cascade_creation.InfluenceGraph(max_proba = .8)
    G.import_from_file("../datasets/subset_facebook_SNAPnormalize.txt")
    A = cascade_creation.generate_cascades(G, p_init=.05, n_cascades=100)

    #Greedy
    G_hat = algorithms.greedy_prediction(G, A)
    algorithms.correctness_measure(G, G_hat, print_values=True)

    #Lagrange Objective
    G_hat = algorithms.recovery_l1obj_l2constraint(G, A,
            passed_function=convex_optimization.type_lasso,
            floor_cstt=.05, lbda=10)
    algorithms.correctness_measure(G, G_hat, print_values=True)


def watts_strogatz(n_cascades, lbda, passed_function):
    """
    Test running time on different algorithms
    """
    G = cascade_creation.InfluenceGraph(max_proba=.7, min_proba=.2)
    G.import_from_file("../datasets/watts_strogatz_300_30_point3.txt")
    A = cascade_creation.generate_cascades(G, p_init=.05, n_cascades=n_cascades)

    if passed_function==algorithms.greedy_prediction:
        G_hat = algorithms.greedy_prediction(G, A)
    else:
        G_hat = algorithms.recovery_passed_function(G, A,
                passed_function=passed_function,
                floor_cstt=.1, lbda=lbda, n_cascades=n_cascades)
    algorithms.correctness_measure(G, G_hat, print_values=True)


# def test():
#     """
#     unit test
#     """
#     G = cascade_creation.InfluenceGraph(max_proba=1, min_proba=.2)
#     G.erdos_init(n=50, p=.2)
#     A = cascade_creation.generate_cascades(G, p_init=.1, n_cascades=1000)
#     G_hat = algorithms.recovery_passed_function(G, A,
#                 passed_function=convex_optimization.sparse_recovery,
#                 floor_cstt=.1, lbda=.001, n_cascades=1000)
#     algorithms.correctness_measure(G, G_hat, print_values=True)


if __name__=="__main__":
    watts_strogatz(n_cascades=3000, lbda=.002, passed_function=
        convex_optimization.sparse_recovery)
        #algorithms.greedy_prediction)