from __future__ import (absolute_import, division, print_function)
import math


def nernst_potential(ion_conc_out, ion_conc_in, charge, T, constants=None, units=None):
    """
    Calculates the Nernst potential using the Nernst equation for a particular
    ion.

    Parameters
    ----------
    ion_conc_out: float with unit
        Extracellular concentration of ion
    ion_conc_in: float with unit
        Intracellular concentration of ion
    charge: integer
        Charge of the ion
    T: float with unit
        Absolute temperature
    constants: object (optional, default: None)
        constant attributes accessed:
            F - Faraday constant
            R - Ideal Gas constant
    units: object (optional, default: None)
        unit attributes: coulomb, joule, kelvin, mol

    Returns
    -------
    Membrane potential
    """
    if constants is None:
        F = 96485.33289
        R = 8.3144598
        if units is not None:
            F *= units.coulomb / units.mol
            R *= units.joule / units.kelvin / units.mol
    else:
        F = constants.Faraday_constant
        R = constants.ideal_gas_constant

    return (R * T) / (charge * F) * math.log(ion_conc_out / ion_conc_in)

from __future__ import (absolute_import, division, print_function)
import math


def nernst_potential(ion_conc_out, ion_conc_in, charge, T,
                     constants=None, units=None, backend=math):
    """
    Calculates the Nernst potential using the Nernst equation for a particular
    ion.

    Parameters
    ----------
    ion_conc_out: float with unit
        Extracellular concentration of ion
    ion_conc_in: float with unit
        Intracellular concentration of ion
    charge: integer
        Charge of the ion
    T: float with unit
        Absolute temperature
    constants: object (optional, default: None)
        constant attributes accessed:
            F - Faraday constant
            R - Ideal Gas constant
    units: object (optional, default: None)
        unit attributes: coulomb, joule, kelvin, mol
    backend: module (optional, default: math)
        module used to calculate log using `log` method, can be substituted
        with sympy to get symbolic answers

    Returns
    -------
    Membrane potential
    """
    if constants is None:
        F = 96485.33289
        R = 8.3144598
        if units is not None:
            F *= units.coulomb / units.mol
            R *= units.joule / units.kelvin / units.mol
    else:
        F = constants.Faraday_constant
        R = constants.ideal_gas_constant

    return (R * T) / (charge * F) * backend.log(ion_conc_out / ion_conc_in)

Add keyword arg for backend for log
Add keyword arg for backend for log

Can be used to switch out math module with other modules, ex. sympy for
symbolic answers

  from __future__ import (absolute_import, division, print_function)
  import math
  
  
- def nernst_potential(ion_conc_out, ion_conc_in, charge, T, constants=None, units=None):
+ def nernst_potential(ion_conc_out, ion_conc_in, charge, T,
+                      constants=None, units=None, backend=math):
      """
      Calculates the Nernst potential using the Nernst equation for a particular
      ion.
  
      Parameters
      ----------
      ion_conc_out: float with unit
          Extracellular concentration of ion
      ion_conc_in: float with unit
          Intracellular concentration of ion
      charge: integer
          Charge of the ion
      T: float with unit
          Absolute temperature
      constants: object (optional, default: None)
          constant attributes accessed:
              F - Faraday constant
              R - Ideal Gas constant
      units: object (optional, default: None)
          unit attributes: coulomb, joule, kelvin, mol
+     backend: module (optional, default: math)
+         module used to calculate log using `log` method, can be substituted
+         with sympy to get symbolic answers
  
      Returns
      -------
      Membrane potential
      """
      if constants is None:
          F = 96485.33289
          R = 8.3144598
          if units is not None:
              F *= units.coulomb / units.mol
              R *= units.joule / units.kelvin / units.mol
      else:
          F = constants.Faraday_constant
          R = constants.ideal_gas_constant
  
-     return (R * T) / (charge * F) * math.log(ion_conc_out / ion_conc_in)
+     return (R * T) / (charge * F) * backend.log(ion_conc_out / ion_conc_in)
  
Add keyword arg for backend for log
## Code Before:
from __future__ import (absolute_import, division, print_function)
import math


def nernst_potential(ion_conc_out, ion_conc_in, charge, T, constants=None, units=None):
    """
    Calculates the Nernst potential using the Nernst equation for a particular
    ion.

    Parameters
    ----------
    ion_conc_out: float with unit
        Extracellular concentration of ion
    ion_conc_in: float with unit
        Intracellular concentration of ion
    charge: integer
        Charge of the ion
    T: float with unit
        Absolute temperature
    constants: object (optional, default: None)
        constant attributes accessed:
            F - Faraday constant
            R - Ideal Gas constant
    units: object (optional, default: None)
        unit attributes: coulomb, joule, kelvin, mol

    Returns
    -------
    Membrane potential
    """
    if constants is None:
        F = 96485.33289
        R = 8.3144598
        if units is not None:
            F *= units.coulomb / units.mol
            R *= units.joule / units.kelvin / units.mol
    else:
        F = constants.Faraday_constant
        R = constants.ideal_gas_constant

    return (R * T) / (charge * F) * math.log(ion_conc_out / ion_conc_in)

## Instruction:
Add keyword arg for backend for log
## Code After:
from __future__ import (absolute_import, division, print_function)
import math


def nernst_potential(ion_conc_out, ion_conc_in, charge, T,
                     constants=None, units=None, backend=math):
    """
    Calculates the Nernst potential using the Nernst equation for a particular
    ion.

    Parameters
    ----------
    ion_conc_out: float with unit
        Extracellular concentration of ion
    ion_conc_in: float with unit
        Intracellular concentration of ion
    charge: integer
        Charge of the ion
    T: float with unit
        Absolute temperature
    constants: object (optional, default: None)
        constant attributes accessed:
            F - Faraday constant
            R - Ideal Gas constant
    units: object (optional, default: None)
        unit attributes: coulomb, joule, kelvin, mol
    backend: module (optional, default: math)
        module used to calculate log using `log` method, can be substituted
        with sympy to get symbolic answers

    Returns
    -------
    Membrane potential
    """
    if constants is None:
        F = 96485.33289
        R = 8.3144598
        if units is not None:
            F *= units.coulomb / units.mol
            R *= units.joule / units.kelvin / units.mol
    else:
        F = constants.Faraday_constant
        R = constants.ideal_gas_constant

    return (R * T) / (charge * F) * backend.log(ion_conc_out / ion_conc_in)
