Пример #1
0
def f_solver():
    tmp = numx.array((1., 2.), )
    sys = multiminimize.gsl_multimin_function(my_f, tmp, 2)
    solver = multiminimize.nmsimplex(sys, 2)

    start_point = numx.array((5., 7.), )
    initial_steps = numx.array((0.1, 0.1), )
    solver.set(start_point, initial_steps)

    print "Using solver ", solver.name() 
    for i in range(100):
        status = solver.iterate()            
        if status != errno.GSL_SUCCESS:
            break
        ssval = solver.size()
        rval = multiminimize.test_size (ssval, 1e-2);

        if rval == 0:
            print "converged to minimum at"
        fval = solver.getf()
        x = solver.getx()
        t = (i, x[0], x[1], fval, ssval)
        print "iter %3d x % 10.3e % 10.3e  f() = %-10.3f ssize = %.3f" % t
        if rval == 0:
            break
    else:
        raise ValueError, "Number of Iterations exceeded!"
Пример #2
0
def run_fsolver():
    params = numx.array((1., 10.), numx.Float)
    
    #solver = multiroots.hybrids(mysys, 2)
    solver = multiroot.dnewton(2)

    tmp = numx.array((-10., -5.), numx.Float)

    solver.set(rosenbrock_f, tmp, params)
    #solver = multiroots.broyden(mysys, 2)
    #solver = multiroots.hybrid(mysys, 2)
    print "# Testing solver ", solver.name(),  solver.type()
    print "# %5s %9s %9s  %9s  %10s" % ("iter", "x[0]", "x[1]", "f[0]", "f[1]")
    for iter in range(100):
        status = solver.iterate()
        x = solver.root()
        dx = solver.dx()
        f = solver.f()
        status = multiroot.test_residual(f, 1e-7)
        if status == 0:
            print "# Converged :"
        print "  %5d % .7f % .7f  % .7f  % .7f" %(iter, x[0], x[1], f[0], f[1])
        if status == 0:
            break
    else:
        raise ValueError, "Number of Iterations exceeded!"
Пример #3
0
def fdf_solver():
    params = numx.array((1., 2.), )
    sys = multiminimize.gsl_multimin_function_fdf(my_f, my_df, my_fdf, params, 2)
    #solver = multiminimize.conjugate_pr(sys, 2)
    #solver = multiminimize.conjugate_fr(sys, 2)
    solver = multiminimize.vector_bfgs(sys, 2)
    #solver = multiminimize.steepest_descent(sys, 2)
    start = numx.array((5., 7.), )
    solver.set(start, 0.01, 1e-4)
    print "Using solver ", solver.name() 
    print "%5s %9s %9s  %9s %9s %9s" % ("iter", "x", "y", "f", "dx", "dy")
    for iter in range(200):
        status = solver.iterate()
        gradient = solver.gradient()
        x = solver.getx()
        f = solver.getf()
        status = multiminimize.test_gradient(gradient, 1e-3)
        if status == errno.GSL_SUCCESS:
            print "Converged "
        print "%5d % .7f % .7f  % .7f % .7f % .7f" %(iter, x[0], x[1], f, gradient[0], gradient[1])
        if status == errno.GSL_SUCCESS:
            break

    else:
        raise ValueError, "Number of Iterations exceeded!"
Пример #4
0
def run_fdfsolver():
    params = numx.array((1., 10.),)
    mysys = multiroots.gsl_multiroot_function_fdf(rosenbrock_f, rosenbrock_df,
                                                  rosenbrock_fdf, params, 2)
    
    #solver = multiroots.newton(mysys, 2)
    solver = multiroots.gnewton(mysys, 2)
    #solver = multiroots.hybridj(mysys, 2)
    #solver = multiroots.hybridsj(mysys, 2)
    
    tmp = numx.array((-10., -5.), )
    solver.set(tmp)
    print "# Testing solver ", solver.name() 
    print "# %5s %9s %9s  %9s  %10s" % ("iter", "x[0]", "x[1]", "f[0]", "f[1]")
    for iter in range(100):
        status = solver.iterate()
        r = solver.root()
        x = solver.getx()
        f = solver.getf()
        status = multiroots.test_residual(f, 1e-7)
        if status == errno.GSL_SUCCESS:
            print "# Converged :"
        print "  %5d % .7f % .7f  % .7f  % .7f" %(iter, x[0], x[1], f[0], f[1])
        if status == errno.GSL_SUCCESS:
            break
    else:
        raise ValueError, "Number of Iterations exceeded!"
Пример #5
0
 def test_wmean(self):        
     self.failIf(wmean(numx.array([1,1,1]), numx.array([-1.,-3.,1.])) != -1.0)
     self.failIf(wmean(numx.array([1,1,1]),[1,2,3]) != 2)
     data = numx.array([1.,2.,3.,4.,5.,6.,7.,8.,9.,10.])
     weight = numx.ones(data.shape)
     self.failIf(wmean(weight,data) != 5.5)
     
     self.failIf(wmean(weight[::2],data[::2]) != 5.0)
     self.failIf(wmean(weight[::-1],data[::-1]) != 5.5)
     self.failIf(wmean(weight[::-2],data[::-2]) != 6.0)
Пример #6
0
    def test_mean(self):
        self.failIf(mean(numx.array([-1.,-3.,1.])) != -1.0)
        self.failIf(mean([1,2,3]) != 2)
        # test stride != 1
        # these are only valid tests when using NumPy,
        # since otherwise the sequence is trnsformed to an
        # contigous array anyway...
        data = numx.array([1.,2.,3.,4.,5.,6.,7.,8.,9.,10.])
        self.failIf(mean(data) != 5.5)

        self.failIf(mean(data[::2]) != 5.0)
        self.failIf(mean(data[::-1]) != 5.5)
        self.failIf(mean(data[::-2]) != 6.0)
Пример #7
0
def run_fdfsolver():
    A       = 1.
    lambda_ = .1
    b       = .5

    n = 40
    p = 3

    t = numx.arange(n);
    y = testfunc(t, A, lambda_, b)
    sigma = numx.ones(n) * 0.1
    data = numx.array((t,y,sigma), numx.Float)
    #mysys = multifit_nlin.gsl_multifit_function_fdf(exp_f, exp_df, exp_fdf,
    # data, n,p)
    pygsl.set_debug_level(0)
    solver = multifit_nlin.lmsder(n, p)
    pygsl.set_debug_level(0)
    #solver = multifit_nlin.lmder(mysys, n, p)


    x = numx.array((1.0, 0.0, 0.0))
    pygsl.set_debug_level(0)
    solver.set(exp_f, exp_df, exp_fdf, x, data)
    pygsl.set_debug_level(0)
    print "# Testing solver ", solver.name() 
    print "# %5s %9s %9s  %9s  %10s" % ("iter", "A", "lambda", "b", "|f(x)|")
    for iter in range(20):	    
        status = solver.iterate()
	x  = solver.x()
	dx = solver.dx()
	f  = solver.f()
	J  = solver.J()
	#tdx = multifit_nlin.gradient(J, f)
	#status = multifit_nlin.test_delta(dx, x, 1e-8, 1e-8)
	status = solver.test_delta(1e-8, 1e-8)
	fn = numx.sqrt(numx.sum(f*f))
	if status == 0:
		print "# Convereged :"
	if status == 0:
                break
        print "  %5d % .7f % .7f  % .7f  % .7f" %(iter, x[0], x[1], x[2], fn)
    else:
	raise ValueError, "Number of Iterations exceeded!"

    J = solver.J()
    covar =  multifit_nlin.covar(solver.J(), 0.0)
    print "# A      = % .5f +/- % .5f" % (x[0], covar[0,0])
    print "# lambda = % .5f +/- % .5f" % (x[1], covar[1,1])
    print "# b      = % .5f +/- % .5f" % (x[2], covar[2,2])
Пример #8
0
def run_fdfsolver():    
    a = 1.0
    b = 0.0
    c = -5.0
    mysys = roots.gsl_function_fdf(quadratic, quadratic_deriv, quadratic_fdf,
                                 numx.array((a,b,c)))

    solver = roots.newton(mysys)    
    #solver = roots.secant(mysys)
    #solver = roots.steffenson(mysys)

    x = 5.0
    solver.set(x)
    r_expected = numx.sqrt(5.0)
    print "# Using solver ", solver.name() 
    print "# %5s %9s  %10s %9s" % ("iter", "root", "err", "err(est)")
    ok = 1
    for iter in range(10):
        status = solver.iterate()
        x0 = x
        x = solver.root()
        status = roots.test_delta(x, x0, 0.0, 1e-3)
        r = solver.root()
        if status == errno.GSL_SUCCESS:
            print "#  Convereged :"
        print "%5d  %.7f  % .6f % .6f" %(iter, r, r -r_expected, x - x0)
        if status == errno.GSL_SUCCESS:
                break
    else:
        raise ValueError, "Exeeded maximum number of iterations!"
Пример #9
0
def test_evolve_bsimp():
    dimension = 2
    step = odeiv.step_bsimp(dimension, func,jac, mu)
    control = odeiv.control_y_new(step, 1e-6, 1e-6)
    evolve  = odeiv.evolve(step, control, dimension)

    step1 = odeiv.step_rkf45(dimension, func,jac,mu)
    control1 = odeiv.control_y_new(step1, 1e-6, 1e-6)
    evolve1  = odeiv.evolve(step1, control1, dimension)
    
    h = 1
    t = 0.0
    t1 = 100.0
    y = numx.array((1.0, 0.0))

    while t<t1:
        t, h, y = evolve.apply(t, t1, h, y)



    sys.stdout = file
    h = 1
    t = 0.0
    t1 = 100.0
    y = (1.0, 0.0)
    while t<t1:
        t, h, y = evolve1.apply(t, t1, h, y)
Пример #10
0
def run():
    def f2(x,y):
        return numx.sin(x) / x
    sys2 = integrate.gsl_function(f2, None)
    
    def f1(x,y):
        return 1 / x        
    sys1 = integrate.gsl_function(f1, None)
    
    def f3(x,y):
        return 1 / -x
    
    sys3 = integrate.gsl_function(f3, None)

    w = integrate.workspace(1000000)
    cyclew = integrate.workspace(1000000)
    
    table1 = integrate.qawo_table(1, 100, integrate.SINE, 100)
    table2 = integrate.qawo_table(-1, 100, integrate.SINE, 100)

    # Borders and singualrity for gagp
    pts = numx.array((-numx.pi, 0, numx.pi))
    
    flag, result1, error = integrate.qagp(sys2, pts, 1e-8, 1e-8, 100000, w)
    flag, result2, error = integrate.qawf(sys1, numx.pi, 1e-8,  100, w,
                                          cyclew, table1)
    flag, result3, error = integrate.qawf(sys3, numx.pi, 1e-8,  100, w,
                                          cyclew, table2)
    
    print "Result of integration is :", result1 + result2 + result3
Пример #11
0
def generate_data():
    r = pygsl.rng.mt19937()
    a = numx.arange(20) / 10.# + .1
    y0 = numx.exp(a)
    sigma = 0.1 * y0
    dy = numx.array(map(r.gaussian, sigma))
    return a, y0+dy,  sigma
Пример #12
0
 def test_qagp(self):
     def f1(x,y):
         return x / x
     sys = integrate.gsl_function(f1, None)
     pts = Numeric.array((-1, 0, 1))
     flag, result, error = integrate.qagp(sys, pts, 1e-8, 1e-8, 100000, self.w)
     assert(Numeric.absolute(result - 2.) < 1e-3)
     assert(error<1e-8)
Пример #13
0
 def setUp(self):
     t = Numeric.arange(self._getn());
     y = testfunc(t, self.A, self.lambda_, self.b)
     sigma = Numeric.ones(self._getn()) * 0.1
     self.data = Numeric.array((t,y,sigma), Float)
     self.sys = multifit_nlin.gsl_multifit_function_fdf(exp_f, exp_df,
                                                        exp_fdf, self.data,
                                                        self._getn(),
                                                        self._getp())
Пример #14
0
 def setUp(self):
     self.dim   = 100
     self.param = 2
     self.a = 1000.1
     self.b = 100        
     self.x = Numeric.arange(self.dim)
     x = self.x
     self.y = self.a + self.b * self.x
     self.w = Numeric.ones((self.dim,))
     self.ws = multifit.linear_workspace(self.dim, self.param)
     self.X = Numeric.transpose(Numeric.array((Numeric.ones(self.dim,), x)))
Пример #15
0
 def _run(self, solver):
     start_point = Numeric.array((5., 7.), Float)
     initial_steps = Numeric.array((0.1, 0.1), Float)
     solver.set(start_point, initial_steps)
     
     for i in range(100):
         status = solver.iterate()            
         if status:
             break
         ssval = solver.size()
         rval = multiminimize.test_size (ssval, 1e-2);
  
         #if rval == 0:
         #    print "converged to minimum at"
         fval = solver.getf()
         x = solver.getx()
         t = (i, x[0], x[1], fval, ssval)
         #print "iter %3d x % 10.3e % 10.3e  f() = %-10.3f ssize = %.3f" % t
         if rval == 0:
             break
     else:
         raise ValueError, "Number of Iterations exceeded!"
Пример #16
0
def exp_df(x, params):
    A       = x[0]
    lambda_ = x[1]
    b       = x[2]
    
    t       = params[0]
    yi      = params[1]
    sigma   = params[2]

    e = exp(-lambda_ * t)
    e_s = e/sigma
    df = numx.array((e_s, -t * A * e_s, 1/sigma))
    df = numx.transpose(df)
    return df
Пример #17
0
def test_evolve():
    dimension = 2
    step = odeiv.step_bsimp(dimension, func, jac, mu)
    control = odeiv.control_y_new(step, 1e-6, 1e-6)
    evolve  = odeiv.evolve(step, control, dimension)
    h = 1
    t = 0.0
    t1 = 1.0
    y = numx.array([1.0, 0.0])
    print  step.name(), step.order()
    while t<t1:
        t, h, y = evolve.apply(t, t1, h, y)

	
    dimension = 2
    steps = (
             odeiv.step_rk2,
             odeiv.step_rk4,
             odeiv.step_rkf45,
             odeiv.step_rkck,
             odeiv.step_rk8pd,
             odeiv.step_rk2imp,
             odeiv.step_rk4imp,
             odeiv.step_gear1,
             odeiv.step_gear2)
    for s in steps:
        step = s(dimension, func, None, mu)
        print  step.name(), step.order()
        control = odeiv.control_y_new(step, 1e-6, 1e-6)
        print control.name()
        evolve  = odeiv.evolve(step, control, dimension)
        h = 1
        t = 0.0
        t1 = 1.0
        y = (1.0, 0.0)
        while t<t1/2.0:
            t, h, y = evolve.apply(t, t1, h, y)
            
        y, yerr, dydt = step.apply(t, h, y, None)
        h, msg = control.hadjust(y, yerr, dydt, h)
        assert(msg == odeiv.HADJ_DEC or
               msg == odeiv.HADJ_INC or
               msg == odeiv.HADJ_NIL
               )
        step.reset()
        evolve.reset()
        while t<t1:
            t, h, y = evolve.apply(t, t1, h, y)
	    y = y
Пример #18
0
def run():
    r = rng.rng()
    bw = bspline(4, nbreak)


    # Data to be fitted
    x = 15. / (N-1) * numx.arange(N)
    y = numx.cos(x) * numx.exp(0.1 * x)    
    sigma = .1
    w = 1.0 / sigma**2 * numx.ones(N) 
    dy = r.gaussian(sigma, N)
    y  = y + dy

    # use uniform breakpoints on [0, 15] 
    bw.knots_uniform(0.0, 15.0)

    X = numx.zeros((N, ncoeffs))
    for i in range(N):
        B = bw.eval(x[i])
        X[i,:] = B
        
    # do the fit
    c, cov, chisq = multifit.wlinear(X, w, y, multifit.linear_workspace(N, ncoeffs))

    # output the smoothed curve
    res_y = []
    res_y_err = []
    for i in range(N):
        B = bw.eval(x[i])
        yi, yi_err = multifit.linear_est(B, c, cov)
        res_y.append(yi)
        res_y_err.append(yi_err)
        #print yi, yerr
    res_y = numx.array(res_y)
    res_y_err = numx.array(res_y_err)    
    return (x, y,), (x, res_y),  res_y_err
Пример #19
0
 def _run(self, solver):
     tmp = Numeric.array((-10., -5.), Float)
     solver.set(tmp)
     for iter in range(100):
         status = solver.iterate()
         r = solver.root()
         x = solver.getx()
         f = solver.getf()
         status = multiroots.test_residual(f, 1e-7)
         if status == 0:
             break
     else:
         raise ValueError, "Number of Iterations exceeded!"
 
     assert(Numeric.absolute(x[0] - 1)<1e-6)
     assert(Numeric.absolute(x[1] - 1)<1e-6)
     assert(Numeric.absolute(f[0])<1e-6)
     assert(Numeric.absolute(f[1])<1e-6)
Пример #20
0
 def _run(self, solver):
     #x = Numeric.array((1.0, .4, .1))
     x = Numeric.array((1.0, 0.0, 0.0))
     solver.set(x)
     #g.title('Start')
     #g.plot(Gnuplot.Data(self.data[0], self.data[1]),
     #       Gnuplot.Data(self.data[0], testfunc(self.data[0]),
     #                    with = 'line'),
     #       )
     #raw_input()
     #print "Testing solver ", solver.name() 
     #print "%5s %9s %9s  %9s  %10s" % ("iter", "A", "lambda", "b", "|f(x)|")
     for iter in range(20):
         status = solver.iterate()
         assert(status == 0 or status == -2)
         x  = solver.getx()
         dx = solver.getdx()
         f  = solver.getf()
         J  = solver.getJ()
         tdx = multifit_nlin.gradient(J, f)
         status = multifit_nlin.test_delta(dx, x, 1e-8, 1e-8)
         #status = multifit_nlin.test_gradient(dx, 1e-4)
         fn = Numeric.sqrt(Numeric.sum(f*f))
         #g.title('Iteration')
         if status == 0:
             break
         #print "%5d % .7f % .7f  % .7f  % .7f" %(iter, x[0], x[1], x[2], fn)
         #g.plot(Gnuplot.Data(self.data[0], self.data[1]),
         #       Gnuplot.Data(self.data[0],
         #                    testfunc(self.data[0], x[0], x[1], x[2]),
         #                    with = 'line', title='iteration ' + str(iter)),
         #       )
         #raw_input()
     else:
         raise ValueError, "Number of Iterations exceeded!"
     #print "Convereged :"        
     #print "%5d % .7f % .7f  %.7f  % .7f" %(iter, x[0], x[1], x[2], fn)
     assert(Numeric.absolute(x[0] - self.A) < _eps)
     assert(Numeric.absolute(x[1] - self.lambda_) < _eps)
     assert(Numeric.absolute(x[2] - self.b) < _eps)
     #J = solver.getJ()
     #print "shape = ", J.shape
     covar =  multifit_nlin.covar(solver.getJ(), 0.0)
Пример #21
0
 def test_qawf(self):
     def f2(x,y):
         return Numeric.sin(x) / x
     sys2 = integrate.gsl_function(f2, None)
     def f1(x,y):
         return 1 / x        
     sys1 = integrate.gsl_function(f1, None)
     def f3(x,y):
         return 1 / -x        
     sys3 = integrate.gsl_function(f3, None)
     
     pts = Numeric.array((-Numeric.pi, 0, Numeric.pi))
     flag, result1, error = integrate.qagp(sys2, pts, 1e-8, 1e-8, 100000, self.w)
     table1 = integrate.qawo_table(1, 100, integrate.SINE, 100)        
     cyclew = integrate.workspace(1000000)
     flag, result2, error = integrate.qawf(sys1, Numeric.pi, 1e-8,  100, self.w, cyclew, table1)
     table2 = integrate.qawo_table(-1, 100, integrate.SINE, 100)        
     flag, result3, error = integrate.qawf(sys3, Numeric.pi, 1e-8,  100, self.w, cyclew, table2)
     assert(Numeric.absolute(result1+result2+result3 - Numeric.pi) < 1e-8)
Пример #22
0
 def _run(self, solver):
     tmp = Numeric.array((5., 7.), Float)
     solver.set(tmp, 0.01, 1e-4)
     #print "Testing solver ", solver.name() 
     #print "%5s %9s %9s  %9s %9s %9s" % ("iter", "x", "y", "f", "dx", "dy")
     for iter in range(200):
         status = solver.iterate()
         gradient = solver.gradient()
         x = solver.getx()
         f = solver.getf()
         status = multiminimize.test_gradient(gradient, 1e-3)
         if status == 0:
             break
         #print "%5d % .7f % .7f  % .7f % .7f % .7f" %(iter, x[0], x[1], f, gradient[0], gradient[1])
     else:
         raise ValueError, "Number of Iterations exceeded!"
     assert(Numeric.absolute(x[0] - 1)<1e-3)
     assert(Numeric.absolute(x[1] - 2)<1e-3)
     assert(Numeric.absolute(f - 30)<1e-3)
     assert(Numeric.absolute(gradient[0])<1e-3)
     assert(Numeric.absolute(gradient[1])<1e-3)
Пример #23
0
def fdf_solver():
    #solver = multiminimize.conjugate_pr(sys, 2)
    #solver = multiminimize.conjugate_fr(sys, 2)
    #solver = multiminimize.vector_bfgs(sys, 2)
    #solver = multiminimize.vector_bfgs2(sys, 2)
    solver = multiminimize.steepest_descent(sys, 2)
    start = numx.array((5., 7.), )
    solver.set(start, 0.01, 1e-4)
    print( "Using solver ", solver.name() )
    print( "%5s %9s %9s  %9s %9s %9s" % ("iter", "x", "y", "f", "dx", "dy"))
    for iter in range(200):
        status = solver.iterate()
        gradient = solver.gradient()
        x = solver.getx()
        f = solver.getf()
        status = multiminimize.test_gradient(gradient, 1e-3)
        if status == errno.GSL_SUCCESS:
            print( "Converged ")
        print( "%5d % .7f % .7f  % .7f % .7f % .7f" %(iter, x[0], x[1], f, gradient[0], gradient[1]))
        if status == errno.GSL_SUCCESS:
            break

    else:
        raise ValueError("Number of Iterations exceeded!")
Пример #24
0
 def test_variance_long(self):
     self.failIf(long.variance(numx.array([-1,-3,1])) != 4.0)
     return
Пример #25
0
 def test_variance_m_long(self):
     self.failIf(long.variance_m(numx.array([-1,-3,1]),
                                 long.mean(numx.array([-1,-3,1]))) != 4)
     return
Пример #26
0
 def test_variance_m(self):
     self.failIf(variance_m(numx.array([-1.,-3.,1.]),
                            mean(numx.array([-1.,-3.,1.]))) != 4.0)
     return
Пример #27
0
 def test_mean_uchar(self):
     self.failIf(uchar.mean(numx.array([1,2,3], UInt8)) != 2)
     self.failIf(uchar.mean([1,2,3]) != 2)
Пример #28
0
 def test_min_long(self): 
     self.failIf(long.min(numx.array([1,2,3])) != 1)
Пример #29
0
 def test_sd_m(self):
     self.failIf(sd_m(numx.array([-1.,-3.,1.]),
                      mean(numx.array([-1.,-3.,1.]))) != 2.0)
Пример #30
0
 def setUp(self):
     a = 1.0
     b = 0.0
     c = -5.0
     self.sys = roots.gsl_function_fdf(quadratic, quadratic_deriv, quadratic_fdf, Numeric.array((a,b,c)))
Пример #31
0
 def test_max_index(self):
     self.failIf(long.max_index(numx.array([1,2,3])) != 2)
Пример #32
0
 def test_max_long(self):
     self.failIf(long.max(numx.array([1,2,3])) != 3)
Пример #33
0
 def test_mean_float(self):
     self.failIf(float.mean(numx.array([-1.,-3.,1.], 'f')) != -1)
     self.failIf(float.mean([1.,2.,3.]) != 2)
Пример #34
0
 def test_mean_char(self):
     tmp = (ord("1") + ord("2") + ord("3")) / 3
     self.failIf(char.mean(numx.array([1,2,3], Int8)) != 2)
     self.failIf(char.mean([1,2,3]) != 2)
Пример #35
0
 def setUp(self):
     self._assertIsNotNone(self._t_type)
     tmp = numx.array((1., 2.), )
     self._dim = 2
     self._sys = multiminimize.gsl_multimin_function(my_f, tmp, self._dim)
     self._solver = self._t_type(self._sys, self._dim)
Пример #36
0
 def test_sd_long(self):
     self.failIf(long.sd(numx.array([-1,-3,1])) != 2)
Пример #37
0
 def test_sd(self):
     self.failIf(sd(numx.array([-1.,-3.,1.])) != 2.0)
Пример #38
0
 def setUp(self):
     tmp = Numeric.array((1., 2.), Float)
     self.sys = multiminimize.gsl_multimin_function(my_f, tmp, self._getsize())
Пример #39
0
         City("Phoenix",        -112.07, 33.54,),
         City("Albuquerque",    -106.62, 35.12,),
         City("Clovis",         -103.20, 34.41,),
         City("Durango",        -107.87, 37.29,),
         City("Dallas",          -96.77, 32.79,),
         City("Tesuque",        -105.92, 35.77,),
         City("Grants",         -107.84, 35.15,),
         City("Los Alamos",     -106.28, 35.89,),
         City("Las Cruces",     -106.76, 32.34,),
         City("Cortez",         -108.58, 37.35,),
         City("Gallup",         -108.74, 35.52,))

n_cities = len(cities)
distance_matrix = numx.zeros((n_cities, n_cities))

cities_vec = numx.array(map(lambda x: x.GetData(), cities))
for i in range(len(cities)):
    cities[i].SetNumber(i)
    
earth_radius = 6375.000
#n_cities = 6

# distance between two cities
def city_distance(c):
    la = c[:,0]
    lo = c[:,1]
    sla = sin(la*pi/180)
    cla = cos(la*pi/180)
    slo = sin(lo*pi/180)
    clo = sin(lo*pi/180)
Пример #40
0
 def test_sd_m_long(self):
     self.failIf(long.sd_m(numx.array([-1,-3,1]),
                           long.mean(numx.array([-1,-3,1]))) != 2)
Пример #41
0
 def setUp(self):
     tmp = Numeric.array((1., 10.), Float)
     self.sys = multiroots.gsl_multiroot_function_fdf(
         rosenbrock_f, rosenbrock_df, rosenbrock_fdf, tmp, self._getsize())
Пример #42
0
def generate_data():
    r = pygsl.rng.mt19937()
    a = numx.arange(20) / 10.  # + .1
    y0 = numx.exp(a)
    sigma = 0.1 * y0
    tmp = tuple(map(r.gaussian, sigma))
    dy = numx.array(tmp)
    tmp = y0 + dy
    return a, tmp, sigma


if __name__ == '__main__':
    x, y, sigma = generate_data()
    data = (x, y, sigma)
    data = numx.array(data).transpose()

    for tmp in data:
        print("%e %e %e" % tuple(tmp))

    #c, cov , chisq = calculate(x, y, sigma)
    #import Gnuplot
    #g = Gnuplot.Gnuplot()
    #xref = numx.arange(100) / 50.
    #yref = c[0] + c[1] * xref + c[2] * xref **2
    #t1 = Gnuplot.Data(x,y, with='points')
    #t2 = Gnuplot.Data(xref, yref, with='line')
    #g.plot(t1,t2)
    #print "Press return !"
    #raw_input()
Пример #43
0
    -106.76,
    32.34,
), City(
    "Cortez",
    -108.58,
    37.35,
), City(
    "Gallup",
    -108.74,
    35.52,
))

n_cities = len(cities)
distance_matrix = numx.zeros((n_cities, n_cities))

cities_vec = numx.array(map(lambda x: x.GetData(), cities))
for i in range(len(cities)):
    cities[i].SetNumber(i)

earth_radius = 6375.000

#n_cities = 6


# distance between two cities
def city_distance(c):
    la = c[:, 0]
    lo = c[:, 1]
    sla = sin(la * pi / 180)
    cla = cos(la * pi / 180)
    slo = sin(lo * pi / 180)
Пример #44
0
 def test_mean_long(self):
     self.failIf(long.mean(numx.array([-1,-3,1])) != -1)
     self.failIf(long.mean([1,2,3]) != 2)
Пример #45
0
 def test_mean_short(self):
     self.failIf(short.mean([1,2,3]) != 2)        
     self.failIf(short.mean(numx.array([-1,-3,1], Int16)) != -1)