def test_EM_algorithm_in_linear_case(self):
        n_sample = 100
        is_f_linear = True
        is_g_linear = True
        state_dim = 1
        output_dim = 1
        A = np.ones((1, 1))
        b = rand(1)
        C = np.ones((1, 1))
        d = rand(1)
        Q = np.array([[0.1]])
        R = np.array([[0.1]])
        ssm = StateSpaceModel(is_f_linear=is_f_linear,
                              is_g_linear=is_g_linear,
                              state_dim=state_dim,
                              output_dim=output_dim,
                              A=A,
                              b=b,
                              C=C,
                              d=d,
                              Q=Q,
                              R=R)
        ssm.draw_sample(T=n_sample)
        ssm.plot_states_in_1D()

        ssm.A[0, 0] = 0.5
        ssm.b[0] = 0.5
        ssm.C[0, 0] = 0.5
        ssm.d[0] = 0.5
        use_smoothed_values = False
        log_likelihood = ssm.learn_f_and_g_with_EM_algorithm(
            use_smoothed_values=use_smoothed_values)
        plt.figure(10)
        plt.title(
            'f and g linear. log-likelihood evolution during EM algorithm')
        plt.plot(log_likelihood)
        plt.show()
        ssm.plot_estimmated_states_in_1D(
            use_smoothed_values=use_smoothed_values)
    def test_EM_algorithm_in_non_linear_case(self):
        n_sample = 5000
        is_f_linear = False
        is_g_linear = True
        state_dim = 1
        output_dim = 1
        A = 0.5 * np.ones((1, 1))
        b = 0.25 * np.ones(1)
        C = np.ones((1, 1))
        d = np.zeros(1)
        Q = np.array([[0.01]])
        R = np.array([[0.01]])
        f_rbf_parameters = {
            'n_rbf': 2,
            'centers': np.array([[-0.2], [0.2]]),
            'width': np.array([[[0.02]], [[0.02]]])
        }
        f_rbf_coeffs = np.array([[0.2], [-0.2]])

        ssm = StateSpaceModel(is_f_linear=is_f_linear,
                              is_g_linear=is_g_linear,
                              f_rbf_parameters=f_rbf_parameters,
                              f_rbf_coeffs=f_rbf_coeffs,
                              state_dim=state_dim,
                              output_dim=output_dim,
                              A=A,
                              b=b,
                              C=C,
                              d=d,
                              Q=Q,
                              R=R)

        #on va definir une f_analytical quelconque
        #ssm.f_analytical=np.cos

        def f_Not_RBF_scalar(x):
            value = 0
            value = np.cos(10 * x)
            return (value)

        f_Not_RBF = np.vectorize(f_Not_RBF_scalar)
        ssm.f_analytical = f_Not_RBF

        ssm.draw_sample(T=n_sample)
        ssm.plot_states_in_1D()

        ssm.A[0, 0] += 0.1 * random()
        ssm.b[0] += 0.1 * random()
        ssm.C[0, 0] += 0.1 * random()
        ssm.d[0] += 0.1 * random()

        #et si on commence a apprendre avec plus de I qu'il n'y en a réellement
        f_rbf_parameters_Bis = {
            'n_rbf': 4,
            'centers': np.array([[-0.2], [0.2], [0.3], [0.7]]),
            'width': np.array([[[0.02]], [[0.02]], [[0.02]], [[0.02]]])
        }
        ssm.f_rbf_parameters = f_rbf_parameters_Bis
        ssm.f_rbf_coeffs = np.array([[-0.2], [0.2], [0.3], [0.7]])
        #ssm.f_rbf_coeffs = np.array([[0.], [0.]])
        use_smoothed_values = False
        log_likelihood = ssm.learn_f_and_g_with_EM_algorithm(
            use_smoothed_values=use_smoothed_values)
        plt.figure(1)
        plt.title(
            'f non-linear, g linear. log-likelihood evolution during EM algorithm'
        )
        plt.plot(log_likelihood)
        plt.xlabel('Number of Iteration')
        plt.ylabel('likelihood')
        plt.show()
        #pour que compute_f me renvoit ce qui a ete appris
        ssm.f_analytical = None
        ssm.plot_estimmated_states_in_1D(
            use_smoothed_values=use_smoothed_values)
        print(ssm.f_rbf_coeffs)