def optimize_via_equation_system(traj_d, start, goal, norm):
'''
this function solves the equation system implied by the Lagrangian Optimization in "Movement Primitives via Optimization" (Dragan
2015) in equation 3 and 4 in order to adapt a demonstrated trajectory to two new endpoints (start and goal). The adaptation
assumes as a norm a finite difference matrix of a spring damper system (new positions are calculated based on
accelerations).
:param traj: (T, n)
:param start: (n,)
:param goal: (n,)
:param norm: (T,T) --> assert positive definite
:return: adapted trajectory (T,n)
'''
assert math.is_pos_def(norm), "norm must be positive definite"
traj_len = traj_d.shape[0]
start_goal_vec = np.zeros(traj_len)
start_goal_vec[0] = start
start_goal_vec[-1] = goal
b = norm.dot(traj_d - start_goal_vec)
mask1 = np.zeros(traj_len)
mask1[0], mask1[-1] = 1, 1
mask2 = np.ones(traj_len)
mask2[0], mask2[-1] = 0, 0
fun = lambda x: norm.dot(np.multiply(mask2, x)) - np.multiply(mask1, x) - b
traj = broyden2(fun, traj_d)
traj[0] = start
traj[-1] = goal
return traj
def schatters_MLLH(data):
"""
Deze functie berekend de schatters voor de maximum likelihood methode. k moet numeriek berekend worden.
Dit wordt gedaan in de functie schatter_k_MLLH.
Er werd gekozen voor scipy.optimize.broyden2 na het testen van verschillende methodes en het vergelijken van de
performantie. broyden2 kwam er uit als de snelste voor deze vergelijking.
:param data: de dataset waaruit k en theta wordt berekend
:return: De schatters k en theta
"""
y = data
gem_y = np.average(y)
def schatter_k_MLLH(k):
"""
:param k: de schatter k
:return: de vergelijking die numeriek moet opgelost worden
"""
gem_lny = np.average(np.log(y))
f = gem_lny - np.log(gem_y) + np.log(k) - digamma(k)
return f
k = float(optimize.broyden2(schatter_k_MLLH, np.array([3.0])))
theta = gem_y / k
return k, theta
def iterate(self, kspace=None, tol=10**-6, maxiter=200):
'''
Iterate the SCMF to get converged order parameters.
Parameters
----------
kspace : BaseSpace, optional
The Brillouin zone of the system.
tol : float, optional
The tolerance of the order parameter.
maxiter : int, optional
The maximum times of the iteration.
'''
def gx(values):
for op, value in zip(self.ops.values(), values):
op.value = value
self.opsupdate(kspace)
return array([self.ops[key].value
for key in self.ops.keys()]) - values
with self.timers.get('Iteration'):
x0 = array([self.ops[key].value for key in self.ops.keys()])
ops = broyden2(gx,
x0,
verbose=True,
reduction_method='svd',
maxiter=maxiter,
x_tol=tol)
self.log << 'Order parameters:\n%s\n' % Sheet.fromordereddict(
OrderedDict([(name, op)
for name, op in zip(self.ops.keys(), ops)]))
self.log << 'Iterate: time consumed %ss.\n\n' % self.timers.time(
'Iteration')
def boundary(x):
# Boundary values obtained by nonlinear solver
x = np.array(x) / N - 0.5
def fun(v):
return [v[0] + v[0] * v[1] ** 2 - v[0] ** 3 / 3 - x[0],
-v[1] - v[1] * v[0] ** 2 + v[1] ** 3 / 3 - x[1]]
v = broyden2(fun, [0, 0])
return v[0] ** 2 - v[1] ** 2
def method_of_moments_estimator(sequence=None, attributes=None, cache=None):
"""
Simple Method-of-Moments Estimator to estimate D (Haas et al, 1995)
can be optimised (training rate, stopping value)
d = d_moments(l - e^(-n))/d_moments)
solve for d_moments in d = d_moments(l - e^(-n))/d_moments)
:param sequence: sample sequence of integers
:type sequence: array of ints
:param attributes: dictionary with keys as the unique elements and values as
counts of those elements
:type attributes: dictionary where keys can be any type, values must be integers
:param cache: argument used by median methods to avoid recomputation of variables
:type cache: dictionary with 4 elements
{"n":no_elements,"d":no_unique_elements,"attr": attribute_counts,
"freq":frequency_dictionary}
:return: estimated distinct count
:rtype: float
"""
if sequence is None and attributes is None and cache is None:
raise Exception(
"Must provide a sequence, or a dictionary of attribute counts ")
if cache is not None:
n, d, frequency_dictionary = cache["n"], cache["d"], cache["freq"]
elif sequence is not None:
n, d, _, frequency_dictionary = precompute_from_seq(sequence)
else:
n, d, _, frequency_dictionary = precompute_from_attr(attributes)
if n == d:
return _compute_birthday_problem_probability(d)
def diff_eqn(D):
return D * (1 - np.exp((-n / D))) - d
warnings.filterwarnings('ignore')
try:
d_moments_1 = float(broyden1(diff_eqn, d))
except Exception as e:
print(e)
d_moments_1 = 1000000000000000000000000
try:
d_moments_2 = float(broyden2(diff_eqn, d))
except:
d_moments_2 = 1000000000000000000000000
warnings.resetwarnings()
result = min(d_moments_1, d_moments_2)
if result == 1000000000000000000000000:
return d
else:
return result
def _get_damage(self):
if self.w == 0.:
damage = np.zeros_like(self.sorted_depsf)
else:
ff = t.clock()
try:
damage = broyden2(self.damage_residuum, 0.2 * np.ones_like(self.sorted_depsf), maxiter=20)
except:
print 'broyden2 does not converge fast enough: switched to fsolve for this step'
damage = fsolve(self.damage_residuum, 0.2 * np.ones_like(self.sorted_depsf))
print 'damage =', np.sum(damage) / len(damage), 'iteration time =', t.clock() - ff, 'sec'
return damage
def compute_ss(self, guess=None, method='fsolve', options={}):
'''Attempts to solve for the steady state of the model.
Args:
guess: (Pandas Series, Numpy array, or list) An initial guess for the
steady state solution. The result is highly sensisitve to the intial
guess chosen, so be careful. If the guess is a Numpy ndarray or a list
then the elements must be ordered to conform with self.names['variables'].
method: (str) The function from the Scipy library to use. Your choices are:
a. root
b. fsolve (default)
c. broyden1
d. broyden2
options: (dict) A dictionary of optional arguments to pass to the numerical solver.
Check out the Scipy documentation to see the options available for each routine:
http://docs.scipy.org/doc/scipy/reference/optimize.html
Returns:
None
Attributes:
ss: (Pandas Series) Steady state values of endogenous variables
'''
if guess is None:
guess = np.ones(self.n_vars)
else:
if isinstance(guess, pd.Series):
guess = guess[self.names['variables']]
# Create function for nonlinear solver
def ss_fun(variables):
variables = pd.Series(variables, index=self.names['variables'])
return self.equilibrium_fun(variables, variables, self.parameters)
if method == 'fsolve':
steady_state = fsolve(ss_fun, guess, **options)
elif method == 'root':
steady_state = root(ss_fun, guess, **options)['x']
elif method == 'broyden1':
steady_state = broyden1(ss_fun, guess, **options)
elif method == 'broyden2':
steady_state = broyden2(ss_fun, guess, **options)
# Add ss attribute
self.ss = pd.Series(steady_state, index=self.names['variables'])
def _get_damage(self):
#ff = time.clock()
if self.w == 0.:
damage = np.zeros_like(self.sorted_depsf)
else:
#ff = t.clock()
try:
damage = broyden2(self.damage_residuum, 0.2 * np.ones_like(self.sorted_depsf), maxiter=20)
except:
#print 'broyden2 does not converge fast enough: switched to fsolve for this step'
damage = fsolve(self.damage_residuum, 0.2 * np.ones_like(self.sorted_depsf))
#print 'damage =', np.sum(damage) / len(damage), 'iteration time =', time.clock() - ff, 'sec'
return damage
def P(phi, phib, df): """ Numerically solve for partition coefficient as a function of \phi_s """ if f(0,phi,phib,df)*f(1,phi,phib,df) < 0: #print 'bisect' #return opt.brentq(f, 0, 1, args=(phi,phib,df)) # Brent's method #return opt.brenth(f, 0, 1, args=(phi,phib,df)) # Brent's method #return opt.bisect(f, 0, 1, args=(phi,phib,df)) # Bisection method #x,r = opt.bisect(f, 0, 1, args=(phi,phib,df), full_output=True) # Bisection method return opt.broyden2(f, 0, 1.0, args=(phi,phib,df)) # Bisection method #print r.iterations #return x else: #print 'newton' return opt.newton(f, 1.0, args=(phi,phib,df)) # Newton-Raphson
def VCACPFF(engine,app):
'''
This method calculates the chemical potential or filling factor.
'''
engine.rundependences(app.name)
engine.cache.pop('ptmesh',None)
kmesh,nk=app.BZ.mesh('k'),app.BZ.rank('k')
fx=lambda omega,mu: (np.trace(engine.mgfmesh(omega=mu+1j*omega,kmesh=kmesh),axis1=1,axis2=2)-engine.nclopt/(1j*omega-app.p)).sum().real
if app.task=='CP':
gx=lambda mu: quad(fx,0,np.float(np.inf),args=mu)[0]/nk/engine.nclopt/np.pi-app.cf
mu=broyden2(gx,app.options.pop('x0',0.0),**app.options)
engine.log<<'mu(error): %s(%s)\n'%(mu,gx(mu))
if app.returndata: return mu
else:
rquad=quad(fx,0,np.float(np.inf),args=app.cf,full_output=2)
filling=rquad[0]/nk/engine.nclopt/np.pi
engine.log<<'Filling factor(mu=%s,err=%.2e,neval=%s): %s\n'%(HP.decimaltostr(app.cf),rquad[1],rquad[2]['neval'],filling)
if app.returndata: return filling
def VCACPFF(engine,app):
'''
This method calculates the chemical potential or filling factor.
'''
engine.rundependences(app.name)
engine.cache.pop('pt_kmesh',None)
kmesh,nk=app.BZ.mesh('k'),app.BZ.rank('k')
fx=lambda omega,mu: (np.trace(engine.mgf_kmesh(omega=mu+1j*omega,kmesh=kmesh),axis1=1,axis2=2)-engine.nclopt/(1j*omega-app.p)).sum().real
if app.task=='CP':
gx=lambda mu: quad(fx,0,np.float(np.inf),args=mu)[0]/nk/engine.nclopt/np.pi-app.cf
mu=broyden2(gx,app.options.pop('x0',0.0),**app.options)
engine.log<<'mu(error): %s(%s)\n'%(mu,gx(mu))
if app.returndata: return mu
else:
rquad=quad(fx,0,np.float(np.inf),args=app.cf,full_output=2)
filling=rquad[0]/nk/engine.nclopt/np.pi
engine.log<<'Filling factor(mu=%s,err=%.2e,neval=%s): %s\n'%(HP.decimaltostr(app.cf),rquad[1],rquad[2]['neval'],filling)
if app.returndata: return filling
def __solver__(self, p):
p.xk = p.x0.copy()
p.fk = asfarray(max(abs(p.f(p.x0)))).flatten()
p.iterfcn()
if p.istop:
p.xf, p.ff = p.xk, p.fk
return
try: xf = broyden2(p.f, p.x0, iter = p.maxIter)
except:
p.istop = -1000
return
p.xk = p.xf = asfarray(xf)
p.fk = p.ff = asfarray(max(abs(p.f(xf)))).flatten()
p.istop = 1000
p.iterfcn()
def _get_damage( self ):
ff = time.clock()
if self.w == 0.:
damage = np.zeros_like( self.sorted_depsf )
else:
ff = t.clock()
try:
damage = broyden2( self.damage_residuum, 0.2 * np.ones_like( self.sorted_depsf ) * ( self.sorted_lf < 0 ), iter = 20 ) # maxiter = 20 , )
except:
print 'broyden2 does not converge fast enough: switched to fsolve for this step'
damage = fsolve( self.damage_residuum, 0.2 * np.ones_like( self.sorted_depsf ) * ( self.sorted_lf < 0 ) )
cont_fibers = self.sorted_lf < 0
dam_cont = np.sum( damage[cont_fibers] )
num_cont = np.sum( cont_fibers )
if num_cont > 0:
print 'damage of continiuos fibers =', dam_cont / num_cont ,
print'iteration time =', time.clock() - ff, 'sec'
return damage
def __solver__(self, p):
p.xk = p.x0.copy()
p.fk = asfarray(max(abs(p.f(p.x0)))).flatten()
p.iterfcn()
if p.istop:
p.xf, p.ff = p.xk, p.fk
return
try:
xf = broyden2(p.f, p.x0, iter=p.maxIter)
except:
p.istop = -1000
return
p.xk = p.xf = asfarray(xf)
p.fk = p.ff = asfarray(max(abs(p.f(xf)))).flatten()
p.istop = 1000
p.iterfcn()
def iterate(self,kspace=None,tol=10**-6,maxiter=200):
'''
Iterate the SCMF to get converged order parameters.
Parameters
----------
kspace : BaseSpace, optional
The Brillouin zone of the system.
tol : float, optional
The tolerance of the order parameter.
maxiter : int, optional
The maximum times of the iteration.
'''
def gx(values):
for op,value in zip(self.ops.values(),values):
op.value=value
self.opsupdate(kspace)
return array([self.ops[key].value for key in self.ops.keys()])-values
with self.timers.get('Iteration'):
x0=array([self.ops[key].value for key in self.ops.keys()])
ops=broyden2(gx,x0,verbose=True,reduction_method='svd',maxiter=maxiter,x_tol=tol)
self.log<<'Order parameters:\n%s\n'%Sheet.fromordereddict(OrderedDict([(name,op) for name,op in zip(self.ops.keys(),ops)]))
self.log<<'Iterate: time consumed %ss.\n\n'%self.timers.time('Iteration')
def aplicarMetodosNL(f, x, y):
try:
print("Resultado con la funcion fsolve = {}".format(
optimize.fsolve(f, [x, y], xtol=10**(-6))))
except Exception as e:
print("El metodo fsolve no converge")
try:
print("Resultado mediante el metodo de Newton-Krylov = {}".format(
optimize.newton_krylov(f, [x, y], x_tol=10**(-6))))
except Exception as e:
print("El metodo de Newton-Krylov no converge")
try:
print("Resultado mediante el metodo de Broyden 1 = {}".format(
optimize.broyden1(f, [x, y], x_tol=2**(-16))))
except Exception as e:
print("El metodo de Broyden 1 no converge")
try:
print("Resultado mediante el metodo de Broyden 2 = {}".format(
optimize.broyden2(f, [x, y], x_tol=2**(-50))))
except Exception as e:
print("El metodo de Broyden 2 no converge")
def test2():
compound1 = compoundfromformula("C18H30O2", 0.9291, name="linseedoil")
compound2 = compoundfromformula("Pb3C2O8H2", 6.8, name="hydrocerussite")
m = mixture([compound1, compound2], [0.5, 0.5], fraction.volume)
mu = m.mass_att_coeff(35.0)
# 60% transmission
T = 0.6
# flat sample
thickness = -np.log(T) / (mu * m.density) # cm
# capillary
# R = 30e-4 # cm
# packing = optimize.broyden2(capillary_refine2(mu,m.density,T,R),0.7)
packing = 1.0
R = optimize.broyden2(capillary_refine(mu, m.density, T, packing),
[80e-4])[0] # cm
# 1-3 ug
mass = 1 * 1e-6 # g
volume = mass / m.density # cm^3
print "Mixture:"
print "density = {} g/cm^3".format(m.density)
print "mass.att. = {} cm^2/g".format(mu)
print "\nCapillary:"
print "R = {} um".format(R * 1e4)
print "packing = {} %".format(packing * 100)
print "h = {} mm (@ total mass = {} ug)".format(
volume / (np.pi * R * R) * 10, mass * 1e6)
print "\nFlat sample:"
print "thickness = {} um".format(thickness * 1e4)
print "footprint = {} mm^2 (@ total mass = {} ug)".format(
volume / thickness * 1e4, mass * 1e6)
ax.plot(sol[0], sol[1], 'r*', markersize=15)
ax.plot(x_guess[0], x_guess[1], 'ko')
ax.annotate("",
xy=(sol[0], sol[1]),
xytext=(x_guess[0], x_guess[1]),
arrowprops=dict(arrowstyle="->", linewidth=2.5))
ax.legend(loc=0)
ax.set_xlabel(r'$x$', fontsize=18)
fig.tight_layout()
fig.savefig('ch5-nonlinear-system.pdf')
# In[79]:
optimize.broyden2(f, x_guesses[1])
# In[80]:
def f(x):
return [x[1] - x[0]**3 - 2 * x[0]**2 + 1, x[1] + x[0]**2 - 1]
x = np.linspace(-3, 2, 5000)
y1 = x**3 + 2 * x**2 - 1
y2 = -x**2 + 1
fig, ax = plt.subplots(figsize=(8, 4))
ax.plot(x, y1, 'k', lw=1.5, label=r'$y = x^3 + 2x^2 - 1$')
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Tue Jun 29 15:55:58 2021
@author: shrohanmohapatra
"""
from scipy.optimize import broyden2
def paretoZeroFinder(x):
return 5**(1 + 1 / x) - x / (x - 1)
print(broyden2(paretoZeroFinder, 0.54, 2500))
print(paretoZeroFinder(1.04477526717764))
def sichel_estimator(sequence=None, attributes=None, cache=None):
"""
Implementation of Sichel’s Parametric Estimator (Sichel 1986a, 1986b and 1992)
which uses a zero-truncated generalized inverse Gaussian-Poisson to estimate D
implementation uses broyden 2 to solve and search linear space for good solution
:param sequence: sample sequence of integers
:type sequence: array of ints
:param attributes: dictionary with keys as the unique elements and values as
counts of those elements
:type attributes: dictionary where keys can be any type, values must be integers
:param cache: argument used by median methods to avoid recomputation of variables
:type cache: dictionary with 4 elements
{"n":no_elements,"d":no_unique_elements,"attr": attribute_counts,
"freq":frequency_dictionary}
:return: estimated distinct count
:rtype: float
"""
if not (sequence is not None or attributes or cache):
raise Exception(
"Must provide a sequence, or a dictionary of attribute counts ")
if cache is not None:
n, d, frequency_dictionary = cache["n"], cache["d"], cache["freq"]
elif sequence is not None:
n, d, _, frequency_dictionary = precompute_from_seq(sequence)
else:
n, d, _, frequency_dictionary = precompute_from_attr(attributes)
if n == d:
return _compute_birthday_problem_probability(d)
f1 = frequency_dictionary[1]
a = ((2 * n) / d) - np.log(n / f1) # does not depend on g
b = ((2 * f1) / d) + np.log(n / f1) # does not depend on g
def diff_eqn(g):
result = (1 + g) * np.log(g) - a * g + b
return result
d_sichel_set = set()
warnings.filterwarnings('ignore')
for value in np.linspace((f1 / n) + 0.00001, 0.999999, 20):
try:
g = broyden2(diff_eqn, value)
if 1 > g > (f1 / n) and ((n * g) / f1) > 0:
b_hat = g * np.log((n * g) / f1) / (1 - g)
c_hat = (1 - g**2) / (n * (g**2))
d_sichel = 2 / (b_hat * c_hat)
d_sichel_set.add(d_sichel)
except Exception as e:
continue
warnings.resetwarnings()
if not d_sichel_set:
return d
else:
return min(d_sichel_set)
def method_of_moments_v2_estimator(sequence=None,
attributes=None,
pop_estimator=lambda x: x * 1000000,
n_pop=None,
cache=None):
"""
Method-of-Moments Estimator with equal frequency assumption while still sampling
from a finite relation (Haas et al, 1995)
:param sequence: sample sequence of integers
:type sequence: array of ints
:param attributes: dictionary with keys as the unique elements and values as
counts of those elements
:type attributes: dictionary where keys can be any type, values must be integers
:param cache: argument used by median methods to avoid recomputation of variables
:type cache: dictionary with 4 elements
{"n":no_elements,"d":no_unique_elements,"attr": attribute_counts,
"freq":frequency_dictionary}
:param pop_estimator: function to estimate population size if possible
:type pop_estimator: function that takes in the length of sequence (int) and outputs
the estimated population size (int)
:param n_pop: estimate of population size if available, will be used over pop_estimator function
:type n_pop: int
:return: estimated distinct count
:rtype: float
"""
if sequence is None and attributes is None and cache is None:
raise Exception(
"Must provide a sequence, or a dictionary of attribute counts ")
if cache is not None:
n, d, attribute_counts = cache["n"], cache["d"], cache["attr"]
elif sequence is not None:
n, d, attribute_counts, _ = precompute_from_seq(sequence)
else:
n, d, attribute_counts, _ = precompute_from_attr(attributes)
if n == d:
return _compute_birthday_problem_probability(d)
if not n_pop:
n_pop = pop_estimator(n)
# need to implement gamma memoized function and h_x again here to enable use of global variables in broydens
memo_dict = {}
def memoized_gamma(x):
"""
:param x:value to evaluate gamma function at
:type x: float
:param memo_dict: memoized dictionary for precomputed gamma values
:type memo_dict: dict
:return: value of gamma function evaluated at x, and memoized results
:rtype: int, dict
"""
x = int(x)
if x in memo_dict:
return memo_dict[x]
else:
result = math.lgamma(x)
memo_dict[x] = result
return result
def h_x(x, n, n_pop):
"""
:param x: h function evaluated at point x
:type x: int
:param n: length of sequence seen
:type n: int
:param n_pop: estimate of total number of tuples in Relation
:type n_pop: int
:return: value of h function evaluated at x
:rtype: float
"""
gamma_num_1 = memoized_gamma(n_pop - x + 1)
gamma_num_2 = memoized_gamma(n_pop - n + 1)
gamma_denom_1 = memoized_gamma(n_pop - x - n + 1)
gamma_denom_2 = memoized_gamma(n_pop + 1)
result = np.exp(gamma_num_1 + gamma_num_2 - gamma_denom_1 -
gamma_denom_2)
return result
def diff_eqn(D):
return D * (1 - h_x((n_pop / D), n, n_pop)) - d
warnings.filterwarnings('ignore')
try:
d_moments_1 = float(broyden1(diff_eqn, d))
except Exception as e:
d_moments_1 = 1000000000000000000000000
try:
d_moments_2 = float(broyden2(diff_eqn, d))
except:
d_moments_2 = 1000000000000000000000000
warnings.resetwarnings()
result = min(d_moments_1, d_moments_2)
if result == 1000000000000000000000000:
return d
else:
return result
def loop_fit(indirizzo, lim_current_inf, sup_current):
data= genfromtxt(indirizzo)
ydata = data[:,1]
xdata = data[:,0]
sigmay = 0.05
sigmax = 0.0003
p0lin = [2]
p0exp = [2, 0.005, 20]
#g_0, pcov_lin = optimize.curve_fit(linfit, xdata[:argmax(ydata>=lim_current_inf)], ydata[:argmax(ydata>=lim_current_inf)], p0lin, sigmay)
g_0, pcov_lin = optimize.curve_fit(linexp, xdata[:argmax(ydata>=lim_current_inf)], ydata[:argmax(ydata>=lim_current_inf)], p0exp, sigmay)
g_0 = g_0[0]
pcov_lin = pcov_lin[0][0]
g_var = sqrt(pcov_lin)
#print('g0: ', g_0, '+-', g_var[0][0])
p0_loop = [20, 0.005, 2]
val_g = False
val_B = False
val_is = False
val_Rs = False
j = 0
while val_g==False or val_B==False or val_is==False or val_Rs==False:
#print(val_g==False & val_B==False & val_is==False & val_Rs==False)
#step 2:
jun_cur = ydata - g_0*xdata
#step 3:
p_loop, pcov_loop = optimize.curve_fit(tension_junc, abs(jun_cur[argmax(jun_cur>=sup_current):]), xdata[argmax(jun_cur>=sup_current):], p0_loop, sigmax)
#p_loop, pcov_loop = optimize.curve_fit(tension_junc, abs(jun_cur), xdata, p0_loop, sigmax)
loop_var = sqrt(pcov_loop.diagonal())
#step 4:
zero_func = lambda x: tension_junc_abs(x, p_loop[1], p_loop[0], p_loop[2])
#jun_cur_1 = optimize.fsolve(fitsolve, jun_cur, (p_loop[1], p_loop[0], p_loop[2], xdata) )
jun_cur_1 = optimize.broyden1(zero_func, jun_cur)
jun_cur_10 = optimize.broyden2(zero_func, jun_cur[100], x_rtol=1)
print(len(jun_cur_1), len(xdata))
#step 5:
tot_cur = g_0*xdata + jun_cur_1
print(len(tot_cur[:argmax(tot_cur>=1000)]))
print(jun_cur_10)
#step 6:
delta_g, delta_g_pcov = optimize.curve_fit(linfit, xdata[:argmax(tot_cur>=lim_current_inf)], ydata[:argmax(tot_cur>=lim_current_inf)]-tot_cur[:argmax(tot_cur>=lim_current_inf)], g_0, sigmay)
g_1 = g_0 + delta_g
#check della convergenza
if abs(g_1 - g_0) <= abs(delta_g):
val_g = True
elif abs(g_1 - g_0) <= 10**(-6):
val_g = True
if abs(p_loop[0] - p0_loop[0]) <= abs(loop_var[0]):
val_B = True
#print(val_B)
#print(abs(p_loop[0] - p0_loop[0]) - abs(loop_var[0]))
if abs(p_loop[1] - p0_loop[1]) <= abs(loop_var[1])/100:
val_is = True
if abs(p_loop[2] - p0_loop[2]) <= abs(loop_var[2])/100:
val_Rs = True
print(val_g, val_B, val_is, val_Rs)
#ridefinizione delle variabili
print('B: ', p_loop[0], '+-', loop_var[0], ' I_s: ', p_loop[1], '+-', loop_var[1], ' R_s: ', p_loop[2], '+-', loop_var[2], 'G:', g_1[0], '+-', delta_g[0])
deltaIj = jun_cur_1 - jun_cur
g_0 = g_1
p0_loop = p_loop
j = j +1
#print(j)
#plot(xdata, ydata-tot_cur)
#show()
grid()
yscale('log')
rc('font', size=16)
title(r"Caratteristica I-V T=%s° - fit"%(data[:,2][1]), size=14.5)
xlabel('Tensione V [V]')
ylabel(r'Corrente I [$\mu $ A]')
ylim(0.02, 10000)
lim_err = 2300
plot(xdata, current_v(xdata, p_loop[1], p_loop[0], p_loop[2]*10**(-6), jun_cur_1, g_0), color='blue', linewidth = 1.5)
errorbar(xdata[:argmax(ydata>=lim_err)], current_v(xdata, p_loop[1], p_loop[0], p_loop[2]*10**(-6), jun_cur_1, g_0)[:argmax(ydata>=lim_err)], prop_error(xdata,sigmax,p_loop[1],loop_var[1],p_loop[0],loop_var[0], p_loop[2], loop_var[2],g_1[0],delta_g[0],jun_cur_1,deltaIj)[:argmax(ydata>=lim_err)], sigmax, linestyle='None', color="blue")
errorbar(xdata, ydata, sigmay, sigmax, linestyle='None', marker='o', markersize=1, color="red")
B = r'B: $ %s \pm %s \, [V^{-1}] $'%(round(p_loop[0], 2), round(loop_var[0], 2))
I_s = r'$I_{S}$: $ %s \pm %s \, [nA] $'%(round(p_loop[1]*10**3, 2), round(loop_var[1]*10**3, 2))
R_s = r'$R_{S}$: $ %s \pm %s \, [\Omega] $'%(round(p_loop[2], 2), round(loop_var[2], 2))
G = r'G: $ %s \pm %s \, [\mu S]$ '%(round(g_1[0], 2), round(delta_g[0], 2))
text(0.45, 10, B, family='serif', style='italic', size=15)
text(0.45, 3, I_s, family='serif', style='italic', size=15)
text(0.45, 1, R_s, family='serif', style='italic', size=15)
text(0.45, 0.3, G, family='serif', style='italic', size=15)
#savefig('%s.png'%(indirizzo), dpi=400)
show()
def root(fun, x0, args=(), method='hybr', jac=None, tol=None, callback=None, options=None): x = opt.broyden2(fun, x0, f_tol=tol, callback=callback) return sol(x, True)
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Tue Jun 29 12:48:33 2021
@author: shrohanmohapatra
"""
from scipy.optimize import broyden2
def paretoZeroFinder(x):
return ((x - 1) / (x - 0.8))**x - 0.2
# print(newton_krylov(paretoZeroFinder,7.21))
print(paretoZeroFinder(1.9484046685235312))
print(broyden2(paretoZeroFinder, 1.95, 1000))
print(paretoZeroFinder(1.0556605455704873))
