def fisher(theta, i, j = None): """ Fisher information using the first order derivative :param theta: the theta of the density :param i: The ith component of the diagonal of the fisher information matrix will be returned (if j is None) :param j: The i,j th component of the fisher information matrix will be returned """ #Bring it in a form that we can derive fh = lambda ti, t0, tn, x: np.log(self.density(x, list(t0) + [ti] + list(tn))) # The derivative f_d_theta_i = lambda x: derivative(fh, theta[i], dx=1e-5, n=1, args=(theta[0:i], theta[i + 1:], x)) if j is not None: f_d_theta_j = lambda x: derivative(fh, theta[j], dx=1e-5, n=1, args=(theta[0:j], theta[j + 1:], x)) f = lambda x: np.float128(0) if fabs(self.density(x, theta)) < 1e-5 else f_d_theta_i(x) * f_d_theta_j(x) * self.density(x, theta) else: # The function to integrate f = lambda x: np.float128(0) if fabs(self.density(x, theta)) < 1e-5 else f_d_theta_i(x) ** 2 * self.density(x, theta) #First order result = integrate(f, self.support) return result
def sec_ord_corr(chains,t1,emission_symbol_1,t2,emission_symbol_2):
ones_at_t1_t2 = 0
ones_at_t1 = 0
ones_at_t2 = 0
for i in range(0,len(chains)):
a_t1 = chains[i][t1]
b_t1 = emission_symbol_1
a_t2 = chains[i][t2]
b_t2 = emission_symbol_2
if a_t1 == b_t1:
ones_at_t1 += 1
if a_t2 == b_t2:
ones_at_t2 += 1
if a_t1 == b_t1 and a_t2 == b_t2:
ones_at_t1_t2 += 1
try:
soc = (np.float128(ones_at_t1_t2) / ones_at_t1) / (np.float128(ones_at_t2) / len(chains))
except ZeroDivisionError:
soc = np.Inf
return soc
def calcPosteriorProb(self, dir, priors, condProb):
totalCmap = {}
# vocabCalc = VocabularyCalculator()
# vocabCalc.calculate(dir)
#
# print "Test class vocab count: ", vocabCalc.getClassVocabCount()
testDir = "earn"
for classDir in os.listdir(dir):
# if classDir == testDir:
if 1:
numberOfFiles = len(os.listdir(os.path.join(dir, classDir)))
correctClassEstimation = 0
for filename in os.listdir(os.path.join(dir, classDir)):
docVocab = {}
currentCmap = {}
testFile = open(os.path.join(dir, classDir, filename), "r")
for line in testFile:
words = line.split()
for word in words:
if word in docVocab:
docVocab[word] += 1
else:
docVocab[word] = 1
# calculate currentCmap
totalCmap[filename] = {}
tempFile = open("temp.txt", "w")
for trainClass, classPrior in priors.iteritems():
prod = np.float128(1.0)
for word, count in docVocab.iteritems():
# print word, count
if word in condProb[trainClass]:
prod = prod * condProb[trainClass][word]
# print prod
# if condProb[trainClass][word] == 0.0:
# print trainClass, word, condProb[trainClass][word]
tempFile.write(trainClass + " " + word + " " + str(condProb[trainClass][word]) + " "
+ str(prod))
tempFile.write("\n")
currentCmap[trainClass] = prod * np.float128(classPrior)
totalCmap[filename] = currentCmap
estimatedClass = max(currentCmap.iteritems(), key=operator.itemgetter(1))[0]
# print "Actual file class: ", classDir, ", Estimated file class: " , estimatedClass
# print "\n"
if(estimatedClass == testDir):
correctClassEstimation += 1
accuracy = (correctClassEstimation / numberOfFiles) * 100
print "Accuracy for ", classDir, ": ", accuracy, "%"
return totalCmap
def alignRec(record, template=template, bgfile='image_Ch1.nrrd', alignSet='', threshold=0.6):
record = checkDir(record)
record['last_host'] = host
print 'Finalising alignment for: ' + record['name']
# bgfile = record['original_nrrd'][('Ch' + str(record['background_channel']) + '_file')]
record['aligned_bg'], r = cmtk.align(bgfile, template=template, settings=alignSet)
record['aligned_avgslice_score'] = str(
ci.rateOne(record['aligned_bg'], results=None, methord=slicescore.avgOverlapCoeff, template=template))
record['aligned_slice_score'] = str(
ci.rateOne(record['aligned_bg'], results=None, methord=slicescore.OverlapCoeff, template=template))
record['aligned_score'] = str(
np.mean([np.float128(record['aligned_avgslice_score']), np.float128(record['aligned_slice_score'])]))
# Note: np.float128 array score converted to string as mongoDB only supports float(64/32 dependant on machine).
record['aligned_bg'] = str(record['aligned_bg']).replace(tempfolder, '')
print 'Result: ' + record['aligned_score']
if record['aligned_score'] > threshold:
record['alignment_stage'] = 6
print 'Passed!'
else:
record['alignment_stage'] = 0
print 'Failed!'
if r > 0:
print 'Error Code:' + str(r)
record['alignment_stage'] = 0
record['max_stage'] = 6
return record
def test_precision(self):
"""
Tests if the errors due to limited floating point precision are reduced
by the more complex averaging algorithms.
Somehow the SumDirectly algorithm seems to be more precise than the
slightly more sophisticated SortedSum algorithm. Maybe this is because
Python can optimize simple algorithms by itself. But since this test
expects the SortedSum algorithm to be more exact, this test fails almost
each time it is run, so it is marked as incomplete.
"""
# create some random values
values = []
for i in range(2 ** 10 - 1):
values.append(random.gauss(0.0, 1.0))
# initialize some averages with the random values
avg1 = sumpf.helper.average.SumDirectly(values=values)
avg2 = sumpf.helper.average.SortedSum(values=values)
avg3 = sumpf.helper.average.SumList(values=values)
# calculate a very precise average
summed = numpy.float128(0.0)
for v in sorted(values):
summed += numpy.float128(v)
average = summed / numpy.float128(len(values))
# calculate the errors of the averaging algorithms
e1 = abs(avg1.GetAverage() - average)
e2 = abs(avg2.GetAverage() - average)
e3 = abs(avg3.GetAverage() - average)
# compare their performance
self.assertGreaterEqual(e1, e2) # the SortedSum algorithm is expected to be more precise than the SumDirectly algorithm
self.assertGreaterEqual(e2, e3) # the SumList algorithm is expected to be more precise than the SortedSum algorithm
def _merge_trigger_into(trigger, cluster):
trigger_snr = trigger["snr"]
cluster['time_min'] = min(trigger['time_min'], cluster['time_min'])
cluster['time_max'] = max(trigger['time_max'], cluster['time_max'])
cluster['freq_min'] = min(trigger['freq_min'], cluster['freq_min'])
cluster['freq_max'] = max(trigger['freq_max'], cluster['freq_max'])
if trigger_snr > cluster['snr']:
cluster['time'] = trigger['time']
cluster['freq'] = trigger['freq']
cluster['snr'] = trigger_snr
cluster['amplitude'] = max(trigger['amplitude'], cluster['amplitude'])
cluster['q'] = max(trigger['q'], cluster['q'])
cluster["trigger_count"] += trigger.get("trigger_count", 1)
cluster["weighted_time"] += trigger.get("weighted_time",
trigger_snr
*np.float128(trigger["time"]))
cluster["weighted_freq"] += trigger.get("weighted_freq",
trigger_snr
*np.float128(trigger["freq"]))
cluster["snr_sum"] += trigger.get("snr_sum", trigger_snr)
return cluster
def test_numpy(self):
assert chash(np.bool_(True)) == chash(np.bool_(True))
assert chash(np.int8(1)) == chash(np.int8(1))
assert chash(np.int16(1))
assert chash(np.int32(1))
assert chash(np.int64(1))
assert chash(np.uint8(1))
assert chash(np.uint16(1))
assert chash(np.uint32(1))
assert chash(np.uint64(1))
assert chash(np.float32(1)) == chash(np.float32(1))
assert chash(np.float64(1)) == chash(np.float64(1))
assert chash(np.float128(1)) == chash(np.float128(1))
assert chash(np.complex64(1+1j)) == chash(np.complex64(1+1j))
assert chash(np.complex128(1+1j)) == chash(np.complex128(1+1j))
assert chash(np.complex256(1+1j)) == chash(np.complex256(1+1j))
assert chash(np.datetime64('2000-01-01')) == chash(np.datetime64('2000-01-01'))
assert chash(np.timedelta64(1,'W')) == chash(np.timedelta64(1,'W'))
self.assertRaises(ValueError, chash, np.object())
assert chash(np.array([[1, 2], [3, 4]])) == \
chash(np.array([[1, 2], [3, 4]]))
assert chash(np.array([[1, 2], [3, 4]])) != \
chash(np.array([[1, 2], [3, 4]]).T)
assert chash(np.array([1, 2, 3])) == chash(np.array([1, 2, 3]))
assert chash(np.array([1, 2, 3], dtype=np.int32)) != \
chash(np.array([1, 2, 3], dtype=np.int64))
def parse_vecfile(a_fname):
"""Parse files containing word vectors
@param a_fname - name of the wordvec file
@return \c dimension of the vectors
"""
global POS, NEG
ivec = None
with codecs.open(a_fname, 'r', ENCODING) as ifile:
fnr = True
toks = None
for iline in ifile:
iline = iline.strip()
if fnr:
ndim = int(iline.split()[-1])
fnr = False
continue
elif not iline:
continue
toks = iline.split()
assert (len(toks) - 1) == ndim, "Wrong vector dimension: {:d}".format(\
len(toks) - 1)
if toks[0] in POS:
ivec = np.array([np.float128(i) for i in toks[1:]])
# ivec /= _get_vec_len(ivec)
POS[toks[0]] = ivec
elif toks[0] in NEG:
ivec = np.array([np.float128(i) for i in toks[1:]])
# ivec /= _get_vec_len(ivec)
NEG[toks[0]] = ivec
# prune words for which there were no vectors
POS = {iword: ivec for iword, ivec in POS.iteritems() if ivec is not None}
NEG = {iword: ivec for iword, ivec in NEG.iteritems() if ivec is not None}
return ndim
def main():
g = geolocation_table('128.173.90.68')
g.start_db()
l= []
start = g.get_start()
end = g.get_end()
i = start
while ( i <= end ):
data = g.get_data(i)
loc = data[6]
loc = loc.strip(' ()') # format location
loc = loc.split(',')
loc[0] = np.float128(loc[0])
loc[1] = np.float128(loc[1])
l.append(loc)
i += 1
g.stop_db()
# print l[0]
# print 'type(l[0]): ',type(l[0][0])
kml_write = sdr_kml_writer.kml_writer()
kml_write.add_colored_pushpin('red-pushpin','ff0000ff')
n = 1
for i in l:
s = 'Guess' + str(n)
kml_write.add_placemark(s,s,i,'red-pushpin')
n += 1
filename = 'guesses_degen.kml'
kml_write.write_to_file(filename)
def _data_to_file(self, data):
# process the datatypes
if self.file_dtype is None:
# load from data
self.file_dtype = data.dtype
else:
# make sure it's a dtype
if not isinstance(self.file_dtype, np.dtype):
try:
self.file_dtype = np.dtype(self.file_dtype)
except:
ValueError("file_dtype should be a numpy dtype.")
# process the gain
if self.gain is None:
# default to 1.0
self.gain = 1.0
# calc it if we are going from float to int
if (self.file_dtype.kind == 'i') and (self.data_dtype.kind == 'f'):
fr = np.float128(np.iinfo(self.file_dtype).max*2)
dr = np.float128(np.abs(data).max()*2 * (1.+self.gain_buffer))
self.gain = np.float64(dr/fr)
# calc and apply gain if necessary
if self.apply_gain and self.gain != 1.0:
return np.asarray(data/self.gain,dtype=self.file_dtype)
else:
return np.asarray(data,dtype=self.file_dtype)
def calc_ev_dos(self, ev_from=-100, ev_to=20, delta=0.01, sigma=0.1):
"""
Calculates dos of electronic eigenvalues
"""
success = True
error = ""
if ((self.eigenvalues is None) and (self.evs_up is None) and (self.evs_down is None)):
success = False
error = "Eigenvalues were not read in"
return success, error
_extraBins = 2
# get min and max
ev_dos_min = np.float128(ev_from)
ev_dos_max = np.float128(ev_to)
# number of bins
ev_dos_n_bins = np.around(int((ev_dos_max - ev_dos_min) / delta) + _extraBins, decimals=0)
# array to hold the ev bin values
ev_dos_bins = np.arange(ev_dos_min, np.around(ev_dos_min + ev_dos_n_bins * delta, decimals=4), delta)
self.ev_dos_bins = copy.deepcopy(ev_dos_bins)
if (self.eigenvalues is not None):
# array for the dos values
ev_dos = np.zeros(ev_dos_n_bins, dtype=np.float128)
# calculating DOS
for i in range(ev_dos_n_bins):
ev_dos[i] = np.sum((1/(sigma*np.pi**0.5)) * np.exp(-(ev_dos_bins[i] - self.eigenvalues)**2 / sigma**2))
self.ev_dos = copy.deepcopy(ev_dos)
if (self.evs_up is not None):
# array for the dos values
ev_dos = np.zeros(ev_dos_n_bins, dtype=np.float128)
# calculating DOS
for i in range(ev_dos_n_bins):
ev_dos[i] = np.sum((1/(sigma*np.pi**0.5)) * np.exp(-(ev_dos_bins[i] - self.evs_up)**2 / sigma**2))
self.ev_up_dos = copy.deepcopy(ev_dos)
if (self.evs_down is not None):
# array for the dos values
ev_dos = np.zeros(ev_dos_n_bins, dtype=np.float128)
# calculating DOS
for i in range(ev_dos_n_bins):
ev_dos[i] = np.sum((1/(sigma*np.pi**0.5)) * np.exp(-(ev_dos_bins[i] - self.evs_down)**2 / sigma**2))
self.ev_down_dos = copy.deepcopy(ev_dos)
return success, error
def unpack_time(payload):
################################################################################
(t_c,) = struct.unpack('!I', payload[0:4])
(t_m,) = struct.unpack('!d', payload[4:12])
t = repr(np.float128(t_c) + np.float128(t_m))
return t
def get_I(k, i):
assert k >= 0
assert 1 >= i >= 0
if k == 1:
return i
else:
k = np.float128(k)
i = np.float128(i)
return (pow(k, i) - 1) / (k-1)
def get_i(k, I):
assert k >= 0
assert 1 >= I >= 0
if k == 1:
return I
else:
k = np.float128(k)
I = np.float128(I)
return np.log(I * (k - 1) + 1) / np.log(k)
def test_ppc64_ibm_double_double128(self):
# check that the precision decreases once we get into the subnormal
# range. Unlike float64, this starts around 1e-292 instead of 1e-308,
# which happens when the first double is normal and the second is
# subnormal.
x = np.float128('2.123123123123123123123123123123123e-286')
got = [str(x/np.float128('2e' + str(i))) for i in range(0,40)]
expected = [
"1.06156156156156156156156156156157e-286",
"1.06156156156156156156156156156158e-287",
"1.06156156156156156156156156156159e-288",
"1.0615615615615615615615615615616e-289",
"1.06156156156156156156156156156157e-290",
"1.06156156156156156156156156156156e-291",
"1.0615615615615615615615615615616e-292",
"1.0615615615615615615615615615615e-293",
"1.061561561561561561561561561562e-294",
"1.06156156156156156156156156155e-295",
"1.0615615615615615615615615616e-296",
"1.06156156156156156156156156e-297",
"1.06156156156156156156156157e-298",
"1.0615615615615615615615616e-299",
"1.06156156156156156156156e-300",
"1.06156156156156156156155e-301",
"1.0615615615615615615616e-302",
"1.061561561561561561562e-303",
"1.06156156156156156156e-304",
"1.0615615615615615618e-305",
"1.06156156156156156e-306",
"1.06156156156156157e-307",
"1.0615615615615616e-308",
"1.06156156156156e-309",
"1.06156156156157e-310",
"1.0615615615616e-311",
"1.06156156156e-312",
"1.06156156154e-313",
"1.0615615616e-314",
"1.06156156e-315",
"1.06156155e-316",
"1.061562e-317",
"1.06156e-318",
"1.06155e-319",
"1.0617e-320",
"1.06e-321",
"1.04e-322",
"1e-323",
"0.0",
"0.0"]
assert_equal(got, expected)
# Note: we follow glibc behavior, but it (or gcc) might not be right.
# In particular we can get two values that print the same but are not
# equal:
a = np.float128('2')/np.float128('3')
b = np.float128(str(a))
assert_equal(str(a), str(b))
assert_(a != b)
def foldlight(self,period,nbins,ephemeris=0):
'''
folds a lightcurve on a known linear ephemeris
v1.0 Kieran O'Brien - Dec 2011
'''
phase=(self.obstimes-np.float128(ephemeris))/np.float128(period)
phase=phase-phase.astype('int')
self.phase,self.phasebins=np.histogram(phase,nbins)
return
def test_legendre_gauss_lobatto_nodes_weights():
from polynomials import legendre_gauss_lobatto_nodes_weights as gll
# n = 6
x_ref = numpy.float128([-1, -0.830223896278567, -0.468848793470714, 0])
w_ref = numpy.float128( \
[0.04761904761904762, 0.276826047361566, 0.431745381209863, 0.487619047619048])
x, w = gll(6)
aaae(x_ref, x[:4], 15, 'n=6, x')
aaae(w_ref, w[:4], 15, 'n=6, w')
def _loadTrailer(tree):
output = []
all_trailers_element = tree.xpath("/IRP_Roadef_Challenge_Instance/trailers/IRP_Roadef_Challenge_Instance_Trailers")
for trailer_element in all_trailers_element:
index = int(trailer_element.find("index").text)
capacity = np.float128(trailer_element.find("Capacity").text)
initial_quantity = np.float128(trailer_element.find("InitialQuantity").text)
distance_cost = float(trailer_element.find("DistanceCost").text)
output.append(Trailer(index, capacity, initial_quantity, distance_cost))
return output;
def intsum(a,b):
c = np.float128(0.0)
d = np.float128(0.0)
c = pairsum(a)
d = pairsum(b)
# for i in xrange(a.size):
# c = c + a[i]
# d = d + b[i]
d = d / 1e12
d = d + c
return d
def fixsum(a,b):
c = np.int64(0)
d = np.int64(0)
e = np.float128(0.0)
for i in xrange(a.size):
c = c + a[i]
d = d + b[i]
e = np.float128(d)
e = e / 1e20
e = e + np.float128(c)
return c
def run(self):
self.data = self.read_input()
self.num_per_mapper = len(self.data)
self.avg_cluster_size = np.float128(self.num_per_mapper) / np.float128(self.no_clusters)
self.keep_ratio = np.float128(self.out_per_mapper) / np.float128(self.num_per_mapper)
np.random.shuffle(self.data)
self.cluster_center_points = self.build_coresets()
self.cluster_centers = [ClusterCenter(c) for c in self.cluster_center_points]
self.sample_points()
def bigkahansum(a):
b = np.float128(0.0)
c = np.float128(0.0)
y = np.float128(0.0)
t = np.float128(0.0)
for i in xrange(a.size):
y = a[i] - c
t = b + y
c = (t - b) - y
b = t
return b
def EqFTh(x,pars):
Ncell = pars[0]
#Nsrc = pars[2]
Nc=Ncell
FAP_ = pars[1]
Nsrc = pars[2]
#return 1.-(1.-(1.+x)*np.exp(-x))**(Nc)-FAP_
sumx=(1.+x)
for i in range(2,2*Nsrc):
sumx = sumx + x**i * invfactorial[i]
return Nc*np.log(np.float128(1.)-np.float128(sumx*np.exp(-x)))-np.log(1.-FAP_)
def test_legendre_gauss_nodes_weights():
from polynomials import legendre_gauss_nodes_weights as gl
# n = 6
x_ref = numpy.float128( \
[-0.949107912342759, -0.741531185599395, -0.405845151377397, 0])
w_ref = numpy.float128( \
[0.129484966168870, 0.279705391489277, 0.381830050505119, 0.417959183673469])
x, w = gl(6)
aaae(x_ref, x[:4], 15, 'n=6, x')
aaae(w_ref, w[:4], 15, 'n=6, w')
def convert_quad_sum(arr1, arr2):
qsum1 = numpy.float128(0)
qsum2 = numpy.float128(0)
for i in xrange(nx):
qsum1 += numpy.float128(arr1[i])
qsum2 += numpy.float128(arr2[i])
sum1 = numpy.float64(qsum1)
sum2 = numpy.float64(qsum2)
return sum1, sum2
def foldlight_freq(light,freq,nbins,ephemeris=0,freqdot=0):
if(freqdot == 0):
phi=(light-np.float128(ephemeris))*np.float128(freq)
phi=phi-phi.astype('int')
phase,phasebins=np.histogram(phi,nbins)
else:
deltat=(light-np.float128(ephemeris))
phi=deltat*(freq+freqdot*deltat)
phi=phi-phi.astype('int')
phase,phasebins=np.histogram(phi,nbins)
return phasebins, phase
def loadPackingData(raw):
retval = {}
raw_as_list = "[" + raw.replace("=", ",").replace("{", "(").replace("}", ")").replace("\r", "") + "]"
raw_as_list = re.sub("([0-9]+\.[0-9]+)", r"ld('\1')", raw_as_list)
variables = ['N', 'L', 'L1', 'L2', 'P', 'P0']
f = np.longdouble
dtypes = [np.int32, f , f , f , f , f ]
eval_environ = dict((a,a) for a in variables)
eval_environ['ld'] = parse_longdouble
data = eval(raw_as_list, eval_environ)
# data = ["N", 64, "L1", [...], ..., [particle positions]]
# first process the variables
vardata = data[:-1] # ["N", 64, ..., "P0", 1e-7]
keys = vardata[0::2] # ["N", ..., "P0"]
values = vardata[1::2] # [64, ..., 1e-7]
for key, dtype, value in zip(keys, dtypes, values):
retval[key] = dtype(value)
# now process the particles
particles = np.array(data[-1]) # [x1, y1, r1, x2, ...]
particles = particles.reshape((particles.size/3, 3)) # [[x1, y1, r1], [x2, ...]]
particles = particles.transpose()
x = particles[0]
y = particles[1]
r = particles[2]
#convertedVectors = jamBashbulk.convertLvectors(retval["L1"], retval["L2"])
#retval['alpha'] = convertedVectors['alpha']
#retval['delta'] = convertedVectors['delta']
#for key, value in jamBashbulk.get_packing_data(retval["N"], retval["P0"], x, y, r, **convertedVectors).iteritems():
# retval[key+"_calc"] = value
x_major = float64(x); x_minor = float64(x-float128(x_major))
y_major = float64(y); y_minor = float64(y-float128(y_major))
r = float64(r)
particles = array(zip(x_major, x_minor, y_major, y_minor, r), dtype=[('x', float64), ('x_err', float64),
('y', float64), ('y_err', float64),
('r', float64)])
# particles = particles[0] # hack around structured array creation; for some
# reason there is a wrapping [ ]; this removes that.
# split particles in two float64 parts
#particles.dtype.names = ['x', 'y', 'r']
retval['particles'] = particles
return retval
def convert_quad_sum_pyramid(arr1, arr2, power):
qarr1 = numpy.float128(arr1)
qarr2 = numpy.float128(arr2)
for p in [2**i for i in xrange(1,power+1)]:
for i in xrange(nx//p):
qarr1[p*i] += qarr1[p*i+p//2]
qarr2[p*i] += qarr2[p*i+p//2]
sum1 = numpy.float64(qarr1[0])
sum2 = numpy.float64(qarr2[0])
return sum1, sum2
def normalize_padded(padded, means=None, stds=None):
"""Normalize by last dim of padded with means/stds or calculate them.
.. TODO::
* consider importing instead ex:
from sklearn.preprocessing import StandardScaler, RobustScaler
robust_scaler = RobustScaler()
x_train = robust_scaler.fit_transform(x_train)
x_test = robust_scaler.transform(x_test)
ValueError: Found array with dim 3. RobustScaler expected <= 2.
* Don't normalize binary features
* If events are sparse then this may lead to huge values.
"""
# TODO epsilon choice is random
epsilon = 1e-6
original_dtype = padded.dtype
is_flat = len(padded.shape) == 2
if is_flat:
padded = np.expand_dims(padded, axis=-1)
n_features = padded.shape[2]
n_obs = padded.shape[0] * padded.shape[1]
if means is None:
means = np.nanmean(np.float128(
padded.reshape(n_obs, n_features)), axis=0)
means = means.reshape([1, 1, n_features])
padded = padded - means
if stds is None:
stds = np.nanstd(np.float128(
padded.reshape(n_obs, n_features)), axis=0)
stds = stds.reshape([1, 1, n_features])
if (stds < epsilon).any():
print('warning. Constant cols: ', np.where((stds < epsilon).flatten()))
stds[stds < epsilon] = 1.0
# should be (small number)/1.0 as mean is subtracted.
# Possible prob depending on machine err
# 128 float cast otherwise
padded = (padded / stds).astype(original_dtype)
if is_flat:
# Return to flat
padded = np.squeeze(padded)
return padded, means, stds
def _botev_fixed_point(t, M, I, a2):
l = 7
I = np.float128(I)
M = np.float128(M)
a2 = np.float128(a2)
f = 2 * np.pi ** (2 * l) * np.sum(I ** l * a2 *
np.exp(-I * np.pi ** 2 * t))
for s in irange(l, 1, -1):
K0 = np.prod(np.arange(1, 2 * s, 2)) / np.sqrt(2 * np.pi)
const = (1 + (1 / 2) ** (s + 1 / 2)) / 3
time = (2 * const * K0 / M / f) ** (2 / (3 + 2 * s))
f = 2 * np.pi ** (2 * s) * \
np.sum(I ** s * a2 * np.exp(-I * np.pi ** 2 * time))
return t - (2 * M * np.sqrt(np.pi) * f) ** (-2 / 5)
def testBijectorOverRange(self):
with self.test_session():
for dtype in (np.float32, np.float64):
skewness = np.array([1.2, 5.], dtype=dtype)
tailweight = np.array([2., 10.], dtype=dtype)
# The inverse will be defined up to where sinh is valid, which is
# arcsinh(np.finfo(dtype).max).
log_boundary = np.log(
np.sinh(
np.arcsinh(np.finfo(dtype).max) / tailweight -
skewness))
x = np.array([
np.logspace(-2, log_boundary[0], base=np.e, num=1000),
np.logspace(-2, log_boundary[1], base=np.e, num=1000)
],
dtype=dtype)
# Ensure broadcasting works.
x = np.swapaxes(x, 0, 1)
y = np.sinh((np.arcsinh(x) + skewness) * tailweight)
bijector = tfb.SinhArcsinh(skewness=skewness,
tailweight=tailweight,
validate_args=True)
self.assertAllClose(y,
bijector.forward(x).eval(),
rtol=1e-4,
atol=0.)
self.assertAllClose(x,
bijector.inverse(y).eval(),
rtol=1e-4,
atol=0.)
# Do the numpy calculation in float128 to avoid inf/nan.
y_float128 = np.float128(y)
self.assertAllClose(np.log(
np.cosh(np.arcsinh(y_float128) / tailweight - skewness) /
np.sqrt(y_float128**2 + 1)) - np.log(tailweight),
bijector.inverse_log_det_jacobian(
y, event_ndims=0).eval(),
rtol=1e-4,
atol=0.)
self.assertAllClose(-bijector.inverse_log_det_jacobian(
y, event_ndims=0).eval(),
bijector.forward_log_det_jacobian(
x, event_ndims=0).eval(),
rtol=1e-4,
atol=0.)
def compute_markus_lyapunov(param):
window_size, offset, scale, sampling, seed, x0, max_iter, max_init, \
step_size, chunk = param
results = np.zeros(step_size, dtype='i4')
pos = 0
while pos < step_size:
step_pos = pos + chunk * step_size
screen_coord = (step_pos / window_size[1], step_pos % window_size[1])
c = np.complex128(
complex(
screen_coord[0] / scale[0] + offset[0],
((window_size[1] - screen_coord[1]) / scale[1] + offset[1])))
markus_func = lambda x: c.real if seed[idx % len(seed)] == "A" \
else c.imag
# Init
x = np.float128(x0)
try:
for idx in range(0, max_init):
r = markus_func(idx)
with np.errstate(over='raise'):
x = r * x * (1 - x)
except FloatingPointError:
pass
# Exponent
total = np.float64(0)
try:
for idx in range(0, max_iter):
r = markus_func(idx)
with np.errstate(over='raise'):
x = r * x * (1 - x)
v = abs(r - 2 * r * x)
if v == 0:
break
total = total + math.log(v) / math.log(1.23)
except FloatingPointError:
pass
if total == 0 or total == float('Inf'):
exponent = 0
else:
exponent = total / float(max_iter)
results[pos] = exponent
pos += sampling
return results
def calculate_distance_cluster_numpy(df, centr):
av = (np.zeros(k))
av_count = (np.zeros(k))
for i in range(df.shape[0]):
cluster = int(df[i][cluster_index])
distance = np.float128(
math.sqrt(
sum([(a - b)**2
for a, b in zip(df[i][0:cluster_index], centr[cluster])
])))
df[i][distance_cluster_index] = (distance)
av[cluster] += (distance)
av_count[cluster] += 1
# print("Iter: ",i," Sum: ", av[0])
return df, av, av_count
def test_scalar(self):
res = make_np(1.1)
self.assertIsInstance(res, np.ndarray) and self.assertEqual(
res.shape, (1, ))
res = make_np(1 << 64 - 1) # uint64_max
self.assertIsInstance(res, np.ndarray) and self.assertEqual(
res.shape, (1, ))
res = make_np(np.float16(1.00000087))
self.assertIsInstance(res, np.ndarray) and self.assertEqual(
res.shape, (1, ))
res = make_np(np.float128(1.00008 + 9))
self.assertIsInstance(res, np.ndarray) and self.assertEqual(
res.shape, (1, ))
res = make_np(np.int64(100000000000))
self.assertIsInstance(res, np.ndarray) and self.assertEqual(
res.shape, (1, ))
def _execute(self, data):
""" Normalizes the samples vector to norm one """
if self.feature_names == []:
self.feature_names = data.feature_names
elif self.feature_names != data.feature_names:
raise InconsistentFeatureVectorsException("Two feature vectors used during training do not contain the same features!")
x = data.view(numpy.ndarray)
a = x[0,:]
if self.dim == None:
self.dim = len(a)
a = a*numpy.float128(1)/numpy.linalg.norm(a)
if self.dimension_scale:
a = FeatureVector([len(a)*a],self.feature_names)
return a
else:
return FeatureVector([a],self.feature_names)
def binding_energy(DG, Na, c0=1):
"""Calculate the binding free energy while considering the
contributions due to the sodium concentration.
Parameters
----------
DG : floating point value collected from MD simulations.
Na : Sodium concentration
Returns
-------
DG : floating point value of the free energy with added
contributions from sodium concentration.
"""
return np.float128(DG - (R * T) * np.log(Na / c0))
def open_wave(fn):
'''Returns a tuple of sync_samples, data_samples, and sample_rate.'''
wavefile = wave.open(fn, 'r')
raw_data = wavefile.readframes(wavefile.getnframes())
samples = numpy.fromstring(raw_data, dtype=numpy.int16)
# try to use 128-bit float for the renormalization
try:
normed_samples = samples / numpy.float128(numpy.iinfo(numpy.int16).max)
except:
normed_samples = samples / float(numpy.iinfo(numpy.int16).max)
sync_samples = normed_samples[0::2]
data_samples = normed_samples[1::2]
# Need to invert these to match Matlab code for some reason.
sync_samples *= -1
data_samples *= -1
return sync_samples, data_samples, wavefile.getframerate()
def test_trig_func_has_correct_abs_max(analyzed_trig_func):
"""Test that absolute_maximum() returns correct value.
First, make sure that its approximation is correct. Then, compare
the exact values.
"""
trig_abs_max = analyzed_trig_func.absolute_maximum
approximate_expected_max = [-46.35559793676238, 1.013176643861527]
np.testing.assert_allclose(
np.float128(trig_abs_max), approximate_expected_max
)
exact_expected_max = analyzed_trig_func.relative_maxima[10]
np.testing.assert_equal(
trig_abs_max,
[exact_expected_max, analyzed_trig_func.func_real(exact_expected_max)],
)
def do_validation(sess, model, validation_iter, epoch, saver):
tot = np.float128(0.0)
loss, records = do_epoch(sess, model, validation_iter, "Validation", epoch)
if do_validation.min_loss is None or do_validation.min_loss > loss:
do_validation.min_loss = loss
ckpt = "{}/deeprccar-model".format(args.checkpoint_dir)
saver.save(sess, ckpt)
validf = "{}/validation-epoch{:03d}.txt".format(args.checkpoint_dir,
epoch)
with open(validf, "w") as valid_f:
for imfile, record in records.items():
print(imfile, record[0], record[1], record[2], file=valid_f)
tot += record[-1]
print("Unormalized Validation RMSE: ", np.sqrt(tot/len(records)))
print("Model saved at ", ckpt)
return loss
def test_numpy_high_precision_float_downcasting(fake_run, record_q, records_util):
# CLI: GH2255
run = fake_run()
run.log(dict(this=np.float128(0.0)))
r = records_util(record_q)
assert len(r.records) == 1
assert len(r.summary) == 0
history = r.history
assert len(history) == 1
found = False
for item in history[0].item:
if item.key == "this":
assert item.value_json == "0.0"
found = True
assert found
def ktda_s(task, higherPriorityTasks, ieq, s, mode=0):
# This function is used to report a upper bound of the probability for one deadline miss
kpoints = []
# pick up k testing points here
kpoints = findpoints(task, higherPriorityTasks, 0)
# for loop checking k points time
minP = np.float128(1.0)
selecteds = 0
minS = 0
for t in kpoints:
workload = determineWorkload(task, higherPriorityTasks, t)
if workload <= t:
return 0
#as WCET does not pass, check if the probability is acceptable
fy = float(t)
if ieq == Chernoff_bounds:
if mode == 0:
probRes = ieq(task, higherPriorityTasks, fy, s)
else:
try:
res = minimize_scalar(
lambda x: ieq(task, higherPriorityTasks, fy, x),
method='bounded',
bounds=[0, s])
probRes = ieq(task, higherPriorityTasks, fy, res.x)
selecteds = res.x
except TypeError:
print("TypeError")
probRes = 1
elif ieq == SympyChernoff:
ResList = []
ResList = ieq(task, higherPriorityTasks, fy, s)
probRes = ResList[0]
selecteds = ResList[1]
elif ieq == Hoeffding_inequality:
probRes = ieq(task, higherPriorityTasks, fy)
elif ieq == Bernstein_inequality:
probRes = ieq(task, higherPriorityTasks, fy)
else:
raise NotImplementedError(
"Error: You use a bound without implementation.")
if minP > probRes: #find out the minimum in k points
minP = probRes
minS = selecteds
return [minP, minS]
def testBijectorOverRange(self):
with self.cached_session():
for dtype in (np.float32, np.float64):
skewness = np.array([1.2, 5.], dtype=dtype)
tailweight = np.array([2., 10.], dtype=dtype)
# The inverse will be defined up to where sinh is valid, which is
# arcsinh(np.finfo(dtype).max).
log_boundary = np.log(
np.sinh(np.arcsinh(np.finfo(dtype).max) / tailweight - skewness))
x = np.array([
np.logspace(-2, log_boundary[0], base=np.e, num=1000),
np.logspace(-2, log_boundary[1], base=np.e, num=1000)
], dtype=dtype)
# Ensure broadcasting works.
x = np.swapaxes(x, 0, 1)
y = np.sinh((np.arcsinh(x) + skewness) * tailweight)
bijector = SinhArcsinh(
skewness=skewness, tailweight=tailweight, validate_args=True)
self.assertAllClose(y, bijector.forward(x).eval(), rtol=1e-4, atol=0.)
self.assertAllClose(x, bijector.inverse(y).eval(), rtol=1e-4, atol=0.)
# On IBM PPC systems, longdouble (np.float128) is same as double except that it can have more precision.
# Type double being of 8 bytes, can't hold square of max of float64 (which is also 8 bytes) and
# below test fails due to overflow error giving inf. So this check avoids that error by skipping square
# calculation and corresponding assert.
if np.amax(y) <= np.sqrt(np.finfo(np.float128).max) and \
np.fabs(np.amin(y)) <= np.sqrt(np.fabs(np.finfo(np.float128).min)):
# Do the numpy calculation in float128 to avoid inf/nan.
y_float128 = np.float128(y)
self.assertAllClose(
np.log(np.cosh(
np.arcsinh(y_float128) / tailweight - skewness) / np.sqrt(
y_float128**2 + 1)) -
np.log(tailweight),
bijector.inverse_log_det_jacobian(y, event_ndims=0).eval(),
rtol=1e-4,
atol=0.)
self.assertAllClose(
-bijector.inverse_log_det_jacobian(y, event_ndims=0).eval(),
bijector.forward_log_det_jacobian(x, event_ndims=0).eval(),
rtol=1e-4,
atol=0.)
def __init__(self, value=None, type=None, **kwargs):
self.value = value
if type is None:
if isinstance(value, int):
self.type = ParamType.Int
elif isinstance(value, (float, numpy.float128)):
self.type = ParamType.Float
self.value = numpy.float128(value)
elif isinstance(value, bool):
self.type = ParamType.Flag
elif isinstance(value, str):
self.type = ParamType.Str
else:
raise ValueError(
'Could not guess datatype for {}'.format(value))
else:
self.type = ParamType(int(type))
def expResAssign(size, n, minIndex, maxIndex):
resArr = np.zeros(size)
for switch in range(0, size):
if switch <= minIndex:
resArr[switch] = 0
elif switch >= maxIndex:
resArr[switch] = 1
else:
resArr[switch] = (np.float128(n)**np.float128(switch - minIndex) -
np.float128(1)) / (np.float128(n)**np.float128(
maxIndex - minIndex) - np.float128(1))
return resArr
def var_stack(d1, x2, x1_mean, n1):
d2 = np.diag(x2.T*x2)
n2 = len(x2)
x2_mean = np.mean(x2, axis=0)
d1 = np.float128(d1)
x1_mean = np.float128(x1_mean)
n1 = np.float128(n1)
d2 = np.float128(d2)
x2_mean = np.float128(x2_mean)
n2 = np.float128(n2)
return np.float32((d1 + d2)/(n1 + n2) - np.matrix(np.array((n1*x1_mean + n2*x2_mean)/(n1+n2))**2))
def log_prob(sentence, v_lambda):
total = np.float128(0)
for w in range(len(sentence)):
ptri, pbi, puni = np.float128(0), np.float128(0), np.float128(0)
unigram = sentence[w]
puni = np.float128(unigram_counts[unigram]) / train_token_count
if w >= 1:
bigram = (sentence[w - 1], sentence[w])
unigram = sentence[w - 1]
pbi = np.float128(0) if bigram not in bigram_counts \
else np.float128(bigram_counts[bigram])/unigram_counts[unigram]
if w >= 2:
trigram = (sentence[w - 2], sentence[w - 1], sentence[w])
bigram = (sentence[w - 2], sentence[w - 1])
ptri = np.float128(0) if trigram not in trigram_counts \
else np.float128(trigram_counts[trigram])/bigram_counts[bigram]
total += np.log2(np.dot([ptri, pbi, puni], v_lambda))
return total
def st_dev(Img, i, j, m, N):
a = int((N - 1) / 2)
sd = 0
valid_cnt = 0
for k in range(-a, a):
for h in range(-a, a):
if ((k + i) > 0 and (k + i) < Img.shape[0] and (h + j) > 0
and (h + j) < Img.shape[1]):
sd = sd + np.square(Img[k + i][h + j] - m)
valid_cnt = valid_cnt + 1
sd = np.float128(sd / (valid_cnt * valid_cnt))
sd = np.sqrt(sd)
return sd
def wRoutine(l, mode=0):
#suppose that the table is ready
#this is the Lemma 1 in the paper
resProb = np.float128(0.)
listProb = []
if l == 0:
return 1.0
else:
for w in range(1, l + 1):
if mode == 0:
resProb = lookupTable[w] * wRoutine(l - w, mode)
else:
resProb = conlookupTable[w] * wRoutine(l - w, mode)
# if resProb == 0.0:
# print "resProb is 0", w, lookupTable[w], wRoutine(l-w, mode)
listProb.append(resProb)
# print "l is ", l, listProb
return max(listProb)
def posterior(self, model_params, my_y, beta=1.0):
tiny = np.finfo(np.float64).tiny
mx = np.finfo(np.float64).max / (self.H)
my_N = my_y.shape[0]
log_posteriors = self.log_p_y(model_params, my_y, beta=beta)
log_posteriors += np.log(model_params['pies'])[None, :] * beta
posteriors = np.float64(np.exp(np.float128(log_posteriors)))
posteriors[np.isnan(posteriors)] = tiny
posteriors[posteriors < tiny] = tiny
posteriors[np.isinf(posteriors)] = mx
return {
'posteriors_h': posteriors / np.sum(posteriors, 1)[:, None],
'logpj': log_posteriors
}
def sec_ord_corr_Adam(chains, t1, emission_symbol_1, t2, emission_symbol_2):
ones_at_t1_t2 = 0
for i in range(0, len(chains)):
a_t1 = chains[i][t1]
b_t1 = emission_symbol_1
a_t2 = chains[i][t2]
b_t2 = emission_symbol_2
if a_t1 == b_t1 and a_t2 == b_t2:
ones_at_t1_t2 += 1
soc = np.float128(ones_at_t1_t2) / len(chains)
# print '\r ',np.float128(ones_at_t1_t2),'--',len(chains),' \r',
# sys.exit('soc test!!!')
return soc
def to_list(p):
line = []
for h in harr:
if (h not in p) or (p[h] == None):
line.append(-1)
else:
line.append(p[h])
#timestamp
line[0] = np.float128(line[0])
#ip
if line[1] != -1:
line[1] = dottedQuadToNum(line[1])
if line[2] != -1:
line[2] = dottedQuadToNum(line[2])
#everything else
for i in range(3, 12):
line[i] = int(line[i])
return line
def ans_one_model(index, mweights, mmeans, mcovs):
#init
nummods = mweights.shape[0]
initgaus = mweights.shape[1]
finalgaus = 64
lenvars = mmeans.shape[2]
weights = numpy.zeros(finalgaus, dtype="float128")
means = numpy.zeros((finalgaus, lenvars), dtype="float128")
covs = numpy.zeros((finalgaus, lenvars, lenvars), dtype="float128")
h = numpy.float128(
numpy.random.randint(1, 10000, (finalgaus, nummods, initgaus)))
h = h / h.sum(0)
for _ in range(80):
#M-step
weights = h.sum(1).sum(1) / (nummods * initgaus)
temp = h * mweights
temp = temp / temp.sum(1).sum(1).reshape(finalgaus, 1, 1)
tempcovs = (mmeans.reshape(1, nummods, initgaus, lenvars, 1) -
means.reshape(finalgaus, 1, 1, lenvars, 1)).reshape(
finalgaus * nummods * initgaus, lenvars, 1)
tempcovs = numpy.array([tt.dot(tt.transpose()) for tt in tempcovs
]).reshape(finalgaus, nummods, initgaus,
lenvars, lenvars)
tempcovs = tempcovs + mcovs
covs = (temp.reshape(finalgaus, nummods, initgaus, 1, 1) *
tempcovs).sum(1).sum(1)
means = (temp.reshape(finalgaus, nummods, initgaus, 1) *
mmeans.reshape(1, nummods, initgaus, lenvars)).sum(1).sum(1)
#E-step
for m in range(finalgaus):
gaus = mnormal(means[m], covs[m])
invcovs = numpy.linalg.inv(numpy.float64(covs[m]))
temp = numpy.zeros((nummods, initgaus), dtype="float128")
for j in range(nummods):
for k in range(initgaus):
temp[j, k] = -0.5 * invcovs.dot(mcovs[j][k]).trace()
h[m, :, :] = sc.power(
gaus.pdf(mmeans) * sc.power(sc.e, temp),
mweights) * weights[m] + 1e-20
h = h / h.sum(0)
with open("final_model/%d.pickle" % (index, ), "wb") as f:
pickle.dump((weights, means, covs), f)
def createROC_curve(dataset):
loss_dic = dataset.loss
weight_dic = dict(zip(dataset.SM_names, dataset.SM_val_weights))
p_SM = np.logspace(base=10, start=-7, stop=0, num=100)
p_SM[-1] = 0.999
t_SM = np.concatenate((loss_dic['Wlnu'], loss_dic['qcd'], loss_dic['Zll'],
loss_dic['ttbar']))
w_SM = np.concatenate(
(np.full_like(loss_dic['Wlnu'], weight_dic['Wlnu'], np.float128),
np.full_like(loss_dic['qcd'], weight_dic['qcd'], np.float128),
np.full_like(loss_dic['Zll'], weight_dic['Zll'], np.float128),
np.full_like(loss_dic['ttbar'], weight_dic['ttbar'], np.float128)))
i_sort = np.argsort(t_SM)
t_SM = t_SM[i_sort]
w_SM = w_SM[i_sort]
l = np.zeros(4)
for i, n in enumerate(dataset.SM_names):
l[i] = dataset.valSamples[n].shape[0]
i_min = np.argmin(l / dataset.SM_fraction)
cum_sum = np.cumsum(w_SM, dtype=np.float128) / np.float128(
l[i_min] / dataset.SM_fraction[i_min])
print('CumSum accuracy:', cum_sum[-1])
idx_q = np.argmax(cum_sum > np.atleast_2d(1 - p_SM).T, axis=1)
q_SM = t_SM[idx_q]
dic_ROC = {}
for n in dataset.BSM_names:
out = loss_dic[n] > np.atleast_2d(q_SM).T
p_BSM = np.float64(
np.sum(out, axis=1, dtype=np.float128) / loss_dic[n].shape[0])
roc_auc = np.trapz(p_BSM, p_SM)
dic_ROC[n] = {'eff_BSM': p_BSM, 'eff_SM': p_SM, 'roc_auc': roc_auc}
return dic_ROC
def convertLongToArray(self, Z, visitIndices):
"""
takes a list Z of dimension [NR_BIOMK] x [NR_SUBJ] x array(NR_VISITS) and a similar list of
visit indices where data is available. For instance, if for biomarker 2 subject 3 had data
only in visits 0 and 2, then visitIndices[2][3] = array([0,2])
:param Z:
:param visitIndices:
:return:
Z_array - a biomarker-wise serialised version of Z, where len(Z[b]) = all possible elements
in Z_array[b] dimension is [NR_BIOMK] x array(all_values_linearised)
N_obs_per_sub - a list of dimensions [NR_BIOMKS] x array(NR_SUBJ), containing the number of
observations for each sbuject in each biomarker
indFullToMissingArrayB - a list of indices which could map a potential array
Z_full with no missing entries to Z_array.
so Z_array = Z_full[indFullToMissingArrayB]
"""
nrBiomk = len(Z)
Z_array = [0 for b in range(nrBiomk)]
N_obs_per_sub = [0 for b in range(nrBiomk)]
indFullToMissingArrayB = [0 for b in range(nrBiomk)]
for b in range(nrBiomk):
# Creating 1d arrays of individuals' time points and observations
Z_array[b] = np.array([
np.float128(item) for sublist in Z[b] for item in sublist
]).reshape(-1, 1)
N_obs_per_sub[b] = [len(Z[b][j]) for j in range(len(Z[b]))]
visitsSoFar = 0
indFullToMissingArrayS = [0 for s in range(len(Z[0]))]
for s in range(len(Z[0])):
indFullToMissingArrayS[s] = visitsSoFar + visitIndices[b][s]
visitsSoFar += visitIndices[b][s].shape[0]
indFullToMissingArrayB[b] = np.array(
[i for subIdx in indFullToMissingArrayS for i in subIdx])
for s in range(len(Z[0])):
if np.sum([Z[b][s].shape[0] for b in range(nrBiomk)]) == 0:
print('Z[b][s]', [Z[b][s].shape[0] for b in range(nrBiomk)])
print('s', s)
return Z_array, N_obs_per_sub, indFullToMissingArrayB
def rhs_variation_of_parameters_stabilized(t, parameters):
state, jac = kepler_three_body(*unpack_three_body(parameters))
m_1, m_2, m_3 = [np.float128(m) for m in [state[6], state[13], state[20]]]
m_i = m_1 + m_2
x_1, x_2, x_3 = [
x.astype(np.float128) for x in [state[:3], state[7:10], state[14:17]]
]
x_i = (m_1 * x_1 + m_2 * x_2) / m_i
x_3_i = x_3 - x_i
r2_3_i = np.sum(x_3_i**2)
a_i = G * m_3 * (x_3 - x_i) * r2_3_i**np.float128(-3. / 2)
x_3_1 = x_3 - x_1
r2_3_1 = np.sum(x_3_1**2)
a_1 = G * m_3 * (x_3 - x_1) * r2_3_1**np.float128(-3. / 2)
x_3_2 = x_3 - x_2
r2_3_2 = np.sum(x_3_2**2)
a_2 = G * m_3 * (x_3 - x_2) * r2_3_2**np.float128(-3. / 2)
# FIXME: compute these differences without subtraction
a_1_delta = a_1 - a_i
a_2_delta = a_2 - a_i
a_3_i = -G * m_i * (x_3 - x_i) * r2_3_i**np.float128(-3. / 2)
a_3_1 = -G * m_1 * (x_3 - x_1) * r2_3_1**np.float128(-3. / 2)
a_3_2 = -G * m_2 * (x_3 - x_2) * r2_3_2**np.float128(-3. / 2)
a_3_delta = a_3_1 + a_3_2 - a_3_i
extra_rhs = np.zeros(21)
extra_rhs[3:6] = a_1_delta
extra_rhs[10:13] = a_2_delta
extra_rhs[17:20] = a_3_delta
rhs = scipy.linalg.solve(jac, extra_rhs)
rhs[6] = 0
rhs[7] += -1
rhs[14] += -1
rhs[-6:] = 0
return rhs
def predict(x, P, Fs):
# discretization period
T = np.float128(1 / Fs)
# total length of output signal
L = len(x) + P
# time axis of input + predicted samples
tp = T * np.linspace(0, L - 1, L)
# order of regression model
N = P
# convolve with leaky integrator to reduce noise
#M = 10
#lbd = float(M-1) / float(M)
#h = (1 - lbd) * pow(lbd, np.arange(100))
#x = np.convolve(x, h, 'valid')
# compute regression coefficients.
while(True):
global A
gotException = False
try:
[A, E, K] = arburg(x, N)
except (ValueError, IndexError):
gotException = True
N = N / 2
if gotException == False:
break
# allocate memory for output
y = np.zeros(L)
# fill part of the output with known part
y[0:len(x)] = x
# apply regression model to the signal.
# actually this is IIR filter.
# use lfilter func in future.
for i in range(len(x), L):
y[i] = -1 * np.sum(np.real(A) * y[i-1:i-1-N:-1])
return tp, y
def maineq(Xtest, Xerrtest, Xtrain, Xerrtrain):
def Pi(di, sigdi, yi, sigyi):
C1 = sigdi**-2
C2 = sigyi**-2
p1 = np.log((2 * np.pi * (C1 + C2))**-0.5 / (sigdi * sigyi))
p2 = 0.5 * (C1 * di**2 + C2 * yi**2)
p3 = 0.5 * ((di * C1 + yi * C2)**2) / (C1 + C2)
return p1 - p2 + p3
ntest = len(Xtest)
ntrain = len(Xtrain)
problist = np.zeros(ntest)
for i in range(ntest):
p = np.sum(Pi(Xtest[i], Xerrtest[i], Xtrain, Xerrtrain), axis=1)
P = np.sum(np.exp(np.float128(p)))
problist[i] = np.log(P) + np.log(0.5) - np.log(ntrain)
return problist
def NewApproximation(n, fr, J, k, tasks, mode=0):
# mode 0 == EMR, 1 = CON
# J is the bound of the idx
prepareTable(n, fr, J, n - 1, tasks, mode)
probsum = 0.
phikl = np.float128(1.0)
# this is the summation from 1 to J (prob * j)
#print "which mode:", mode
for x in range(1, J + 1):
#print "for index:", x
phikl = wRoutine(x, mode)
# print phikl
probsum += phikl * x
if probsum == 0:
return 0
else:
#for avoiding numerical inconsistance
return probsum / (1 + probsum - wRoutine(1, mode))
def von_mises_deg(xx,mu,k,a,b):
# make a von mises function over the range in xx
# assume the input is 0-180 or 0-360 deg space.
axis_size_deg = np.max(xx)+1
if k<10**(-15):
print('WARNING: k is too small, might get precision errors')
xx_rad2pi = np.float128(xx/axis_size_deg*2*np.pi)
mu_rad2pi = mu/axis_size_deg*2*np.pi
yy = np.exp(k*(np.cos(xx_rad2pi-mu_rad2pi)-1))
# first make the y values span from 0-1
yy = yy-min(yy)
yy = yy/max(yy)
# then apply the entered amplitude and baseline.
yy = a*yy+b
return yy
def calc_sampling_weight(self):
if self.q is None:
# Formula slide 33, dm-09
center_dist_ratio = np.float128(1.0)
if Helper.dist_func(self.cluster.center,
self.point) != np.float128(0.0):
center_dist_ratio = Helper.dist_func(
self.cluster.center,
self.point) / self.cluster.dist_point_sum()
self.q = np.ceil(
((np.float128(5.0) / np.float128(len(self.cluster))) +
center_dist_ratio) * np.float128(3.0)) - np.float128(2.0)
return self.q
