def rho_harm(x, xp, beta):
# here upsilon_1 and upsilon_2 are just exponents
Upsilon_1 = sum((x[d] + xp[d]) ** 2 / 4.0 * \
math.tanh(beta / 2.0) for d in range(3))
Upsilon_2 = sum((x[d] - xp[d]) ** 2 / 4.0 / \
math.tanh(beta / 2.0) for d in range(3))
return math.exp(- Upsilon_1 - Upsilon_2)
def levy_harmonic_path(k):
x = [random.gauss(0.0, 1.0 / math.sqrt(2.0 * math.tanh(k * beta / 2.0)))]
if k == 2:
Ups1 = 2.0 / math.tanh(beta)
Ups2 = 2.0 * x[0] / math.sinh(beta)
x.append(random.gauss(Ups2 / Ups1, 1.0 / math.sqrt(Ups1)))
return x[:]
def feedForward(self):
nIn = len(self.wordIds)
nHidden = len(self.hiddenIds)
nOut = len(self.urlIds)
# the only inputs are the query words
for i in range(nIn):
self.wordOut[i] = 1.0
# hidden activations
for i in range(nHidden):
sum = 0.0
for j in range(nIn):
sum += self.wordOut[j] * self.wordHidden[j][i]
self.hiddenOut[i] = tanh(sum)
# output activations
for i in range(nOut):
sum = 0.0
for j in range(nHidden):
sum += self.hiddenOut[j] * self.hiddenUrl[j][i]
self.urlOut[i] = tanh(sum)
return self.urlOut[:]
def testHyperbolic(self):
self.assertEqual(math.sinh(5), hyperbolic.sineh_op(5))
self.assertEqual(math.cosh(5), hyperbolic.cosineh_op(5))
self.assertEqual(math.tanh(5), hyperbolic.tangenth_op(5))
self.assertEqual(1. / math.sinh(5), hyperbolic.cosecanth_op(5))
self.assertEqual(1. / math.cosh(5), hyperbolic.secanth_op(5))
self.assertEqual(1. / math.tanh(5), hyperbolic.cotangenth_op(5))
def feed_forward(self):
'''
This returns the output of all the output nodes, with the inputs
coming from the setup_network function.
'''
# first it sets the input word weights to 1.0
for i in xrange(len(self.word_ids)):
self.ai[i] = 1.0
# then it iterates through all of the hidden nodes associated with
# the words and urls (query and results) and uses a sigmoid to
# accumulate the weights coming from the inputs (ai) and the
# input weight matrix (wi) for each word-hidden_node relation.
for j in xrange(len(self.hidden_ids)):
sum = 0.0
for i in xrange(len(self.word_ids)):
sum = sum + self.ai[i] * self.wi[i][j]
self.ah[j] = tanh(sum)
# finally it iterates through all of the output nodes (urls)
# and uses a sigmoid function to accumulate the weights
# coming from the hidden nodes (ah) updated in the
# previous step and the output weights (wo) for each
# hidden_node-url relation.
for k in xrange(len(self.url_ids)):
sum = 0.0
for j in xrange(len(self.hidden_ids)):
sum = sum + self.ah[j] * self.wo[j][k]
self.ao[k] = tanh(sum)
return self.ao[:]
def _zoom_animation(self):
import time
from math import tanh
scale = 5
for i1 in range(-scale, scale+1):
self.replot(zlfrac=0.5 + 0.5*tanh(i1*2.0/scale)/tanh(2.0))
self.c.update()
def rho_harm(x, xp, beta):
''' Gives a diagonal harmonic density matrix, exchanging 2 particles '''
Upsilon_1 = sum((x[d] + xp[d]) ** 2 / 4.0 *
math.tanh(beta / 2.0) for d in range(3))
Upsilon_2 = sum((x[d] - xp[d]) ** 2 / 4.0 /
math.tanh(beta / 2.0) for d in range(3))
return math.exp(- Upsilon_1 - Upsilon_2)
def set_eta1eta2(self, eta1, eta2):
eta=sqrt(eta1**2 + eta2**2)
if eta==0.:
self.e1,self.e2,self.g1,self.g2=(0.,0.,0.,0.)
return
etot=tanh(eta)
gtot=tanh(eta/2.)
if etot >= 1.0:
mess="e values must be < 1, found %.16g" % etot
raise ShapeRangeError(mess)
if gtot >= 1.0:
mess="g values must be < 1, found %.16g" % gtot
raise ShapeRangeError(mess)
cos2theta = eta1/eta
sin2theta = eta2/eta
e1=etot*cos2theta
e2=etot*sin2theta
g1=gtot*cos2theta
g2=gtot*sin2theta
self.eta1,self.eta2=eta1,eta2
self.e1,self.e2=e1,e2
self.g1,self.g2=g1,g2
def we_context_mod(w, v, words,phrases,rep):
w = deepcopy(w)
v = deepcopy(v)
for repet in range(rep):
for o in range(len(words)):
print o, ' of ', len(words)
# h = np.zeros(prof)
# for pal in phrases[c].split():
# h += v[words.index(pal)]
# div = 0.0
# for aux in w:
# div += math.exp(-1 * math.tanh(np.dot(aux, h)))
for c in range(len(phrases)):
##
h = np.zeros(prof)
for pal in phrases[c].split():
h += v[words.index(pal)]
div = 0.0
for aux in w:
div += math.exp(-1 * math.tanh(np.dot(aux, h)))
##
poc = math.exp(-1 * math.tanh(np.dot(w[o],h))) / div
err = 0.0
if words[o] in phrases[c]:
err = 1 - poc
else:
err = 0 - poc
v[o] = v[o] - (eta * err * h)
for word in phrases[c].split():
w[words.index(word)] -= (eta * sum(v) / len(phrases[c].split()))
return {'w': w, 'v':v}
def feedforward(self):
# the only inputs are the query words
for i in range(len(self.wordids)):
self.ai[i] = 1.0
# hidden activations
for j in range(len(self.hiddenids)):
sum = 0.0
for i in range(len(self.wordids)):
sum = sum + self.ai[i] * self.wi[i][j]
self.ah[j] = tanh(sum) * 10
# output activations
for k in range(len(self.urlids)):
sum = 0.0
for j in range(len(self.hiddenids)):
sum = sum + self.ah[j] * self.wo[j][k]
self.ao[k] = tanh(sum)
return self.ao[:]
def feed_forward(self):
"""
フィードフォワードアルゴリズム
"""
# 入力はクエリの単語たち？(aiの初期化)
for i in range(len(self.wordids)):
self.ai[i] = 1.0
# 隠れ層の発火
for j in range(len(self.hiddenids)):
sum = 0.0
for i in range(len(self.wordids)):
# リンクの強度を掛け合わせる
# TODO : なぜaiを使うのか。1.0直値ではいけない理由が不明
# sum = sum + self.ai[j] * self.wi[i][j]
sum = sum + 1.0 * self.wi[i][j]
# tanhを適用して最終的な出力を作り出す
self.ah[j] = tanh(sum)
# 出力層の発火
for k in range(len(self.urlids)):
sum = 0.0
for j in range(len(self.hiddenids)):
sum = sum + self.ah[j] * self.wo[j][k]
self.ao[k] = tanh(sum)
return self.ao[:]
def n_b_prof(coef,set,sol):
tip = 7
tipp = 1
for y in range(1,set['Ny'],2):
for x in range(1,set['Nx'],2):
step = int(set['Ny']/(tip))
range_1 = step
range_2 = step*2+1
range_3 = step*3
range_4 = step*4+1
range_5 = step*5
range_6 = step*6+1
if tipp == 1:
if y > range_3 and y < range_4:
sol['n'][x,y] = 0.4*m.exp(-(x*set['Hh']-set['rad'])**2/0.0005)*(m.sin(tip*m.pi*y*set['Hh']))**2
sol['b'][x,y] = (0.5 + 0.5*m.tanh(((set['rad']-0.05)-x*set['Hh'])/0.01))*(m.sin(tip*m.pi*y*set['Hh']))**2
else:
if y > range_1 and y < range_2:
sol['n'][x,y] = 0.4*m.exp(-(x*set['Hh']-set['rad'])**2/0.0005)*(m.sin(tip*m.pi*y*set['Hh']))**2
sol['b'][x,y] = (0.5 + 0.5*m.tanh(((set['rad']-0.05)-x*set['Hh'])/0.01))*(m.sin(tip*m.pi*y*set['Hh']))**2
if y > range_3 and y < range_4:
sol['n'][x,y] = 0.4*m.exp(-(x*set['Hh']-set['rad'])**2/0.0005)*(m.sin(tip*m.pi*y*set['Hh']))**2
sol['b'][x,y] = (0.5 + 0.5*m.tanh(((set['rad']-0.05)-x*set['Hh'])/0.01))*(m.sin(tip*m.pi*y*set['Hh']))**2
if y > range_5 and y < range_6:
sol['n'][x,y] = 0.4*m.exp(-(x*set['Hh']-set['rad'])**2/0.0005)*(m.sin(tip*m.pi*y*set['Hh']))**2
sol['b'][x,y] = (0.5 + 0.5*m.tanh(((set['rad']-0.05)-x*set['Hh'])/0.01))*(m.sin(tip*m.pi*y*set['Hh']))**2
# sol['n'][x,y] = 0.4*m.exp(-(x*set['Hh']-set['rad'])**2/0.01)*(m.sin(tip*m.pi*y*set['Hh']))**2
# sol['b'][x,y] = (m.sin(tip*m.pi*y*set['Hh']))**2*(0.5 + 0.5*m.tanh(((set['rad']-0.05)-x*set['Hh'])/0.01))
# if x*set['Hh'] <= set['rad']:
return sol
def skill_variation(self, K, V):
"""calcola la variazione di skill dei players K e V in seguito alla kill"""
if self.PT[V].team == 3:
return # A volte viene killato qualcuno che risulta spect
D = self.PT[K].skill - self.PT[V].skill # Delta skill tra i due player
Dk = self.PT[K].skill - self.TeamSkill[(self.PT[V].team - 1)] # Delta skill Killer rispetto al team avversario
Dv = self.TeamSkill[(self.PT[K].team - 1)] - self.PT[V].skill # Delta skill Vittima rispetto al team avversario
K_opponent_variation = (
1 - math.tanh(D / self.Sk_range)
) / self.Sk_Kpp # Variazione skill del Killer in base a skill vittima
V_opponent_variation = (
2 / self.Sk_Kpp - K_opponent_variation
) # Variazione skill della Vittima in base a skill killer
KT_variation = (
1 - math.tanh(Dk / self.Sk_range)
) / self.Sk_Kpp # Variazione skill del Killer in base a skill team vittima
VT_variation = (
-(1 - math.tanh(Dv / self.Sk_range)) / self.Sk_Kpp
) # Variazione skill della Vittima in base a skill team killer
Dsk_K = self.Sbil * (
self.Sk_team_impact * KT_variation + (1 - self.Sk_team_impact) * K_opponent_variation
) # delta skill del Killer
Dsk_V = self.Sbil * (
self.Sk_team_impact * VT_variation + (1 - self.Sk_team_impact) * V_opponent_variation
) # delta skill della vittima
self.PT[K].skill += Dsk_K * self.PT[K].skill_coeff # (nuova skill)
self.PT[V].skill += Dsk_V * self.PT[V].skill_coeff # (nuova skill)
self.PT[K].skill_var += Dsk_K # variazione skill per mappa
self.PT[V].skill_var += Dsk_V # variazione skill per mappa
return
def Evap(self, p0, p1, t1, tau, beta, duration): """Evaporation ramp""" if duration <=0: return else: N=int(round(duration/self.ss)) print '...Evap nsteps = ' + str(N) ramp=[] ramphash = 'L:/software/apparatus3/seq/ramps/' + 'Evap_' \ + hashlib.md5(str(self.ss)+str(duration)+str(p0)+str(p1)+str(t1)+str(tau)+str(beta)).hexdigest() if not os.path.exists(ramphash): print '...Making new Evap ramp' for xi in range(N): t = (xi+1)*self.ss if t < t1: phys = (p0-p1)*math.tanh( beta/tau * (t-t1)* p1/(p0-p1))/math.tanh( beta/tau * (-t1) * p1/(p0-p1)) + p1 else: phys = p1 * math.pow(1,beta) / math.pow( 1 + (t-t1)/tau ,beta) volt = cnv(self.name,phys) ramp = numpy.append( ramp, [ volt]) ramp.tofile(ramphash,sep=',',format="%.4f") else: print '...Recycling previously calculated Evap ramp' ramp = numpy.fromfile(ramphash,sep=',') self.y=numpy.append(self.y,ramp) return
def tanh(self, other=None):
# Return hyperbolic tangent of interval
if other != None:
intv = IReal(self, other)
else:
if type(self) == float or type(self) == str:
intv = IReal(self)
else:
intv = self
if math.tanh(intv.inf) > math.tanh(intv.sup):
inf = max(intv.inf, intv.sup)
sup = min(intv.inf, intv.sup)
else:
inf = intv.inf
sup = intv.sup
ireal.rounding.set_mode(1)
ireal.rounding.set_mode(-1)
ireal.rounding.set_mode(-1)
new_inf = math.tanh(inf)
ireal.rounding.set_mode(1)
new_sup = max(float(IReal('%.16f' % math.tanh(sup)).sup), float(IReal('%.19f' % math.tanh(sup)).sup))
return IReal(new_inf, new_sup)
def compute(self, plug, data):
# Check if output value is connected
if plug == self.aOutputVaue:
# Get input datas
operationTypeHandle = data.inputValue(self.aOperationType)
operationType = operationTypeHandle.asInt()
inputValueXHandle = data.inputValue(self.aInputValueX)
inputValueX = inputValueXHandle.asFloat()
inputValueYHandle = data.inputValue(self.aInputValueY)
inputValueY = inputValueYHandle.asFloat()
# Math tanus
outputValue = 0
if operationType == 0:
outputValue = math.atan(inputValueX)
if operationType == 1:
outputValue = math.tan(inputValueX)
if operationType == 2:
outputValue = math.atanh(inputValueX)
if operationType == 3:
outputValue = math.tanh(inputValueX)
if operationType == 4:
outputValue = math.tanh(inputValueY, inputValueX)
# Output Value
output_data = data.outputValue(self.aOutputVaue)
output_data.setFloat(outputValue)
# Clean plug
data.setClean(plug)
def feedforward(self): """ the feedforward algorithm. This takes a list of inputs, pushes them through the network, and returns the output of all the nodes in the out put layer. In this case, since youve only constructed a network with words in the query, the output from all the input nodes will always be 1: """ # The only inputs are the query words for i in range(len(self.wordids)): self.ai[i] = 1.0 # Hidden activations for j in range(len(self.hiddenids)): sum = 0.0 for i in range(len(self.wordids)): sum =sum + self.ai[i] * self.wi[i][j] self.ah[j] = tanh(sum) # output activations for k in range(len(self.urlids)): sum = 0.0 for j in range(len(self.hiddenids)): sum = sum + self.ah[j] * self.wo[j][k] self.ao[k] = tanh(sum) return self.ao[:] # Return a copy of self.ao
def get_gm(self, xxx_todo_changeme2, dev, debug=False):
"""Returns the source to output transconductance or d(I)/d(Vsn1-Vsn2)."""
(vout, vin) = xxx_todo_changeme2
self._update_status(vin, dev)
gm = self.A * self.SLOPE * (math.tanh(self.SLOPE * (self.V - vin)) ** 2 - 1) / (
self.A * math.tanh(self.SLOPE * (self.V - vin)) - self.B) ** 2
return gm + options.gmin
def score(filename):
"""
Score individual image files for the genetic algorithm.
The idea is to derive predictive factors for the langmuir performance
(i.e., max power) based on the connectivity, phase fractions, domain sizes,
etc. The scoring function should be based on multivariate fits from a database
of existing simulations. To ensure good results, use robust regression techniques
and cross-validate the best-fit.
:param filename: image file name
:type filename: str
:return score (ideally as an estimated maximum power in W/(m^2))
:rtype float
"""
# this works around a weird bug in scipy.misc.imread with 1-bit images
# open them with PIL as 8-bit greyscale "L" and then convert to ndimage
pil_img = Image.open(filename)
image = misc.fromimage(pil_img.convert("L"))
width, height = image.shape
if width != 256 or height != 256:
print "Size Error: ", filename
# isize = analyze.interface_size(image)
ads1, std1 = analyze.average_domain_size(image)
# we now need to invert the image to get the second domain size
inverted = (image < image.mean())
ads2, std2 = analyze.average_domain_size(inverted)
#overall average domain size
ads = (ads1 + ads2) / 2.0
# transfer distances
# connectivity
td1, connect1, td2, connect2 = analyze.transfer_distance(image)
spots = np.logical_xor(image,
ndimage.binary_erosion(image, structure=np.ones((2,2))))
erosion = np.count_nonzero(spots)
spots = np.logical_xor(image,
ndimage.binary_dilation(image, structure=np.ones((2,2))))
dilation = np.count_nonzero(spots)
# fraction of phase one
nonzero = np.count_nonzero(image)
fraction = float(nonzero) / float(image.size)
# scores zero at 0, 1 and maximum at 0.5
ps = fraction*(1.0-fraction)
# from simulations with multivariate nonlinear regression
return (-1.98566e8) + (-1650.14)/ads + (-680.92)*math.pow(ads,0.25) + \
1.56236e7*math.tanh(14.5*(connect1 + 0.4)) + 1.82945e8*math.tanh(14.5*(connect2 + 0.4)) \
+ 2231.32*connect1*connect2 \
+ (-4.72813)*td1 + (-4.86025)*td2 \
+ 3.79109e7*ps**8 \
+ 0.0540293*dilation + 0.0700451*erosion
def getallhiddenids(self,wordids,urlids):
l1={}
for wordid in wordids:
cur=self.con.execute('select toid from wordhidden where from id=%d'% wordid)
for row in cur: l1[row[0]=1
for urlid in urlids:
cur=self.con.select('select fromid from hiddenurl where toid=%d'% urlid)
for row in cur:l1[row[0]]=1
return l1.keys()
def setupnetwork(self,wordids,urlids):
self.wordids=wordids
self.hiddenids=self.getallhiddenids(wordids,urlids)
self.urlids=self.urlids
self.ai=[1.0]*len(self.wordids)
self.ah=[1.0]*len(self.hiddenids)
self.ao=[1.0]*len(self.urlids)
self.wi=[[self.getstrength(wordid,hiddenid,0) for hiddenid in self.hiddenids] for wordid in self.wordids]
self.wo=[[self.getstrenth(hiddenid,urlid,1) for urlid in self.urlids]for hiddenid in self.hiddenids]
def feedforward(self):
for i in range(len(self.wordids)):
self.ai[i]=1
for j in range(len(self.hiddenids)):
sum=0.0
for i in range(len(self.wordids)):
sum=sum+self.ai[i]*self.wi[i][j]
self.ah[j]=tanh(sum)
for k in range(len(self.urlids)):
sum=0.0
for j in range(len(self.hiddenids)):
sum=sum+self.ah[j]*self.wo[j][k]
self.ao[k]=tanh(sum)
return self.ao[:]
def getresult(self,wordids,urlids):
self.setupnetwork(wordids,urlids)
return self.feedforward()
def dtanh(y):
return 1.0-y*y
def backPropagete(self,targets,N=0.5):
output_deltas=[0.0]*len(self.urlids)
for k in range(len(self.urlids)):
error=targets[k]-self.ao[k]
output_deltas=dtanh(self.ao[k]])*error
hidden_deltas=[0.0]*len(self.hiddenids)
for j in range(len(self.hidddenids)):
error=0.0
for k in range(len(self.len(urlids))):
error=error+output[k]*self.wo[j][k]
hidden_deltas[j]=dtanh(self.ah[j])*error
for j in range(len(self.hiddenids)):
for k in range(len(self.urlids)):
change = output_delta[k]*self.ah[j]
self.wo[j][k]=self.wo[j][k]+N*change
for i in range(len(self.wordids)):
for j in range(len(self.hiddenids)):
change=hidden_delta[j]*self.ai[i]
self.wi[i][j]=self.wi[i][j]+N*change
def distance_Sigmoid(X,Y,a,r):
d = np.dot(X,X)
d = math.tanh(a * d + r)
b = np.dot(Y,Y)
b = math.tanh(a * b + r)
c = np.dot(X,Y)
c = math.tanh(a * c + r)
return a + b - 2 * c
def levy_harmonic_path(xstart, xend, dtau, N):
x = [xstart]
for k in range(1, N):
dtau_prime = (N - k) * dtau
Ups1 = 1.0 / math.tanh(dtau) + 1.0 / math.tanh(dtau_prime)
Ups2 = x[k-1] / math.sinh(dtau) + xend / math.sinh(dtau_prime)
x.append(random.gauss(Ups2 / Ups1, 1.0 / math.sqrt(Ups1)))
return x
def st_tanh(x):
if isinstance(x, StataVarVals):
return StataVarVals([
mv if _is_missing(v) else math.tanh(v) for v in x.values
])
if _is_missing(x):
return mv
return math.tanh(x)
def __init__(self):
ActivationFunction.__init__(
self,
lambda x: math.tanh(x),
# This could be optimized as the derivative
# will always be called after the fn.
# And will be called with the same x value.
lambda x: 1 - math.pow(math.tanh(x), 2))
def testTanh(self):
self.assertRaises(TypeError, math.tanh)
self.ftest('tanh(0)', math.tanh(0), 0)
self.ftest('tanh(1)+tanh(-1)', math.tanh(1)+math.tanh(-1), 0,
abs_tol=ulp(1))
# self.ftest('tanh(inf)', math.tanh(INF), 1)
# self.ftest('tanh(-inf)', math.tanh(NINF), -1)
self.assertTrue(math.isnan(math.tanh(NAN)))
def run_gr4j(x, p, e, q, s, uh1_tab, uh2_tab, l, m):
for t in range(p.size):
if p[t] > e[t]:
pn = p[t] - e[t]
en = 0.0
tmp = s[0] / x[0]
ps = x[0] * (1.0 - tmp * tmp) * math.tanh(pn / x[0]) / (1.0 + tmp * math.tanh(pn / x[0]))
s[0] += ps
elif p[t] < e[t]:
ps = 0.0
pn = 0.0
en = e[t] - p[t]
tmp = s[0] / x[0]
es = s[0] * (2.0 - tmp) * np.tanh(en / x[0]) / (1.0 + (1.0 - tmp) * np.tanh(en / x[0]))
tmp = s[0] - es
if tmp > 0.0:
s[0] = tmp
else:
s[0] = 0.0
else:
pn = 0.0
en = 0.0
ps = 0.0
tmp = 4.0 * s[0] / (9.0 * x[0])
perc = s[0] * (1.0 - (1.0 + tmp * tmp * tmp * tmp) ** (-1.0 / 4.0))
s[0] -= perc
pr_0 = perc + pn - ps
q9 = 0.0
q1 = 0.0
for i in range(m):
if i == 0:
pr_i = pr_0
else:
pr_i = s[2 + i - 1]
if i < l:
q9 += uh1_tab[i] * pr_i
q1 += uh2_tab[i] * pr_i
q9 *= 0.9
q1 *= 0.1
f = x[1] * ((s[1] / x[2]) ** (7.0 / 2.0))
tmp = s[1] + q9 + f
if tmp > 0.0:
s[1] = tmp
else:
s[1] = 0.0
tmp = s[1] / x[2]
qr = s[1] * (1.0 - ((1.0 + tmp * tmp * tmp * tmp) ** (-1.0 / 4.0)))
s[1] -= qr
tmp = q1 + f
if tmp > 0.0:
qd = tmp
else:
qd = 0.0
q[t] = qr + qd
for i in range(s.size - 2 - 2, -1, -1):
s[2 + i + 1] = s[2 + i]
if s.size > 2:
s[2] = pr_0
def check_increasing(x, y):
"""Determine whether the relationship between x and y appears to be
increasing or decreasing based on Spearman correlation.
Parameters
----------
x : array-like, shape=(n_samples,)
Training data.
y : array-like, shape=(n_samples,)
Training target.
Returns
-------
`increasing_bool` : boolean
Whether the relationship is increasing or decreasing.
Notes
-----
Determine whether the relationship between x and y appears to be
increasing or decreasing. The Spearman correlation coefficient is
estimated from the data, and the sign of the resulting estimate
is used as the result.
In the event that the 95% confidence interval based on Fisher transform
spans zero, a warning is raised.
References
----------
Fisher transformation. Wikipedia.
http://en.wikipedia.org/w/index.php?title=Fisher_transformation
"""
# Calculate Spearman rho estimate and set return accordingly.
rho, _ = spearmanr(x, y)
if rho >= 0:
increasing_bool = True
else:
increasing_bool = False
# Run Fisher transform to get the rho CI, but handle rho=+/-1
if rho not in [-1.0, 1.0]:
F = 0.5 * math.log((1. + rho) / (1. - rho))
F_se = 1 / math.sqrt(len(x) - 3)
# Use a 95% CI, i.e., +/-1.96 S.E.
# http://en.wikipedia.org/wiki/Fisher_transformation
rho_0 = math.tanh(F - 1.96 * F_se)
rho_1 = math.tanh(F + 1.96 * F_se)
# Warn if the CI spans zero.
if np.sign(rho_0) != np.sign(rho_1):
warnings.warn("Confidence interval of the Spearman "
"correlation coefficient spans zero. "
"Determination of ``increasing`` may be "
"suspect.")
return increasing_bool
def pi_two_bosons(x, beta):
pi_x_1 = math.sqrt(math.tanh(beta / 2.0)) / math.sqrt(math.pi) *\
np.exp(-x ** 2 * math.tanh(beta / 2.0))
pi_x_2 = math.sqrt(math.tanh(beta)) / math.sqrt(math.pi) *\
np.exp(-x ** 2 * math.tanh(beta))
weight_1 = z(beta) ** 2 / (z(beta) ** 2 + z(2.0 * beta))
weight_2 = z(2.0 * beta) / (z(beta) ** 2 + z(2.0 * beta))
pi_x = pi_x_1 * weight_1 + pi_x_2 * weight_2
return pi_x
def tanhfilter(nx, fl, aa): # generate discretized tanh filter from math import pi, tanh n = nx//2 + nx%2 f = [0.0]*n for i in xrange(n): x = float(i)/nx f[i] = 0.5*( tanh(pi*(x+fl)/2.0/aa/fl) - tanh(pi*(x-fl)/2.0/aa/fl) ) return [[float(i)/nx for i in xrange(n)],f]
def uTOpwm(u):
pwm = np.array([0.0,0.0])
pwm[0] = 1800 + 200 * math.tanh(u[0]-1)
pwm[1] = 1500 + 500 * math.tanh(u[1])
return pwm
def run(_numAgents, _squareFactor, _generations, _cuttOff, _badImagesStart):
numAgents = _numAgents #100
squareFactor = _squareFactor #0.5
numShapes = 4
imageSize = 6 * 6
#middleNeurons = 3
#lastNeurons = 1
generations = _generations #200 #Number of Generations
generation = 1 #Starting Generation
cutOff = _cuttOff #20 #Number of Agents Moving to Next generation
badImagesStart = _badImagesStart #4-1
random.seed(time.time() * 1000)
Agents = []
BestAgent = []
BestAgent2 = []
BestAgent3 = []
for i in range(0, numAgents):
#print(i) #debugging
NeuronLinks = []
#for i in range(0,imageSize*imageSize):
# agent.append(random.random())
for i in range(0, 6):
NeuronLinks.append(random.random())
#random.seed(time.time()*1000+10)
for i in range(0, middleNeurons):
NeuronLinks.append(random.random())
#random.seed(time.time()*1000)
Agents.append(NeuronLinks)
#print(len(NeuronLinks))
#print(Agents) #debugging
#print(Agents[0])
#print(Agents[1])
# Import Image Data
print('This many samples:')
images = imageImport.getImages()
print(len(images))
# Main Loop
while generation != generations + 1:
random.seed(time.time() * 1000)
#image = round(random.random()*(len(images)-1))
#objectDataSL = images[image]
print('-----------')
print('Generation:')
print(generation)
print('-----------')
perImageAgentScores = []
for image in images:
AgentScores = []
objectDataSL = image
for agentNum in range(0, numAgents):
NeuronLinks = Agents[agentNum]
# First row connects to First Neuron, 2nd row to 2nd etc.
Layer1Nodes = []
for k in range(0, 6):
#Simply each row adds to become the first neuron (goes through a function) (was averaging, now its tanh).
valueAt_k = (objectDataSL[k * 6] +
objectDataSL[(k * 6) + 1] +
objectDataSL[(k * 6) + 2] +
objectDataSL[(k * 6) + 3] +
objectDataSL[(k * 6) + 4] +
objectDataSL[(k * 6) + 5])
valueAt_k = float((1 / 2) * (math.tanh(
(1 / 2) * (valueAt_k - 3)) + 1))
Layer1Nodes.append(valueAt_k)
#print(Layer1Nodes)
#There are 3 middle neurons
Layer2Nodes = []
for k in range(0, middleNeurons):
valueAt_k = ((Layer1Nodes[k * 2] * NeuronLinks[k * 2]) +
(Layer1Nodes[(k * 2) + 1] * NeuronLinks[
(k * 2) + 1])) * 2
valueAt_k = float((1 / 2) * (math.tanh(
(2) * (valueAt_k - 1)) + 1))
Layer2Nodes.append(valueAt_k)
#print(Layer2Nodes)
#There is 1 single output.
Layer3Nodes = []
for k in range(0, lastNeurons):
valueAt_k = (
(Layer2Nodes[k] * NeuronLinks[k + 6]) +
(Layer2Nodes[k + 1] * NeuronLinks[k + 6 + 1]) +
(Layer2Nodes[k + 2] * NeuronLinks[k + 6 + 2])) * 2
valueAt_k = float((1 / 2) * (math.tanh(
(1) * (valueAt_k - (3 / 2))) + 1))
Layer3Nodes.append(valueAt_k)
#print(Layer3Nodes)
AgentScores.append(Layer3Nodes[0])
perImageAgentScores.append(AgentScores)
#if Layer3Nodes[0] > squareFactor:
#print('A Square!')
#squareScore+=1
#else:
#print('Not a Square!')
#print(perImageAgentScores)
#Score Agents:
AgentScores = []
for agent in range(0, len(Agents)):
agentScore = 0
GenerationScore = []
for image in range(0, badImagesStart):
if perImageAgentScores[image][agent] > squareFactor:
agentScore += 1
GenerationScore.append('Square')
else:
GenerationScore.append('Not Square')
for image in range(badImagesStart, len(images)):
if perImageAgentScores[image][agent] < squareFactor:
agentScore += 1
GenerationScore.append('Not Square')
else:
GenerationScore.append('Square')
AgentScores.append(agentScore)
# Sort Agents Based on Score
#print(bubbleSort.sort(AgentScores, Agents))
sortedAgents = bubbleSort.sort(AgentScores, Agents)
#print(AgentScores)
#print(sortedAgents)
BestAgent = sortedAgents[-1:]
BestAgent2 = sortedAgents[-2:-1]
BestAgent3 = sortedAgents[-3:-2]
# Kill low scoring agents
AliveAgents = sortedAgents[-cutOff:]
# Breed and Mutate Agents
NewAgents = []
for i in range(0, int((numAgents - (numAgents - cutOff)) / 2)):
newAgent = AliveAgents[i * 2][0:5] + AliveAgents[
(i * 2) + 1][5:len(AliveAgents[0])]
NewAgents.append(newAgent)
#Mutation
NewAgents[int(random.random() * (len(NewAgents) - 2))][int(
random.random() * (len(NewAgents[0]) - 2))] = random.random()
NewAgents[int(random.random() * (len(NewAgents) - 2))][int(
random.random() * (len(NewAgents[0]) - 2))] = random.random()
#NewAgents[int(random.random()*len(NewAgents))-1][int(random.random()*len(NewAgents[0]))] = random.random()
#Missing Agents
newAgent = []
for k in range(0, numAgents - (len(NewAgents) + len(AliveAgents))):
for i in range(0, 43 - 34):
newAgent.append(random.random())
#random.seed(time.time()*1000)
NewAgents.append(newAgent)
Agents = NewAgents + AliveAgents
print(len(Agents[0]))
#print(len(Agents))
# THIS IS END OF LOOP
os.system('cls')
generation += 1
if (generation == generations + 1):
print(AgentScores)
print(GenerationScore)
print(BestAgent)
return BestAgent[0]
#After the Loop
print(AgentScores)
print(GenerationScore)
print(BestAgent)
def tangentehiper(value):
return math.tanh(value)
from collections import namedtuple
NodeParams = namedtuple("Node", "name additional frm")
def f_rlu(a, x):
if x >= 0:
return x
else:
return x * (1.0 / a)
func = {
'var':
lambda params, x: x,
'tnh':
lambda params, x: np.array(list(map(lambda z: math.tanh(z), x[0].flatten())
),
dtype="float64").reshape(x[0].shape),
'rlu':
lambda params, x: np.array(list(
map(lambda z: f_rlu(params[0], z), x[0].flatten())),
dtype="float64").reshape(x[0].shape),
'mul':
lambda params, x: x[0].dot(x[1]),
'sum':
lambda params, x: reduce(lambda p1, p2: p1 + p2, x),
'had':
lambda params, x: reduce(lambda p1, p2: p1 * p2, x),
}
'exp': [math.exp],
'expm1': [math.exp],
'fabs': [_deriv_fabs],
'hypot': [lambda x, y: x/math.hypot(x, y),
lambda x, y: y/math.hypot(x, y)],
'log': [log_der0,
lambda x, y: -math.log(x, y)/y/math.log(y)],
'log10': [lambda x: 1/x/math.log(10)],
'log1p': [lambda x: 1/(1+x)],
'pow': [_deriv_pow_0, _deriv_pow_1],
'radians': [lambda x: math.radians(1)],
'sin': [math.cos],
'sinh': [math.cosh],
'sqrt': [lambda x: 0.5/math.sqrt(x)],
'tan': [lambda x: 1+math.tan(x)**2],
'tanh': [lambda x: 1-math.tanh(x)**2]
}
# Many built-in functions in the math module are wrapped with a
# version which is uncertainty aware:
this_module = sys.modules[__name__]
def wrap_locally_cst_func(func):
'''
Return a function that returns the same arguments as func, but
after converting any AffineScalarFunc object to its nominal value.
This function is useful for wrapping functions that are locally
constant: the uncertainties should have no role in the result
(since they are supposed to keep the function linear and hence,
def tanh_activation(self):
return math.tanh(self.membrane_potential)
def getSigmoid(self):
s = lambda d: 1.7159 * math.tanh(.6666 * d)
return numpy.vectorize(s)
def drop_chance(length, maximum):
return tanh(float(length - maximum) / maximum * 2.0)
def opera(y):
# En caso de ENTER sin número...
print("__________________")
# Árbol condicional de opciones.
if (y == 0):
username = getpass.getuser()
print("Saliendo del programa... Adiós {:2}! ".format(username))
time.sleep(3)
os.system('clear')
os.system('cls')
sys.exit()
elif (y == 1):
print("Opción: Suma")
a = int(input("Introduzca el primer número: "))
b = int(input("Introduzca el segundo número: "))
print("\n")
resultado = (a + b)
print("El resultado es: ", resultado)
elif (y == 2):
print("Opción: Resta")
a = int(input("Introduzca el primer número: "))
b = int(input("Introduzca el segundo número: "))
resultado = a - b
print("El resultado es: ", resultado)
elif (y == 3):
print("Opción: Multiplicación")
a = int(input("Introduzca el primer número: "))
b = int(input("Introduzca el segundo número: "))
resultado = (a * b)
print("El resultado es: ", resultado)
elif (y == 4):
print("Opción: División")
a = int(input("Introduzca el primer número: "))
b = int(input("Introduzca el segundo número: "))
resultado = (a / b)
resto = (a % b)
print("El resultado es: ", resultado, " y de resto: ", resto)
elif (y == 5):
print("Opción: Porcentaje")
b = int(input("¿Porcentaje? (Número) "))
a = int(input("¿A qué le calculamos el {:2}% ?: ".format(b)))
resultado = ((a * b) / 100)
print("El ", b, "% de ", a, " es: ", resultado)
elif (y == 6):
print("Opción: Exponencial al cuadrado")
a = int(input("Introduzca el número: "))
resultado = (a**2)
print("El resultado de {:2} a la '2' es: ".format(a), resultado)
elif (y == 7):
print("Opción: Exponente a la 'x'")
a = int(input("Introduzca el número natural: "))
b = int(input("¿A cuánto lo exponemos? "))
resultado = (a**b)
print("El resultado de {:2} a la {:2} es: ".format(a, b), resultado)
elif (y == 8):
print("Opción:Polinomio de primer grado")
a = int(input("Introduzca valor de las 'X's' : "))
b = int(input("Introduzca valor de los enteros : "))
resultado = (b / a)
print("El resultado de {:2}x+({:2}) = 0, X = ".format(a, b), resultado)
elif (y == 9):
print("Opción: Polinomio de segundo grado")
a = int(input("Introduzca valor de las 'X^2' : "))
b = int(input("Introduzca valor de las 'X' : "))
c = int(input("Introduzca valor de los enteros : "))
calc = ((b**2) - (4 * a * c))
if calc < 0:
print(50 * "*")
print("No puedo calular una raiz negativa... Sorry")
print(50 * "*")
else:
resultado1 = (((-b) + math.sqrt(calc)) / (2 * a))
resultado2 = (((-b) - math.sqrt(calc)) / (2 * a))
print(
"El resultado para +X de {:2}x^2+({:2}x)+({:2}) = 0 es: ".
format(a, b, c), resultado1)
print(
"El resultado para -X de {:2}x^2+({:2}x)+({:2}) = 0 es: ".
format(a, b, c), resultado2)
elif (y == 10):
print("Opción: Raíz cuadrada")
a = int(input("Introduzca el número: "))
resultado = (math.sqrt(a))
print("El resultado es:", resultado)
elif (y == 11):
print("Opción: DEC a BIN")
def binario(decimal):
binario = ''
while decimal // 2 != 0:
binario = str(decimal % 2) + binario
decimal = decimal // 2
return str(decimal) + binario
numero = int(input('Introduce el número a convertir a binario: '))
print(numero, "> ", binario(numero))
# OPCION FÁCIL: bin(numero)
print("Opción 2: bin()")
print(bin(numero)[2:])
elif (y == 12):
print("Opción: BIN a DEC")
def decimal(binario):
decimal = int(str(binario), 2)
return decimal
numero = int(input('Introduce el número a convertir a decimal: '))
print(numero, "> ", decimal(numero))
elif (y == 13):
print("Opción: DEC a HEX")
# def hexadec(decimal, base):
# conversion = ''
# while decimal // base != 0:
# conversion = str(decimal % base) + conversion
# decimal = decimal // base
# primero = str(decimal)
# segundo = conversion
# print(primero, "\n")
# print(segundo, "\n")
# #print(type(primero))
# #print(type(segundo))
# if primero == '10':
# primero = 'A'
# elif primero == '11':
# primero = 'B'
# elif primero == '12':
# primero = 'C'
# elif primero == '13':
# primero = 'D'
# elif primero == '14':
# primero = 'E'
# elif primero == '15':
# primero = 'F'
# if segundo == '10':
# segundo = 'A'
# elif segundo == '11':
# segundo = 'B'
# elif segundo == '12':
# segundo = 'C'
# elif segundo == '13':
# segundo = 'D'
# elif segundo == '14':
# segundo = 'E'
# elif segundo == '15':
# segundo = 'F'
# return (primero+segundo)
numero = int(input('Introduce el número a cambiar de base: '))
base = 16
print(hex(numero)[2:])
# print("Opción 2: \n", hexadec(numero, base))
elif (y == 14):
print("Opción: DEC a base 'X'")
def cambio_base(decimal, base):
conversion = ''
while decimal // base != 0:
conversion = str(decimal % base) + conversion
decimal = decimal // base
return str(decimal) + conversion
numero = int(input('Introduce el número a cambiar de base: '))
base = int(input('Introduce la base: '))
print(cambio_base(numero, base))
elif (y == 15):
print("Opción: LOGARITMO EN CUALQUIER BASE.")
a = float(input("Introduzca el número: "))
b = int(input("¿Qué base? "))
if a < 0.1:
print(
"TE RECUERDO QUE: \n Los logaritmos no deben ser mayores que cero."
)
else:
resultado = math.log(a, b)
print(
"El resultado del logaritmo {:2} en base {:2} es:".format(
a, b), resultado)
elif (y == 16):
print("Opción: LOGARITMO NEPERIANO DE UN NÚMERO.")
a = float(input("Introduzca el número: "))
if a < 0.1:
print(
"TE RECUERDO QUE: \n Los logaritmos no deben ser mayores que cero."
)
else:
resultado = (a)
print("El resultado del logaritmo neperiano de {:2} es:".format(a),
resultado)
print("ESTE DE MOMENTO NO LO HE SACADO...")
elif (y == 17):
print("Opción: Lado desconocido de un triángulo.")
tipo = input("""
¿Qué tipo de triángulo es? (A-D)
a. - Equilatero
b. - Isóceles
c. - Escaleno
d. - Rectángulo
""")
print("Genial, ha seleccionado: ", tipo)
print()
if tipo == 'a' or tipo == 'A':
lado = int(input("Introduzca valor del lado: "))
print(
"Como es un triángulo equilatero, todos sus lados son iguales, asi que"
)
print("El lado desconocido es: ", lado)
elif tipo == 'b' or tipo == 'B':
lado2 = input("¿Es el lado desigual? (Y/N) ")
if lado2 == 'y' or lado2 == 'Y':
a = int(input("Introduzca valor del lado que conoce: "))
interior = (2 * (a**2) - (2 * (a**2) * math.cos(60)))
b = (math.sqrt(interior))
print("El lado que desconoce mide: ", b)
else:
print("Como es isóceles, dos de sus lados son iguales.")
print("Lado desconocido: ", a)
elif tipo == 'c' or tipo == 'C':
print("""
A
*
| + +
| + +
| + +
h | + + c
| + +
| b + +
| + +
| + +
| + +
-+- C *---------------* B
a
""")
h = input("¿Sabes la altura (h)? (Y/N) ")
if h == 'N' or h == 'n':
print("Genial!")
lado = input("¿Qué lado desconocemos? (a/b/c)")
lado = lado.upper
if lado == 'A':
ang = float(input("¿Ángulo de 'A'? "))
b = float(input("Lado 'b': "))
c = float(input("Lado 'c': "))
a = ((b**2) + (c**2) - (2 * b * c * math.cos(ang)))
print()
print("""Tenemos:
- a: {:2}
- b: {:2}
- c: {:2}
""".format(a, b, c))
elif lado == 'B':
ang = float(input("¿Ángulo de 'B'? "))
a = float(input("Lado 'a': "))
c = float(input("Lado 'c': "))
b = ((a**2) + (c**2) - (2 * a * c * math.cos(ang)))
print()
print("""Tenemos:
- a: {:2}
- b: {:2}
- c: {:2}
""".format(a, b, c))
elif lado == 'C':
ang = float(input("¿Ángulo de 'C'? "))
a = float(input("Lado 'a': "))
b = float(input("Lado 'b': "))
c = ((b**2) + (a**2) - (2 * b * a * math.cos(ang)))
print()
print("""Tenemos:
- a: {:2}
- b: {:2}
- c: {:2}
""".format(a, b, c))
else:
print("Error en los datos de entrada")
else:
h = input("Dime la altura")
lado = input("¿Qué lado calculamos? (A-C) ")
lado = lado.upper
if lado == 'A':
ang = float(input(" ¿Ángulo de 'B'? "))
a = h / (math.sin(ang))
print("El lado 'a' mide: ", a)
elif lado == 'B':
ang = float(input(" ¿Ángulo de 'A'? "))
b = h / (math.sin(ang))
print("El lado 'a' mide: ", b)
elif lado == 'C':
a = float(input("Valor de 'a': "))
b = float(input("Valor de 'b': "))
if h < b:
hipo = h**2
cat2 = b**2
else:
hipo = b**2
cat2 = h**2
x = (math.sqrt(hipo - cat2))
base = x + a
c = math.sqrt((base**2) + (h**2))
print("El lado 'c' mide: ", c)
else:
print("Error en los datos de entrada")
elif tipo == 'd' or tipo == 'D':
lado = input("¿Qué lado desconoce? (c1 , c2 o h) ")
if lado == 'c1' or lado == 'C1':
h = input("Hipotenusa: ")
c2 = input("Cateto :")
c1 = math.sqrt((h**2) - (c2**2))
print(" La medida del cateto es: ", c1)
elif lado == 'c2' or lado == 'C2':
h = input("Hipotenusa: ")
c1 = input("Cateto :")
c2 = math.sqrt((h**2) - (c1**2))
print(" La medida del cateto es: ", c2)
elif lado == 'h' or lado == 'H':
c1 = input("Cateto 1: ")
c2 = input("Cateto 2:")
h = math.sqrt((c1**2) + (c2**2))
print(" La medida de la hipotenusa es: ", h)
elif (y == 18):
print("Opción:Trigonometría")
ang = float(input("¿Ángulo? "))
print("")
print("""
OPCIONES (Sin usar pitágoras):
Calcula
1- La tangente de un ángulo.
2- El seno de un ángulo.
3- El coseno de un ángulo.
4- La cotangente de un ángulo
""")
opcion = int(input("Seleccione una opcion: "))
c1 = math.tan(ang)
c2 = math.sin(ang)
c3 = math.cos(ang)
c4 = math.tanh(ang)
# Diccionario de minioperaciones
opciones = {1: c1, 2: c2, 3: c3, 4: c4}
print(15 * "_____")
print(opciones)
print(15 * "_____")
valor = opciones.get(opcion)
clave = list(opciones.keys())[list(opciones.values()).index(valor)]
print("Resultado en RADIANES de la opción ", clave, " es: ", valor)
def transfer_function(self, x):
#use hyperbolic tan
return math.tanh(x)
def sigmoid(x):
return math.tanh(x)
# 가상으로 구현한 loocv(leave one out cross validation) 시뮬레이터
from collections import deque
import numpy as np
import random
import time
import math
def cross_validation(dataset, address, acc):
print("%d th test_set : %s" % (int(address + 1), dataset[address]))
print("cross_validation %d times... " % int(address + 1))
print("accuracy : %.5f %%" % float(acc * 100))
time.sleep(0.3)
#make fake 10000 datasets that have 7 features and 1 label
dataset = np.zeros((10000, 8))
acc = 0
for i in range(10000):
for j in range(0, 7):
dataset[i, j] = random.randrange(1, 10)
dataset[i, 7] = random.choice([True, False])
dataset_address = deque(range(10000), maxlen=10000)
for i in range(dataset_address.__len__()):
cross_validation(dataset, i, acc)
acc = math.tanh((i / 100000000) * i * i)
dataset_address.rotate(-1)
#
import random, math
h = 1.0
beta = 2.0
p = math.exp(-2.0 * beta * h)
sigma = 1
tmax = 10000000
M_tot = 0
for t in range(tmax):
if sigma == -1:
sigma = 1
elif random.uniform(0.0, 1.0) < p:
sigma = -1
M_tot += sigma
print('magnetization:', M_tot / float(tmax))
print('exact result: ', math.tanh(beta * h))
argCount=2,
alg=lambda args: args[0] - args[1]),
'=':
Operator(leftAssoc=True,
priority=1,
argCount=2,
alg=lambda args: args[0] == args[1]),
}
_functions = {
'abs': Function(argCount=1, alg=lambda args: math.fabs(args[0])),
'acosh': Function(argCount=1, alg=lambda args: math.acosh(args[0])),
'acos': Function(argCount=1, alg=lambda args: math.acos(args[0])),
'asinh': Function(argCount=1, alg=lambda args: math.asinh(args[0])),
'asin': Function(argCount=1, alg=lambda args: math.asin(args[0])),
'atan2': Function(argCount=1, alg=lambda args: math.atan2(args[0])),
'atanh': Function(argCount=1, alg=lambda args: math.atanh(args[0])),
'atan': Function(argCount=1, alg=lambda args: math.atan(args[0])),
'cos': Function(argCount=1, alg=lambda args: math.cos(args[0])),
'exp': Function(argCount=1, alg=lambda args: math.exp(args[0])),
'log10': Function(argCount=1, alg=lambda args: math.log10(args[0])),
'log': Function(argCount=1, alg=lambda args: math.log(args[0])),
'sin': Function(argCount=1, alg=lambda args: math.sin(args[0])),
'sqrt': Function(argCount=1, alg=lambda args: math.sqrt(args[0])),
'tanh': Function(argCount=1, alg=lambda args: math.tanh(args[0])),
'tan': Function(argCount=1, alg=lambda args: math.tan(args[0])),
}
_constants = {
'e': Constant(value=2.71828182846),
'pi': Constant(value=3.14159265359),
}
import math import matplotlib.pyplot as plt import numpy as np x = np.arange(-6, 6, 0.05) y1 = np.array([max(a, 0) for a in x]) y2 = np.array([1./(1+math.exp(-a)) for a in x]) y3 = np.array([math.tanh(a) for a in x]) plt.grid(color='gray', linestyle='--', linewidth=0.5) plt.plot(x, y1, label='ReLU', linewidth=2) plt.plot(x, y2, label='Logistic', linewidth=2) plt.plot(x, y3, label='tanh', linewidth=2) plt.legend() plt.show()
def transfer(activation): return tanh(activation)
def activationF(val):
return math.tanh(val)
def activationFunction(x):
return math.tanh(x)
def rho_harm(x, xp, beta):
Upsilon_1 = sum(
(x[d] + xp[d])**2 / 4.0 * math.tanh(beta / 2.0) for d in range(3))
Upsilon_2 = sum(
(x[d] - xp[d])**2 / 4.0 / math.tanh(beta / 2.0) for d in range(3))
return math.exp(-Upsilon_1 - Upsilon_2)
def getFitness(self):
print "evaluations taken ", self.evaluations_taken, " energy: ", self.energy
energy_norm = math.tanh(self.energy)
return max(self.evaluations_taken + energy_norm, 1)
def math_tanh(A, B):
i = cuda.grid(1)
B[i] = math.tanh(A[i])
def funcao_ativacao_tang_hip(x):
return math.tanh(x)
def control(self, u_d=0, psi_d=0):
#Nr hydrodynamic variable
self.N_r = (-0.52) * (math.pow(
math.pow((self.u), 2) + math.pow((self.v), 2), 0.5))
#rospy.logwarn("Nr %f", self.N_r)
#Xu and Xuu
u_abs = math.fabs(self.u)
#rospy.logwarn("abs u %f", u_abs)
self.X_u = -25
self.X_uu = 0
if u_abs > 1.2:
self.X_u = 64.55
self.X_uu = -70.92
self.error_u = self.u - u_d #Speed error
if (math.fabs(self.error_u) < 0.05):
self.error_u = 0
#rospy.logwarn("u error %f", self.error_u)
self.error_psi = self.psi - psi_d #Yaw error
if (math.fabs(self.error_psi) > (math.pi)):
self.error_psi = (self.error_psi / math.fabs(self.error_psi)) * (
math.fabs(self.error_psi) - 2 * math.pi)
if (math.fabs(self.error_psi)) < 0.015:
self.error_psi = 0
self.degree_error = math.degrees(self.error_psi)
#rospy.logwarn("psi error %f", degree_error)
psiexp = (-5.73) * math.fabs(self.error_psi)
self.min_u = self.udyaw + (u_d - self.udyaw) * math.exp(psiexp)
self.u_d_ref = min(self.min_u, u_d)
tanhval = self.ka * (self.u_d_ref - self.u) / self.uamax
self.u_dot_d = self.uamax * math.tanh(tanhval)
self.epsilon_u = self.u_dot_d - (self.ku * self.error_u)
self.epsilon_psi = (self.k1) * (self.error_psi) - (self.k2) * (self.r)
self.X_drag = (self.X_uu) * (self.u) * u_abs + (self.X_u) * (self.u)
self.T_x = (self.mass - self.X_u_dot) * (self.epsilon_u) - (
self.mass - self.Y_v_dot) * (self.v) * (self.r) - (self.X_drag)
self.T_z = (self.I_z - self.N_r_dot) * (self.epsilon_psi) - (
self.Y_v_dot -
self.X_u_dot) * (self.u) * (self.v) - (self.N_r) * (self.r)
if math.fabs(self.error_psi) > 0.03:
self.T_z = self.T_z * .5
if math.fabs(self.error_psi) > 0.1:
self.T_z = self.T_z * .7
if math.fabs(self.error_psi) > 0.2:
self.T_z = self.T_z * .7
if math.fabs(self.error_psi) > 0.3:
self.T_z = self.T_z * .8
self.T_port = (self.T_x / (2 * self.c)) + (self.T_z /
(self.B * self.c))
self.T_stbd = (self.T_x / 2) - (self.T_z / self.B)
if self.T_port > 36.5:
self.T_port = 20
elif self.T_port < -30:
self.T_port = -20
if self.T_stbd > 36.5:
self.T_stbd = 20
elif self.T_stbd < -30:
self.T_stbd = -20
#Controller outputs
self.right_thruster_pub.publish(self.T_stbd)
self.left_thruster_pub.publish(self.T_port)
self.u_error_pub.publish(self.error_u)
self.psi_error_pub.publish(self.degree_error)
def delta(phi: float) -> float:
return 1 - (1 + math.tanh(2 * (phi - max_dis))) / 2
def mish(x):
return x * math.tanh(math.log(1 + math.exp(x)))
def tanh(x1, x2, k, c):
return math.tanh(k * np.dot(x1, x2) + c)
def sho_energy(T):
'''Return the energy of a simple harmonic osscilator at temperature T.'''
# \hbar \omega / k_B = 1
return 0.5 / math.tanh(0.5 / T)
def tanh(self,x):
return math.tanh(x)
def forward(self, distance):
TForward = Transform.shiftOrigin(Point(math.tanh(-distance/2), 0))
TToOrigin = self.transformToOrigin()
TFromOrigin = TToOrigin.inverted()
T = Transform.merge(TToOrigin, TForward, TFromOrigin)
return Turtle(*T(self.point, self.head))
ainvfinal = math.log10(1 + settings["zc_final"])
ainvarr = []
zcarr = []
for i in range(settings["bins"] + 1):
ainvarr.append(float(i) / settings["bins"] * (ainvfinal - ainvinit))
zcarr.append(10**ainvarr[i] - 1.0)
fp = open("TREECOOL.mod", "w")
for ii, zc in enumerate(zcarr):
if zc > settings["XRadRedShiftOn"] or zc < settings["XRadRedShiftOff"]:
settings["RampX"] = 0.0
else:
if zc > settings["XRadRedShiftFullOn"]:
settings["RampX"] = 0.5 - 0.5*math.tanh(15.0*(zc-0.5*\
(settings["XRadRedShiftOn"] \
+ settings["XRadRedShiftFullOn"])))
if zc < settings["XRadRedShiftDropOff"]:
settings["RampX"] = ( zc - settings["XRadRedShiftDropOff"] + \
settings["XRadRedShiftf0to3"] * \
(settings["XRadRedShiftDropOff"]-zc)) / \
(settings["XRadRedShiftDropOff"] - \
settings["XRadRedShiftOff"])
if zc > settings["RadRedShiftOn"] or zc < settings["RadRedShiftOff"]:
settings["Ramp"] = 0.0
else:
if zc > settings["RadRedShiftFullOn"]:
settings["Ramp"] = 0.5 - 0.5*math.tanh(15.0*(zc-0.5*\
def sigmoidkernel(x1, x2, k, delta):
# print(pow(np.dot(x1, x2)+1, power))
# print(k*np.dot(x1, x2) - delta)
return m.tanh((k * np.dot(x1, x2) - delta) * m.pi / 180.0) + 1
