def calculateAllAverages(self, start, stop, receiver, emitter, avgMatrix):
calculateNxxLookUp = mp.memoize(calculateNxx)
calculateNxyLookUp = mp.memoize(calculateNxy)
fLookUP = mp.memoize(f)
gLookUP = mp.memoize(g)
start = int(float(mp.nstr(start)))
stop = int(float(mp.nstr(stop)))
for j in range(start, stop):
if (start == 0):
val = (((j * 100) / receiver.nElements) * self.nThreads)
print(
mp.nstr(((j * 100) / receiver.nElements) * self.nThreads,
4), "%")
self.emit(QtCore.SIGNAL('PROGRESS'), val)
a11 = mp.mpf('0')
a12 = mp.mpf('0')
a13 = mp.mpf('0')
a22 = mp.mpf('0')
a23 = mp.mpf('0')
a33 = mp.mpf('0')
emEle = int(float(mp.nstr(emitter.nElements)))
for i in range(emEle):
delx, dely, delz = calculateDistance(
emitter.smallBlocksStructure[i],
receiver.smallBlocksStructure[j])
dx = emitter.widthSmall
dy = emitter.depthSmall
dz = emitter.heightSmall
a11 += calculateNxxLookUp(delx, dely, delz, dx, dy, dz,
emitter, fLookUP)
a12 += calculateNxyLookUp(delx, dely, delz, dx, dy, dz,
emitter, gLookUP)
a13 += calculateNxyLookUp(delx, delz, dely, dx, dz, dy,
emitter, gLookUP)
a22 += calculateNxxLookUp(dely, delx, delz, dy, dx, dz,
emitter, fLookUP)
a23 += calculateNxyLookUp(dely, delz, delx, dy, dz, dx,
emitter, gLookUP)
# a31 = a13
# a32 = a23
a33 += calculateNxxLookUp(delz, dely, delx, dz, dy, dx,
emitter, fLookUP)
a11 = a11 / emitter.nElements
a12 = a12 / emitter.nElements
a13 = a13 / emitter.nElements
a22 = a22 / emitter.nElements
a23 = a23 / emitter.nElements
a33 = a33 / emitter.nElements
avgMatrix.append([a11, a12, a13, a12, a22, a23, a13, a23, a33])
return avgMatrix
def __init__(
self,
func: Func,
x_range: Tuple[Real, Real],
derivatives: Dict[int, Func] = None,
**_,
):
"""Initialize AnalyzedFuncBase with explicit MRO.
Parameters
----------
func
The function to analyze
x_range
The interval of x-values. This is treated as an
open interval except when finding absolute extrema.
derivatives
A dictionary of derivatives. ``derivatives[nth]``
is the nth derivative of the function.
_
Unused arguments intended for other ``AnalyzedFuncBase``
children.
"""
self.x_range = Interval(*x_range)
self._derivatives = derivatives
self.func_plotted = SaveXY(func)
self.func_memoized = mp.memoize(self.func_plotted)
def derivatives(self) -> Dict[int, Func]:
"""Return all known derivatives of the function.
Returns
-------
derivatives : Dict[int, Callable[[Real], Real]
A dictionary of known derivatives of the function being
analyzed.
"""
if self._derivatives:
return {
derivative: mp.memoize(func)
for derivative, func in self._derivatives.items()
}
return {}
http://christian.mendl.net/pages/software.html
http://nsb-entropy.sourceforge.net
Ilya Nemenman, Fariel Shafee, and William Bialek. Entropy and Inference,
Revisited. arXiv:physics/0108025
Ilya Nemenman, William Bialek, and Rob de Ruyter van Steveninck. Entropy and
information in neural spike trains: Progress on the sampling problem. Physical
Review E 69, 056111 (2004)
"""
from mpmath import psi, rf, power, quadgl, mp, memoize
import numpy as np
DPS = 40
psi = memoize(psi)
rf = memoize(rf)
power = memoize(power)
def make_nxkx(n, K):
"""
Return the histogram of the input histogram n assuming that the number of
all bins is K.
>>> from numpy import array
>>> nTest = array([4, 2, 3, 0, 2, 4, 0, 0, 2])
>>> make_nxkx(nTest, 9)
{0: 3, 2: 3, 3: 1, 4: 2}
"""
nxkx = {}
nn = n[n>0]
import mpmath as mp
import logging
#define memoize function to improve performance TODO: Evaluate if this is indeed a speedup in terms of performance
memopower = mp.memoize(mp.power)
memolog1p = mp.memoize(mp.log1p)
memoexp = mp.memoize(mp.exp)
memolog = mp.memoize(mp.log)
'''
def calculateKmerLikelihood(observedCounts,expectedCounts,kmerError,k,validKmers):
#We use a mpmath float to have a sufficiently precise numerical representation
probability = mp.mpf(0)
#Split probability for analysis purposes
unexpectedProbability = mp.mpf(0)
#Calculate default value for expected counts
sharedKmers = set(observedCounts.keys()).difference(set(expectedCounts.keys()))
expectedDefaultValue = kmerError*sum(observedCounts.values())/len(sharedKmers)
#print("Expected Count for Zeros:"+str(expectedDefaultValue))
for kmerID in validKmers:
#If we didn't observe a kmer at all we assume we observed it 0 times
observedCount = 0
expectedCount = expectedDefaultValue