class TestCensoredLike():

    def cdf_by_integration(self, v, V, a, z, Z, t,T, cdf_lb=-5, cdf_ub=5, dt=0.001):
        """create a cdf array using numerical integration over the pdf"""
        # init
        x = np.arange(cdf_lb, cdf_ub, dt)
        l_cdf = np.empty(x.shape[0], dtype=np.double)
        l_cdf[0] = 0

        # get pdf values
        for i in range(x.shape[0]):
            pdf = hddm.wfpt.full_pdf(x[i], v, V, a, z, Z, t, T, 1e-4)
            l_cdf[i] = l_cdf[i-1] + pdf

        # normalize
        l_cdf /= l_cdf[x.shape[0]-1]

        return l_cdf, x

    def eval_censored_like_on_set_of_rts(self, rts, v, V, a, z, Z, t, T):
        """evalutate censored_like on set of rts with a set of given parameters"""

        #cdf by integration
        i_t = time()
        l_cdf, x_axis = self.cdf_by_integration(v=v, V=V, a=a, z=z, Z=Z, t=t, T=T, cdf_lb=-7, cdf_ub=7, dt=1e-4)
        integ_time = time() - i_t
        params_holder = np.zeros(6);


        for rt in rts:
            for i_cond in range(2):
                #get censored_like using the cdf method
                i_xpos = np.searchsorted(x_axis, rt)
                i_xneg = np.searchsorted(x_axis, -rt)
                p_a = l_cdf[i_xpos] - l_cdf[i_xneg]
                if i_cond == 1:
                    p_a = 1 - p_a

                #get it using the censored_like method
                i_t = time()
                if i_cond == 0:
                    logp_b = hddm.likelihoods.censored_like(1, rt, 0, 1,
                                                          v, V, a, z, Z, t, T,
                                                          precision=3.)
                else:
                    logp_b = hddm.likelihoods.censored_like(0, 0, 1, rt,
                                                          v, V, a, z, Z, t, T,
                                                          precision=3.)
                dm_time = time() - i_t
                p_b = np.exp(logp_b)

                #print results
                print "*****"
                print "rt: .%3f" % rt
                print "fastdm:      %.4f  (%.3f secs)" % (p_b, dm_time)
                print "integration: %.4f  (%.3f secs)" % (p_a, integ_time)
                np.testing.assert_almost_equal(p_a, p_b, 2)


    def run_censored_like_single_include(self, include, large_V = True):
        """run a single censored_like test by generating a set of random params.
        random params are generated using the include argument.
        if large_V is True then V is much can get larger values than usual.
         """
        if len(include) == 0:
            print "@@@@@@@@@@@  simple Test @@@@@@@@@@@"
        else:
            print "@@@@@@@@@@@  %s Test @@@@@@@@@@@" % include
        for i in range(10):
            params = hddm.generate.gen_rand_params(include = include)
            if large_V:
                params['V'] *= 5
            print "*** test %d  ***" % i
            print params
            print "!!!!!!!!!!!!!!!!"
            self.eval_censored_like_on_set_of_rts(np.arange(0, 3,0.3), **params)

    def test_censored_like(self):
        """
        run censored_like test
        """
        np.random.seed(1)

        self.run_censored_like_single_include(())
        self.run_censored_like_single_include(['T'])
        self.run_censored_like_single_include(['V'])
        self.run_censored_like_single_include(['V'], large_V = True)
        self.run_censored_like_single_include(['Z'])
        self.run_censored_like_single_include(['T','V'])
        self.run_censored_like_single_include(['T', 'Z'])
        self.run_censored_like_single_include(['Z', 'V'])
        self.run_censored_like_single_include(['Z', 'V', 'T'])