def init_session(ipython=None, pretty_print=True, order=None,
        use_unicode=None, quiet=False, argv=[]):
    """Initialize an embedded IPython or Python session. """
    import sys

    in_ipython = False

    if ipython is False:
        ip = _init_python_session()
        mainloop = ip.interact
    else:
        try:
            import IPython
        except ImportError:
            if ipython is not True:
                if not quiet:
                    print no_ipython
                ip = _init_python_session()
                mainloop = ip.interact
            else:
                raise RuntimeError("IPython is not available on this system")
        else:
            ipython = True
            if IPython.__version__ >= '0.11':
                try:
                    ip = get_ipython()
                except NameError:
                    ip = None
            else:
                ip = IPython.ipapi.get()
                if ip:
                    ip = ip.IP

            if ip is not None:
                in_ipython = True
            else:
                ip = _init_ipython_session(argv)

            if IPython.__version__ >= '0.11':
                # runsource is gone, use run_cell instead, which doesn't
                # take a symbol arg.  The second arg is `store_history`,
                # and False means don't add the line to IPython's history.
                ip.runsource = lambda src, symbol='exec': ip.run_cell(src, False)
                mainloop = ip.mainloop
            else:
                mainloop = ip.interact

    _preexec_source = preexec_source

    ip.runsource(_preexec_source, symbol='exec')
    init_printing(pretty_print=pretty_print, order=order, use_unicode=use_unicode, ip=ip)

    message = _make_message(ipython, quiet, _preexec_source)

    if not in_ipython:
        mainloop(message)
        sys.exit('Exiting ...')
    else:
        ip.write(message)
        ip.set_hook('shutdown_hook', lambda ip: ip.write("Exiting ...\n"))

def load_ipython_extension(ip):
    """Load the extension in IPython."""
    # Since Python filters deprecation warnings by default,
    # we add a filter to make sure this message will be shown.
    warnings.simplefilter("once", SymPyDeprecationWarning)
    SymPyDeprecationWarning(
        feature="using %load_ext sympy.interactive.ipythonprinting",
        useinstead="from sympy import init_printing ; init_printing()",
        deprecated_since_version="0.7.3",
        issue=3914
    ).warn()
    init_printing(ip=ip)

def load_ipython_extension(ip):
    """Load the extension in IPython."""
    import IPython

    global _loaded
    # Use extension manager to track loaded status if available
    # This is currently in IPython 0.14.dev
    if hasattr(ip.extension_manager, 'loaded'):
        loaded = 'sympy.interactive.ipythonprinting' not in ip.extension_manager.loaded
    else:
        loaded = _loaded

    if not loaded:
        init_printing(ip=ip)
        _loaded = True

def init_session(ipython=None, pretty_print=True, order=None,
        use_unicode=None, quiet=False, keep_sign=False, argv=[]):
    """Initialize an embedded IPython or Python session. """
    import sys

    in_ipython = False

    if ipython is False:
        ip = _init_python_session()
    else:
        try:
            import IPython
        except ImportError:
            if ipython is not True:
                print no_ipython
                ip = _init_python_session()
            else:
                raise RuntimeError("IPython is not available on this system")
        else:
            ip = IPython.ipapi.get()
            ipython = True

            if ip is not None:
                ip, in_ipython = ip.IP, True
            else:
                ip = _init_ipython_session(argv)

    _preexec_source = preexec_source

    if keep_sign:
        _preexec_source += "Basic.keep_sign = True\n"

    ip.runsource(_preexec_source, symbol='exec')
    init_printing(pretty_print=pretty_print, order=order, use_unicode=use_unicode)

    message = _make_message(ipython, quiet, _preexec_source)

    if not in_ipython:
        ip.interact(message)
        sys.exit('Exiting ...')
    else:
        ip.write(message)
        ip.set_hook('shutdown_hook', lambda ip: ip.write("Exiting ...\n"))

def init_vprinting(**kwargs):
    """Initializes time derivative printing for all SymPy objects, i.e. any
    functions of time will be displayed in a more compact notation. The main
    benefit of this is for printing of time derivatives; instead of
    displaying as ``Derivative(f(t),t)``, it will display ``f'``. This is
    only actually needed for when derivatives are present and are not in a
    physics.vector.Vector or physics.vector.Dyadic object. This function is a
    light wrapper to `sympy.interactive.init_printing`. Any keyword
    arguments for it are valid here.

    {0}

    Examples
    ========

    >>> from sympy import Function, symbols
    >>> from sympy.physics.vector import init_vprinting
    >>> t, x = symbols('t, x')
    >>> omega = Function('omega')
    >>> omega(x).diff()
    Derivative(omega(x), x)
    >>> omega(t).diff()
    Derivative(omega(t), t)

    Now use the string printer:

    >>> init_vprinting(pretty_print=False)
    >>> omega(x).diff()
    Derivative(omega(x), x)
    >>> omega(t).diff()
    omega'

    """
    kwargs['str_printer'] = vsstrrepr
    kwargs['pretty_printer'] = vpprint
    kwargs['latex_printer'] = vlatex
    init_printing(**kwargs)

from __future__ import division
from sympy.interactive import printing

printing.init_printing(use_latex="mathjax")


from IPython.display import display, Image, Latex
import numpy as np
import math
import scipy.constants as sc

import sympy as sym

# from sympy import *


class FlatPlate(object):
    """ Definition of boundary layer thickness, friction coefficient, Nusselt number (both local and average)
        as a function of the regime.
        import HT_external_convection_flat_plate.py as flatplate
        
        bl =flatplate.FlatPlate(regime,thermal_bc,U_infty,nu,alpha_f,L,xi,Re_xc)
        where 
        regime = 'laminar' or 'turbulent' or 'mixed', 
        thermal_bc = 'isothermal', 'heat flux', 'unheated starting length',
        U_infty is the free stream velocity,
        nu the fluid viscosity,
        alpha the fluid thermal diffusivity,
        L length of the plate
        xi unheated started length
        Re_xc critical Reynolds number for transition laminar to turbulence

def init_session(ipython=None, pretty_print=True, order=None,
        use_unicode=None, quiet=False, auto_symbols=False, auto_int_to_Integer=False, argv=[]):
    """
    Initialize an embedded IPython or Python session. The IPython session is
    initiated with the --pylab option, without the numpy imports, so that
    matplotlib plotting can be interactive.

    Parameters
    ==========

    pretty_print: boolean
        If True, use pretty_print to stringify;
        if False, use sstrrepr to stringify.
    order: string or None
        There are a few different settings for this parameter:
        lex (default), which is lexographic order;
        grlex, which is graded lexographic order;
        grevlex, which is reversed graded lexographic order;
        old, which is used for compatibility reasons and for long expressions;
        None, which sets it to lex.
    use_unicode: boolean or None
        If True, use unicode characters;
        if False, do not use unicode characters.
    quiet: boolean
        If True, init_session will not print messages regarding its status;
        if False, init_session will print messages regarding its status.
    auto_symbols: boolean
        If True, IPython will automatically create symbols for you.
        If False, it will not.
        The default is False.
    auto_int_to_Integer: boolean
        If True, IPython will automatically wrap int literals with Integer, so
        that things like 1/2 give Rational(1, 2).
        If False, it will not.
        The default is False.
    ipython: boolean or None
        If True, printing will initialize for an IPython console;
        if False, printing will initialize for a normal console;
        The default is None, which does what False does.
    argv: list of arguments for IPython
        See sympy.bin.isympy for options that can be used to initialize IPython.

    See Also
    ========

    sympy.interactive.printing.init_printing: for examples and the rest of the parameters.


    Examples
    ========

    >>> from sympy import init_session, Symbol, sin, sqrt
    >>> sin(x) #doctest: +SKIP
    NameError: name 'x' is not defined
    >>> init_session() #doctest: +SKIP
    >>> sin(x) #doctest: +SKIP
    sin(x)
    >>> sqrt(5) #doctest: +SKIP
      ___
    \/ 5
    >>> init_session(pretty_print=False) #doctest: +SKIP
    >>> sqrt(5) #doctest: +SKIP
    sqrt(5)
    >>> y + x + y**2 + x**2 #doctest: +SKIP
    x**2 + x + y**2 + y
    >>> init_session(order='grlex') #doctest: +SKIP
    >>> y + x + y**2 + x**2 #doctest: +SKIP
    x**2 + y**2 + x + y
    >>> init_session(order='grevlex') #doctest: +SKIP
    >>> y * x**2 + x * y**2 #doctest: +SKIP
    x**2*y + x*y**2
    >>> init_session(order='old') #doctest: +SKIP
    >>> x**2 + y**2 + x + y #doctest: +SKIP
    x + y + x**2 + y**2
    >>> theta = Symbol('theta') #doctest: +SKIP
    >>> theta #doctest: +SKIP
    theta
    >>> init_session(use_unicode=True) #doctest: +SKIP
    >>> theta # doctest: +SKIP
    \u03b8
    """
    import sys

    in_ipython = False

    if ipython is False:
        ip = init_python_session()
        mainloop = ip.interact
    else:
        try:
            import IPython
        except ImportError:
            if ipython is not True:
                if not quiet:
                    print no_ipython
                ip = init_python_session()
                mainloop = ip.interact
            else:
                raise RuntimeError("IPython is not available on this system")
        else:
#.........这里部分代码省略.........

import sympy as s
from sympy.interactive.printing import init_printing
from sympy.matrices import Matrix
import numpy as np

init_printing(use_unicode=False, wrap_line=False, no_global=True)

# In [1]: %load_ext autoreload
#
# In [2]: %autoreload 2

class GradientDescentState(object):
    """holds the state for gradient descent"""

    def __init__(self, size, symbols, fn, initalGuess, grad):
        self.numberOfVariables = size
        self.x = symbols
        self.fn = fn
        self.initalGuess = initalGuess
        self.grad = grad

        self.currentIterValue = Matrix(initalGuess)

    # compute the gradient at point
    def atPoint(self, subs):
        if len(subs) != self.numberOfVariables:
            raise Exception('airity mismatch: atPoint')

        res = self.grad
        for idx in range(0, self.numberOfVariables):
            res = res.subs(self.x[idx], subs[idx]);

def load_ipython_extension(ip):
    """Load the extension in IPython."""
    init_printing(ip=ip)

"""Tools for setting up interactive sessions. """

from __future__ import print_function, division

from sympy.external import import_module
from sympy.interactive.printing import init_printing

preexec_source = """\
from __future__ import division
from sympy import *
x, y, z, t = symbols('x y z t')
k, m, n = symbols('k m n', integer=True)
f, g, h = symbols('f g h', cls=Function)
init_printing()
"""

verbose_message = """\
These commands were executed:
%(source)s
Documentation can be found at http://www.sympy.org
"""

no_ipython = """\
Couldn't locate IPython. Having IPython installed is greatly recommended.
See http://ipython.scipy.org for more details. If you use Debian/Ubuntu,
just install the 'ipython' package and start isympy again.
"""


def _make_message(ipython=True, quiet=False, source=None):
    """Create a banner for an interactive session. """

def calculate_Integral(expression,var1,var2,var3,varSup1,varSup2,varSup3,varInf1,varInf2,varInf3,\
                       typeIntegral,numDimensions,numColumns,\
                       showIntegral,showTime,numDigText,numerTypeIntegral,simplifyResult,outputResult):
    global nonCalculatedIntegral, nonCalculatedIntegralOutput, resultIntegral, resultIntegralSimp, resultOutput, timeIntegral

    init_printing(use_unicode=True, num_columns=numColumns)
    timet1=time.time()

    integrand = expression
    diffvar1 = var1.strip()
    diffvar2 = var2.strip()
    diffvar3 = var3.strip()
    limSup1 = varSup1.strip()
    limSup2 = varSup2.strip()
    limSup3 = varSup3.strip()
    limInf1 = varInf1.strip()
    limInf2 = varInf2.strip()
    limInf3 = varInf3.strip()

    integrateExpr = '('+integrand+','
    if typeIntegral == integralType['indefinite']:
        integrateExpr += diffvar1
        if numDimensions > 1:
            integrateExpr += ','+diffvar2
        if numDimensions > 2:
            integrateExpr += ','+diffvar3
        integrateExpr += ')'
        try:
            nonCalculatedIntegral = sympify('Integral'+integrateExpr)
        except:
            nonCalculatedIntegral = 'Integral'+integrateExpr
        try:
            resultIntegral = sympify('integrate'+integrateExpr)
        except:
            resultIntegral = integralErrorMessage
    else:
        integrateExpr += '('+diffvar1+','+limInf1+','+limSup1+')'
        if numDimensions > 1:
            integrateExpr += ',('+diffvar2+','+limInf2+','+limSup2+')'
        if numDimensions > 2:
            integrateExpr += ',('+diffvar3+','+limInf3+','+limSup3+')'
        integrateExpr += ')'
        try:
            nonCalculatedIntegral = sympify('Integral'+integrateExpr)
        except:
            nonCalculatedIntegral = 'Integral'+integrateExpr
        if typeIntegral == integralType['definite']:
            try:
                resultIntegral = sympify('integrate'+integrateExpr)
            except:
                resultIntegral = integralErrorMessage
        else:
            if numerTypeIntegral == numerIntegralType['approx']:
                try:
                    resultIntegral = sympify('N(integrate'+integrateExpr+','+numDigText+')')
                except:
                    resultIntegral = integralErrorMessage
            else:
                mp.dps=int(numDigText)
                integrateExpr = "(lambda "
                if numDimensions > 2:
                    integrateExpr += diffvar3+","
                if numDimensions > 1:
                    integrateExpr += diffvar2+","
                integrand = fixMPMathText(integrand)
                integrateExpr += diffvar1+": "+integrand
                if numDimensions > 2:
                    limInf3 = fixMPMathText(limInf3)
                    limSup3 = fixMPMathText(limSup3)
                    integrateExpr += ',['+limInf3+','+limSup3+']'
                if numDimensions > 1:
                    limInf2 = fixMPMathText(limInf2)
                    limSup2 = fixMPMathText(limSup2)
                    integrateExpr += ',['+limInf2+','+limSup2+']'
                limInf1 = fixMPMathText(limInf1)
                limSup1 = fixMPMathText(limSup1)
                integrateExpr += ",["+limInf1+","+limSup1+"])"
                try:
                    if numerTypeIntegral == numerIntegralType['infinities']:
                        resultIntegral = eval("quadts"+integrateExpr)
                    else:
                        resultIntegral = eval("quadgl"+integrateExpr)
                    resultIntegral = sympify('N('+fixMPMathOutput(str(resultIntegral))+','+numDigText+')')
                except:
                    resultIntegral = integralNumerErrorMessage

    if (resultIntegral) and (type(resultIntegral) != str) and (typeIntegral != integralType['numerical']):
        if simplifyResult == simplifyType['none']:
            resultIntegralSimp = sympify(resultIntegral)
        elif simplifyResult == simplifyType['expandterms']:
            resultIntegralSimp = sympify(mapexpr(resultIntegral,expand))
        elif simplifyResult == simplifyType['simplifyterms']:
            resultIntegralSimp = sympify(mapexpr(resultIntegral,simplify))
        elif simplifyResult == simplifyType['expandall']:
            resultIntegralSimp = sympify(expand(resultIntegral))
        elif simplifyResult == simplifyType['simplifyall']:
            resultIntegralSimp = sympify(simplify(resultIntegral))
    else:
        resultIntegralSimp = resultIntegral

#.........这里部分代码省略.........

def init_session(ipython=None, pretty_print=True, order=None,
        use_unicode=None, use_latex=None, quiet=False, auto_symbols=False,
        auto_int_to_Integer=False, str_printer=None, pretty_printer=None,
        latex_printer=None, argv=[]):
    """
    Initialize an embedded IPython or Python session. The IPython session is
    initiated with the --pylab option, without the numpy imports, so that
    matplotlib plotting can be interactive.

    Parameters
    ==========

    pretty_print: boolean
        If True, use pretty_print to stringify;
        if False, use sstrrepr to stringify.
    order: string or None
        There are a few different settings for this parameter:
        lex (default), which is lexographic order;
        grlex, which is graded lexographic order;
        grevlex, which is reversed graded lexographic order;
        old, which is used for compatibility reasons and for long expressions;
        None, which sets it to lex.
    use_unicode: boolean or None
        If True, use unicode characters;
        if False, do not use unicode characters.
    use_latex: boolean or None
        If True, use latex rendering if IPython GUI's;
        if False, do not use latex rendering.
    quiet: boolean
        If True, init_session will not print messages regarding its status;
        if False, init_session will print messages regarding its status.
    auto_symbols: boolean
        If True, IPython will automatically create symbols for you.
        If False, it will not.
        The default is False.
    auto_int_to_Integer: boolean
        If True, IPython will automatically wrap int literals with Integer, so
        that things like 1/2 give Rational(1, 2).
        If False, it will not.
        The default is False.
    ipython: boolean or None
        If True, printing will initialize for an IPython console;
        if False, printing will initialize for a normal console;
        The default is None, which automatically determines whether we are in
        an ipython instance or not.
    str_printer: function, optional, default=None
        A custom string printer function. This should mimic
        sympy.printing.sstrrepr().
    pretty_printer: function, optional, default=None
        A custom pretty printer. This should mimic sympy.printing.pretty().
    latex_printer: function, optional, default=None
        A custom LaTeX printer. This should mimic sympy.printing.latex()
        This should mimic sympy.printing.latex().
    argv: list of arguments for IPython
        See sympy.bin.isympy for options that can be used to initialize IPython.

    See Also
    ========

    sympy.interactive.printing.init_printing: for examples and the rest of the parameters.


    Examples
    ========

    >>> from sympy import init_session, Symbol, sin, sqrt
    >>> sin(x) #doctest: +SKIP
    NameError: name 'x' is not defined
    >>> init_session() #doctest: +SKIP
    >>> sin(x) #doctest: +SKIP
    sin(x)
    >>> sqrt(5) #doctest: +SKIP
      ___
    \/ 5
    >>> init_session(pretty_print=False) #doctest: +SKIP
    >>> sqrt(5) #doctest: +SKIP
    sqrt(5)
    >>> y + x + y**2 + x**2 #doctest: +SKIP
    x**2 + x + y**2 + y
    >>> init_session(order='grlex') #doctest: +SKIP
    >>> y + x + y**2 + x**2 #doctest: +SKIP
    x**2 + y**2 + x + y
    >>> init_session(order='grevlex') #doctest: +SKIP
    >>> y * x**2 + x * y**2 #doctest: +SKIP
    x**2*y + x*y**2
    >>> init_session(order='old') #doctest: +SKIP
    >>> x**2 + y**2 + x + y #doctest: +SKIP
    x + y + x**2 + y**2
    >>> theta = Symbol('theta') #doctest: +SKIP
    >>> theta #doctest: +SKIP
    theta
    >>> init_session(use_unicode=True) #doctest: +SKIP
    >>> theta # doctest: +SKIP
    \u03b8
    """
    import sys

    in_ipython = False

    if ipython is not False:
#.........这里部分代码省略.........

# -*- coding: utf-8 -*-
# <nbformat>3.0</nbformat>

# <codecell>

from IPython.display import display

from sympy.interactive import printing
printing.init_printing()

from __future__ import division
import sympy as sym
from sympy import *


import matplotlib
matplotlib.rc('font',**{'family':'serif'})

# <markdowncell>

# # Outline of the HTSE solution to second order

# <codecell>

z0, z, u, B, t , U= symbols(r"z_{0} z u \beta t U")
m=6.
grand = -sym.log( z0 ) / B - B * (t/z0)**2 * m * ( z + z**3 * u + 2*z**2 * (1-u) / (B*U))
grand

# <codecell>

def init_mprinting():
    init_printing(pretty_print=False, str_printer=mstr)

# coding: utf-8

# In[1]:

from sympy import *
from sympy.interactive.printing import init_printing
init_printing()


# In[2]:

from sympa import domath


# In[3]:

import pandas as pd


# In[4]:

df = pd.DataFrame({'x' : range(7)})
df['x'] = df.x * 10
df['y'] = df.x * 0.05
df['r'] = pi * df['y'] / 2
df


# In[5]:

def calculate_Derivative(expression,var1,numvar1,var2,numvar2,var3,numvar3,\
                         flagPortrait,showDerivative,showTime,numerApprox,numDigText,\
                         simplifyResult,outputResult):
    global nonCalculatedDerivative, nonCalculatedDerivativeOutput, resultDerivative, \
           resultDerivativeSimp, resultOutput, timeDerivative

    if flagPortrait:
        init_printing(use_unicode=True, num_columns=35)
    else:
        init_printing(use_unicode=True, num_columns=60)
    timet1=time.time()

    expressionDerivative = expression
    variable1Derivative = var1.strip()
    numVar1Derivative = numvar1.strip()
    if not numVar1Derivative:
        numVar1Derivative = '0'
    variable2Derivative = var2.strip()
    numVar2Derivative = numvar2.strip()
    if not numVar2Derivative:
        numVar2Derivative = '0'
    variable3Derivative = var3.strip()
    numVar3Derivative = numvar3.strip()
    if not numVar3Derivative:
        numVar3Derivative = '0'

    derivativeExpr = '('+expressionDerivative
    if variable1Derivative and (eval(numVar1Derivative) > 0):
        derivativeExpr += ','+variable1Derivative+','+numVar1Derivative
    if variable2Derivative and (eval(numVar2Derivative) > 0):
        derivativeExpr += ','+variable2Derivative+','+numVar2Derivative
    if variable3Derivative and (eval(numVar3Derivative) > 0):
        derivativeExpr += ','+variable3Derivative+','+numVar3Derivative
    derivativeExpr += u')'
    try:
        nonCalculatedDerivative = sympify('Derivative'+derivativeExpr)
    except:
        nonCalculatedDerivative = 'Derivative'+derivativeExpr
    try:
        if numerApprox:
            resultDerivative = sympify('N(diff'+derivativeExpr+','+numDigText+')')
        else:
            resultDerivative = sympify('diff'+derivativeExpr)
    except:
        resultDerivative = derivativeErrorMessage

    if (resultDerivative) and (type(resultDerivative) != str):
        if (simplifyResult == simplifyType['none']) or (numerApprox):
            resultDerivativeSimp = sympify(resultDerivative)
        elif simplifyResult == simplifyType['expandterms']:
            resultDerivativeSimp = sympify(mapexpr(resultDerivative,expand))
        elif simplifyResult == simplifyType['simplifyterms']:
            resultDerivativeSimp = sympify(mapexpr(resultDerivative,simplify))
        elif simplifyResult == simplifyType['expandall']:
            resultDerivativeSimp = sympify(expand(resultDerivative))
        elif simplifyResult == simplifyType['simplifyall']:
            resultDerivativeSimp = sympify(simplify(resultDerivative))
    else:
        resultDerivativeSimp = resultDerivative

    timet2=time.time()
    timeDerivative = timet2-timet1

    nonCalculatedDerivativeOutput = str(nonCalculatedDerivative)
    resultOutput = str(resultDerivativeSimp)
    if outputResult == outputType['bidimensional']:
        if (type(nonCalculatedDerivative) != str):
            nonCalculatedDerivativeOutput = fixUnicodeText(printing.pretty(nonCalculatedDerivative))
        if (type(resultDerivativeSimp) != str):
            resultOutput = fixUnicodeText(printing.pretty(resultDerivativeSimp))
    elif outputResult == outputType['latex']:
        if (type(nonCalculatedDerivative) != str):
            nonCalculatedDerivativeOutput = latex(nonCalculatedDerivative)
        if (type(resultDerivativeSimp) != str):
            resultOutput = latex(resultDerivativeSimp)
#    elif outputResult == outputType['mathml']:
#        if (type(nonCalculatedDerivative) != str):
#            nonCalculatedDerivativeOutput = str(mathml(nonCalculatedDerivative))
#        if (type(resultDerivativeSimp) != str):
#            resultOutput = str(print_mathml(resultDerivativeSimp))
    elif outputResult == outputType['c']:
        if (type(resultDerivativeSimp) != str):
            resultOutput = ccode(resultDerivativeSimp)
    elif outputResult == outputType['fortran']:
        if (type(resultDerivativeSimp) != str):
            resultOutput = fcode(resultDerivativeSimp)
    elif outputResult == outputType['javascript']:
        if (type(resultDerivativeSimp) != str):
            resultOutput = jscode(resultDerivativeSimp)
    elif outputResult == outputType['python']:
        if (type(resultDerivativeSimp) != str):
            resultOutput = python(resultDerivativeSimp)

    if showTime and (timeDerivative > 0.0):
        result = '<FONT COLOR="LightGreen">'+("Calculated after %f s :" % timeDerivative)+'</FONT><br>'
    else:
        result = u""
    if showDerivative and nonCalculatedDerivativeOutput:
        result += u'<FONT COLOR="LightBlue">'+(nonCalculatedDerivativeOutput.replace(' ','&nbsp;')).replace("\n","<br>")+'<br>=</FONT><br>'
    if (type(resultDerivativeSimp) != str):
#.........这里部分代码省略.........

def calculate_Limit(
    expression,
    variable,
    point,
    direction,
    flagPortrait,
    showLimit,
    showTime,
    numerApprox,
    numDigText,
    simplifyResult,
    outputResult,
):
    global nonCalculatedLimit, nonCalculatedLimitOutput, resultLimit, resultLimitSimp, resultOutput, timeLimit

    if flagPortrait:
        init_printing(use_unicode=True, num_columns=35)
    else:
        init_printing(use_unicode=True, num_columns=60)
    timet1 = time.time()

    expressionLimit = expression
    variableLimit = variable.strip()
    pointLimit = point.strip()
    limitExpr = u"(" + expressionLimit + u"," + variableLimit + u"," + pointLimit
    if direction != "Bilateral":
        limitExpr += u',dir="'
        if direction == "Left":
            limitExpr += u'-"'
        elif direction == "Right":
            limitExpr += u'+"'
    limitExpr += u")"

    if direction == "Bilateral":
        try:
            nonCalculatedLimit = sympify(u"Limit" + limitExpr)
        except:
            nonCalculatedLimit = u"Limit" + limitExpr
    else:
        # "Limit" has a bug not showing the "+" and "-" above the point value.
        nonCalculatedLimit = u"Limit" + limitExpr
    if direction == "Bilateral":
        try:
            if (sympify(u"limit" + limitExpr)) == (sympify(u"limit" + limitExpr[:-1] + u',dir="-")')):
                resultLimit = sympify(u"limit" + limitExpr)
            else:
                resultLimit = (
                    u"Bilateral limit does not exist because the limits from the left and right are different."
                )
        except:
            resultLimit = limitErrorMessage
    else:
        try:
            resultLimit = sympify(u"limit" + limitExpr)
        except:
            resultLimit = limitErrorMessage
    if (type(resultLimit) != str) and numerApprox:
        try:
            resultLimit = sympify("N(" + str(resultLimit) + "," + numDigText + ")")
        except:
            resultLimit = limitErrorMessage

    if (resultLimit) and (type(resultLimit) != str) and (not numerApprox):
        if simplifyResult == simplifyType["none"]:
            resultLimitSimp = sympify(resultLimit)
        elif simplifyResult == simplifyType["expandterms"]:
            resultLimitSimp = sympify(mapexpr(resultLimit, expand))
        elif simplifyResult == simplifyType["simplifyterms"]:
            resultLimitSimp = sympify(mapexpr(resultLimit, simplify))
        elif simplifyResult == simplifyType["expandall"]:
            resultLimitSimp = sympify(expand(resultLimit))
        elif simplifyResult == simplifyType["simplifyall"]:
            resultLimitSimp = sympify(simplify(resultLimit))
    else:
        resultLimitSimp = resultLimit

    timet2 = time.time()
    timeLimit = timet2 - timet1

    if direction == "Bilateral":
        nonCalculatedLimitOutput = fixUnicodeText(printing.pretty(nonCalculatedLimit))
    if type(resultLimitSimp) != str:
        resultOutput = fixUnicodeText(printing.pretty(resultLimitSimp))

    nonCalculatedLimitOutput = str(nonCalculatedLimit)
    resultOutput = str(resultLimitSimp)
    if outputResult == outputType["bidimensional"]:
        if (direction == "Bilateral") and (type(nonCalculatedLimit) != str):
            nonCalculatedLimitOutput = fixUnicodeText(printing.pretty(nonCalculatedLimit))
        if type(resultLimitSimp) != str:
            resultOutput = fixUnicodeText(printing.pretty(resultLimitSimp))
    elif outputResult == outputType["latex"]:
        if (direction == "Bilateral") and (type(nonCalculatedLimit) != str):
            nonCalculatedLimitOutput = latex(nonCalculatedLimit)
        if type(resultLimitSimp) != str:
            resultOutput = latex(resultLimitSimp)
    elif outputResult == outputType["c"]:
        if type(resultLimitSimp) != str:
            resultOutput = ccode(resultLimitSimp)
    elif outputResult == outputType["fortran"]:
#.........这里部分代码省略.........

""" Object name 1: FlatPlate
    Object name 2: CircularCylinder
    Object name 3: NoncircularCylinder
    Object name 4: BankofTubes
"""
from __future__ import division
from sympy.interactive import printing
printing.init_printing(use_latex='mathjax')


from IPython.display import display,Image, Latex
import numpy as np
import math
import scipy.constants as sc

import sympy as sym
#from sympy import *

class FlatPlate(object):
    """ Definition of boundary layer thickness, friction coefficient, Nusselt number (both local and average)
        as a function of the regime.
        import HT_external_convection.py as extconv
        
        bl =extconv.FlatPlate(regime,thermal_bc,U_infty,nu,alpha_f,L,xi,Re_xc)
        where 
        regime = 'laminar' or 'turbulent' or 'mixed', 
        thermal_bc = 'isothermal', 'heat flux', 'unheated starting length',
        U_infty is the free stream velocity,
        nu the fluid viscosity,
        alpha the fluid thermal diffusivity,
        L length of the plate

# coding: utf-8

# In[64]:

get_ipython().magic(u'matplotlib inline')
import matplotlib.pyplot as plt
import numpy as np
import mpld3
from IPython.display import Image
import numpy as np
from sympy.interactive import printing
printing.init_printing(use_latex=True)
Image(filename='afr_circuit.png')


# This code will compare simulation results for the Active Feedback Resonator (depicted above) with measurements.
# 
# The main output will be modeling the predicted behavior of the noise and snr vs Q in the case of coherent and incoherent noise.
# 
# Table of Contents:
# 
# [Theory](#theory)
# 
# [Simulations](#simulations)
# 
# [Measurements](#measurements)
# 
# [Comparison](#comparison)
# 
# [Literature Review](#literature)