def brownian_targ(C,x,y,h,amp,cmin, cmax,symm):
# Compute covariance for this bit
if h==.5:
isotropic_cov_funs.brownian(C,x,y,cmin=0,cmax=-1,symm=symm)
else:
isotropic_cov_funs.frac_brownian(C,x,y,h,cmin=0,cmax=-1,symm=symm)
imul(C, amp*amp, cmin=cmin, cmax=cmax, symm=symm)
# Possibly symmetrize this bit
if symm:
symmetrize(C, cmin=cmin, cmax=cmax)
def __call__(self,x,y,amp=1.,scale=1.,symm=None,*args,**kwargs):
if amp<0. or scale<0.:
raise ValueError, 'The amp and scale parameters must be positive.'
if symm is None:
symm = (x is y)
# Figure out how to divide job up between threads.
nx = x.shape[0]
ny = y.shape[0]
n_threads = min(get_threadpool_size(), nx*ny / 10000)
if n_threads > 1:
if not symm:
bounds = np.linspace(0,ny,n_threads+1)
else:
bounds = np.array(np.sqrt(np.linspace(0,ny*ny,n_threads+1)),dtype=int)
# Split off the distance arguments
distance_arg_dict = {}
if hasattr(self.distance_fun, 'extra_parameters'):
for key in self.extra_distance_params.iterkeys():
if key in kwargs.keys():
distance_arg_dict[key] = kwargs.pop(key)
# Allocate the matrix
C = np.asmatrix(np.empty((nx,ny),dtype=float,order='F'))
def targ(C,x,y, cmin, cmax,symm, d_kwargs=distance_arg_dict, c_args=args, c_kwargs=kwargs):
# Compute distance for this bit
self.distance_fun(C, x, y, cmin=cmin, cmax=cmax, symm=symm, **d_kwargs)
imul(C, 1./scale, cmin=cmin, cmax=cmax, symm=symm)
# Compute covariance for this bit
self.cov_fun(C, cmin=cmin, cmax=cmax,symm=symm, *c_args, **c_kwargs)
imul(C, amp*amp, cmin=cmin, cmax=cmax, symm=symm)
# Possibly symmetrize this bit
# FIXME: Intermittent errors apparently originating in symmetrize!
# if symm:
# symmetrize(C, cmin=cmin, cmax=cmax)
if n_threads <= 1:
targ(C,x,y,0,-1,symm)
else:
thread_args = [(C,x,y,bounds[i],bounds[i+1],symm) for i in xrange(n_threads)]
map_noreturn(targ, thread_args)
if symm:
symmetrize(C)
return C
def __call__(self, x, y, amp=1., scale=1., symm=None, *args, **kwargs):
if amp < 0. or scale < 0.:
raise ValueError, 'The amp and scale parameters must be positive.'
if symm is None:
symm = (x is y)
# Figure out how to divide job up between threads.
nx = x.shape[0]
ny = y.shape[0]
n_threads = min(get_threadpool_size(), nx * ny / 10000)
if n_threads > 1:
if not symm:
bounds = np.linspace(0, ny, n_threads + 1)
else:
bounds = np.array(np.sqrt(
np.linspace(0, ny * ny, n_threads + 1)),
dtype=int)
# Split off the distance arguments
distance_arg_dict = {}
if hasattr(self.distance_fun, 'extra_parameters'):
for key in self.extra_distance_params.iterkeys():
if key in kwargs.keys():
distance_arg_dict[key] = kwargs.pop(key)
# Allocate the matrix
C = np.asmatrix(np.empty((nx, ny), dtype=float, order='F'))
def targ(C,
x,
y,
cmin,
cmax,
symm,
d_kwargs=distance_arg_dict,
c_args=args,
c_kwargs=kwargs):
# Compute distance for this bit
self.distance_fun(C,
x,
y,
cmin=cmin,
cmax=cmax,
symm=symm,
**d_kwargs)
imul(C, 1. / scale, cmin=cmin, cmax=cmax, symm=symm)
# Compute covariance for this bit
if self.with_x:
self.cov_fun(C,
x,
y,
cmin=cmin,
cmax=cmax,
symm=symm,
*c_args,
**c_kwargs)
else:
self.cov_fun(C,
cmin=cmin,
cmax=cmax,
symm=symm,
*c_args,
**c_kwargs)
imul(C, amp * amp, cmin=cmin, cmax=cmax, symm=symm)
if n_threads <= 1:
targ(C, x, y, 0, -1, symm)
else:
thread_args = [(C, x, y, bounds[i], bounds[i + 1], symm)
for i in xrange(n_threads)]
map_noreturn(targ, thread_args)
if symm:
symmetrize(C)
return C
