// Partial derivative of Mu_h with respect to T; x and V held constant.
func dMu_hdT(env *tempAll.Environment) (float64, error) {
ct := 0
// F gets Mu_h given Beta
F := func(Beta float64) (float64, error) {
ct += 1
// save the environment state before changing it
// (don't want one call of F to affect the next)
oD1, oMu_h, oBeta, oMu_b := env.D1, env.Mu_h, env.Beta, env.Mu_b
env.Beta = Beta
// fix free variables
eps := 1e-9
_, err := D1MuF0Solve(env, eps, eps)
if err != nil {
return 0.0, err
}
Mu_h := env.Mu_h
// restore the environment
env.D1, env.Mu_h, env.Beta, env.Mu_b = oD1, oMu_h, oBeta, oMu_b
return Mu_h, nil
}
h := 1e-4
epsAbs := 1e-5
deriv, err := solve.OneDimDerivative(F, env.Beta, h, epsAbs)
//fmt.Println("MuT ct", ct)
return -math.Pow(env.Beta, 2.0) * deriv, err
}
// Partial derivative of F (some function of env) with respect to Mu_h;
// T and V held constant.
func dFdMu_h(env *tempAll.Environment, F envFunc) (float64, error) {
ct := 0
// G gets F given Mu_h (allow x to vary; constant Beta)
G := func(Mu_h float64) (float64, error) {
ct += 1
// save the environment state before changing it
// (don't want one call of F to affect the next)
oD1, oMu_h, oX, oMu_b := env.D1, env.Mu_h, env.X, env.Mu_b
env.Mu_h = Mu_h
// fix free variables2
eps := 1e-9
_, err := D1F0XSolve(env, eps, eps)
if err != nil {
return 0.0, err
}
vF, err := F(env)
if err != nil {
return 0.0, err
}
// restore the environment
env.D1, env.Mu_h, env.X, env.Mu_b = oD1, oMu_h, oX, oMu_b
return vF, nil
}
h := 1e-4
epsAbs := 1e-5
deriv, err := solve.OneDimDerivative(G, env.Mu_h, h, epsAbs)
//fmt.Println("dF_dMu ct", ct)
return deriv, err
}
// Partial derivative of F with respect to T; Mu_h and V held constant.
func dFdT(env *tempAll.Environment, F envFunc) (float64, error) {
ct := 0
// G gets F given Beta (allow x to vary; constant Mu_h)
G := func(Beta float64) (float64, error) {
ct += 1
// save the environment state before changing it
// (don't want one call of F to affect the next)
oD1, oBeta, oX, oMu_b := env.D1, env.Beta, env.X, env.Mu_b
env.Beta = Beta
// fix free variables
eps := 1e-9
_, err := SolveD1Mu_bX(env, eps, eps)
if err != nil {
return 0.0, err
}
vF, err := F(env)
if err != nil {
return 0.0, err
}
// restore the environment
env.D1, env.Beta, env.X, env.Mu_b = oD1, oBeta, oX, oMu_b
return vF, nil
}
h := 1e-4
epsAbs := 1e-5
deriv, err := solve.OneDimDerivative(G, env.Beta, h, epsAbs)
fmt.Println("dF_dT ct", ct)
return -math.Pow(env.Beta, 2.0) * deriv, err
}