diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml new file mode 100644 index 0000000..ff2e7b2 --- /dev/null +++ b/.github/workflows/ci.yml @@ -0,0 +1,43 @@ +name: CI +on: + pull_request: + branches: [ "master" ] + push: + branches: + - master + workflow_dispatch: + +permissions: read-all + +concurrency: + group: ${{ github.workflow }}-${{ github.event_name }}-${{ github.ref_name }}-${{ github.event.number || github.sha }} + cancel-in-progress: true + +jobs: + build-and-test: + strategy: + fail-fast: false + matrix: + os: [ + { name: arm Ubuntu-24.04, label: ubuntu-24.04-arm }, + { name: x86 Ubuntu-latest, label: ubuntu-latest }, + { name: x86 Windows-latest, label: windows-latest }, + ] + + name: CI-${{ matrix.os.name }} + runs-on: ${{ matrix.os.label }} + steps: + - name: Checkout EqTools + uses: actions/checkout@v4 + - name: Install Python + uses: actions/setup-python@v5 + with: + python-version: "3.x" + - name: Install EqTools + run: python -m pip install . + - name: Run tests + run: python tests/test.py + - name: Run unittests + # Windows cannot properly load the python2 test data pickle file + if: runner.os != 'Windows' + run: python tests/unittests.py || true diff --git a/README.md b/README.md index 2cf991e..49533f8 100644 --- a/README.md +++ b/README.md @@ -14,14 +14,14 @@ The following packages are required or recommended: - NumPy: Required. - SciPy: Required. -- F2PY: Optional, needed to build the optional `trispline` module. +- setuptools: Required. - matplotlib: Optional, needed to produce plot of flux surfaces. - MDSplus: Optional, needed to use data stored in MDSplus trees. - dd: Optional, needed to use data from ASDEX-Upgrade shotfiles. All of these should be available via pip (and should be installed automatically if you run `pip install eqtools` as described in the next section). If you wish to build in place, you may first need to run: - pip install numpy scipy f2py matplotlib + pip install numpy scipy setuptools matplotlib Installation ------------ diff --git a/eqtools/AUGData.py b/eqtools/AUGData.py index 23545ae..14d6b39 100644 --- a/eqtools/AUGData.py +++ b/eqtools/AUGData.py @@ -20,7 +20,7 @@ working with ASDEX Upgrade experimental data. """ -import scipy +import numpy from collections import namedtuple from .core import PropertyAccessMixin, ModuleWarning, Equilibrium, inPolygon @@ -436,8 +436,8 @@ def getFluxVol(self, length_unit=3): if self._fluxVol is None: try: fluxVolNode = self._MDSTree('Vol') # Lpf is unreliable so I have to do this trick.... - temp = scipy.where( - scipy.sum(fluxVolNode.data, axis=0)[::2] != 0 + temp = numpy.where( + numpy.sum(fluxVolNode.data, axis=0)[::2] != 0 )[0].max() + 1 # Find the where the volume is non-zero, give the maximum index and add one (for the core value) self._fluxVol = fluxVolNode.data[:self._timeidxend][ @@ -510,17 +510,17 @@ def getRLCFS(self, length_unit=1): try: rgeo = self.getSSQ('Rgeo') RLCFSNode = self.getSSQ('rays') - RLCFStemp = scipy.hstack( - (scipy.atleast_2d(RLCFSNode.data[:, -1]).T, RLCFSNode.data) + RLCFStemp = numpy.hstack( + (numpy.atleast_2d(RLCFSNode.data[:, -1]).T, RLCFSNode.data) ) templen = RLCFSNode.data.shape - self._RLCFS = scipy.tile( + self._RLCFS = numpy.tile( rgeo.data, (templen[1] + 1, 1) - ).T + RLCFStemp * scipy.cos( - scipy.tile( + ).T + RLCFStemp * numpy.cos( + numpy.tile( ( - scipy.linspace(0, 2 * scipy.pi, templen[1] + 1) + numpy.linspace(0, 2 * numpy.pi, templen[1] + 1) ), (templen[0], 1) ) ) # construct a 2d grid of angles, take cos, multiply by radius @@ -550,16 +550,16 @@ def getZLCFS(self, length_unit=1): try: zgeo = self.getSSQ('Zgeo') ZLCFSNode = self.getSSQ('rays') - ZLCFStemp = scipy.hstack( - (scipy.atleast_2d(ZLCFSNode.data[:, -1]).T, ZLCFSNode.data) + ZLCFStemp = numpy.hstack( + (numpy.atleast_2d(ZLCFSNode.data[:, -1]).T, ZLCFSNode.data) ) templen = ZLCFSNode.data.shape - self._ZLCFS = scipy.tile( + self._ZLCFS = numpy.tile( zgeo.data, (templen[1] + 1, 1) - ).T + ZLCFStemp * scipy.sin( - scipy.tile( - (scipy.linspace(0, 2 * scipy.pi, templen[1] + 1)), + ).T + ZLCFStemp * numpy.sin( + numpy.tile( + (numpy.linspace(0, 2 * numpy.pi, templen[1] + 1)), (templen[0], 1) ) ) # construct a 2d grid of angles, take sin, multiply by radius @@ -624,14 +624,14 @@ def remapLCFS(self, mask=False): v = path.vertices RLCFS_frame.extend(v[:, 0]) ZLCFS_frame.extend(v[:, 1]) - RLCFS_frame.append(scipy.nan) - ZLCFS_frame.append(scipy.nan) - RLCFS_frame = scipy.array(RLCFS_frame) - ZLCFS_frame = scipy.array(ZLCFS_frame) + RLCFS_frame.append(numpy.nan) + ZLCFS_frame.append(numpy.nan) + RLCFS_frame = numpy.array(RLCFS_frame) + ZLCFS_frame = numpy.array(ZLCFS_frame) # generate masking array to vessel if mask: - maskarr = scipy.array([False for i in range(len(RLCFS_frame))]) + maskarr = numpy.array([False for i in range(len(RLCFS_frame))]) for i, x in enumerate(RLCFS_frame): y = ZLCFS_frame[i] maskarr[i] = inPolygon(Rlim, Zlim, x, y) @@ -644,8 +644,8 @@ def remapLCFS(self, mask=False): RLCFS_stores.append(RLCFS_frame) ZLCFS_stores.append(ZLCFS_frame) - RLCFS = scipy.zeros((nt, maxlen)) - ZLCFS = scipy.zeros((nt, maxlen)) + RLCFS = numpy.zeros((nt, maxlen)) + ZLCFS = numpy.zeros((nt, maxlen)) for i in range(nt): RLCFS_frame = RLCFS_stores[i] ZLCFS_frame = ZLCFS_stores[i] @@ -1097,9 +1097,9 @@ def getBtVac(self): btaxvNode = self._MDSTree('Bave') # technically Bave is the average over the volume, but for the core its a singular value self._btaxv = btaxvNode.data[ - :self._timeidxend, scipy.sum(btaxvNode.data, 0) != 0 + :self._timeidxend, numpy.sum(btaxvNode.data, 0) != 0 ][:, -1] - self._btaxv *= scipy.sign(self.getBCentr()) + self._btaxv *= numpy.sign(self.getBCentr()) self._defaultUnits['_btaxv'] = str(btaxvNode.unit) except (PyddError, AttributeError): raise ValueError('data retrieval failed.') @@ -1141,7 +1141,7 @@ def getIpCalc(self): if self._IpCalc is None: try: IpCalcNode = self._MDSTree('IpiPSI') - self._IpCalc = scipy.squeeze(IpCalcNode.data)[ + self._IpCalc = numpy.squeeze(IpCalcNode.data)[ :self._timeidxend ] self._defaultUnits['_IpCalc'] = str(IpCalcNode.unit) @@ -1425,7 +1425,7 @@ def getCurrentSign(self): currentSign (Integer): 1 for positive-direction current, -1 for negative. """ if self._currentSign is None: - self._currentSign = -1 if scipy.mean(self.getIpMeas()) > 1e5 else 1 + self._currentSign = -1 if numpy.mean(self.getIpMeas()) > 1e5 else 1 return self._currentSign def getParam(self, path): @@ -1460,13 +1460,13 @@ def getSSQ(self, inp, **kwargs): # create a dict mapping the various quantities to positions in the in the data array self._SSQname = SSQnameNode.data try: - self._SSQname = scipy.char.strip( + self._SSQname = numpy.char.strip( SSQnameNode.data.view( 'S' + str(SSQnameNode.data.shape[1]) ) ) # concatenate and strip blanks except ValueError: - self._SSQname = scipy.char.strip( + self._SSQname = numpy.char.strip( SSQnameNode.data.T.view( 'S' + str(SSQnameNode.data.shape[0]) ) @@ -1474,7 +1474,7 @@ def getSSQ(self, inp, **kwargs): self._SSQname = self._SSQname[self._SSQname != ''] # remove empty entries self._SSQname = dict( - zip(self._SSQname, scipy.arange(self._SSQname.shape[0])) + zip(self._SSQname, numpy.arange(self._SSQname.shape[0])) ) # zip the dict together self._SSQ = self._MDSTree('SSQ').data @@ -1536,7 +1536,7 @@ def rz2BR( `Z` or be a scalar. Default is True (evaluate ALL `R`, `Z` at EACH element in `t`). make_grid (Boolean): Set to True to pass `R` and `Z` through - :py:func:`scipy.meshgrid` before evaluating. If this is set to + :py:func:`numpy.meshgrid` before evaluating. If this is set to True, `R` and `Z` must each only have a single dimension, but can have different lengths. Default is False (do not form meshgrid). @@ -1569,7 +1569,7 @@ def rz2BR( * **BR** (`Array or scalar float`) - The major radial component of the magnetic field. If all of the input arguments are scalar, then - a scalar is returned. Otherwise, a scipy Array is returned. If `R` + a scalar is returned. Otherwise, a numpy Array is returned. If `R` and `Z` both have the same shape then `BR` has this shape as well, unless the `make_grid` keyword was True, in which case `BR` has shape (len(`Z`), len(`R`)). @@ -1609,7 +1609,7 @@ def rz2BR( return super(AUGDDData, self).rz2BR( R, Z, t, return_t=return_t, make_grid=make_grid, each_t=each_t, length_unit=length_unit - ) / (2 * scipy.pi) + ) / (2 * numpy.pi) def rz2BZ( self, R, Z, t, return_t=False, make_grid=False, each_t=True, @@ -1650,7 +1650,7 @@ def rz2BZ( `Z` or be a scalar. Default is True (evaluate ALL `R`, `Z` at EACH element in `t`). make_grid (Boolean): Set to True to pass `R` and `Z` through - :py:func:`scipy.meshgrid` before evaluating. If this is set to + :py:func:`numpy.meshgrid` before evaluating. If this is set to True, `R` and `Z` must each only have a single dimension, but can have different lengths. Default is False (do not form meshgrid). @@ -1683,7 +1683,7 @@ def rz2BZ( * **BZ** (`Array or scalar float`) - The vertical component of the magnetic field. If all of the input arguments are scalar, then a - scalar is returned. Otherwise, a scipy Array is returned. If `R` + scalar is returned. Otherwise, a numpy Array is returned. If `R` and `Z` both have the same shape then `BZ` has this shape as well, unless the `make_grid` keyword was True, in which case `BZ` has shape (len(`Z`), len(`R`)). @@ -1720,7 +1720,7 @@ def rz2BZ( BZ_mat = Eq_instance.rz2BZ(R, Z, 0.2, make_grid=True) """ - return super(AUGDDData, self).rz2BZ(R, Z, t, return_t=return_t, make_grid=make_grid, each_t=each_t, length_unit=length_unit)/(2*scipy.pi) + return super(AUGDDData, self).rz2BZ(R, Z, t, return_t=return_t, make_grid=make_grid, each_t=each_t, length_unit=length_unit)/(2*numpy.pi) class YGCAUGInterface(object): @@ -1812,13 +1812,13 @@ class YGCAUGInterface(object): } # ONLY CERTAIN YGC FILES EXIST I MEAN CMON ITS NOT THAT MUCH MEMORY - _ygc_shotfiles = scipy.array([0, 948, 8650, 9401, 12751, 14051, 14601, 16315, 18204, 19551, 21485, 25891, 30136]) + _ygc_shotfiles = numpy.array([0, 948, 8650, 9401, 12751, 14051, 14601, 16315, 18204, 19551, 21485, 25891, 30136]) def _getData(self, shot): try: self._ygc_shot = self._ygc_shotfiles[ - scipy.searchsorted(self._ygc_shotfiles, [shot], 'right') - 1 + numpy.searchsorted(self._ygc_shotfiles, [shot], 'right') - 1 ][0] # find nearest shotfile which is the before it if self._ygc_shot < 8650: @@ -1900,8 +1900,8 @@ def getMachineCrossSectionFull(self, shot): x.append(None) y.append(None) - x = scipy.array(x[:-1]) - y = scipy.array(y[:-1]) + x = numpy.array(x[:-1]) + y = numpy.array(y[:-1]) return (x, y) diff --git a/eqtools/CModEFIT.py b/eqtools/CModEFIT.py index 7a739cf..859476f 100644 --- a/eqtools/CModEFIT.py +++ b/eqtools/CModEFIT.py @@ -20,7 +20,7 @@ working with C-Mod EFIT data. """ -import scipy +import numpy as np from .EFIT import EFITTree from .core import PropertyAccessMixin, ModuleWarning @@ -367,8 +367,8 @@ def getMachineCrossSectionFull(self): x.append(None) y.append(None) - x = scipy.array(x) - y = scipy.array(y) + x = np.array(x) + y = np.array(y) return (x, y) def getRCentr(self, length_unit=1): diff --git a/eqtools/EFIT.py b/eqtools/EFIT.py index e7ce939..d6ad002 100644 --- a/eqtools/EFIT.py +++ b/eqtools/EFIT.py @@ -20,6 +20,7 @@ with EFIT data. """ +import numpy import scipy from collections import namedtuple @@ -601,12 +602,12 @@ def remapLCFS(self, mask=False): ZLCFS_frame.extend(v[:, 1]) RLCFS_frame.append(scipy.nan) ZLCFS_frame.append(scipy.nan) - RLCFS_frame = scipy.array(RLCFS_frame) - ZLCFS_frame = scipy.array(ZLCFS_frame) + RLCFS_frame = numpy.array(RLCFS_frame) + ZLCFS_frame = numpy.array(ZLCFS_frame) # generate masking array to vessel if mask: - maskarr = scipy.array([False for i in range(len(RLCFS_frame))]) + maskarr = numpy.array([False for i in range(len(RLCFS_frame))]) for i, x in enumerate(RLCFS_frame): y = ZLCFS_frame[i] maskarr[i] = inPolygon(Rlim, Zlim, x, y) diff --git a/eqtools/FromArrays.py b/eqtools/FromArrays.py index 2e7998b..1c83321 100644 --- a/eqtools/FromArrays.py +++ b/eqtools/FromArrays.py @@ -18,7 +18,7 @@ from .core import Equilibrium -import scipy +import numpy class ArrayEquilibrium(Equilibrium): @@ -91,17 +91,17 @@ class ArrayEquilibrium(Equilibrium): """ def __init__(self, psiRZ, rGrid, zGrid, time, q, fluxVol, psiLCFS, psiAxis, rmag, zmag, Rout, **kwargs): - self._psiRZ = scipy.asarray(psiRZ, dtype=float) - self._rGrid = scipy.asarray(rGrid, dtype=float) - self._zGrid = scipy.asarray(zGrid, dtype=float) - self._time = scipy.asarray(time, dtype=float) - self._qpsi = scipy.asarray(q, dtype=float) - self._fluxVol = scipy.asarray(fluxVol, dtype=float) - self._psiLCFS = scipy.asarray(psiLCFS, dtype=float) - self._psiAxis = scipy.asarray(psiAxis, dtype=float) - self._rmag = scipy.asarray(rmag, dtype=float) - self._zmag = scipy.asarray(zmag, dtype=float) - self._RmidLCFS = scipy.asarray(Rout, dtype=float) + self._psiRZ = numpy.asarray(psiRZ, dtype=float) + self._rGrid = numpy.asarray(rGrid, dtype=float) + self._zGrid = numpy.asarray(zGrid, dtype=float) + self._time = numpy.asarray(time, dtype=float) + self._qpsi = numpy.asarray(q, dtype=float) + self._fluxVol = numpy.asarray(fluxVol, dtype=float) + self._psiLCFS = numpy.asarray(psiLCFS, dtype=float) + self._psiAxis = numpy.asarray(psiAxis, dtype=float) + self._rmag = numpy.asarray(rmag, dtype=float) + self._zmag = numpy.asarray(zmag, dtype=float) + self._RmidLCFS = numpy.asarray(Rout, dtype=float) self._defaultUnits = {} self._defaultUnits['_psiRZ'] = 'Wb/rad' diff --git a/eqtools/NSTXEFIT.py b/eqtools/NSTXEFIT.py index 41008d4..634ede0 100644 --- a/eqtools/NSTXEFIT.py +++ b/eqtools/NSTXEFIT.py @@ -20,7 +20,7 @@ working with NSTX EFIT data. """ -import scipy +import numpy from .EFIT import EFITTree from .core import PropertyAccessMixin, ModuleWarning @@ -215,7 +215,7 @@ def getRmidPsi(self, length_unit=1): self._defaultUnits['_RmidPsi'], length_unit ) else: - unit_factor = scipy.array([1.]) + unit_factor = numpy.array([1.]) with warnings.catch_warnings(): warnings.filterwarnings("ignore", category=RuntimeWarning) diff --git a/eqtools/TCVLIUQE.py b/eqtools/TCVLIUQE.py index 495198f..11600f5 100644 --- a/eqtools/TCVLIUQE.py +++ b/eqtools/TCVLIUQE.py @@ -20,7 +20,7 @@ working with TCV LIUQE Equilibrium. """ -import scipy +import numpy from collections import namedtuple from .EFIT import EFITTree from .core import PropertyAccessMixin, ModuleWarning @@ -198,7 +198,7 @@ def getFluxGrid(self): if self._psiRZ is None: try: psinode = self._MDSTree.getNode(self._root+'::psi') - self._psiRZ = psinode.data() / (2.*scipy.pi) + self._psiRZ = psinode.data() / (2.*numpy.pi) self._rGrid = psinode.dim_of(0).data() self._zGrid = psinode.dim_of(1).data() self._defaultUnits['_psiRZ'] = str(psinode.units) @@ -260,7 +260,7 @@ def getFluxAxis(self): if self._psiAxis is None: try: psiAxisNode = self._MDSTree.getNode(self._root+'::psi_axis') - self._psiAxis = psiAxisNode.data() / (2.*scipy.pi) + self._psiAxis = psiAxisNode.data() / (2.*numpy.pi) self._defaultUnits['_psiAxis'] = str(psiAxisNode.units) except Exception: raise ValueError('data retrieval failed.') @@ -281,7 +281,7 @@ def getFluxLCFS(self): # psiLCFSNode = self._MDSTree.getNode(self._root+'::surface_flux') # self._psiLCFS = psiLCFSNode.data() # self._defaultUnits['_psiLCFS'] = str(psiLCFSNode.units) - self._psiLCFS = scipy.zeros(self.getTimeBase().size) + self._psiLCFS = numpy.zeros(self.getTimeBase().size) self._defaultUnits['_psiLCFS'] = 'T*m^2' except Exception: raise ValueError('data retrieval failed.') @@ -312,17 +312,17 @@ def getFluxVol(self, length_unit=3): # then the psi from psiGrid psiRZ = self.getFluxGrid() # the rGrid, zGrid in an appropriate mesh - R, Z = scipy.meshgrid(self.getRGrid(), self.getZGrid()) + R, Z = numpy.meshgrid(self.getRGrid(), self.getZGrid()) # read the LCFS Volume and Area and compute the appropriate twopi R rUsed = self.getVolLCFS() / self.getAreaLCFS() # define the output - volumes = scipy.zeros((psiRZ.shape[0], nPsi)) - outArea = scipy.zeros(nPsi) + volumes = numpy.zeros((psiRZ.shape[0], nPsi)) + outArea = numpy.zeros(nPsi) # now we start to iterate over the times for i in range(psiRZ.shape[0]): psi = psiRZ[i] # define the levels - levels = scipy.linspace(psi.max(), 0, nPsi) + levels = numpy.linspace(psi.max(), 0, nPsi) c = cntr.Cntr(R, Z, psi) for j in range(nPsi - 1): nlist = c.trace(levels[j + 1]) @@ -475,15 +475,15 @@ def getFluxPres(self): duData = fluxPPresNode.data() # then we build an appropriate grid nPsi = self.getRmidPsi().shape[1] - psiV = scipy.linspace(1, 0, nPsi) + psiV = numpy.linspace(1, 0, nPsi) rad = [psiV] for i in range(duData.shape[1]-1): rad += [rad[-1]*psiV*(i+1)/(i+2)] - rad = scipy.vstack(rad) - self._fluxPres = scipy.reshape( + rad = numpy.vstack(rad) + self._fluxPres = numpy.reshape( self.getFluxAxis(), (self.getFluxAxis().size, 1) - ) * scipy.dot(duData, rad)/(2*scipy.pi) + ) * numpy.dot(duData, rad)/(2*numpy.pi) self._defaultUnits['_fluxPres'] = 'Pa' except Exception: @@ -535,16 +535,16 @@ def getPPrime(self): # then we build an appropriate grid nPsi = self.getRmidPsi().shape[1] - psiV = scipy.linspace(1, 0, nPsi) + psiV = numpy.linspace(1, 0, nPsi) # This should be faster through some vectorization / # slowing down to fortran matrix multiplication subroutines - rad = [scipy.ones(psiV.size)] + rad = [numpy.ones(psiV.size)] for i in range(duData.shape[1]-1): rad += [rad[-1]*psiV] - rad = scipy.vstack(rad) + rad = numpy.vstack(rad) - self._pprime = scipy.dot(duData, rad) + self._pprime = numpy.dot(duData, rad) self._defaultUnits['_fluxPres'] = 'A/m^3' except Exception: raise ValueError('data retrieval failed.') @@ -835,7 +835,7 @@ def getBtVac(self): btTime = conn.get('dim_of(tcv_eq("BZERO"))').data() conn.closeTree(self._tree, self._shot) # we need to interpolate on the time basis of LIUQE - self._btaxv = scipy.interp(self.getTimeBase(), btTime, bt) + self._btaxv = numpy.interp(self.getTimeBase(), btTime, bt) self._defaultUnits['_btaxv'] = 'T' except Exception: raise ValueError('data retrieval failed.') @@ -897,7 +897,7 @@ def getIpMeas(self): ip = conn.get('tcv_ip()').data() ipTime = conn.get('dim_of(tcv_ip())').data() conn.closeTree(self._tree, self._shot) - self._IpMeas = scipy.interp(self.getTimeBase(), ipTime, ip) + self._IpMeas = numpy.interp(self.getTimeBase(), ipTime, ip) self._defaultUnits['_IpMeas'] = 'A' except Exception: raise ValueError('data retrieval failed.') @@ -1177,8 +1177,8 @@ def updateTime(val): elif limx is not None: psi.plot(limx, limy, 'k', linewidth=3, zorder=5) # catch NaNs separating disjoint sections of R,ZLCFS in mask - maskarr = scipy.where( - scipy.logical_or(RLCFS[t_idx] > 0.0, scipy.isnan(RLCFS[t_idx])) + maskarr = numpy.where( + numpy.logical_or(RLCFS[t_idx] > 0.0, numpy.isnan(RLCFS[t_idx])) ) RLCFSframe = RLCFS[t_idx, maskarr[0]] ZLCFSframe = ZLCFS[t_idx, maskarr[0]] diff --git a/eqtools/_tricub.c b/eqtools/_tricub.c index 86c4567..121d2d6 100644 --- a/eqtools/_tricub.c +++ b/eqtools/_tricub.c @@ -1,6 +1,7 @@ #include #include #include +#include "_tricub.h" /***************************************************************** @@ -156,17 +157,18 @@ int A_v2[64][64] = { double factorial[4] = {1.0,1.0,2.0,6.0}; /* value needed for derivatives, and a lookup table is the easiest/fastest method */ -int clip(int x, int a) +inline int clip(int x, int a) { /* use of a set of ternary operators to bound a value x between 0 and a */ return x > a - 1 ? a - 1 : (x < 0 ? 0 : x); } -int ismonotonic(double val[], int ix) +long ismonotonic(double val[], int ix) { /* while loop based check of monotonicity, so on very large bases that fail, it stops early. Starts at end. */ - int counter = ix - 1,output = 1; + int counter = ix - 1; + long output = 1; while( counter ) { counter--; @@ -180,11 +182,12 @@ int ismonotonic(double val[], int ix) } -int isregular(double val[], int ix) +long isregular(double val[], int ix) { /* while loop based check of monotonicity, so on very large bases that fail, it stops early. Starts at end. */ - int counter = ix - 2,output = 1; + int counter = ix - 2; + long output = 1; double eps = 1e-6; /* Difference between values within .001% */ double temp = val[counter] - val[counter + 1]; while( counter ) @@ -199,7 +202,7 @@ int isregular(double val[], int ix) } -int ijk2n(int i, int j, int k) +inline int ijk2n(int i, int j, int k) { return(i+4*j+16*k); } @@ -534,7 +537,6 @@ void nonreg_ev(double val[], double x0[], double x1[], double x2[], double f[], free(tempx2); free(pos); free(indx); - } @@ -599,11 +601,9 @@ void nonreg_ev_full(double val[], double x0[], double x1[], double x2[], double free(tempx2); free(pos); free(indx); - } - void reg_ev(double val[], double x0[], double x1[], double x2[], double f[], double fx0[], double fx1[], double fx2[], int ix0, int ix1, int ix2, int ix) { int i, iter=-1, loc; @@ -744,7 +744,6 @@ void reg_ev_full(double val[], double x0[], double x1[], double x2[], double f[] } - void ev(double val[], double x0[], double x1[], double x2[], double f[], double fx0[], double fx1[], double fx2[], int ix0, int ix1, int ix2, int ix) { if(isregular(fx0, ix0) && isregular(fx1, ix1) && isregular(fx2, ix2)) diff --git a/eqtools/_tricub.h b/eqtools/_tricub.h new file mode 100644 index 0000000..b3cf8b3 --- /dev/null +++ b/eqtools/_tricub.h @@ -0,0 +1,29 @@ +/***************************************************************** + + This file is part of the eqtools package. + + EqTools is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + EqTools is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with EqTools. If not, see . + + Copyright 2025 Ian C. Faust + +******************************************************************/ + +long ismonotonic(double val[], int ix); +long isregular(double val[], int ix); + +void nonreg_ev(double val[], double x0[], double x1[], double x2[], double f[], double fx0[], double fx1[], double fx2[], int ix0, int ix1, int ix2, int ix); +void nonreg_ev_full(double val[], double x0[], double x1[], double x2[], double f[], double fx0[], double fx1[], double fx2[], int ix0, int ix1, int ix2, int ix, int d0, int d1, int d2); +void reg_ev(double val[], double x0[], double x1[], double x2[], double f[], double fx0[], double fx1[], double fx2[], int ix0, int ix1, int ix2, int ix); +void reg_ev_full(double val[], double x0[], double x1[], double x2[], double f[], double fx0[], double fx1[], double fx2[], int ix0, int ix1, int ix2, int ix, int d0, int d1, int d2); +void ev(double val[], double x0[], double x1[], double x2[], double f[], double fx0[], double fx1[], double fx2[], int ix0, int ix1, int ix2, int ix); diff --git a/eqtools/_tricubmodule.c b/eqtools/_tricubmodule.c new file mode 100644 index 0000000..40bfa58 --- /dev/null +++ b/eqtools/_tricubmodule.c @@ -0,0 +1,320 @@ +#include + +#include +#include + +#include "_tricub.h" + +/***************************************************************** + + This file is part of the eqtools package. + + EqTools is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + EqTools is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with EqTools. If not, see . + + Copyright 2025 Ian C. Faust + +******************************************************************/ + +#define LENGTH_ASSERT(a, i) \ + if (check_1d_array(a, i)) \ + return 1 + +#define ARRAY_SHAPE(a, i) PyArray_DIM((PyArrayObject *)a, i) +#define ARRAY_DATA(a) PyArray_DATA((PyArrayObject *)a) + +#define CHECK_ARRAY(a) \ + if (to_array(&a)) \ + return 1 + +struct input { + double *x0; + double *x1; + double *x2; + double *f; + double *fx0; + double *fx1; + double *fx2; + int ix0; + int ix1; + int ix2; + int ix; + int d0; + int d1; + int d2; +}; + +static inline int +to_array(PyObject **obj) { /* Check in numpy array, dtype is double, and if the + * number of dimensions of the array is correct, then + * return the numpy C-contiguous array. Otherwise, + * raise a specified Python error and return NULL. + */ + PyArrayObject *array = NULL; + + if (!((*obj) && PyArray_Check(*obj))) { + PyErr_SetString(PyExc_TypeError, "Input is not a numpy.ndarray subtype"); + return 1; + } + array = (PyArrayObject *)*obj; + + if (PyArray_TYPE(array) != NPY_DOUBLE) { + PyErr_SetString(PyExc_TypeError, "array must be dtype double"); + return 1; + } + + if (!PyArray_ISCARRAY_RO(array)) + array = PyArray_GETCONTIGUOUS(*obj); + *obj = (PyObject*) array; + + return 0; +} + +static inline int check_1d_array(PyObject *array, int length) { + if (array && ARRAY_SHAPE(array, 0) != length) { + PyErr_SetString(PyExc_TypeError, "1-d array has incorrect length"); + return 1; + } + return 0; +} + +static int to_scalar(PyObject *obj, void *output) { + // if not supplied do nothing + if (!obj) + return 0; + + if (PyArray_CheckScalar(obj)) { + PyErr_SetString(PyExc_TypeError, "Input is not a numpy scalar"); + return 1; + } + + if (PyArray_TYPE((PyArrayObject *)obj) != NPY_INT) { + PyErr_SetString(PyExc_TypeError, "scalar must be dtype int"); + return 1; + } + + PyArray_ScalarAsCtype(obj, output); + return 0; +} + +static inline int parse_input(PyObject *args, struct input *data) { + PyObject *x0obj, *x1obj, *x2obj, *fobj, *fx0obj, *fx1obj, *fx2obj; + PyObject *d0obj = NULL, *d1obj = NULL, *d2obj = NULL; + if (!PyArg_ParseTuple(args, "OOOOOOO|OOO", &x0obj, &x1obj, &x2obj, &fobj, + &fx0obj, &fx1obj, &fx2obj, &d0obj, &d1obj, &d2obj)) + return 1; + + CHECK_ARRAY(x0obj); + CHECK_ARRAY(x1obj); + CHECK_ARRAY(x2obj); + CHECK_ARRAY(fobj); + CHECK_ARRAY(fx0obj); + CHECK_ARRAY(fx1obj); + CHECK_ARRAY(fx2obj); + + // get dimension for testing + data->ix = ARRAY_SHAPE(x0obj, 0); + + LENGTH_ASSERT(x1obj, data->ix); + LENGTH_ASSERT(x2obj, data->ix); + + // assert f is 3 dimensions + if (!fobj || PyArray_NDIM((PyArrayObject *)fobj) != 3) { + PyErr_SetString(PyExc_TypeError, "f array is not 3 dimensional"); + return 1; + } + + data->ix0 = ARRAY_SHAPE(fobj, 2); + data->ix1 = ARRAY_SHAPE(fobj, 1); + data->ix2 = ARRAY_SHAPE(fobj, 0); + + LENGTH_ASSERT(fx0obj, data->ix0); + LENGTH_ASSERT(fx1obj, data->ix1); + LENGTH_ASSERT(fx2obj, data->ix2); + // set values for C code + data->x0 = (double *)ARRAY_DATA(x0obj); + data->x1 = (double *)ARRAY_DATA(x1obj); + data->x2 = (double *)ARRAY_DATA(x2obj); + data->f = (double *)ARRAY_DATA(fobj); + data->fx0 = (double *)ARRAY_DATA(fx0obj); + data->fx1 = (double *)ARRAY_DATA(fx1obj); + data->fx2 = (double *)ARRAY_DATA(fx2obj); + + if (d0obj && to_scalar(d0obj, &data->d0)) + return 1; + if (d1obj && to_scalar(d0obj, &data->d1)) + return 1; + if (d2obj && to_scalar(d0obj, &data->d2)) + return 1; + + return 0; +} + +static PyObject *python_reg_ev( + PyObject *self, + PyObject *args) { /* If the above function returns -1, an + * appropriate Python exception will have been + * set, and the function simply returns NULL + */ + double *val; + struct input s; + npy_intp length; + PyObject *output; + + if (parse_input(args, &s)) + return NULL; + length = (npy_intp)s.ix; + output = PyArray_SimpleNew(1, &length, NPY_DOUBLE); + val = (double *)ARRAY_DATA(output); + + reg_ev(val, s.x0, s.x1, s.x2, s.f, s.fx0, s.fx1, s.fx2, s.ix0, s.ix1, s.ix2, + s.ix); + return output; +} + +static PyObject *python_reg_ev_full( + PyObject *self, + PyObject *args) { /* If the above function returns -1, an appropriate Python + * exception will have been set, and the function simply + * returns NULL + */ + double *val; + struct input s; + npy_intp length; + PyObject *output; + + if (parse_input(args, &s)) + return NULL; + length = (npy_intp)s.ix; + output = PyArray_SimpleNew(1, &length, NPY_DOUBLE); + val = (double *)ARRAY_DATA(output); + + reg_ev_full(val, s.x0, s.x1, s.x2, s.f, s.fx0, s.fx1, s.fx2, s.ix0, s.ix1, + s.ix2, s.ix, s.d0, s.d1, s.d2); + return output; +} + +static PyObject *python_nonreg_ev( + PyObject *self, + PyObject *args) { /* If the above function returns -1, an appropriate Python + * exception will have been set, and the function simply + * returns NULL + */ + double *val; + struct input s; + npy_intp length; + PyObject *output; + + if (parse_input(args, &s)) + return NULL; + length = (npy_intp)s.ix; + output = PyArray_SimpleNew(1, &length, NPY_DOUBLE); + val = (double *)ARRAY_DATA(output); + + nonreg_ev(val, s.x0, s.x1, s.x2, s.f, s.fx0, s.fx1, s.fx2, s.ix0, s.ix1, + s.ix2, s.ix); + return output; +} + +static PyObject *python_nonreg_ev_full( + PyObject *self, + PyObject *args) { /* If the above function returns -1, an appropriate Python + * exception will have been set, and the function simply + * returns NULL + */ + double *val; + struct input s; + npy_intp length; + PyObject *output; + + if (parse_input(args, &s)) + return NULL; + length = (npy_intp)s.ix; + output = PyArray_SimpleNew(1, &length, NPY_DOUBLE); + val = (double *)ARRAY_DATA(output); + + nonreg_ev_full(val, s.x0, s.x1, s.x2, s.f, s.fx0, s.fx1, s.fx2, s.ix0, s.ix1, + s.ix2, s.ix, s.d0, s.d1, s.d2); + return output; +} + +static PyObject * +python_ev(PyObject *self, + PyObject *args) { /* If the above function returns -1, an appropriate + * Python exception will have been set, and the + * function simply returns NULL + */ + double *val; + struct input s; + npy_intp length; + PyObject *output; + + if (parse_input(args, &s)) + return NULL; + length = (npy_intp)s.ix; + output = PyArray_SimpleNew(1, &length, NPY_DOUBLE); + val = (double *)ARRAY_DATA(output); + + ev(val, s.x0, s.x1, s.x2, s.f, s.fx0, s.fx1, s.fx2, s.ix0, s.ix1, s.ix2, + s.ix); + return output; +} + +static PyObject *python_ismonotonic(PyObject *self, PyObject *arg) { + int ix; + double *data; + + if (to_array(&arg)) + return NULL; + ix = ARRAY_SHAPE(arg, 0); + data = (double *)ARRAY_DATA(arg); + return PyBool_FromLong(ismonotonic(data, ix)); +} + +static PyObject *python_isregular(PyObject *self, PyObject *arg) { + int ix; + double *data; + if (to_array(&arg)) + return NULL; + + ix = ARRAY_SHAPE(arg, 0); + data = (double *)ARRAY_DATA(arg); + return PyBool_FromLong(isregular(data, ix)); +} + +static PyMethodDef TricubMethods[] = { + {"reg_ev", python_reg_ev, METH_VARARGS, ""}, + {"reg_ev_full", python_reg_ev_full, METH_VARARGS, ""}, + {"nonreg_ev", python_nonreg_ev, METH_VARARGS, ""}, + {"nonreg_ev_full", python_nonreg_ev_full, METH_VARARGS, ""}, + {"ev", python_ev, METH_VARARGS, ""}, + {"ismonotonic", python_ismonotonic, METH_O, ""}, + {"isregular", python_isregular, METH_O, ""}, + {NULL, NULL, 0, NULL} /* Sentinel */ +}; + +static struct PyModuleDef _tricubStruct = {PyModuleDef_HEAD_INIT, + "_tricub", + "", + -1, + TricubMethods, + NULL, + NULL, + NULL, + NULL}; + +/* Module initialization */ +PyObject *PyInit__tricub(void) { + import_array(); + return PyModule_Create(&_tricubStruct); +} diff --git a/eqtools/core.py b/eqtools/core.py index 5ccc9a0..f248a84 100644 --- a/eqtools/core.py +++ b/eqtools/core.py @@ -19,7 +19,7 @@ """This module provides the core classes for :py:mod:`eqtools`, including the base :py:class:`Equilibrium` class. """ -import scipy +import numpy import scipy.interpolate import scipy.integrate import scipy.constants @@ -29,6 +29,9 @@ import sys if sys.version_info.major >= 3: long = int +# gracefully handle scipy cumtrapz deprecation +if hasattr(scipy.integrate, "cumulative_trapezoid"): + scipy.integrate.cumtrapz = scipy.integrate.cumulative_trapezoid # Constants to determine how plot labels are formatted: B_LABEL = '$B$ [T]' @@ -460,7 +463,7 @@ def rho2rho(self, origin, destination, *args, **kwargs): a scalar. Default is True (evaluate ALL `rho` at EACH element in `t`). make_grid (Boolean): Only applicable if `origin` is 'RZ'. Set to - True to pass `R` and `Z` through :py:func:`scipy.meshgrid` + True to pass `R` and `Z` through :py:func:`numpy.meshgrid` before evaluating. If this is set to True, `R` and `Z` must each only have a single dimension, but can have different lengths. Default is False (do not form meshgrid). @@ -499,7 +502,7 @@ def rho2rho(self, origin, destination, *args, **kwargs): * **rho** (`Array or scalar float`) - The converted coordinates. If all of the input arguments are scalar, then a scalar is returned. - Otherwise, a scipy Array is returned. + Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `rho`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -531,7 +534,7 @@ def rho2rho(self, origin, destination, *args, **kwargs): """ if origin.startswith('sqrt'): args = list(args) - args[0] = scipy.asarray(args[0])**2 + args[0] = numpy.asarray(args[0])**2 origin = origin[4:] if destination.startswith('sqrt'): @@ -591,7 +594,7 @@ def rz2psi( `Z` or be a scalar. Default is True (evaluate ALL `R`, `Z` at EACH element in `t`). make_grid (Boolean): Set to True to pass `R` and `Z` through - :py:func:`scipy.meshgrid` before evaluating. If this is set to + :py:func:`numpy.meshgrid` before evaluating. If this is set to True, `R` and `Z` must each only have a single dimension, but can have different lengths. Default is False (do not form meshgrid). @@ -624,7 +627,7 @@ def rz2psi( * **psi** (`Array or scalar float`) - The unnormalized poloidal flux. If all of the input arguments are scalar, then a scalar is - returned. Otherwise, a scipy Array is returned. If `R` and `Z` + returned. Otherwise, a numpy Array is returned. If `R` and `Z` both have the same shape then `psi` has this shape as well, unless the `make_grid` keyword was True, in which case `psi` has shape (len(`Z`), len(`R`)). @@ -676,7 +679,7 @@ def rz2psi( ) if self._tricubic: - out_vals = scipy.reshape( + out_vals = numpy.reshape( self._getFluxTriSpline().ev(t, Z, R), original_shape ) @@ -686,10 +689,10 @@ def rz2psi( if single_val: out_vals = out_vals[0] else: - out_vals = scipy.reshape(out_vals, original_shape) + out_vals = numpy.reshape(out_vals, original_shape) elif each_t: - out_vals = scipy.zeros( - scipy.concatenate( + out_vals = numpy.zeros( + numpy.concatenate( ([len(time_idxs), ], original_shape) ).astype(int) ) @@ -698,13 +701,13 @@ def rz2psi( t_idx ).ev(Z, R).reshape(original_shape) else: - out_vals = scipy.zeros_like(t, dtype=float) + out_vals = numpy.zeros_like(t, dtype=float) for t_idx in unique_idxs: t_mask = (time_idxs == t_idx) out_vals[t_mask] = self._getFluxBiSpline( t_idx ).ev(Z[t_mask], R[t_mask]) - out_vals = scipy.reshape(out_vals, original_shape) + out_vals = numpy.reshape(out_vals, original_shape) # Correct for current sign: out_vals = -1.0 * out_vals * self.getCurrentSign() @@ -761,7 +764,7 @@ def rz2psinorm(self, R, Z, t, return_t=False, sqrt=False, make_grid=False, `Z` or be a scalar. Default is True (evaluate ALL `R`, `Z` at EACH element in `t`). make_grid (Boolean): Set to True to pass `R` and `Z` through - :py:func:`scipy.meshgrid` before evaluating. If this is set to + :py:func:`numpy.meshgrid` before evaluating. If this is set to True, `R` and `Z` must each only have a single dimension, but can have different lengths. Default is False (do not form meshgrid). @@ -794,7 +797,7 @@ def rz2psinorm(self, R, Z, t, return_t=False, sqrt=False, make_grid=False, * **psinorm** (`Array or scalar float`) - The normalized poloidal flux. If all of the input arguments are scalar, then a scalar is - returned. Otherwise, a scipy Array is returned. If `R` and `Z` + returned. Otherwise, a numpy Array is returned. If `R` and `Z` both have the same shape then `psinorm` has this shape as well, unless the `make_grid` keyword was True, in which case `psinorm` has shape (len(`Z`), len(`R`)). @@ -852,8 +855,8 @@ def rz2psinorm(self, R, Z, t, return_t=False, sqrt=False, make_grid=False, if not blob[-3]: if each_t: for k in range(0, len(blob[-1])): - psi_boundary = scipy.expand_dims(psi_boundary, -1) - psi_0 = scipy.expand_dims(psi_0, -1) + psi_boundary = numpy.expand_dims(psi_boundary, -1) + psi_0 = numpy.expand_dims(psi_0, -1) else: psi_boundary = psi_boundary.reshape(blob[-1]) psi_0 = psi_0.reshape(blob[-1]) @@ -865,8 +868,8 @@ def rz2psinorm(self, R, Z, t, return_t=False, sqrt=False, make_grid=False, if psi_norm < 0.0: psi_norm = 0.0 else: - scipy.place(psi_norm, psi_norm < 0, 0) - out = scipy.sqrt(psi_norm) + numpy.place(psi_norm, psi_norm < 0, 0) + out = numpy.sqrt(psi_norm) else: out = psi_norm @@ -922,7 +925,7 @@ def rz2phinorm(self, *args, **kwargs): `Z` or be a scalar. Default is True (evaluate ALL `R`, `Z` at EACH element in `t`). make_grid (Boolean): Set to True to pass `R` and `Z` through - :py:func:`scipy.meshgrid` before evaluating. If this is set to + :py:func:`numpy.meshgrid` before evaluating. If this is set to True, `R` and `Z` must each only have a single dimension, but can have different lengths. Default is False (do not form meshgrid). @@ -957,7 +960,7 @@ def rz2phinorm(self, *args, **kwargs): * **phinorm** (`Array or scalar float`) - The normalized toroidal flux. If all of the input arguments are scalar, then a scalar is - returned. Otherwise, a scipy Array is returned. If `R` and `Z` + returned. Otherwise, a numpy Array is returned. If `R` and `Z` both have the same shape then `phinorm` has this shape as well, unless the `make_grid` keyword was True, in which case `phinorm` has shape (len(`Z`), len(`R`)). @@ -1032,7 +1035,7 @@ def rz2volnorm(self, *args, **kwargs): `Z` or be a scalar. Default is True (evaluate ALL `R`, `Z` at EACH element in `t`). make_grid (Boolean): Set to True to pass `R` and `Z` through - :py:func:`scipy.meshgrid` before evaluating. If this is set to + :py:func:`numpy.meshgrid` before evaluating. If this is set to True, `R` and `Z` must each only have a single dimension, but can have different lengths. Default is False (do not form meshgrid). @@ -1067,7 +1070,7 @@ def rz2volnorm(self, *args, **kwargs): * **volnorm** (`Array or scalar float`) - The normalized volume. If all of the input arguments are scalar, then a scalar is - returned. Otherwise, a scipy Array is returned. If `R` and `Z` + returned. Otherwise, a numpy Array is returned. If `R` and `Z` both have the same shape then `volnorm` has this shape as well, unless the `make_grid` keyword was True, in which case `volnorm` has shape (len(`Z`), len(`R`)). @@ -1141,7 +1144,7 @@ def rz2rmid(self, *args, **kwargs): `Z` or be a scalar. Default is True (evaluate ALL `R`, `Z` at EACH element in `t`). make_grid (Boolean): Set to True to pass `R` and `Z` through - :py:func:`scipy.meshgrid` before evaluating. If this is set to + :py:func:`numpy.meshgrid` before evaluating. If this is set to True, `R` and `Z` must each only have a single dimension, but can have different lengths. Default is False (do not form meshgrid). @@ -1179,7 +1182,7 @@ def rz2rmid(self, *args, **kwargs): * **Rmid** (`Array or scalar float`) - The outboard midplan major radius. If all of the input arguments are scalar, then a scalar - is returned. Otherwise, a scipy Array is returned. If `R` and `Z` + is returned. Otherwise, a numpy Array is returned. If `R` and `Z` both have the same shape then `Rmid` has this shape as well, unless the `make_grid` keyword was True, in which case `Rmid` has shape (len(`Z`), len(`R`)). @@ -1269,7 +1272,7 @@ def rz2roa(self, *args, **kwargs): `Z` or be a scalar. Default is True (evaluate ALL `R`, `Z` at EACH element in `t`). make_grid (Boolean): Set to True to pass `R` and `Z` through - :py:func:`scipy.meshgrid` before evaluating. If this is set to + :py:func:`numpy.meshgrid` before evaluating. If this is set to True, `R` and `Z` must each only have a single dimension, but can have different lengths. Default is False (do not form meshgrid). @@ -1304,7 +1307,7 @@ def rz2roa(self, *args, **kwargs): * **roa** (`Array or scalar float`) - The normalized minor radius. If all of the input arguments are scalar, then a scalar - is returned. Otherwise, a scipy Array is returned. If `R` and `Z` + is returned. Otherwise, a numpy Array is returned. If `R` and `Z` both have the same shape then `roa` has this shape as well, unless the `make_grid` keyword was True, in which case `roa` has shape (len(`Z`), len(`R`)). @@ -1400,7 +1403,7 @@ def rz2rho(self, method, *args, **kwargs): `Z` or be a scalar. Default is True (evaluate ALL `R`, `Z` at EACH element in `t`). make_grid (Boolean): Set to True to pass `R` and `Z` through - :py:func:`scipy.meshgrid` before evaluating. If this is set to + :py:func:`numpy.meshgrid` before evaluating. If this is set to True, `R` and `Z` must each only have a single dimension, but can have different lengths. Default is False (do not form meshgrid). @@ -1439,7 +1442,7 @@ def rz2rho(self, method, *args, **kwargs): * **rho** (`Array or scalar float`) - The converted coordinates. If all of the input arguments are scalar, then a scalar is returned. - Otherwise, a scipy Array is returned. + Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `rho`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -1562,7 +1565,7 @@ def rmid2roa( * **roa** (`Array or scalar float`) - Normalized midplane minor radius. If all of the input arguments are scalar, then a scalar - is returned. Otherwise, a scipy Array is returned. + is returned. Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `roa`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -1627,8 +1630,8 @@ def rmid2roa( else: roa = roa.reshape(original_shape) elif each_t: - roa = scipy.zeros( - scipy.concatenate( + roa = numpy.zeros( + numpy.concatenate( ([len(time_idxs), ], original_shape) ).astype(int) ) @@ -1644,8 +1647,8 @@ def rmid2roa( if roa < 0: roa = 0.0 else: - scipy.place(roa, roa < 0, 0.0) - roa = scipy.sqrt(roa) + numpy.place(roa, roa < 0, 0.0) + roa = numpy.sqrt(roa) if return_t: if self._tricubic: @@ -1711,7 +1714,7 @@ def rmid2psinorm(self, R_mid, t, **kwargs): * **psinorm** (`Array or scalar float`) - Normalized poloidal flux. If all of the input arguments are scalar, then a scalar is - returned. Otherwise, a scipy Array is returned. + returned. Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `psinorm`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -1805,7 +1808,7 @@ def rmid2phinorm(self, *args, **kwargs): * **phinorm** (`Array or scalar float`) - Normalized toroidal flux. If all of the input arguments are scalar, then a scalar is - returned. Otherwise, a scipy Array is returned. + returned. Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `phinorm`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -1889,7 +1892,7 @@ def rmid2volnorm(self, *args, **kwargs): * **volnorm** (`Array or scalar float`) - Normalized volume. If all of the input arguments are scalar, then a scalar is - returned. Otherwise, a scipy Array is returned. + returned. Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `volnorm`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -1988,7 +1991,7 @@ def rmid2rho(self, method, R_mid, t, **kwargs): * **rho** (`Array or scalar float`) - The converted coordinates. If all of the input arguments are scalar, then a scalar is returned. - Otherwise, a scipy Array is returned. + Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `rho`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -2055,31 +2058,31 @@ def rmid2rho(self, method, R_mid, t, **kwargs): # we only need to make it have the same shape as R_mid. Note # that ones_like appears to be clever enough to handle the case # of a scalar R_mid. - Z_mid = Z_mid * scipy.ones_like(R_mid, dtype=float) + Z_mid = Z_mid * numpy.ones_like(R_mid, dtype=float) else: # For multiple t, we need to repeat R_mid for every t, then # repeat the corresponding Z_mid that many times for each such # entry. - t = scipy.asarray(t) + t = numpy.asarray(t) if t.ndim != 1: raise ValueError( "rmid2rho: When using the each_t keyword, " "t must have only one dimension." ) - R_mid = scipy.tile( + R_mid = numpy.tile( R_mid, - scipy.concatenate( + numpy.concatenate( ( [len(t), ], - scipy.ones_like( - scipy.shape(R_mid), dtype=float + numpy.ones_like( + numpy.shape(R_mid), dtype=float ) ) ) # may need to be declared as ints ) # TODO: Is there a clever way to do this without a loop? - Z_mid_temp = scipy.ones_like(R_mid, dtype=float) - t_temp = scipy.ones_like(R_mid, dtype=float) + Z_mid_temp = numpy.ones_like(R_mid, dtype=float) + t_temp = numpy.ones_like(R_mid, dtype=float) for k in range(0, len(Z_mid)): Z_mid_temp[k] *= Z_mid[k] t_temp[k] *= t[k] @@ -2137,7 +2140,7 @@ def roa2rmid( * **Rmid** (`Array or scalar float`) - The converted coordinates. If all of the input arguments are scalar, then a scalar is returned. - Otherwise, a scipy Array is returned. + Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `Rmid`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -2200,8 +2203,8 @@ def roa2rmid( else: R_mid = R_mid.reshape(original_shape) elif each_t: - R_mid = scipy.zeros( - scipy.concatenate( + R_mid = numpy.zeros( + numpy.concatenate( ([len(time_idxs), ], original_shape) ).astype(int) ) @@ -2260,7 +2263,7 @@ def roa2psinorm(self, *args, **kwargs): * **psinorm** (`Array or scalar float`) - The converted coordinates. If all of the input arguments are scalar, then a scalar is returned. - Otherwise, a scipy Array is returned. + Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `psinorm`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -2324,7 +2327,7 @@ def roa2phinorm(self, *args, **kwargs): * **phinorm** (`Array or scalar float`) - The converted coordinates. If all of the input arguments are scalar, then a scalar is returned. - Otherwise, a scipy Array is returned. + Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `phinorm`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -2388,7 +2391,7 @@ def roa2volnorm(self, *args, **kwargs): * **volnorm** (`Array or scalar float`) - The converted coordinates. If all of the input arguments are scalar, then a scalar is returned. - Otherwise, a scipy Array is returned. + Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `volnorm`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -2488,7 +2491,7 @@ def roa2rho(self, method, *args, **kwargs): * **rho** (`Array or scalar float`) - The converted coordinates. If all of the input arguments are scalar, then a scalar is returned. - Otherwise, a scipy Array is returned. + Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `rho`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -2576,7 +2579,7 @@ def psinorm2rmid(self, psi_norm, t, **kwargs): * **Rmid** (`Array or scalar float`) - The converted coordinates. If all of the input arguments are scalar, then a scalar is returned. - Otherwise, a scipy Array is returned. + Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `Rmid`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -2654,7 +2657,7 @@ def psinorm2roa(self, psi_norm, t, **kwargs): * **roa** (`Array or scalar float`) - Normalized midplane minor radius. If all of the input arguments are scalar, then a scalar - is returned. Otherwise, a scipy Array is returned. + is returned. Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `roa`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -2719,7 +2722,7 @@ def psinorm2volnorm(self, psi_norm, t, **kwargs): * **volnorm** (`Array or scalar float`) - The converted coordinates. If all of the input arguments are scalar, then a scalar is returned. - Otherwise, a scipy Array is returned. + Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `volnorm`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -2785,7 +2788,7 @@ def psinorm2phinorm(self, psi_norm, t, **kwargs): * **phinorm** (`Array or scalar float`) - The converted coordinates. If all of the input arguments are scalar, then a scalar is returned. - Otherwise, a scipy Array is returned. + Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `phinorm`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -2887,7 +2890,7 @@ def psinorm2rho(self, method, *args, **kwargs): * **rho** (`Array or scalar float`) - The converted coordinates. If all of the input arguments are scalar, then a scalar is returned. - Otherwise, a scipy Array is returned. + Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `rho`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -2983,7 +2986,7 @@ def phinorm2psinorm(self, phinorm, t, **kwargs): * **psinorm** (`Array or scalar float`) - The converted coordinates. If all of the input arguments are scalar, then a scalar is returned. - Otherwise, a scipy Array is returned. + Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `psinorm`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -3049,7 +3052,7 @@ def phinorm2volnorm(self, *args, **kwargs): * **volnorm** (`Array or scalar float`) - The converted coordinates. If all of the input arguments are scalar, then a scalar is returned. - Otherwise, a scipy Array is returned. + Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `volnorm`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -3133,7 +3136,7 @@ def phinorm2rmid(self, *args, **kwargs): * **Rmid** (`Array or scalar float`) - The converted coordinates. If all of the input arguments are scalar, then a scalar is returned. - Otherwise, a scipy Array is returned. + Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `Rmid`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -3210,7 +3213,7 @@ def phinorm2roa(self, phi_norm, t, **kwargs): * **roa** (`Array or scalar float`) - Normalized midplane minor radius. If all of the input arguments are scalar, then a scalar - is returned. Otherwise, a scipy Array is returned. + is returned. Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `roa`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -3313,7 +3316,7 @@ def phinorm2rho(self, method, *args, **kwargs): * **rho** (`Array or scalar float`) - The converted coordinates. If all of the input arguments are scalar, then a scalar is returned. - Otherwise, a scipy Array is returned. + Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `rho`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -3408,7 +3411,7 @@ def volnorm2psinorm(self, *args, **kwargs): * **psinorm** (`Array or scalar float`) - The converted coordinates. If all of the input arguments are scalar, then a scalar is returned. - Otherwise, a scipy Array is returned. + Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `psinorm`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -3474,7 +3477,7 @@ def volnorm2phinorm(self, *args, **kwargs): * **phinorm** (`Array or scalar float`) - The converted coordinates. If all of the input arguments are scalar, then a scalar is returned. - Otherwise, a scipy Array is returned. + Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `phinorm`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -3558,7 +3561,7 @@ def volnorm2rmid(self, *args, **kwargs): * **Rmid** (`Array or scalar float`) - The converted coordinates. If all of the input arguments are scalar, then a scalar is returned. - Otherwise, a scipy Array is returned. + Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `Rmid`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -3633,7 +3636,7 @@ def volnorm2roa(self, *args, **kwargs): * **roa** (`Array or scalar float`) - The converted coordinates. If all of the input arguments are scalar, then a scalar is returned. - Otherwise, a scipy Array is returned. + Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `roa`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -3736,7 +3739,7 @@ def volnorm2rho(self, method, *args, **kwargs): * **rho** (`Array or scalar float`) - The converted coordinates. If all of the input arguments are scalar, then a scalar is returned. - Otherwise, a scipy Array is returned. + Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `rho`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -3838,7 +3841,7 @@ def rz2q(self, R, Z, t, **kwargs): `Z` or be a scalar. Default is True (evaluate ALL `R`, `Z` at EACH element in `t`). make_grid (Boolean): Set to True to pass `R` and `Z` through - :py:func:`scipy.meshgrid` before evaluating. If this is set to + :py:func:`numpy.meshgrid` before evaluating. If this is set to True, `R` and `Z` must each only have a single dimension, but can have different lengths. Default is False (do not form meshgrid). @@ -3871,7 +3874,7 @@ def rz2q(self, R, Z, t, **kwargs): * **q** (`Array or scalar float`) - The safety factor ("q"). If all of the input arguments are scalar, then a scalar is - returned. Otherwise, a scipy Array is returned. If `R` and `Z` + returned. Otherwise, a numpy Array is returned. If `R` and `Z` both have the same shape then `q` has this shape as well, unless the `make_grid` keyword was True, in which case `q` has shape (len(`Z`), len(`R`)). @@ -3964,7 +3967,7 @@ def rmid2q(self, R_mid, t, **kwargs): * **q** (`Array or scalar float`) - The safety factor ("q"). If all of the input arguments are scalar, then a scalar is - returned. Otherwise, a scipy Array is returned. + returned. Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `q`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -4030,7 +4033,7 @@ def roa2q(self, roa, t, **kwargs): * **q** (`Array or scalar float`) - The safety factor ("q"). If all of the input arguments are scalar, then a scalar is returned. - Otherwise, a scipy Array is returned. + Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `q`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -4096,7 +4099,7 @@ def psinorm2q(self, psinorm, t, **kwargs): * **q** (`Array or scalar float`) - The safety factor ("q"). If all of the input arguments are scalar, then a scalar is returned. - Otherwise, a scipy Array is returned. + Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `q`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -4162,7 +4165,7 @@ def phinorm2q(self, phinorm, t, **kwargs): * **q** (`Array or scalar float`) - The safety factor ("q"). If all of the input arguments are scalar, then a scalar is returned. - Otherwise, a scipy Array is returned. + Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `q`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -4228,7 +4231,7 @@ def volnorm2q(self, volnorm, t, **kwargs): * **q** (`Array or scalar float`) - The safety factor ("q"). If all of the input arguments are scalar, then a scalar is returned. - Otherwise, a scipy Array is returned. + Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `q`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -4295,7 +4298,7 @@ def rz2F(self, R, Z, t, **kwargs): `Z` or be a scalar. Default is True (evaluate ALL `R`, `Z` at EACH element in `t`). make_grid (Boolean): Set to True to pass `R` and `Z` through - :py:func:`scipy.meshgrid` before evaluating. If this is set to + :py:func:`numpy.meshgrid` before evaluating. If this is set to True, `R` and `Z` must each only have a single dimension, but can have different lengths. Default is False (do not form meshgrid). @@ -4328,7 +4331,7 @@ def rz2F(self, R, Z, t, **kwargs): * **F** (`Array or scalar float`) - The flux function :math:`F=RB_{\phi}`. If all of the input arguments are scalar, then a scalar is - returned. Otherwise, a scipy Array is returned. If `R` and `Z` + returned. Otherwise, a numpy Array is returned. If `R` and `Z` both have the same shape then `F` has this shape as well, unless the `make_grid` keyword was True, in which case `F` has shape (len(`Z`), len(`R`)). @@ -4421,7 +4424,7 @@ def rmid2F(self, R_mid, t, **kwargs): * **F** (`Array or scalar float`) - The flux function :math:`F=RB_{\phi}`. If all of the input arguments are scalar, then a scalar is - returned. Otherwise, a scipy Array is returned. + returned. Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `F`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -4487,7 +4490,7 @@ def roa2F(self, roa, t, **kwargs): * **F** (`Array or scalar float`) - The flux function :math:`F=RB_{\phi}`. If all of the input arguments are scalar, then a scalar is returned. - Otherwise, a scipy Array is returned. + Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `F`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -4553,7 +4556,7 @@ def psinorm2F(self, psinorm, t, **kwargs): * **F** (`Array or scalar float`) - The flux function :math:`F=RB_{\phi}`. If all of the input arguments are scalar, then a scalar is returned. - Otherwise, a scipy Array is returned. + Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `F`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -4619,7 +4622,7 @@ def phinorm2F(self, phinorm, t, **kwargs): * **F** (`Array or scalar float`) - The flux function :math:`F=RB_{\phi}`. If all of the input arguments are scalar, then a scalar is returned. - Otherwise, a scipy Array is returned. + Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `F`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -4685,7 +4688,7 @@ def volnorm2F(self, volnorm, t, **kwargs): * **F** (`Array or scalar float`) - The flux function :math:`F=RB_{\phi}`. If all of the input arguments are scalar, then a scalar is returned. - Otherwise, a scipy Array is returned. + Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `F`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -4755,7 +4758,7 @@ def Fnorm2psinorm(self, F, t, **kwargs): * **psinorm** (`Array or scalar float`) - The normalized poloidal flux. If all of the input arguments are scalar, then a scalar is - returned. Otherwise, a scipy Array is returned. + returned. Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `psinorm`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -4824,7 +4827,7 @@ def rz2FFPrime(self, R, Z, t, **kwargs): `Z` or be a scalar. Default is True (evaluate ALL `R`, `Z` at EACH element in `t`). make_grid (Boolean): Set to True to pass `R` and `Z` through - :py:func:`scipy.meshgrid` before evaluating. If this is set to + :py:func:`numpy.meshgrid` before evaluating. If this is set to True, `R` and `Z` must each only have a single dimension, but can have different lengths. Default is False (do not form meshgrid). @@ -4857,7 +4860,7 @@ def rz2FFPrime(self, R, Z, t, **kwargs): * **FFPrime** (`Array or scalar float`) - The flux function :math:`FF'`. If all of the input arguments are scalar, then a scalar is - returned. Otherwise, a scipy Array is returned. If `R` and `Z` + returned. Otherwise, a numpy Array is returned. If `R` and `Z` both have the same shape then `FFPrime` has this shape as well, unless the `make_grid` keyword was True, in which case `FFPrime` has shape (len(`Z`), len(`R`)). @@ -4950,7 +4953,7 @@ def rmid2FFPrime(self, R_mid, t, **kwargs): * **FFPrime** (`Array or scalar float`) - The flux function :math:`FF'`. If all of the input arguments are scalar, then a scalar is - returned. Otherwise, a scipy Array is returned. + returned. Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `FFPrime`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -5016,7 +5019,7 @@ def roa2FFPrime(self, roa, t, **kwargs): * **FFPrime** (`Array or scalar float`) - The flux function :math:`FF'`. If all of the input arguments are scalar, then a scalar is returned. - Otherwise, a scipy Array is returned. + Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `FFPrime`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -5082,7 +5085,7 @@ def psinorm2FFPrime(self, psinorm, t, **kwargs): * **FFPrime** (`Array or scalar float`) - The flux function :math:`FF'`. If all of the input arguments are scalar, then a scalar is returned. - Otherwise, a scipy Array is returned. + Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `FFPrime`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -5148,7 +5151,7 @@ def phinorm2FFPrime(self, phinorm, t, **kwargs): * **FFPrime** (`Array or scalar float`) - The flux function :math:`FF'`. If all of the input arguments are scalar, then a scalar is returned. - Otherwise, a scipy Array is returned. + Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `FFPrime`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -5214,7 +5217,7 @@ def volnorm2FFPrime(self, volnorm, t, **kwargs): * **FFPrime** (`Array or scalar float`) - The flux function :math:`FF'`. If all of the input arguments are scalar, then a scalar is returned. - Otherwise, a scipy Array is returned. + Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `FFPrime`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -5281,7 +5284,7 @@ def rz2p(self, R, Z, t, **kwargs): `Z` or be a scalar. Default is True (evaluate ALL `R`, `Z` at EACH element in `t`). make_grid (Boolean): Set to True to pass `R` and `Z` through - :py:func:`scipy.meshgrid` before evaluating. If this is set to + :py:func:`numpy.meshgrid` before evaluating. If this is set to True, `R` and `Z` must each only have a single dimension, but can have different lengths. Default is False (do not form meshgrid). @@ -5314,7 +5317,7 @@ def rz2p(self, R, Z, t, **kwargs): * **p** (`Array or scalar float`) - The pressure. If all of the input arguments are scalar, then a scalar is - returned. Otherwise, a scipy Array is returned. If `R` and `Z` + returned. Otherwise, a numpy Array is returned. If `R` and `Z` both have the same shape then `p` has this shape as well, unless the `make_grid` keyword was True, in which case `p` has shape (len(`Z`), len(`R`)). @@ -5407,7 +5410,7 @@ def rmid2p(self, R_mid, t, **kwargs): * **p** (`Array or scalar float`) - The pressure. If all of the input arguments are scalar, then a scalar is - returned. Otherwise, a scipy Array is returned. + returned. Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `p`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -5473,7 +5476,7 @@ def roa2p(self, roa, t, **kwargs): * **p** (`Array or scalar float`) - The pressure. If all of the input arguments are scalar, then a scalar is returned. - Otherwise, a scipy Array is returned. + Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `p`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -5539,7 +5542,7 @@ def psinorm2p(self, psinorm, t, **kwargs): * **p** (`Array or scalar float`) - The pressure. If all of the input arguments are scalar, then a scalar is returned. - Otherwise, a scipy Array is returned. + Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `p`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -5605,7 +5608,7 @@ def phinorm2p(self, phinorm, t, **kwargs): * **p** (`Array or scalar float`) - The pressure. If all of the input arguments are scalar, then a scalar is returned. - Otherwise, a scipy Array is returned. + Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `p`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -5671,7 +5674,7 @@ def volnorm2p(self, volnorm, t, **kwargs): * **p** (`Array or scalar float`) - The pressure. If all of the input arguments are scalar, then a scalar is returned. - Otherwise, a scipy Array is returned. + Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `p`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -5738,7 +5741,7 @@ def rz2pprime(self, R, Z, t, **kwargs): `Z` or be a scalar. Default is True (evaluate ALL `R`, `Z` at EACH element in `t`). make_grid (Boolean): Set to True to pass `R` and `Z` through - :py:func:`scipy.meshgrid` before evaluating. If this is set to + :py:func:`numpy.meshgrid` before evaluating. If this is set to True, `R` and `Z` must each only have a single dimension, but can have different lengths. Default is False (do not form meshgrid). @@ -5771,7 +5774,7 @@ def rz2pprime(self, R, Z, t, **kwargs): * **pprime** (`Array or scalar float`) - The pressure gradient. If all of the input arguments are scalar, then a scalar is - returned. Otherwise, a scipy Array is returned. If `R` and `Z` + returned. Otherwise, a numpy Array is returned. If `R` and `Z` both have the same shape then `p` has this shape as well, unless the `make_grid` keyword was True, in which case `p` has shape (len(`Z`), len(`R`)). @@ -5864,7 +5867,7 @@ def rmid2pprime(self, R_mid, t, **kwargs): * **pprime** (`Array or scalar float`) - The pressure gradient. If all of the input arguments are scalar, then a scalar is - returned. Otherwise, a scipy Array is returned. + returned. Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `pprime`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -5930,7 +5933,7 @@ def roa2pprime(self, roa, t, **kwargs): * **pprime** (`Array or scalar float`) - The pressure gradient. If all of the input arguments are scalar, then a scalar is returned. - Otherwise, a scipy Array is returned. + Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `pprime`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -5996,7 +5999,7 @@ def psinorm2pprime(self, psinorm, t, **kwargs): * **pprime** (`Array or scalar float`) - The pressure gradient. If all of the input arguments are scalar, then a scalar is returned. - Otherwise, a scipy Array is returned. + Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `pprime`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -6062,7 +6065,7 @@ def phinorm2pprime(self, phinorm, t, **kwargs): * **pprime** (`Array or scalar float`) - The pressure gradient. If all of the input arguments are scalar, then a scalar is returned. - Otherwise, a scipy Array is returned. + Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `pprime`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -6128,7 +6131,7 @@ def volnorm2pprime(self, volnorm, t, **kwargs): * **pprime** (`Array or scalar float`) - The pressure gradient. If all of the input arguments are scalar, then a scalar is returned. - Otherwise, a scipy Array is returned. + Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `pprime`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -6195,7 +6198,7 @@ def rz2v(self, R, Z, t, **kwargs): `Z` or be a scalar. Default is True (evaluate ALL `R`, `Z` at EACH element in `t`). make_grid (Boolean): Set to True to pass `R` and `Z` through - :py:func:`scipy.meshgrid` before evaluating. If this is set to + :py:func:`numpy.meshgrid` before evaluating. If this is set to True, `R` and `Z` must each only have a single dimension, but can have different lengths. Default is False (do not form meshgrid). @@ -6228,7 +6231,7 @@ def rz2v(self, R, Z, t, **kwargs): * **v** (`Array or scalar float`) - The flux surface volume. If all of the input arguments are scalar, then a scalar is - returned. Otherwise, a scipy Array is returned. If `R` and `Z` + returned. Otherwise, a numpy Array is returned. If `R` and `Z` both have the same shape then `v` has this shape as well, unless the `make_grid` keyword was True, in which case `v` has shape (len(`Z`), len(`R`)). @@ -6321,7 +6324,7 @@ def rmid2v(self, R_mid, t, **kwargs): * **v** (`Array or scalar float`) - The flux surface volume. If all of the input arguments are scalar, then a scalar is - returned. Otherwise, a scipy Array is returned. + returned. Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `v`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -6387,7 +6390,7 @@ def roa2v(self, roa, t, **kwargs): * **v** (`Array or scalar float`) - The flux surface volume. If all of the input arguments are scalar, then a scalar is returned. - Otherwise, a scipy Array is returned. + Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `v`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -6453,7 +6456,7 @@ def psinorm2v(self, psinorm, t, **kwargs): * **v** (`Array or scalar float`) - The pressure. If all of the input arguments are scalar, then a scalar is returned. - Otherwise, a scipy Array is returned. + Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `v`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -6519,7 +6522,7 @@ def phinorm2v(self, phinorm, t, **kwargs): * **v** (`Array or scalar float`) - The flux surface volume. If all of the input arguments are scalar, then a scalar is returned. - Otherwise, a scipy Array is returned. + Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `v`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -6585,7 +6588,7 @@ def volnorm2v(self, volnorm, t, **kwargs): * **v** (`Array or scalar float`) - The flux surface volume. If all of the input arguments are scalar, then a scalar is returned. - Otherwise, a scipy Array is returned. + Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `v`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -6657,7 +6660,7 @@ def rz2BR( `Z` or be a scalar. Default is True (evaluate ALL `R`, `Z` at EACH element in `t`). make_grid (Boolean): Set to True to pass `R` and `Z` through - :py:func:`scipy.meshgrid` before evaluating. If this is set to + :py:func:`numpy.meshgrid` before evaluating. If this is set to True, `R` and `Z` must each only have a single dimension, but can have different lengths. Default is False (do not form meshgrid). @@ -6690,7 +6693,7 @@ def rz2BR( * **BR** (`Array or scalar float`) - The major radial component of the magnetic field. If all of the input arguments are scalar, then - a scalar is returned. Otherwise, a scipy Array is returned. If `R` + a scalar is returned. Otherwise, a numpy Array is returned. If `R` and `Z` both have the same shape then `BR` has this shape as well, unless the `make_grid` keyword was True, in which case `BR` has shape (len(`Z`), len(`R`)). @@ -6743,7 +6746,7 @@ def rz2BR( ) if self._tricubic: - out_vals = scipy.reshape( + out_vals = numpy.reshape( -1.0 / R * self._getFluxTriSpline().ev( t, Z, R, dx=0, dy=1, dz=0 ), @@ -6757,22 +6760,22 @@ def rz2BR( if single_val: out_vals = out_vals[0] else: - out_vals = scipy.reshape(out_vals, original_shape) + out_vals = numpy.reshape(out_vals, original_shape) elif each_t: - out_vals = scipy.zeros( - scipy.concatenate( + out_vals = numpy.zeros( + numpy.concatenate( ([len(time_idxs), ], original_shape) ).astype(int) ) for idx, t_idx in enumerate(time_idxs): - out_vals[idx] = scipy.reshape( + out_vals[idx] = numpy.reshape( -1.0 / R * self._getFluxBiSpline(t_idx).ev( Z, R, dx=1, dy=0 ), original_shape ) else: - out_vals = scipy.zeros_like(t, dtype=float) + out_vals = numpy.zeros_like(t, dtype=float) for t_idx in unique_idxs: t_mask = (time_idxs == t_idx) out_vals[t_mask] = ( @@ -6780,7 +6783,7 @@ def rz2BR( Z[t_mask], R[t_mask], dx=1, dy=0 ) ) - out_vals = scipy.reshape(out_vals, original_shape) + out_vals = numpy.reshape(out_vals, original_shape) # Correct for current sign: out_vals = -1.0 * out_vals * self.getCurrentSign() @@ -6835,7 +6838,7 @@ def rz2BZ( `Z` or be a scalar. Default is True (evaluate ALL `R`, `Z` at EACH element in `t`). make_grid (Boolean): Set to True to pass `R` and `Z` through - :py:func:`scipy.meshgrid` before evaluating. If this is set to + :py:func:`numpy.meshgrid` before evaluating. If this is set to True, `R` and `Z` must each only have a single dimension, but can have different lengths. Default is False (do not form meshgrid). @@ -6868,7 +6871,7 @@ def rz2BZ( * **BZ** (`Array or scalar float`) - The vertical component of the magnetic field. If all of the input arguments are scalar, then a - scalar is returned. Otherwise, a scipy Array is returned. If `R` + scalar is returned. Otherwise, a numpy Array is returned. If `R` and `Z` both have the same shape then `BZ` has this shape as well, unless the `make_grid` keyword was True, in which case `BZ` has shape (len(`Z`), len(`R`)). @@ -6921,7 +6924,7 @@ def rz2BZ( ) if self._tricubic: - out_vals = scipy.reshape( + out_vals = numpy.reshape( 1.0 / R * self._getFluxTriSpline().ev( t, Z, R, dx=0, dy=0, dz=1 ), @@ -6935,28 +6938,28 @@ def rz2BZ( if single_val: out_vals = out_vals[0] else: - out_vals = scipy.reshape(out_vals, original_shape) + out_vals = numpy.reshape(out_vals, original_shape) elif each_t: - out_vals = scipy.zeros( - scipy.concatenate( + out_vals = numpy.zeros( + numpy.concatenate( ([len(time_idxs), ], original_shape) ).astype(int) ) for idx, t_idx in enumerate(time_idxs): - out_vals[idx] = scipy.reshape( + out_vals[idx] = numpy.reshape( 1.0 / R * self._getFluxBiSpline(t_idx).ev( Z, R, dx=0, dy=1 ), original_shape ) else: - out_vals = scipy.zeros_like(t, dtype=float) + out_vals = numpy.zeros_like(t, dtype=float) for t_idx in unique_idxs: t_mask = (time_idxs == t_idx) out_vals[t_mask] = 1.0 / R[t_mask] * self._getFluxBiSpline( t_idx ).ev(Z[t_mask], R[t_mask], dx=0, dy=1) - out_vals = scipy.reshape(out_vals, original_shape) + out_vals = numpy.reshape(out_vals, original_shape) # Correct for current sign: out_vals = -1.0 * out_vals * self.getCurrentSign() @@ -7013,7 +7016,7 @@ def rz2BT(self, R, Z, t, **kwargs): `Z` or be a scalar. Default is True (evaluate ALL `R`, `Z` at EACH element in `t`). make_grid (Boolean): Set to True to pass `R` and `Z` through - :py:func:`scipy.meshgrid` before evaluating. If this is set to + :py:func:`numpy.meshgrid` before evaluating. If this is set to True, `R` and `Z` must each only have a single dimension, but can have different lengths. Default is False (do not form meshgrid). @@ -7046,7 +7049,7 @@ def rz2BT(self, R, Z, t, **kwargs): * **BT** (`Array or scalar float`) - The toroidal magnetic field. If all of the input arguments are scalar, then a scalar is - returned. Otherwise, a scipy Array is returned. If `R` and `Z` + returned. Otherwise, a numpy Array is returned. If `R` and `Z` both have the same shape then `BT` has this shape as well, unless the `make_grid` keyword was True, in which case `BT` has shape (len(`Z`), len(`R`)). @@ -7096,7 +7099,7 @@ def rz2BT(self, R, Z, t, **kwargs): # This will have NaN anywhere outside of the LCFS. Only handle if we # we need to. - if scipy.isnan(B_T).any(): + if numpy.isnan(B_T).any(): warnings.warn( "Flux function F not provided outside of LCFS, assuming field " "goes like 1/R there to compute BT! This may be inaccurate!", @@ -7115,16 +7118,16 @@ def rz2BT(self, R, Z, t, **kwargs): ) if self._tricubic: B_T = B_T.ravel() - mask = scipy.isnan(B_T) + mask = numpy.isnan(B_T) B_T[mask] = ( self.getBtVacSpline()(t[mask]) * self.getMagRSpline()(t[mask]) / R[mask] ) - B_T = scipy.reshape(B_T, original_shape) + B_T = numpy.reshape(B_T, original_shape) else: if single_time: B_T = B_T.ravel() - mask = scipy.isnan(B_T) + mask = numpy.isnan(B_T) B_T[mask] = ( self.getBtVac()[time_idxs] * self.getMagR()[time_idxs] / R[mask] @@ -7132,28 +7135,28 @@ def rz2BT(self, R, Z, t, **kwargs): if single_val: B_T = B_T[0] else: - B_T = scipy.reshape(B_T, original_shape) + B_T = numpy.reshape(B_T, original_shape) elif kwargs.get('each_t', True): for idx, t_idx in enumerate(time_idxs): tmp_out = B_T[idx].ravel() - mask = scipy.isnan(tmp_out) + mask = numpy.isnan(tmp_out) tmp_out[mask] = ( self.getBtVac()[t_idx] * self.getMagR()[t_idx] / R[mask] ) - B_T[idx] = scipy.reshape(tmp_out, original_shape) + B_T[idx] = numpy.reshape(tmp_out, original_shape) else: B_T = B_T.ravel() for t_idx in unique_idxs: t_mask = (time_idxs == t_idx) tmp_out = B_T[t_mask] - mask = scipy.isnan(tmp_out) + mask = numpy.isnan(tmp_out) tmp_out[mask] = ( self.getBtVac()[t_idx] * self.getMagR()[t_idx] / R[t_mask][mask] ) B_T[t_mask] = tmp_out - B_T = scipy.reshape(B_T, original_shape) + B_T = numpy.reshape(B_T, original_shape) if return_t: return unit_factor * B_T, blob @@ -7190,7 +7193,7 @@ def rz2B(self, R, Z, t, **kwargs): `Z` or be a scalar. Default is True (evaluate ALL `R`, `Z` at EACH element in `t`). make_grid (Boolean): Set to True to pass `R` and `Z` through - :py:func:`scipy.meshgrid` before evaluating. If this is set to + :py:func:`numpy.meshgrid` before evaluating. If this is set to True, `R` and `Z` must each only have a single dimension, but can have different lengths. Default is False (do not form meshgrid). @@ -7223,7 +7226,7 @@ def rz2B(self, R, Z, t, **kwargs): * **B** (`Array or scalar float`) - The magnitude of the magnetic field. If all of the input arguments are scalar, then a scalar is - returned. Otherwise, a scipy Array is returned. If `R` and `Z` + returned. Otherwise, a numpy Array is returned. If `R` and `Z` both have the same shape then `B` has this shape as well, unless the `make_grid` keyword was True, in which case `B` has shape (len(`Z`), len(`R`)). @@ -7263,7 +7266,7 @@ def rz2B(self, R, Z, t, **kwargs): BR = self.rz2BR(R, Z, t, **kwargs) BZ = self.rz2BZ(R, Z, t, **kwargs) BT = self.rz2BT(R, Z, t, **kwargs) - return scipy.sqrt(BR**2.0 + BZ**2.0 + BT**2.0) + return numpy.sqrt(BR**2.0 + BZ**2.0 + BT**2.0) ############################ # Current density routines # @@ -7303,7 +7306,7 @@ def rz2jR(self, R, Z, t, **kwargs): `Z` or be a scalar. Default is True (evaluate ALL `R`, `Z` at EACH element in `t`). make_grid (Boolean): Set to True to pass `R` and `Z` through - :py:func:`scipy.meshgrid` before evaluating. If this is set to + :py:func:`numpy.meshgrid` before evaluating. If this is set to True, `R` and `Z` must each only have a single dimension, but can have different lengths. Default is False (do not form meshgrid). @@ -7336,7 +7339,7 @@ def rz2jR(self, R, Z, t, **kwargs): * **jR** (`Array or scalar float`) - The major radial component of the current density. If all of the input arguments are scalar, then - a scalar is returned. Otherwise, a scipy Array is returned. If `R` + a scalar is returned. Otherwise, a numpy Array is returned. If `R` and `Z` both have the same shape then `jR` has this shape as well, unless the `make_grid` keyword was True, in which case `jR` has shape (len(`Z`), len(`R`)). @@ -7421,7 +7424,7 @@ def rz2jZ(self, R, Z, t, **kwargs): `Z` or be a scalar. Default is True (evaluate ALL `R`, `Z` at EACH element in `t`). make_grid (Boolean): Set to True to pass `R` and `Z` through - :py:func:`scipy.meshgrid` before evaluating. If this is set to + :py:func:`numpy.meshgrid` before evaluating. If this is set to True, `R` and `Z` must each only have a single dimension, but can have different lengths. Default is False (do not form meshgrid). @@ -7454,7 +7457,7 @@ def rz2jZ(self, R, Z, t, **kwargs): * **jZ** (`Array or scalar float`) - The vertical component of the current density. If all of the input arguments are scalar, then a - scalar is returned. Otherwise, a scipy Array is returned. If `R` + scalar is returned. Otherwise, a numpy Array is returned. If `R` and `Z` both have the same shape then `jZ` has this shape as well, unless the `make_grid` keyword was True, in which case `jZ` has shape (len(`Z`), len(`R`)). @@ -7538,7 +7541,7 @@ def rz2jT(self, R, Z, t, **kwargs): `Z` or be a scalar. Default is True (evaluate ALL `R`, `Z` at EACH element in `t`). make_grid (Boolean): Set to True to pass `R` and `Z` through - :py:func:`scipy.meshgrid` before evaluating. If this is set to + :py:func:`numpy.meshgrid` before evaluating. If this is set to True, `R` and `Z` must each only have a single dimension, but can have different lengths. Default is False (do not form meshgrid). @@ -7571,7 +7574,7 @@ def rz2jT(self, R, Z, t, **kwargs): * **jT** (`Array or scalar float`) - The major radial component of the current density. If all of the input arguments are scalar, - then a scalar is returned. Otherwise, a scipy Array is returned. + then a scalar is returned. Otherwise, a numpy Array is returned. If `R` and `Z` both have the same shape then `jT` has this shape as well, unless the `make_grid` keyword was True, in which case `jT` has shape (len(`Z`), len(`R`)). @@ -7651,7 +7654,7 @@ def rz2j(self, R, Z, t, **kwargs): `Z` or be a scalar. Default is True (evaluate ALL `R`, `Z` at EACH element in `t`). make_grid (Boolean): Set to True to pass `R` and `Z` through - :py:func:`scipy.meshgrid` before evaluating. If this is set to + :py:func:`numpy.meshgrid` before evaluating. If this is set to True, `R` and `Z` must each only have a single dimension, but can have different lengths. Default is False (do not form meshgrid). @@ -7684,7 +7687,7 @@ def rz2j(self, R, Z, t, **kwargs): * **j** (`Array or scalar float`) - The magnitude of the current density. If all of the input arguments are scalar, then a scalar - is returned. Otherwise, a scipy Array is returned. If `R` and `Z` + is returned. Otherwise, a numpy Array is returned. If `R` and `Z` both have the same shape then `j` has this shape as well, unless the `make_grid` keyword was True, in which case `j` has shape (len(`Z`), len(`R`)). @@ -7725,7 +7728,7 @@ def rz2j(self, R, Z, t, **kwargs): jR = self.rz2jR(R, Z, t, **kwargs) jZ = self.rz2jZ(R, Z, t, **kwargs) jT = self.rz2jT(R, Z, t, **kwargs) - return scipy.sqrt(jR**2.0 + jZ**2.0 + jT**2.0) + return numpy.sqrt(jR**2.0 + jZ**2.0 + jT**2.0) ########################## # Field mapping routines # @@ -7765,7 +7768,7 @@ def _fl_func(self, phi, RZ, t, field='B'): return [uR * R / uT, uZ * R / uT] def rz2FieldLineTrace(self, R0, Z0, t, phi0=0.0, field='B', num_rev=1.0, - rev_method='toroidal', dphi=2.0 * scipy.pi / 100.0, + rev_method='toroidal', dphi=2.0 * numpy.pi / 100.0, integrator='dopri5'): """Trace a field line starting from a given (R, phi, Z) point. @@ -7807,7 +7810,7 @@ def rz2FieldLineTrace(self, R0, Z0, t, phi0=0.0, field='B', num_rev=1.0, q = self.rz2q(R0, Z0, t) num_rev = num_rev * q nsteps = int( - scipy.absolute(scipy.ceil(num_rev * 2.0 * scipy.pi / dphi)) + numpy.absolute(numpy.ceil(num_rev * 2.0 * numpy.pi / dphi)) ) if isinstance(integrator, scipy.integrate.ode): @@ -7817,7 +7820,7 @@ def rz2FieldLineTrace(self, R0, Z0, t, phi0=0.0, field='B', num_rev=1.0, r.set_integrator(integrator) r.set_f_params(t, field) r.set_initial_value([R0, Z0], phi0) - out = scipy.zeros((nsteps + 1, 3)) # R, Z, Phi + out = numpy.zeros((nsteps + 1, 3)) # R, Z, Phi out[0, :] = [R0, Z0, phi0] for i in range(1, nsteps + 1): out[i, 0:2] = r.integrate(r.t + dphi) @@ -7945,9 +7948,9 @@ def plotField(self, t, rhovals=6, rhomin=0.05, rhomax=0.95, color='b', Returns: (figure, axis): The figure and axis which the field lines were plotted in. """ - rhovals = scipy.asarray(rhovals, dtype=float) + rhovals = numpy.asarray(rhovals, dtype=float) if rhovals.ndim == 0: - rhovals = scipy.linspace(rhomin, rhomax, int(rhovals)) + rhovals = numpy.linspace(rhomin, rhomax, int(rhovals)) rzt = [] for rho in rhovals: @@ -7970,7 +7973,7 @@ def plotField(self, t, rhovals=6, rhomin=0.05, rhomax=0.95, color='b', # Need to do this ahead of time to get the right scaling for all lines: if color == 'magnitude': mag_max = 0.0 - mag_min = scipy.inf + mag_min = numpy.inf mag = [] for v in rzt: if kwargs.get('field', 'B') == 'B': @@ -7993,8 +7996,8 @@ def plotField(self, t, rhovals=6, rhomin=0.05, rhomax=0.95, color='b', ) v_ext = max( - scipy.absolute(self.getRGrid()).max(), - scipy.absolute(self.getZGrid()).max() + numpy.absolute(self.getRGrid()).max(), + numpy.absolute(self.getZGrid()).max() ) for j, v in enumerate(rzt): @@ -8003,7 +8006,7 @@ def plotField(self, t, rhovals=6, rhomin=0.05, rhomax=0.95, color='b', for i in range(0, v.shape[0] - 1): c = plt.get_cmap(cmap)( int( - scipy.around( + numpy.around( 255 * ( (mag[j][i] + mag[j][i + 1]) / 2.0 - mag_min ) / (mag_max - mag_min) @@ -8011,8 +8014,8 @@ def plotField(self, t, rhovals=6, rhomin=0.05, rhomax=0.95, color='b', ) )[:3] a.plot( - v[i:i + 2, 0] * scipy.cos(v[i:i + 2, 2]), - v[i:i + 2, 0] * scipy.sin(v[i:i + 2, 2]), + v[i:i + 2, 0] * numpy.cos(v[i:i + 2, 2]), + v[i:i + 2, 0] * numpy.sin(v[i:i + 2, 2]), v[i:i + 2, 1], color=c, alpha=alpha, @@ -8020,8 +8023,8 @@ def plotField(self, t, rhovals=6, rhomin=0.05, rhomax=0.95, color='b', ) else: l, = a.plot( - v[:, 0] * scipy.cos(v[:, 2]), - v[:, 0] * scipy.sin(v[:, 2]), + v[:, 0] * numpy.cos(v[:, 2]), + v[:, 0] * numpy.sin(v[:, 2]), v[:, 1], color=None if color == 'sequential' else color, alpha=alpha, @@ -8038,13 +8041,13 @@ def plotField(self, t, rhovals=6, rhomin=0.05, rhomax=0.95, color='b', uR = self.rz2jR(v[0, 0], v[0, 1], t) uZ = self.rz2jZ(v[0, 0], v[0, 1], t) uT = self.rz2jT(v[0, 0], v[0, 1], t) - u = scipy.sqrt(uR**2.0 + uZ**2.0 + uT**2.0) + u = numpy.sqrt(uR**2.0 + uZ**2.0 + uT**2.0) a.quiver( - v[0, 0] * scipy.cos(v[0, 2]), - v[0, 0] * scipy.sin(v[0, 2]), + v[0, 0] * numpy.cos(v[0, 2]), + v[0, 0] * numpy.sin(v[0, 2]), v[0, 1], - (uR * scipy.cos(v[0, 2]) - uT * scipy.sin(v[0, 2])) / u, - (uR * scipy.sin(v[0, 2]) + uT * scipy.cos(v[0, 2])) / u, + (uR * numpy.cos(v[0, 2]) - uT * numpy.sin(v[0, 2])) / u, + (uR * numpy.sin(v[0, 2]) + uT * numpy.cos(v[0, 2])) / u, uZ / u, color=c, alpha=alpha, @@ -8125,7 +8128,7 @@ def _psinorm2Quan(self, spline_func, psi_norm, t, each_t=True, * **rho** (`Array or scalar float`) - The converted quantity. If all of the input arguments are scalar, then a scalar is returned. - Otherwise, a scipy Array is returned. + Otherwise, a numpy Array is returned. * **time_idxs** (Array with same shape as `rho`) - The indices (in :py:meth:`self.getTimeBase`) that were used for nearest-neighbor interpolation. Only returned if `return_t` is @@ -8172,10 +8175,10 @@ def _psinorm2Quan(self, spline_func, psi_norm, t, each_t=True, if single_val: quan_norm = quan_norm[0] else: - quan_norm = scipy.reshape(quan_norm, original_shape) + quan_norm = numpy.reshape(quan_norm, original_shape) elif each_t: - quan_norm = scipy.zeros( - scipy.concatenate( + quan_norm = numpy.zeros( + numpy.concatenate( ([len(time_idxs), ], original_shape) ).astype(int) ) @@ -8191,7 +8194,7 @@ def _psinorm2Quan(self, spline_func, psi_norm, t, each_t=True, else: if convert_roa: psi_norm = self._roa2rmid(psi_norm, time_idxs) - quan_norm = scipy.zeros_like(t, dtype=float) + quan_norm = numpy.zeros_like(t, dtype=float) for t_idx in unique_idxs: t_mask = (time_idxs == t_idx) tmp = spline_func(t_idx, k=k)(psi_norm[t_mask]) @@ -8204,8 +8207,8 @@ def _psinorm2Quan(self, spline_func, psi_norm, t, each_t=True, if quan_norm < 0.0: quan_norm = 0.0 else: - scipy.place(quan_norm, quan_norm < 0, 0.0) - quan_norm = scipy.sqrt(quan_norm) + numpy.place(quan_norm, quan_norm < 0, 0.0) + quan_norm = numpy.sqrt(quan_norm) if return_t: if self._tricubic: @@ -8252,10 +8255,10 @@ def _psinorm2Quan(self, spline_func, psi_norm, t, each_t=True, if single_val: quan_norm = quan_norm[0] else: - quan_norm = scipy.reshape(quan_norm, original_shape) + quan_norm = numpy.reshape(quan_norm, original_shape) elif each_t: - quan_norm = scipy.zeros( - scipy.concatenate( + quan_norm = numpy.zeros( + numpy.concatenate( ([len(time_idxs),], original_shape) ).astype(int) ) @@ -8267,7 +8270,7 @@ def _psinorm2Quan(self, spline_func, psi_norm, t, each_t=True, tmp = self._rmid2roa(tmp, t_idx) quan_norm[idx] = tmp.reshape(original_shape) else: - quan_norm = scipy.zeros_like(time_idxs, dtype=float) + quan_norm = numpy.zeros_like(time_idxs, dtype=float) for t_idx in unique_idxs: t_mask = (time_idxs == t_idx) tmp = spline_func(t_idx, k=k)(psi_norm_flat[t_mask]) @@ -8281,8 +8284,8 @@ def _psinorm2Quan(self, spline_func, psi_norm, t, each_t=True, if quan_norm < 0: quan_norm = 0.0 else: - scipy.place(quan_norm, quan_norm < 0, 0.0) - quan_norm = scipy.sqrt(quan_norm) + numpy.place(quan_norm, quan_norm < 0, 0.0) + quan_norm = numpy.sqrt(quan_norm) if return_t: return quan_norm, blob @@ -8451,7 +8454,7 @@ def _RZ2Quan(self, spline_func, R, Z, t, **kwargs): Returns: Quan: Array or scalar float. If all of the input arguments are - scalar, then a scalar is returned. Otherwise, a scipy Array + scalar, then a scalar is returned. Otherwise, a numpy Array instance is returned. If R and Z both have the same shape then Quand has this shape as well. If the make_grid keyword was True then R_mid has shape (len(Z), len(R)). @@ -8555,7 +8558,7 @@ def _Rmid2Quan(self, spline_func, R_mid, t, **kwargs): Returns: Quan: Array or scalar float. If all of the input arguments are - scalar, then a scalar is returned. Otherwise, a scipy Array + scalar, then a scalar is returned. Otherwise, a numpy Array instance is returned. Has the same shape as R_mid. time_idxs: Array with same shape as Quan. The indices (in self.getTimeBase()) that were used for nearest-neighbor @@ -8641,7 +8644,7 @@ def _phinorm2Quan(self, spline_func, phinorm, t, **kwargs): Returns: Quan: Array or scalar float. If all of the input arguments are - scalar, then a scalar is returned. Otherwise, a scipy Array + scalar, then a scalar is returned. Otherwise, a numpy Array instance is returned. Has the same shape as `phinorm`. time_idxs: Array with same shape as `Quan`. The indices (in self.getTimeBase()) that were used for nearest-neighbor @@ -8723,7 +8726,7 @@ def _volnorm2Quan(self, spline_func, volnorm, t, **kwargs): Returns: Quan: Array or scalar float. If all of the input arguments are - scalar, then a scalar is returned. Otherwise, a scipy Array + scalar, then a scalar is returned. Otherwise, a numpy Array instance is returned. Has the same shape as `volnorm`. time_idxs: Array with same shape as `Quan`. The indices (in self.getTimeBase()) that were used for nearest-neighbor @@ -8919,7 +8922,7 @@ def _processRZt( ): """Input checker/processor. - Takes R, Z and t. Appropriately packages them into scipy arrays. Checks + Takes R, Z and t. Appropriately packages them into numpy.arrays. Checks the validity of the R, Z ranges. If there is a single time value but multiple R, Z values, creates matching time vector. If there is a single R, Z value but multiple t values, creates matching R and Z vectors. @@ -9005,9 +9008,9 @@ def _processRZt( # Get everything into sensical datatypes. Must force it to be float to # keep scipy.interpolate happy. - R = scipy.asarray(R, dtype=float) - Z = scipy.asarray(Z, dtype=float) - t = scipy.asarray(t, dtype=float) + R = numpy.asarray(R, dtype=float) + Z = numpy.asarray(Z, dtype=float) + t = numpy.asarray(t, dtype=float) single_time = (t.ndim == 0) single_val = (R.ndim == 0) and (Z.ndim == 0) @@ -9025,7 +9028,7 @@ def _processRZt( "_processRZt: When using the make_grid keyword, the number " "of dimensions of R and Z must both be one!" ) - R, Z = scipy.meshgrid(R, Z) + R, Z = numpy.meshgrid(R, Z) else: if R.shape != Z.shape: raise ValueError( @@ -9058,34 +9061,34 @@ def _processRZt( # Handle bug in older scipy: if R.ndim == 0: if not good_points: - R = scipy.nan + R = numpy.nan else: - scipy.place(R, ~good_points, scipy.nan) + numpy.place(R, ~good_points, numpy.nan) if Z.ndim == 0: if not good_points: - Z = scipy.nan + Z = numpy.nan else: - scipy.place(Z, ~good_points, scipy.nan) + numpy.place(Z, ~good_points, numpy.nan) if self._tricubic: # When using tricubic spline interpolation, the arrays must be # replicated when using the each_t keyword. if single_time: - t = t * scipy.ones_like(R, dtype=float) + t = t * numpy.ones_like(R, dtype=float) elif each_t: - R = scipy.tile(R, [len(t), ] + [1, ] * R.ndim) - Z = scipy.tile(Z, [len(t), ] + [1, ] * Z.ndim) - t = t[scipy.indices(R.shape)[0]] + R = numpy.tile(R, [len(t), ] + [1, ] * R.ndim) + Z = numpy.tile(Z, [len(t), ] + [1, ] * Z.ndim) + t = t[numpy.indices(R.shape)[0]] time_idxs = None unique_idxs = None - t = scipy.reshape(t, -1) + t = numpy.reshape(t, -1) else: - t = scipy.reshape(t, -1) + t = numpy.reshape(t, -1) timebase = self.getTimeBase() # Get nearest-neighbor points: time_idxs = self._getNearestIdx(t, timebase) # Check errors and warn if needed: - t_errs = scipy.absolute(t - timebase[time_idxs]) + t_errs = numpy.absolute(t - timebase[time_idxs]) # Assume a constant sampling rate to save time: if ( len(time_idxs) > 1 and @@ -9099,13 +9102,13 @@ def _processRZt( RuntimeWarning ) if compute_unique and not single_time and not each_t: - unique_idxs = scipy.unique(time_idxs) + unique_idxs = numpy.unique(time_idxs) else: unique_idxs = None original_shape = R.shape - R = scipy.reshape(R, -1) - Z = scipy.reshape(Z, -1) + R = numpy.reshape(R, -1) + Z = numpy.reshape(Z, -1) return ( R, Z, t, time_idxs, unique_idxs, single_time, single_val, @@ -9139,8 +9142,8 @@ def _checkRZ(self, R, Z): (Z >= self.getZGrid(length_unit='m')[0])) # Gracefully handle single-value versus array inputs, returning in the # corresponding type. - num_good = scipy.sum(good_points) - test = scipy.array(R) + num_good = numpy.sum(good_points) + test = numpy.array(R) if len(test.shape) > 0: num_pts = test.size else: @@ -9161,7 +9164,7 @@ def _getNearestIdx(self, v, a): """Returns the array of indices of the nearest value in a corresponding to each value in v. If the monotonic keyword in the instance is True, then this is done using - scipy.digitize under the assumption that a is monotonic. Otherwise, + numpy.digitize under the assumption that a is monotonic. Otherwise, this is done in a general manner by looking for the minimum distance between the points in v and a. @@ -9179,17 +9182,17 @@ def _getNearestIdx(self, v, a): # corresponding type. if not self._monotonic: try: - return scipy.array( - [(scipy.absolute(a - val)).argmin() for val in v] + return numpy.array( + [(numpy.absolute(a - val)).argmin() for val in v] ) except TypeError: - return (scipy.absolute(a - v)).argmin() + return (numpy.absolute(a - v)).argmin() else: try: - return scipy.digitize(v, (a[1:] + a[:-1]) / 2.0) + return numpy.digitize(v, (a[1:] + a[:-1]) / 2.0) except ValueError: - return scipy.digitize( - scipy.atleast_1d(v), (a[1:] + a[:-1]) / 2.0 + return numpy.digitize( + numpy.atleast_1d(v), (a[1:] + a[:-1]) / 2.0 ).reshape(()) def _getFluxBiSpline(self, idx): @@ -9272,17 +9275,17 @@ def _getPhiNormSpline(self, idx, k=3): # zero: # we need to add the psi axis x = ( - scipy.linspace(0, 1, num=self.getQProfile()[idx].size) * + numpy.linspace(0, 1, num=self.getQProfile()[idx].size) * (self.getFluxLCFS()[idx] - self.getFluxAxis()[idx]) ) - phi_norm_meas = scipy.insert( + phi_norm_meas = numpy.insert( scipy.integrate.cumtrapz(self.getQProfile()[idx], x=x), 0, 0 ) phi_norm_meas = phi_norm_meas / phi_norm_meas[-1] spline = trispline.UnivariateInterpolator( - scipy.linspace(0.0, 1.0, len(phi_norm_meas)), + numpy.linspace(0.0, 1.0, len(phi_norm_meas)), phi_norm_meas, k=k ) @@ -9299,14 +9302,14 @@ def _getPhiNormSpline(self, idx, k=3): # Insert zero at beginning because older versions of cumtrapz # don't support the initial keyword to make the initial value # zero: - phi_norm_meas = scipy.insert( + phi_norm_meas = numpy.insert( scipy.integrate.cumtrapz(self.getQProfile(), axis=1), 0, 0, axis=1 ) - phi_norm_meas = phi_norm_meas / phi_norm_meas[:, -1, scipy.newaxis] + phi_norm_meas = phi_norm_meas / phi_norm_meas[:, -1, numpy.newaxis] self._phiNormSpline = trispline.RectBivariateSpline( self.getTimeBase(), - scipy.linspace(0, 1, len(phi_norm_meas[0, :])), + numpy.linspace(0, 1, len(phi_norm_meas[0, :])), phi_norm_meas, bounds_error=False, s=0 @@ -9342,10 +9345,10 @@ def _getPhiNormToPsiNormSpline(self, idx, k=3): # don't support the initial keyword to make the initial value # zero: x = ( - scipy.linspace(0, 1, num=self.getQProfile()[idx].size) * + numpy.linspace(0, 1, num=self.getQProfile()[idx].size) * (self.getFluxLCFS()[idx] - self.getFluxAxis()[idx]) ) - phi_norm_meas = scipy.insert( + phi_norm_meas = numpy.insert( scipy.integrate.cumtrapz(self.getQProfile()[idx], x=x), 0, 0 ) @@ -9353,7 +9356,7 @@ def _getPhiNormToPsiNormSpline(self, idx, k=3): spline = trispline.UnivariateInterpolator( phi_norm_meas, - scipy.linspace(0.0, 1.0, len(phi_norm_meas)), + numpy.linspace(0.0, 1.0, len(phi_norm_meas)), k=k ) @@ -9369,15 +9372,15 @@ def _getPhiNormToPsiNormSpline(self, idx, k=3): # Insert zero at beginning because older versions of cumtrapz # don't support the initial keyword to make the initial value # zero: - phi_norm_meas = scipy.insert( + phi_norm_meas = numpy.insert( scipy.integrate.cumtrapz(self.getQProfile(), axis=1), 0, 0, axis=1 ) - phi_norm_meas = phi_norm_meas / phi_norm_meas[:, -1, scipy.newaxis] - psinorm_grid, t_grid = scipy.meshgrid( - scipy.linspace(0, 1, phi_norm_meas.shape[1]), + phi_norm_meas = phi_norm_meas / phi_norm_meas[:, -1, numpy.newaxis] + psinorm_grid, t_grid = numpy.meshgrid( + numpy.linspace(0, 1, phi_norm_meas.shape[1]), self.getTimeBase() ) self._phiNormToPsiNormSpline = trispline.BivariateInterpolator( @@ -9416,7 +9419,7 @@ def _getVolNormSpline(self, idx, k=3): vol_norm_meas = vol_norm_meas / vol_norm_meas[-1] spline = trispline.UnivariateInterpolator( - scipy.linspace(0, 1, len(vol_norm_meas)), + numpy.linspace(0, 1, len(vol_norm_meas)), vol_norm_meas, k=k ) @@ -9431,10 +9434,10 @@ def _getVolNormSpline(self, idx, k=3): return self._volNormSpline else: vol_norm_meas = self.getFluxVol() - vol_norm_meas = vol_norm_meas / vol_norm_meas[:, -1, scipy.newaxis] + vol_norm_meas = vol_norm_meas / vol_norm_meas[:, -1, numpy.newaxis] self._volNormSpline = trispline.RectBivariateSpline( self.getTimeBase(), - scipy.linspace(0, 1, len(vol_norm_meas[0, :])), + numpy.linspace(0, 1, len(vol_norm_meas[0, :])), vol_norm_meas, bounds_error=False, s=0 @@ -9471,7 +9474,7 @@ def _getVolNormToPsiNormSpline(self, idx, k=3): spline = trispline.UnivariateInterpolator( vol_norm_meas, - scipy.linspace(0.0, 1.0, len(vol_norm_meas)), + numpy.linspace(0.0, 1.0, len(vol_norm_meas)), k=k ) try: @@ -9485,10 +9488,10 @@ def _getVolNormToPsiNormSpline(self, idx, k=3): return self._volNormToPsiNormSpline else: vol_norm_meas = self.getFluxVol() - vol_norm_meas = vol_norm_meas / vol_norm_meas[:, -1, scipy.newaxis] + vol_norm_meas = vol_norm_meas / vol_norm_meas[:, -1, numpy.newaxis] - psinorm_grid, t_grid = scipy.meshgrid( - scipy.linspace(0, 1, len(vol_norm_meas[0, :])), + psinorm_grid, t_grid = numpy.meshgrid( + numpy.linspace(0, 1, len(vol_norm_meas[0, :])), self.getTimeBase() ) self._volNormToPsiNormSpline = trispline.BivariateInterpolator( @@ -9539,7 +9542,7 @@ def _getRmidSpline(self, idx, k=3): # core. The bivariate spline seems to be a little more robust # in this respect. resample_factor = 3 - R_grid = scipy.linspace( + R_grid = numpy.linspace( self.getMagR(length_unit='m')[idx], self.getRGrid(length_unit='m')[-1], resample_factor * len(self.getRGrid(length_unit='m')) @@ -9547,14 +9550,14 @@ def _getRmidSpline(self, idx, k=3): psi_norm_on_grid = self.rz2psinorm( R_grid, - self.getMagZ(length_unit='m')[idx] * scipy.ones(R_grid.shape), + self.getMagZ(length_unit='m')[idx] * numpy.ones(R_grid.shape), self.getTimeBase()[idx] ) # Correct for the slight issues at the magnetic axis: psi_norm_on_grid[0] = 0.0 # Find if it ever goes non-monotonic: psinorm is assumed to be # strictly INCREASING from the magnetic axis out. - decr_idx, = scipy.where( + decr_idx, = numpy.where( (psi_norm_on_grid[1:] - psi_norm_on_grid[:-1]) < 0 ) if len(decr_idx) > 0: @@ -9576,17 +9579,17 @@ def _getRmidSpline(self, idx, k=3): resample_factor = 3 * len(self.getRGrid(length_unit='m')) # generate timebase and R_grid through a meshgrid - t, R_grid = scipy.meshgrid( + t, R_grid = numpy.meshgrid( self.getTimeBase(), - scipy.zeros((resample_factor,)) + numpy.zeros((resample_factor,)) ) - Z_grid = scipy.dot( - scipy.ones((resample_factor, 1)), - scipy.atleast_2d(self.getMagZ(length_unit='m')) + Z_grid = numpy.dot( + numpy.ones((resample_factor, 1)), + numpy.atleast_2d(self.getMagZ(length_unit='m')) ) - for idx in scipy.arange(self.getTimeBase().size): - R_grid[:, idx] = scipy.linspace( + for idx in numpy.arange(self.getTimeBase().size): + R_grid[:, idx] = numpy.linspace( self.getMagR(length_unit='m')[idx], self.getRGrid(length_unit='m')[-1], resample_factor @@ -9651,7 +9654,7 @@ def _getRmidToPsiNormSpline(self, idx, k=3): # flux grid to avoid 1d interpolation problems in the core. The # bivariate spline seems to be a little more robust in this respect. resample_factor = 3 - R_grid = scipy.linspace( + R_grid = numpy.linspace( # self.getMagR(length_unit='m')[idx], self.getRGrid(length_unit='m')[0], self.getRGrid(length_unit='m')[-1], @@ -9660,7 +9663,7 @@ def _getRmidToPsiNormSpline(self, idx, k=3): psi_norm_on_grid = self.rz2psinorm( R_grid, - self.getMagZ(length_unit='m')[idx] * scipy.ones(R_grid.shape), + self.getMagZ(length_unit='m')[idx] * numpy.ones(R_grid.shape), self.getTimeBase()[idx] ) @@ -9679,18 +9682,18 @@ def _getRmidToPsiNormSpline(self, idx, k=3): resample_factor = 3 * len(self.getRGrid(length_unit='m')) # generate timebase and R_grid through a meshgrid - t, R_grid = scipy.meshgrid( + t, R_grid = numpy.meshgrid( self.getTimeBase(), - scipy.zeros((resample_factor,)) + numpy.zeros((resample_factor,)) ) - Z_grid = scipy.dot( - scipy.ones((resample_factor, 1)), - scipy.atleast_2d(self.getMagZ(length_unit='m')) + Z_grid = numpy.dot( + numpy.ones((resample_factor, 1)), + numpy.atleast_2d(self.getMagZ(length_unit='m')) ) - for idx in scipy.arange(self.getTimeBase().size): + for idx in numpy.arange(self.getTimeBase().size): # TODO: This can be done much more efficiently! - R_grid[:, idx] = scipy.linspace( + R_grid[:, idx] = numpy.linspace( self.getRGrid(length_unit='m')[0], self.getRGrid(length_unit='m')[-1], resample_factor @@ -9735,7 +9738,7 @@ def _getQSpline(self, idx, k=3): except KeyError: q = self.getQProfile()[idx] spline = trispline.UnivariateInterpolator( - scipy.linspace(0.0, 1.0, len(q)), + numpy.linspace(0.0, 1.0, len(q)), q, k=k ) @@ -9751,7 +9754,7 @@ def _getQSpline(self, idx, k=3): q = self.getQProfile() self._qSpline = trispline.RectBivariateSpline( self.getTimeBase(), - scipy.linspace(0.0, 1.0, q.shape[1]), + numpy.linspace(0.0, 1.0, q.shape[1]), q, bounds_error=False, s=0 @@ -9785,7 +9788,7 @@ def _getFSpline(self, idx, k=3): except KeyError: F = self.getF()[idx] spline = trispline.UnivariateInterpolator( - scipy.linspace(0.0, 1.0, len(F)), + numpy.linspace(0.0, 1.0, len(F)), F, k=k ) @@ -9801,7 +9804,7 @@ def _getFSpline(self, idx, k=3): F = self.getF() self._FSpline = trispline.RectBivariateSpline( self.getTimeBase(), - scipy.linspace(0.0, 1.0, F.shape[1]), + numpy.linspace(0.0, 1.0, F.shape[1]), F, bounds_error=False, s=0 @@ -9837,11 +9840,11 @@ def _getFNormToPsiNormSpline(self, idx, k=3): except KeyError: F = self.getF()[idx] F = (F - F.min()) / (F.max() - F.min()) - psinorm_grid = scipy.linspace(0.0, 1.0, len(F)) + psinorm_grid = numpy.linspace(0.0, 1.0, len(F)) # Find if it ever goes non-monotonic: F hacked to be # strictly INCREASING from the magnetic axis out. if self.getCurrentSign() == 1.0: - incr_idx, = scipy.where((F[1:] - F[:-1]) > 0) + incr_idx, = numpy.where((F[1:] - F[:-1]) > 0) if len(incr_idx) > 0: F = F[:incr_idx[0] + 1] psinorm_grid = psinorm_grid[:incr_idx[0] + 1] @@ -9849,7 +9852,7 @@ def _getFNormToPsiNormSpline(self, idx, k=3): F = F[::-1] psinorm_grid = psinorm_grid[::-1] else: - decr_idx, = scipy.where((F[1:] - F[:-1]) < 0) + decr_idx, = numpy.where((F[1:] - F[:-1]) < 0) if len(decr_idx) > 0: F = F[:decr_idx[0] + 1] psinorm_grid = psinorm_grid[:decr_idx[0] + 1] @@ -9869,7 +9872,7 @@ def _getFNormToPsiNormSpline(self, idx, k=3): self._FToPsinormSpline = trispline.RectBivariateSpline( self.getTimeBase(), F, - scipy.linspace(0.0, 1.0, F.shape[1]), + numpy.linspace(0.0, 1.0, F.shape[1]), bounds_error=False, s=0 ) @@ -9902,7 +9905,7 @@ def _getFFPrimeSpline(self, idx, k=3): except KeyError: FFPrime = self.getFFPrime()[idx] spline = trispline.UnivariateInterpolator( - scipy.linspace(0.0, 1.0, len(FFPrime)), + numpy.linspace(0.0, 1.0, len(FFPrime)), FFPrime, k=k ) @@ -9918,7 +9921,7 @@ def _getFFPrimeSpline(self, idx, k=3): FFPrime = self.getFFPrime() self._FFPrimeSpline = trispline.RectBivariateSpline( self.getTimeBase(), - scipy.linspace(0.0, 1.0, FFPrime.shape[1]), + numpy.linspace(0.0, 1.0, FFPrime.shape[1]), FFPrime, bounds_error=False, s=0 @@ -9952,7 +9955,7 @@ def _getPSpline(self, idx, k=3): except KeyError: p = self.getFluxPres()[idx] spline = trispline.UnivariateInterpolator( - scipy.linspace(0.0, 1.0, len(p)), + numpy.linspace(0.0, 1.0, len(p)), p, k=k ) @@ -9968,7 +9971,7 @@ def _getPSpline(self, idx, k=3): p = self.getFluxPres() self._pSpline = trispline.RectBivariateSpline( self.getTimeBase(), - scipy.linspace(0.0, 1.0, p.shape[1]), + numpy.linspace(0.0, 1.0, p.shape[1]), p, bounds_error=False, s=0 @@ -10002,7 +10005,7 @@ def _getPPrimeSpline(self, idx, k=3): except KeyError: pprime = self.getPPrime()[idx] spline = trispline.UnivariateInterpolator( - scipy.linspace(0.0, 1.0, len(pprime)), + numpy.linspace(0.0, 1.0, len(pprime)), pprime, k=k ) @@ -10018,7 +10021,7 @@ def _getPPrimeSpline(self, idx, k=3): pprime = self.getPPrime() self._pPrimeSpline = trispline.RectBivariateSpline( self.getTimeBase(), - scipy.linspace(0.0, 1.0, pprime.shape[1]), + numpy.linspace(0.0, 1.0, pprime.shape[1]), pprime, bounds_error=False, s=0 @@ -10052,7 +10055,7 @@ def _getVSpline(self, idx, k=3): except KeyError: v = self.getFluxVol()[idx] spline = trispline.UnivariateInterpolator( - scipy.linspace(0.0, 1.0, len(v)), + numpy.linspace(0.0, 1.0, len(v)), v, k=k ) @@ -10068,7 +10071,7 @@ def _getVSpline(self, idx, k=3): v = self.getFluxVol() self._vSpline = trispline.RectBivariateSpline( self.getTimeBase(), - scipy.linspace(0.0, 1.0, v.shape[1]), + numpy.linspace(0.0, 1.0, v.shape[1]), v, bounds_error=False, s=0 @@ -11179,8 +11182,8 @@ def updateTime(val): elif limx is not None: psi.plot(limx, limy, 'k', linewidth=lw, zorder=5) # catch NaNs separating disjoint sections of R,ZLCFS in mask - maskarr = scipy.where( - scipy.logical_or(RLCFS[t_idx] > 0.0, scipy.isnan(RLCFS[t_idx])) + maskarr = numpy.where( + numpy.logical_or(RLCFS[t_idx] > 0.0, numpy.isnan(RLCFS[t_idx])) ) RLCFSframe = RLCFS[t_idx, maskarr[0]] ZLCFSframe = ZLCFS[t_idx, maskarr[0]] diff --git a/eqtools/eqdskreader.py b/eqtools/eqdskreader.py index 114a0a1..af5e063 100644 --- a/eqtools/eqdskreader.py +++ b/eqtools/eqdskreader.py @@ -25,7 +25,7 @@ equilibrium data. """ -import scipy +import numpy import glob import re import csv @@ -234,7 +234,7 @@ def __init__(self, time = re.findall(r'\d+', timestring)[0] tunits = timestring.split(time)[1] timeConvertDict = {'ms': 1./1000., 's': 1.} - self._time = scipy.array([float(time)*timeConvertDict[tunits]]) # returns time in seconds as array + self._time = numpy.array([float(time)*timeConvertDict[tunits]]) # returns time in seconds as array except KeyError: tunits = None @@ -250,14 +250,14 @@ def __init__(self, line = re.findall(r'-?\d\.\d*[eE][-+]\d*', line) # regex magic! xdim = float(line[0]) # width of R-axis in grid zdim = float(line[1]) # height of Z-axis in grid - self._RCentr = scipy.array(float(line[2])) # rcentr for Bcentr + self._RCentr = numpy.array(float(line[2])) # rcentr for Bcentr self._defaultUnits['_RCentr'] = 'm' rgrid0 = float(line[3]) # start point of R grid zmid = float(line[4]) # midpoint of Z grid # construct EFIT grid - self._rGrid = scipy.linspace(rgrid0, rgrid0 + xdim, nw) - self._zGrid = scipy.linspace(zmid - zdim/2.0, zmid + zdim/2.0, nh) + self._rGrid = numpy.linspace(rgrid0, rgrid0 + xdim, nw) + self._zGrid = numpy.linspace(zmid - zdim/2.0, zmid + zdim/2.0, nh) # drefit = (self._rGrid[-1] - self._rGrid[0])/(nw-1) # dzefit = (self._zGrid[-1] - self._zGrid[0])/(nh-1) self._defaultUnits['_rGrid'] = 'm' @@ -266,13 +266,13 @@ def __init__(self, # read R,Z of magnetic axis, psi at magnetic axis and LCFS, and bzero line = next(reader)[0] line = re.findall(r'-?\d\.\d*[eE][-+]\d*', line) - self._rmag = scipy.array([float(line[0])]) - self._zmag = scipy.array([float(line[1])]) + self._rmag = numpy.array([float(line[0])]) + self._zmag = numpy.array([float(line[1])]) self._defaultUnits['_rmag'] = 'm' self._defaultUnits['_zmag'] = 'm' - self._psiAxis = scipy.array([float(line[2])]) - self._psiLCFS = scipy.array([float(line[3])]) - self._BCentr = scipy.array([float(line[4])]) + self._psiAxis = numpy.array([float(line[2])]) + self._psiLCFS = numpy.array([float(line[3])]) + self._BCentr = numpy.array([float(line[4])]) self._defaultUnits['_psiAxis'] = 'Wb/rad' self._defaultUnits['_psiLCFS'] = 'Wb/rad' @@ -280,7 +280,7 @@ def __init__(self, # dummy, R of magnetic axis (duplicate), dummy line = next(reader)[0] line = re.findall(r'-?\d\.\d*[eE][-+]\d*', line) - self._IpCalc = scipy.array([float(line[0])]) + self._IpCalc = numpy.array([float(line[0])]) self._defaultUnits['_IpCalc'] = 'A' # read Z of magnetic axis (duplicate), dummy, psi at LCFS (duplicate), dummy, dummy @@ -298,7 +298,7 @@ def __init__(self, line = re.findall(r'-?\d\.\d*[eE][-+]\d*', line) for val in line: self._fpol.append(float(val)) - self._fpol = scipy.array(self._fpol).reshape((1, nw)) + self._fpol = numpy.array(self._fpol).reshape((1, nw)) self._defaultUnits['_fpol'] = 'T m' # and likewise for pressure @@ -308,7 +308,7 @@ def __init__(self, line = re.findall(r'-?\d\.\d*[eE][-+]\d*', line) for val in line: self._fluxPres.append(float(val)) - self._fluxPres = scipy.array(self._fluxPres).reshape((1, nw)) + self._fluxPres = numpy.array(self._fluxPres).reshape((1, nw)) self._defaultUnits['_fluxPres'] = 'Pa' # geqdsk written as negative for positive plasma current @@ -319,7 +319,7 @@ def __init__(self, line = re.findall(r'-?\d\.\d*[eE][-+]\d*', line) for val in line: self._ffprim.append(float(val)) - self._ffprim = scipy.array(self._ffprim).reshape((1, nw)) + self._ffprim = numpy.array(self._ffprim).reshape((1, nw)) self._defaultUnits['_ffprim'] = 'T^2 m' self._pprime = [] @@ -328,7 +328,7 @@ def __init__(self, line = re.findall(r'-?\d\.\d*[eE][-+]\d*', line) for val in line: self._pprime.append(float(val)) - self._pprime = scipy.array(self._pprime).reshape((1, nw)) + self._pprime = numpy.array(self._pprime).reshape((1, nw)) self._defaultUnits['_pprime'] = 'J/m^2' # read the 2d [nw,nh] array for psiRZ @@ -345,7 +345,7 @@ def __init__(self, line = re.findall(r'-?\d\.\d*[eE][-+]\d*', line) for val in line: psis.append(float(val)) - self._psiRZ = scipy.array(psis).reshape((1, nh, nw), order='C') + self._psiRZ = numpy.array(psis).reshape((1, nh, nw), order='C') self._defaultUnits['_psiRZ'] = 'Wb/rad' # read q(psi) profile, nw points (same basis as fpol, pres, etc.) @@ -359,7 +359,7 @@ def __init__(self, line = re.findall(r'-?\d\.\d*[eE][-+]\d*', line) for val in line: self._qpsi.append(float(val)) - self._qpsi = scipy.array(self._qpsi).reshape((1, nw)) + self._qpsi = numpy.array(self._qpsi).reshape((1, nw)) # read nbbbs, limitr line = next(reader)[0].split() @@ -378,7 +378,7 @@ def __init__(self, line = re.findall(r'-?\d\.\d*[eE][-+]\d*', line) for val in line: bbbs.append(float(val)) - bbbs = scipy.array(bbbs).reshape((2, nbbbs), order='F') + bbbs = numpy.array(bbbs).reshape((2, nbbbs), order='F') self._RLCFS = bbbs[0].reshape((1, nbbbs)) self._ZLCFS = bbbs[1].reshape((1, nbbbs)) self._defaultUnits['_RLCFS'] = 'm' @@ -396,7 +396,7 @@ def __init__(self, line = re.findall(r'-?\d\.\d*[eE][-+]\d*', line) for val in line: lim.append(float(val)) - lim = scipy.array(lim).reshape((2, limitr), order='F') + lim = numpy.array(lim).reshape((2, limitr), order='F') self._xlim = lim[0, :] self._ylim = lim[1, :] @@ -421,17 +421,17 @@ def __init__(self, line = re.findall(r'-?\d.\d*[eE][-+]\d*', line) for val in line: self._presw.append(float(val)) - self._presw = scipy.array(self._presw).reshape((nw, 1)) + self._presw = numpy.array(self._presw).reshape((nw, 1)) self._preswp = [] for i in range(nrows): line = next(reader)[0] line = re.findall(r'-?\d.\d*[eE][-+]\d*', line) for val in line: self._preswp.append(float(val)) - self._preswp = scipy.array(self._preswp).reshape((1, nw)) + self._preswp = numpy.array(self._preswp).reshape((1, nw)) else: - self._presw = scipy.atleast_2d(scipy.array([0])) - self._preswp = scipy.atleast_2d(scipy.array([0])) + self._presw = numpy.atleast_2d(numpy.array([0])) + self._preswp = numpy.atleast_2d(numpy.array([0])) # read ion mass density if present if nmass > 0: @@ -444,9 +444,9 @@ def __init__(self, line = re.findall(r'-?\d.\d*[eE][-+]\d*', line) for val in line: self._dmion.append(float(val)) - self._dmion = scipy.array(self._dmion).reshape((1, nw)) + self._dmion = numpy.array(self._dmion).reshape((1, nw)) else: - self._dmion = scipy.atleast_2d(scipy.array([0])) + self._dmion = numpy.atleast_2d(numpy.array([0])) # read rhovn nrows = nw/5 @@ -458,7 +458,7 @@ def __init__(self, line = re.findall(r'-?\d.\d*[eE][-+]\d*', line) for val in line: self._rhovn.append(float(val)) - self._rhovn = scipy.array(self._rhovn).reshape((1, nw)) + self._rhovn = numpy.array(self._rhovn).reshape((1, nw)) # read keecur; if >0 read workk line = gfile.readline.split() @@ -470,15 +470,15 @@ def __init__(self, line = re.findall(r'-?\d.\d*[eE][-+]\d*', line) for val in line: self._workk.append(float(val)) - self._workk = scipy.array(self._workk).reshape((1, nw)) + self._workk = numpy.array(self._workk).reshape((1, nw)) else: - self._workk = scipy.atleast_2d(scipy.array([0])) + self._workk = numpy.atleast_2d(numpy.array([0])) except Exception: - self._presw = scipy.atleast_2d(scipy.array([0])) - self._preswp = scipy.atleast_2d(scipy.array([0])) - self._rhovn = scipy.atleast_2d(scipy.array([0])) - self._dmion = scipy.atleast_2d(scipy.array([0])) - self._workk = scipy.atleast_2d(scipy.array([0])) + self._presw = numpy.atleast_2d(numpy.array([0])) + self._preswp = numpy.atleast_2d(numpy.array([0])) + self._rhovn = numpy.atleast_2d(numpy.array([0])) + self._dmion = numpy.atleast_2d(numpy.array([0])) + self._workk = numpy.atleast_2d(numpy.array([0])) # read through to end of file to get footer line try: @@ -630,52 +630,52 @@ def readAFile(self, afile): afr = AFileReader(afile) # fields - self._btaxp = scipy.array([afr.btaxp]) - self._btaxv = scipy.array([afr.btaxv]) - self._bpolav = scipy.array([afr.bpolav]) + self._btaxp = numpy.array([afr.btaxp]) + self._btaxv = numpy.array([afr.btaxv]) + self._bpolav = numpy.array([afr.bpolav]) # currents - self._IpMeas = scipy.array([afr.pasmat]) + self._IpMeas = numpy.array([afr.pasmat]) # safety factor parameters - self._q0 = scipy.array([afr.qqmin]) - self._q95 = scipy.array([afr.qpsib]) - self._qLCFS = scipy.array([afr.qout]) - self._rq1 = scipy.array([afr.aaq1]) - self._rq2 = scipy.array([afr.aaq2]) - self._rq3 = scipy.array([afr.aaq3]) + self._q0 = numpy.array([afr.qqmin]) + self._q95 = numpy.array([afr.qpsib]) + self._qLCFS = numpy.array([afr.qout]) + self._rq1 = numpy.array([afr.aaq1]) + self._rq2 = numpy.array([afr.aaq2]) + self._rq3 = numpy.array([afr.aaq3]) # shaping parameters - self._kappa = scipy.array([afr.eout]) - self._dupper = scipy.array([afr.doutu]) - self._dlower = scipy.array([afr.doutl]) + self._kappa = numpy.array([afr.eout]) + self._dupper = numpy.array([afr.doutu]) + self._dlower = numpy.array([afr.doutl]) # dimensional geometry parameters - self._aLCFS = scipy.array([afr.aout]) - self._areaLCFS = scipy.array([afr.areao]) - self._RmidLCFS = scipy.array([afr.rmidout]) + self._aLCFS = numpy.array([afr.aout]) + self._areaLCFS = numpy.array([afr.areao]) + self._RmidLCFS = numpy.array([afr.rmidout]) # calc. normalized pressure values - self._betat = scipy.array([afr.betat]) - self._betap = scipy.array([afr.betap]) - self._Li = scipy.array([afr.ali]) + self._betat = numpy.array([afr.betat]) + self._betap = numpy.array([afr.betap]) + self._Li = numpy.array([afr.ali]) # diamagnetic measurements - self._diamag = scipy.array([afr.diamag]) - self._betatd = scipy.array([afr.betatd]) - self._betapd = scipy.array([afr.betapd]) - self._WDiamag = scipy.array([afr.wplasmd]) - self._tauDiamag = scipy.array([afr.taudia]) + self._diamag = numpy.array([afr.diamag]) + self._betatd = numpy.array([afr.betatd]) + self._betapd = numpy.array([afr.betapd]) + self._WDiamag = numpy.array([afr.wplasmd]) + self._tauDiamag = numpy.array([afr.taudia]) # calculated energy - self._WMHD = scipy.array([afr.wplasm]) - self._tauMHD = scipy.array([afr.taumhd]) - self._Pinj = scipy.array([afr.pbinj]) - self._Wbdot = scipy.array([afr.wbdot]) - self._Wpdot = scipy.array([afr.wpdot]) + self._WMHD = numpy.array([afr.wplasm]) + self._tauMHD = numpy.array([afr.taumhd]) + self._Pinj = numpy.array([afr.pbinj]) + self._Wbdot = numpy.array([afr.wbdot]) + self._Wpdot = numpy.array([afr.wpdot]) # fitting parameters - self._volLCFS = scipy.array([afr.vout]) + self._volLCFS = numpy.array([afr.vout]) self._fluxVol = None # not written in g- or a-file; disable volnorm mapping routine self._RmidPsi = None # not written in g- or a-file, not used by fitting parameters @@ -915,7 +915,7 @@ def rz2rho(self, method, R, Z, t=False, sqrt=False, make_grid=False, k=3, Returns: rho (Array-like or scalar float): If all of the input arguments are - scalar, then a scalar is returned. Otherwise, a scipy Array + scalar, then a scalar is returned. Otherwise, a numpy Array instance is returned. If R and Z both have the same shape then rho has this shape as well. If the make_grid keyword was True then rho has shape (len(Z), len(R)). @@ -1018,7 +1018,7 @@ def rz2rmid(self, R, Z, t=False, sqrt=False, make_grid=False, rho=False, Returns: R_mid (Array or scalar float): If all of the input arguments are - scalar, then a scalar is returned. Otherwise, a scipy Array + scalar, then a scalar is returned. Otherwise, a numpy Array instance is returned. If `R` and `Z` both have the same shape then `R_mid` has this shape as well. If the make_grid keyword was True then `R_mid` has shape (`len(Z)`, `len(R)`). @@ -1086,7 +1086,7 @@ def psinorm2rmid(self, psi_norm, t=False, rho=False, k=3, length_unit=1): Returns: R_mid (Array-like or scalar float): If all of the input arguments - are scalar, then a scalar is returned. Otherwise, a scipy Array + are scalar, then a scalar is returned. Otherwise, a numpy Array instance is returned. Examples: @@ -1139,7 +1139,7 @@ def psinorm2phinorm(self, psi_norm, t=False, k=3): Returns: phinorm (Array-like or scalar float): If all of the input arguments - are scalar, then a scalar is returned. Otherwise, a scipy Array + are scalar, then a scalar is returned. Otherwise, a numpy Array instance is returned. Examples: @@ -1182,7 +1182,7 @@ def getCurrentSign(self): currentSign (Int): 1 for positive current, -1 for reversed. """ if self._currentSign is None: - self._currentSign = 1 if scipy.mean(self.getIpCalc()) > 1e5 else -1 + self._currentSign = 1 if numpy.mean(self.getIpCalc()) > 1e5 else -1 return self._currentSign def getFluxGrid(self): @@ -1227,7 +1227,7 @@ def getFluxAxis(self): implementations with time variation. """ # scale by current sign for consistency with sign of psiRZ. - return -1. * self.getCurrentSign() * scipy.array(self._psiAxis) + return -1. * self.getCurrentSign() * numpy.array(self._psiAxis) def getFluxLCFS(self): """Returns psi at separatrix. @@ -1238,7 +1238,7 @@ def getFluxLCFS(self): implementations with time variation. """ # scale by current sign for consistency with sign of psiRZ. - return -1 * self.getCurrentSign() * scipy.array(self._psiLCFS) + return -1 * self.getCurrentSign() * numpy.array(self._psiLCFS) def getRLCFS(self, length_unit=1): """Returns array of R-values of LCFS. @@ -1306,14 +1306,14 @@ def remapLCFS(self, mask=False): v = path.vertices RLCFS.extend(v[:, 0]) ZLCFS.extend(v[:, 1]) - RLCFS.append(scipy.nan) - ZLCFS.append(scipy.nan) - RLCFS = scipy.array(RLCFS) - ZLCFS = scipy.array(ZLCFS) + RLCFS.append(numpy.nan) + ZLCFS.append(numpy.nan) + RLCFS = numpy.array(RLCFS) + ZLCFS = numpy.array(ZLCFS) # generate masking array if mask: - maskarr = scipy.array([False for i in range(len(RLCFS))]) + maskarr = numpy.array([False for i in range(len(RLCFS))]) for i, x in enumerate(RLCFS): y = ZLCFS[i] maskarr[i] = inPolygon(Rlim, Zlim, x, y) @@ -2242,7 +2242,7 @@ def getParam(self, name): except AttributeError: try: attr = self.__getattribute__('_'+name) - if type(attr) is scipy.array: + if type(attr) is numpy.array: return attr.copy() else: return attr diff --git a/eqtools/filewriter.py b/eqtools/filewriter.py index a9d00e2..1e466b2 100644 --- a/eqtools/filewriter.py +++ b/eqtools/filewriter.py @@ -16,7 +16,7 @@ # You should have received a copy of the GNU General Public License # along with EqTools. If not, see . -import scipy +import numpy import scipy.interpolate import warnings import time @@ -119,9 +119,9 @@ def gfile( '\n' ) - rgrid = scipy.linspace(obj.getRGrid()[0], obj.getRGrid()[-1], nw) - zgrid = scipy.linspace(obj.getZGrid()[0], obj.getZGrid()[-1], nh) - rgrid2, zgrid2 = scipy.meshgrid(rgrid, zgrid) + rgrid = numpy.linspace(obj.getRGrid()[0], obj.getRGrid()[-1], nw) + zgrid = numpy.linspace(obj.getZGrid()[0], obj.getZGrid()[-1], nh) + rgrid2, zgrid2 = numpy.meshgrid(rgrid, zgrid) print(header) gfiler = open(name, 'wb') @@ -182,7 +182,7 @@ def gfile( 0., 0.])) - pts1 = scipy.linspace(0., 1., nw) + pts1 = numpy.linspace(0., 1., nw) # this needs to be time mapped (sigh) if not obj._tricubic: for i in [obj.getF(), @@ -190,24 +190,24 @@ def gfile( obj.getFFPrime(), obj.getPPrime()]: - pts0 = scipy.linspace(0., 1., i.shape[-1]) # find original nw + pts0 = numpy.linspace(0., 1., i.shape[-1]) # find original nw temp = scipy.interpolate.interp1d(pts0, - scipy.atleast_2d(i)[idx], + numpy.atleast_2d(i)[idx], kind='nearest', bounds_error=False) gfiler.write(_fmt(temp(pts1).ravel())) else: - tempt = tin*scipy.ones(pts1.shape) + tempt = tin*numpy.ones(pts1.shape) for i in [obj.getF(), obj.getFluxPres(), obj.getFFPrime(), obj.getPPrime()]: - pts0 = scipy.linspace(0., 1., i.shape[-1]) # find original nw + pts0 = numpy.linspace(0., 1., i.shape[-1]) # find original nw temp = scipy.interpolate.RectBivariateSpline(obj.getTimeBase(), pts0, - scipy.atleast_2d(i)) + numpy.atleast_2d(i)) gfiler.write(_fmt(temp.ev(tempt, pts1).ravel())) psiRZ = -1*obj.getCurrentSign()*obj.rz2psi(rgrid2, @@ -218,7 +218,7 @@ def gfile( if not obj._tricubic: temp = scipy.interpolate.interp1d( pts0, - scipy.atleast_2d(obj.getQProfile())[idx], + numpy.atleast_2d(obj.getQProfile())[idx], kind='nearest', bounds_error=False ) @@ -229,7 +229,7 @@ def gfile( temp = scipy.interpolate.RectBivariateSpline( obj.getTimeBase(), pts0, - scipy.atleast_2d(obj.getQProfile()) + numpy.atleast_2d(obj.getQProfile()) ) gfiler.write(_fmt(temp.ev(tempt, pts1).ravel())) @@ -244,7 +244,7 @@ def gfile( nbbbs=nbbbs) # write boundary - lim = scipy.array(obj.getMachineCrossSection()).T + lim = numpy.array(obj.getMachineCrossSection()).T gfiler.write(' '+str(int(len(out)))+' '+str(int(len(lim)))+'\n') @@ -259,63 +259,63 @@ def _findLCFS(rgrid, zgrid, psiRZ, rcent, zcent, psiLCFS, nbbbs=100): """ internal function for finding the last closed flux surface based off of a Equilibrium instance""" - ang = scipy.linspace(-scipy.pi, scipy.pi, nbbbs) + ang = numpy.linspace(-numpy.pi, numpy.pi, nbbbs) plt.ioff() fig = plt.figure() cs = plt.contour(rgrid, zgrid, - scipy.squeeze(psiRZ), - scipy.atleast_1d(psiLCFS)) + numpy.squeeze(psiRZ), + numpy.atleast_1d(psiLCFS)) splines = [] for i in cs.collections[0].get_paths(): temp = i.vertices # turn points into polar coordinates about the plasma center - rvals = scipy.sqrt((temp[:, 0] - rcent)**2 + (temp[:, 1] - zcent)**2) - thetvals = scipy.arctan2(temp[:, 1] - zcent, temp[:, 0] - rcent) + rvals = numpy.sqrt((temp[:, 0] - rcent)**2 + (temp[:, 1] - zcent)**2) + thetvals = numpy.arctan2(temp[:, 1] - zcent, temp[:, 0] - rcent) # find all monotonic sections of contour line in r,theta space - temp = scipy.diff(thetvals) + temp = numpy.diff(thetvals) idx = 0 - sign = scipy.sign(temp[0]) + sign = numpy.sign(temp[0]) for j in range(len(temp)-1): - if (scipy.sign(temp[j+1]) != sign): - sign = scipy.sign(temp[j+1]) + if (numpy.sign(temp[j+1]) != sign): + sign = numpy.sign(temp[j+1]) # only write data if the jump at the last point is well resolved - if (j+2-idx > 2): # abs(thetvals[idx]-thetvals[j+1]) < 7*scipy.pi/4) and + if (j+2-idx > 2): # abs(thetvals[idx]-thetvals[j+1]) < 7*numpy.pi/4) and plt.plot(thetvals[idx:j+2], rvals[idx:j+2], 'o') - sortang = scipy.argsort(thetvals[idx:j+2]) + sortang = numpy.argsort(thetvals[idx:j+2]) splines += [ scipy.interpolate.interp1d( thetvals[sortang+idx], rvals[sortang+idx], kind='linear', bounds_error=False, - fill_value=scipy.inf + fill_value=numpy.inf ) ] idx = j+1 if (len(thetvals) - idx > 2): plt.plot(thetvals[idx:], rvals[idx:], 'o') - sortang = scipy.argsort(thetvals[idx:]) + sortang = numpy.argsort(thetvals[idx:]) splines += [scipy.interpolate.interp1d(thetvals[sortang+idx], rvals[sortang+idx], kind='linear', bounds_error=False, - fill_value=scipy.inf)] + fill_value=numpy.inf)] # construct a set of angles about the center, and use the splines # to find the closest part of the contour to the center at that # angle, this is the LCFS, store value. If no value is found, store # an infite value, which is then tossed out. - outr = scipy.empty((nbbbs,)) + outr = numpy.empty((nbbbs,)) for i in range(nbbbs): - temp = scipy.inf + temp = numpy.inf for j in splines: pos = j(ang[i]) if pos < temp: @@ -323,13 +323,13 @@ def _findLCFS(rgrid, zgrid, psiRZ, rcent, zcent, psiLCFS, nbbbs=100): outr[i] = temp # remove infinites - ang = ang[scipy.isfinite(outr)] - outr = outr[scipy.isfinite(outr)] + ang = ang[numpy.isfinite(outr)] + outr = outr[numpy.isfinite(outr)] # move back to r,z space - output = scipy.empty((2, len(ang) + 1)) - output[0, :-1] = outr*scipy.cos(ang) + rcent - output[1, :-1] = outr*scipy.sin(ang) + zcent + output = numpy.empty((2, len(ang) + 1)) + output[0, :-1] = outr*numpy.cos(ang) + rcent + output[1, :-1] = outr*numpy.sin(ang) + zcent output[0, -1] = output[0, 0] output[1, -1] = output[1, 0] diff --git a/eqtools/trispline.py b/eqtools/trispline.py index fd5e6d0..50311ba 100644 --- a/eqtools/trispline.py +++ b/eqtools/trispline.py @@ -21,8 +21,7 @@ contains an enhanced bivariate spline which generates bounds errors. """ - -import scipy +import numpy import scipy.interpolate try: from . import _tricub @@ -75,7 +74,7 @@ class Spline(): """ def __init__( self, x, y, z, f, boundary='natural', dx=0, dy=0, dz=0, - bounds_error=True, fill_value=scipy.nan + bounds_error=True, fill_value=numpy.nan ): #if dx != 0 or dy != 0 or dz != 0: # raise NotImplementedError( @@ -83,17 +82,17 @@ def __init__( # "interpolation if you need to compute magnetic fields!" # ) - self._x = scipy.array(x, dtype=float) - self._y = scipy.array(y, dtype=float) - self._z = scipy.array(z, dtype=float) + self._x = numpy.array(x, dtype=float) + self._y = numpy.array(y, dtype=float) + self._z = numpy.array(z, dtype=float) - self._xlim = scipy.array((x.min(), x.max())) - self._ylim = scipy.array((y.min(), y.max())) - self._zlim = scipy.array((z.min(), z.max())) + self._xlim = numpy.array((x.min(), x.max())) + self._ylim = numpy.array((y.min(), y.max())) + self._zlim = numpy.array((z.min(), z.max())) - self._dx = scipy.array(dx, dtype=int) - self._dy = scipy.array(dy, dtype=int) - self._dz = scipy.array(dz, dtype=int) + self._dx = numpy.array(dx, dtype=int) + self._dy = numpy.array(dy, dtype=int) + self._dz = numpy.array(dz, dtype=int) self.bounds_error = bounds_error self.fill_value = fill_value @@ -106,15 +105,15 @@ def __init__( _tricub.ismonotonic(self._y) and _tricub.ismonotonic(self._z) ): - self._x = scipy.insert(self._x, 0, 2*self._x[0]-self._x[1]) - self._x = scipy.append(self._x, 2*self._x[-1]-self._x[-2]) - self._y = scipy.insert(self._y, 0, 2*self._y[0]-self._y[1]) - self._y = scipy.append(self._y, 2*self._y[-1]-self._y[-2]) - self._z = scipy.insert(self._z, 0, 2*self._z[0]-self._z[1]) - self._z = scipy.append(self._z, 2*self._z[-1]-self._z[-2]) + self._x = numpy.insert(self._x, 0, 2*self._x[0]-self._x[1]) + self._x = numpy.append(self._x, 2*self._x[-1]-self._x[-2]) + self._y = numpy.insert(self._y, 0, 2*self._y[0]-self._y[1]) + self._y = numpy.append(self._y, 2*self._y[-1]-self._y[-2]) + self._z = numpy.insert(self._z, 0, 2*self._z[0]-self._z[1]) + self._z = numpy.append(self._z, 2*self._z[-1]-self._z[-2]) - self._f = scipy.zeros(scipy.array(f.shape)+(2, 2, 2)) - self._f[1:-1, 1:-1, 1:-1] = scipy.array(f) # place f in center, so that it is padded by unfilled values on all sides + self._f = numpy.zeros(numpy.array(f.shape)+(2, 2, 2)) + self._f[1:-1, 1:-1, 1:-1] = numpy.array(f) # place f in center, so that it is padded by unfilled values on all sides if boundary == 'clamped': # faces @@ -264,13 +263,13 @@ def _check_bounds(self, x_new, y_new, z_new): "A value in z is above the interpolation range." ) - out_of_bounds = scipy.logical_not( - scipy.logical_or( - scipy.logical_or( - scipy.logical_or(below_bounds_x, above_bounds_x), - scipy.logical_or(below_bounds_y, above_bounds_y) + out_of_bounds = numpy.logical_not( + numpy.logical_or( + numpy.logical_or( + numpy.logical_or(below_bounds_x, above_bounds_x), + numpy.logical_or(below_bounds_y, above_bounds_y) ), - scipy.logical_or(below_bounds_z, above_bounds_z) + numpy.logical_or(below_bounds_z, above_bounds_z) ) ) return out_of_bounds @@ -294,11 +293,11 @@ def ev(self, xi, yi, zi, dx=0, dy=0, dz=0): of the grid """ - x = scipy.atleast_1d(xi) - y = scipy.atleast_1d(yi) - z = scipy.atleast_1d(zi) # This will not modify x1,y1,z1. + x = numpy.atleast_1d(xi) + y = numpy.atleast_1d(yi) + z = numpy.atleast_1d(zi) # This will not modify x1,y1,z1. - val = self.fill_value*scipy.ones(x.shape) + val = self.fill_value*numpy.ones(x.shape) idx = self._check_bounds(x, y, z) if dx == 0: @@ -368,14 +367,14 @@ class RectBivariateSpline(scipy.interpolate.RectBivariateSpline): def __init__( self, x, y, z, bbox=[None] * 4, kx=3, ky=3, s=0, bounds_error=True, - fill_value=scipy.nan + fill_value=numpy.nan ): super(RectBivariateSpline, self).__init__( x, y, z, bbox=bbox, kx=kx, ky=ky, s=s ) - self._xlim = scipy.array((x.min(), x.max())) - self._ylim = scipy.array((y.min(), y.max())) + self._xlim = numpy.array((x.min(), x.max())) + self._ylim = numpy.array((y.min(), y.max())) self.bounds_error = bounds_error self.fill_value = fill_value @@ -415,10 +414,10 @@ def _check_bounds(self, x_new, y_new): "A value in y is above the interpolation range." ) - out_of_bounds = scipy.logical_not( - scipy.logical_or( - scipy.logical_or(below_bounds_x, above_bounds_x), - scipy.logical_or(below_bounds_y, above_bounds_y) + out_of_bounds = numpy.logical_not( + numpy.logical_or( + numpy.logical_or(below_bounds_x, above_bounds_x), + numpy.logical_or(below_bounds_y, above_bounds_y) ) ) return out_of_bounds @@ -436,9 +435,9 @@ def ev(self, xi, yi): """ idx = self._check_bounds(xi, yi) # print(idx) - zi = self.fill_value*scipy.ones(xi.shape) + zi = self.fill_value*numpy.ones(xi.shape) zi[idx] = super(RectBivariateSpline, self).ev( - scipy.atleast_1d(xi)[idx], scipy.atleast_1d(yi)[idx] + numpy.atleast_1d(xi)[idx], numpy.atleast_1d(yi)[idx] ) return zi @@ -451,13 +450,13 @@ class BivariateInterpolator(object): """ def __init__(self, x, y, z): self._ct_interp = scipy.interpolate.CloughTocher2DInterpolator( - scipy.hstack((scipy.atleast_2d(x).T, scipy.atleast_2d(y).T)), + numpy.hstack((numpy.atleast_2d(x).T, numpy.atleast_2d(y).T)), z ) def ev(self, xi, yi): return self._ct_interp( - scipy.hstack((scipy.atleast_2d(xi).T, scipy.atleast_2d(yi).T)) + numpy.hstack((numpy.atleast_2d(xi).T, numpy.atleast_2d(yi).T)) ) @@ -477,12 +476,12 @@ def __init__(self, *args, **kwargs): super(UnivariateInterpolator, self).__init__(*args, **kwargs) def __call__(self, x, *args, **kwargs): - x = scipy.asarray(x, dtype=float) + x = numpy.asarray(x, dtype=float) out = super(UnivariateInterpolator, self).__call__(x, *args, **kwargs) if self.min_val is not None: out[out < self.min_val] = self.min_val if self.max_val is not None: out[out > self.max_val] = self.max_val out[(x < self.get_knots().min()) | (x > self.get_knots().max())] = \ - scipy.nan + numpy.nan return out diff --git a/setup.py b/setup.py index 7353c1c..04f9172 100644 --- a/setup.py +++ b/setup.py @@ -1,7 +1,10 @@ -from numpy.distutils.core import setup, Extension +import numpy +from setuptools import Extension, setup tricub = Extension( - 'eqtools._tricub', ['eqtools/_tricub.pyf', 'eqtools/_tricub.c'] + name='eqtools._tricub', + sources=['eqtools/_tricubmodule.c', 'eqtools/_tricub.c'], + include_dirs=[numpy.get_include(), './eqtools'], ) setup( diff --git a/tests/SolovievEFIT.py b/tests/SolovievEFIT.py index 509b6d2..fc587ac 100644 --- a/tests/SolovievEFIT.py +++ b/tests/SolovievEFIT.py @@ -24,7 +24,7 @@ mapping routines using the Soloviev solution to the Grad-Shafranov equation. """ -import scipy +import numpy from collections import namedtuple from eqtools.core import Equilibrium, ModuleWarning, inPolygon @@ -96,23 +96,23 @@ def __init__(self, R, a, B0, Ip, betat, length_unit='m', npts=257): self._currentSign = -1 if Ip > 0 else 1 # Remember: Ip is in MA. - self._qstar = (2.*scipy.pi * a**2 * B0) / (4.*scipy.pi*1.e-1 * R * Ip) + self._qstar = (2.*numpy.pi * a**2 * B0) / (4.*numpy.pi*1.e-1 * R * Ip) # flux definitions - self._psiLCFS = scipy.array([0.0]) + self._psiLCFS = numpy.array([0.0]) self._psi0 = -0.5 * self._B0 * self._a**2 / self._qstar - self._psi0 = scipy.array([self._psi0]) + self._psi0 = numpy.array([self._psi0]) # RZ grid - self._rGrid = scipy.linspace(R-1.25*a, R+1.25*a, self._npts) + self._rGrid = numpy.linspace(R-1.25*a, R+1.25*a, self._npts) self._defaultUnits['_rGrid'] = length_unit - self._zGrid = scipy.linspace(-1.25*a, 1.25*a, self._npts) + self._zGrid = numpy.linspace(-1.25*a, 1.25*a, self._npts) self._defaultUnits['_zGrid'] = length_unit self._psiRZ = self.rz2psi_analytic( self._rGrid, self._zGrid, length_unit=length_unit, make_grid=True ) - self._psiRZ = scipy.reshape(self._psiRZ, (1, npts, npts)) + self._psiRZ = numpy.reshape(self._psiRZ, (1, npts, npts)) def __str__(self): """string formatting for CircSolovievEFIT class. @@ -185,11 +185,11 @@ def _RZtortheta(self, R, Z, make_grid=False): check_space=False ) - R = scipy.reshape(R, oshape) - Z = scipy.reshape(Z, oshape) + R = numpy.reshape(R, oshape) + Z = numpy.reshape(Z, oshape) - r = scipy.sqrt((R - self._R)**2 + (Z)**2) - theta = scipy.arctan2(Z, (R - self._R)) + r = numpy.sqrt((R - self._R)**2 + (Z)**2) + theta = numpy.arctan2(Z, (R - self._R)) return (r, theta) def rz2psi_analytic(self, R, Z, length_unit='m', make_grid=False): @@ -224,7 +224,7 @@ def rz2psi_analytic(self, R, Z, length_unit='m', make_grid=False): Returns: psi: Array or scalar float. If all of the input arguments are scalar, - then a scalar is returned. Otherwise, a scipy Array instance is + then a scalar is returned. Otherwise, a numpy Array instance is returned. If R and Z both have the same shape then psi has this shape as well. If the make_grid keyword was True then psi has shape (len(Z), len(R)). @@ -236,7 +236,7 @@ def rz2psi_analytic(self, R, Z, length_unit='m', make_grid=False): psi = ( A / 4. * (r**2 - self._a**2) + C / 8. * (r**2 - self._a**2) * r * - scipy.cos(theta) + numpy.cos(theta) ) return psi @@ -337,7 +337,7 @@ def rz2psi(self, R, Z, *args, **kwargs): Returns: psi: Array or scalar float. If all of the input arguments are scalar, - then a scalar is returned. Otherwise, a scipy Array instance is + then a scalar is returned. Otherwise, a numpy Array instance is returned. If R and Z both have the same shape then psi has this shape as well. If the make_grid keyword was True then psi has shape (len(Z), len(R)). @@ -408,7 +408,7 @@ def rz2psinorm(self, R, Z, *args, **kwargs): Returns: psinorm: Array or scalar float. If all of the input arguments are - scalar, then a scalar is returned. Otherwise, a scipy Array + scalar, then a scalar is returned. Otherwise, a numpy Array instance is returned. If R and Z both have the same shape then psinorm has this shape as well. If the make_grid keyword was True then psinorm has shape (len(Z), len(R)). @@ -535,7 +535,7 @@ def getNearestIdx(self, *args, **kwargs): ################# def getTimeBase(self): - return scipy.array([0.0]) + return numpy.array([0.0]) def getCurrentSign(self): """Returns the sign of the current, for flux mapping. Note - inverted from intuitive, due to Soloviev formalism. diff --git a/tests/test.py b/tests/test.py index 2a1ade0..7dbed0d 100644 --- a/tests/test.py +++ b/tests/test.py @@ -24,7 +24,7 @@ import SolovievEFIT as sefit import matplotlib as mpl import matplotlib.pyplot as plt -import scipy +import numpy import warnings warnings.simplefilter("ignore") @@ -49,10 +49,10 @@ # gets axes for psiRZ in equil R = equil.getRGrid() Z = equil.getZGrid() -rGrid, zGrid = scipy.meshgrid(R, Z) +rGrid, zGrid = numpy.meshgrid(R, Z) # construct face points as meshgrid -rFace, zFace = scipy.meshgrid((R[:-1] + R[1:]) / 2.0, (Z[:-1] + Z[1:]) / 2.0) +rFace, zFace = numpy.meshgrid((R[:-1] + R[1:]) / 2.0, (Z[:-1] + Z[1:]) / 2.0) print(rFace.shape) # plot illustration diff --git a/tests/unittests.py b/tests/unittests.py index 6289f91..2b175db 100644 --- a/tests/unittests.py +++ b/tests/unittests.py @@ -1,7 +1,8 @@ import unittest -import scipy +import numpy import eqtools +import os import warnings try: @@ -27,8 +28,9 @@ import cPickle as pkl except: import pickle as pkl - with open('test_data.pkl', 'rb') as f: - shot, e, et = pkl.load(f, encoding='bytes') + dir_path = os.path.dirname(os.path.realpath(__file__)) + with open(os.sep.join([dir_path, 'test_data.pkl']), 'rb') as f: + shot, e, et = pkl.load(f, encoding='latin1') if not eqtools.core._has_trispline: et = e @@ -38,16 +40,16 @@ vector_R = e.getRGrid() vector_Z = e.getZGrid() vector_t = e.getTimeBase()[10:-10] -matrix_R, matrix_Z = scipy.meshgrid(vector_R, vector_Z) -matrix_t = scipy.linspace( +matrix_R, matrix_Z = numpy.meshgrid(vector_R, vector_Z) +matrix_t = numpy.linspace( vector_t.min(), vector_t.max(), len(vector_R) * len(vector_Z) ).reshape(matrix_R.shape) # psinorm may be used as a stand-in for any normalized variable. scalar_psinorm = 0.5 -vector_psinorm = scipy.linspace(0.0, 1.0, 100) -matrix_psinorm = scipy.linspace( +vector_psinorm = numpy.linspace(0.0, 1.0, 100) +matrix_psinorm = numpy.linspace( 0, 1.0, len(vector_R) * len(vector_Z) ).reshape(matrix_R.shape) scalar_Rmid = 0.75 @@ -70,15 +72,15 @@ def test_rz2psi_scalar_R_scalar_Z_scalar_t_make_grid_False_each_t_True(self): with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_rz2psi_scalar_R_scalar_Z_scalar_t_make_grid_True_each_t_True(self): @@ -93,15 +95,15 @@ def test_rz2psi_scalar_R_scalar_Z_scalar_t_make_grid_False_each_t_False(self): with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_rz2psi_scalar_R_scalar_Z_scalar_t_make_grid_True_each_t_False(self): @@ -116,14 +118,14 @@ def test_rz2psi_vector_R_vector_Z_scalar_t_make_grid_False_each_t_True(self): out_t = et.rz2psi(vector_R, vector_Z, scalar_t) self.assertEqual(out.shape, (len(vector_R),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_R),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_rz2psi_vector_R_vector_Z_scalar_t_make_grid_True_each_t_True(self): @@ -131,14 +133,14 @@ def test_rz2psi_vector_R_vector_Z_scalar_t_make_grid_True_each_t_True(self): out_t = et.rz2psi(vector_R, vector_Z, scalar_t, make_grid=True) self.assertEqual(out.shape, (len(vector_R), len(vector_Z))) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_R), len(vector_Z))) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_rz2psi_vector_R_vector_Z_scalar_t_make_grid_False_each_t_False(self): @@ -146,14 +148,14 @@ def test_rz2psi_vector_R_vector_Z_scalar_t_make_grid_False_each_t_False(self): out_t = et.rz2psi(vector_R, vector_Z, scalar_t, each_t=False) self.assertEqual(out.shape, (len(vector_R),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_R),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_rz2psi_vector_R_vector_Z_scalar_t_make_grid_True_each_t_False(self): @@ -161,14 +163,14 @@ def test_rz2psi_vector_R_vector_Z_scalar_t_make_grid_True_each_t_False(self): out_t = et.rz2psi(vector_R, vector_Z, scalar_t, make_grid=True, each_t=False) self.assertEqual(out.shape, (len(vector_R), len(vector_Z))) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_R), len(vector_Z))) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) # matrix R, matrix Z, scalar t: @@ -177,14 +179,14 @@ def test_rz2psi_matrix_R_matrix_Z_scalar_t_make_grid_False_each_t_True(self): out_t = et.rz2psi(matrix_R, matrix_Z, scalar_t) self.assertEqual(out.shape, matrix_R.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_R.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_rz2psi_matrix_R_matrix_Z_scalar_t_make_grid_True_each_t_True(self): @@ -198,14 +200,14 @@ def test_rz2psi_matrix_R_matrix_Z_scalar_t_make_grid_False_each_t_False(self): out_t = et.rz2psi(matrix_R, matrix_Z, scalar_t, each_t=False) self.assertEqual(out.shape, matrix_R.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_R.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_rz2psi_matrix_R_matrix_Z_scalar_t_make_grid_True_each_t_False(self): @@ -220,14 +222,14 @@ def test_rz2psi_scalar_R_scalar_Z_vector_t_make_grid_False_each_t_True(self): out_t = et.rz2psi(scalar_R, scalar_Z, vector_t) self.assertEqual(out.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_rz2psi_scalar_R_scalar_Z_vector_t_make_grid_True_each_t_True(self): @@ -254,14 +256,14 @@ def test_rz2psi_vector_R_vector_Z_vector_t_make_grid_False_each_t_True(self): out_t = et.rz2psi(vector_R, vector_Z, vector_t) self.assertEqual(out.shape, (len(vector_t), len(vector_R))) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t), len(vector_R))) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_rz2psi_vector_R_vector_Z_vector_t_make_grid_True_each_t_True(self): @@ -269,14 +271,14 @@ def test_rz2psi_vector_R_vector_Z_vector_t_make_grid_True_each_t_True(self): out_t = et.rz2psi(vector_R, vector_Z, vector_t, make_grid=True) self.assertEqual(out.shape, (len(vector_t), len(vector_R), len(vector_Z))) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t), len(vector_R), len(vector_Z))) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_rz2psi_vector_R_vector_Z_vector_t_make_grid_False_each_t_False(self): @@ -297,14 +299,14 @@ def test_rz2psi_matrix_R_matrix_Z_vector_t_make_grid_False_each_t_True(self): out_t = et.rz2psi(matrix_R, matrix_Z, vector_t) self.assertEqual(out.shape, tuple([len(vector_t),] + list(matrix_R.shape))) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, tuple([len(vector_t),] + list(matrix_R.shape))) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_rz2psi_matrix_R_matrix_Z_vector_t_make_grid_True_each_t_True(self): @@ -343,15 +345,15 @@ def test_rz2psi_matrix_R_matrix_Z_matrix_t_make_grid_False_each_t_False(self): out_t = et.rz2psi(matrix_R, matrix_Z, matrix_t, each_t=False) self.assertEqual(out.shape, matrix_R.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_R.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) # TODO: Only good to 2%. - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, 0.02) def test_rz2psi_matrix_R_matrix_Z_matrix_t_make_grid_True_each_t_False(self): @@ -372,15 +374,15 @@ def test_rz2psinorm_scalar_R_scalar_Z_scalar_t_make_grid_False_each_t_True(self) with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_rz2psinorm_scalar_R_scalar_Z_scalar_t_make_grid_True_each_t_True(self): @@ -395,15 +397,15 @@ def test_rz2psinorm_scalar_R_scalar_Z_scalar_t_make_grid_False_each_t_False(self with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_rz2psinorm_scalar_R_scalar_Z_scalar_t_make_grid_True_each_t_False(self): @@ -418,14 +420,14 @@ def test_rz2psinorm_vector_R_vector_Z_scalar_t_make_grid_False_each_t_True(self) out_t = et.rz2psinorm(vector_R, vector_Z, scalar_t) self.assertEqual(out.shape, (len(vector_R),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_R),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_rz2psinorm_vector_R_vector_Z_scalar_t_make_grid_True_each_t_True(self): @@ -433,14 +435,14 @@ def test_rz2psinorm_vector_R_vector_Z_scalar_t_make_grid_True_each_t_True(self): out_t = et.rz2psinorm(vector_R, vector_Z, scalar_t, make_grid=True) self.assertEqual(out.shape, (len(vector_R), len(vector_Z))) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_R), len(vector_Z))) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_rz2psinorm_vector_R_vector_Z_scalar_t_make_grid_False_each_t_False(self): @@ -448,14 +450,14 @@ def test_rz2psinorm_vector_R_vector_Z_scalar_t_make_grid_False_each_t_False(self out_t = et.rz2psinorm(vector_R, vector_Z, scalar_t, each_t=False) self.assertEqual(out.shape, (len(vector_R),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_R),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_rz2psinorm_vector_R_vector_Z_scalar_t_make_grid_True_each_t_False(self): @@ -463,14 +465,14 @@ def test_rz2psinorm_vector_R_vector_Z_scalar_t_make_grid_True_each_t_False(self) out_t = et.rz2psinorm(vector_R, vector_Z, scalar_t, make_grid=True, each_t=False) self.assertEqual(out.shape, (len(vector_R), len(vector_Z))) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_R), len(vector_Z))) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) # matrix R, matrix Z, scalar t: @@ -479,14 +481,14 @@ def test_rz2psinorm_matrix_R_matrix_Z_scalar_t_make_grid_False_each_t_True(self) out_t = et.rz2psinorm(matrix_R, matrix_Z, scalar_t) self.assertEqual(out.shape, matrix_R.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_R.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_rz2psinorm_matrix_R_matrix_Z_scalar_t_make_grid_True_each_t_True(self): @@ -500,14 +502,14 @@ def test_rz2psinorm_matrix_R_matrix_Z_scalar_t_make_grid_False_each_t_False(self out_t = et.rz2psinorm(matrix_R, matrix_Z, scalar_t, each_t=False) self.assertEqual(out.shape, matrix_R.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_R.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_rz2psinorm_matrix_R_matrix_Z_scalar_t_make_grid_True_each_t_False(self): @@ -522,14 +524,14 @@ def test_rz2psinorm_scalar_R_scalar_Z_vector_t_make_grid_False_each_t_True(self) out_t = et.rz2psinorm(scalar_R, scalar_Z, vector_t) self.assertEqual(out.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_rz2psinorm_scalar_R_scalar_Z_vector_t_make_grid_True_each_t_True(self): @@ -556,14 +558,14 @@ def test_rz2psinorm_vector_R_vector_Z_vector_t_make_grid_False_each_t_True(self) out_t = et.rz2psinorm(vector_R, vector_Z, vector_t) self.assertEqual(out.shape, (len(vector_t), len(vector_R))) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t), len(vector_R))) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_rz2psinorm_vector_R_vector_Z_vector_t_make_grid_True_each_t_True(self): @@ -571,14 +573,14 @@ def test_rz2psinorm_vector_R_vector_Z_vector_t_make_grid_True_each_t_True(self): out_t = et.rz2psinorm(vector_R, vector_Z, vector_t, make_grid=True) self.assertEqual(out.shape, (len(vector_t), len(vector_R), len(vector_Z))) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t), len(vector_R), len(vector_Z))) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_rz2psinorm_vector_R_vector_Z_vector_t_make_grid_False_each_t_False(self): @@ -599,14 +601,14 @@ def test_rz2psinorm_matrix_R_matrix_Z_vector_t_make_grid_False_each_t_True(self) out_t = et.rz2psinorm(matrix_R, matrix_Z, vector_t) self.assertEqual(out.shape, tuple([len(vector_t),] + list(matrix_R.shape))) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, tuple([len(vector_t),] + list(matrix_R.shape))) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_rz2psinorm_matrix_R_matrix_Z_vector_t_make_grid_True_each_t_True(self): @@ -645,14 +647,14 @@ def test_rz2psinorm_matrix_R_matrix_Z_matrix_t_make_grid_False_each_t_False(self out_t = et.rz2psinorm(matrix_R, matrix_Z, matrix_t, each_t=False) self.assertEqual(out.shape, matrix_R.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_R.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() # TODO: Only good to 2%. self.assertLessEqual(diff, 0.02) @@ -674,15 +676,15 @@ def test_rz2phinorm_scalar_R_scalar_Z_scalar_t_make_grid_False_each_t_True(self) with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_rz2phinorm_scalar_R_scalar_Z_scalar_t_make_grid_True_each_t_True(self): @@ -697,15 +699,15 @@ def test_rz2phinorm_scalar_R_scalar_Z_scalar_t_make_grid_False_each_t_False(self with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_rz2phinorm_scalar_R_scalar_Z_scalar_t_make_grid_True_each_t_False(self): @@ -720,15 +722,15 @@ def test_rz2phinorm_vector_R_vector_Z_scalar_t_make_grid_False_each_t_True(self) out_t = et.rz2phinorm(vector_R, vector_Z, scalar_t) self.assertEqual(out.shape, (len(vector_R),)) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_R),)) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) - diff = scipy.sqrt(((out[~scipy.isnan(out)] - out_t[~scipy.isnan(out)])**2).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) + diff = numpy.sqrt(((out[~numpy.isnan(out)] - out_t[~numpy.isnan(out)])**2).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_rz2phinorm_vector_R_vector_Z_scalar_t_make_grid_True_each_t_True(self): @@ -736,15 +738,15 @@ def test_rz2phinorm_vector_R_vector_Z_scalar_t_make_grid_True_each_t_True(self): out_t = et.rz2phinorm(vector_R, vector_Z, scalar_t, make_grid=True) self.assertEqual(out.shape, (len(vector_R), len(vector_Z))) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_R), len(vector_Z))) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) - diff = scipy.sqrt(((out[~scipy.isnan(out)] - out_t[~scipy.isnan(out)])**2).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) + diff = numpy.sqrt(((out[~numpy.isnan(out)] - out_t[~numpy.isnan(out)])**2).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_rz2phinorm_vector_R_vector_Z_scalar_t_make_grid_False_each_t_False(self): @@ -752,15 +754,15 @@ def test_rz2phinorm_vector_R_vector_Z_scalar_t_make_grid_False_each_t_False(self out_t = et.rz2phinorm(vector_R, vector_Z, scalar_t, each_t=False) self.assertEqual(out.shape, (len(vector_R),)) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_R),)) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) - diff = scipy.sqrt(((out[~scipy.isnan(out)] - out_t[~scipy.isnan(out)])**2).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) + diff = numpy.sqrt(((out[~numpy.isnan(out)] - out_t[~numpy.isnan(out)])**2).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_rz2phinorm_vector_R_vector_Z_scalar_t_make_grid_True_each_t_False(self): @@ -768,15 +770,15 @@ def test_rz2phinorm_vector_R_vector_Z_scalar_t_make_grid_True_each_t_False(self) out_t = et.rz2phinorm(vector_R, vector_Z, scalar_t, make_grid=True, each_t=False) self.assertEqual(out.shape, (len(vector_R), len(vector_Z))) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_R), len(vector_Z))) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) - diff = scipy.sqrt(((out[~scipy.isnan(out)] - out_t[~scipy.isnan(out)])**2).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) + diff = numpy.sqrt(((out[~numpy.isnan(out)] - out_t[~numpy.isnan(out)])**2).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) # matrix R, matrix Z, scalar t: @@ -785,15 +787,15 @@ def test_rz2phinorm_matrix_R_matrix_Z_scalar_t_make_grid_False_each_t_True(self) out_t = et.rz2phinorm(matrix_R, matrix_Z, scalar_t) self.assertEqual(out.shape, matrix_R.shape) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_R.shape) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) - diff = scipy.sqrt(((out[~scipy.isnan(out)] - out_t[~scipy.isnan(out)])**2).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) + diff = numpy.sqrt(((out[~numpy.isnan(out)] - out_t[~numpy.isnan(out)])**2).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_rz2phinorm_matrix_R_matrix_Z_scalar_t_make_grid_True_each_t_True(self): @@ -807,15 +809,15 @@ def test_rz2phinorm_matrix_R_matrix_Z_scalar_t_make_grid_False_each_t_False(self out_t = et.rz2phinorm(matrix_R, matrix_Z, scalar_t, each_t=False) self.assertEqual(out.shape, matrix_R.shape) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_R.shape) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) - diff = scipy.sqrt(((out[~scipy.isnan(out)] - out_t[~scipy.isnan(out)])**2).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) + diff = numpy.sqrt(((out[~numpy.isnan(out)] - out_t[~numpy.isnan(out)])**2).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_rz2phinorm_matrix_R_matrix_Z_scalar_t_make_grid_True_each_t_False(self): @@ -830,14 +832,14 @@ def test_rz2phinorm_scalar_R_scalar_Z_vector_t_make_grid_False_each_t_True(self) out_t = et.rz2phinorm(scalar_R, scalar_Z, vector_t) self.assertEqual(out.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_rz2phinorm_scalar_R_scalar_Z_vector_t_make_grid_True_each_t_True(self): @@ -864,15 +866,15 @@ def test_rz2phinorm_vector_R_vector_Z_vector_t_make_grid_False_each_t_True(self) out_t = et.rz2phinorm(vector_R, vector_Z, vector_t) self.assertEqual(out.shape, (len(vector_t), len(vector_R))) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t), len(vector_R))) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) - diff = scipy.sqrt(((out[~scipy.isnan(out)] - out_t[~scipy.isnan(out)])**2).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) + diff = numpy.sqrt(((out[~numpy.isnan(out)] - out_t[~numpy.isnan(out)])**2).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_rz2phinorm_vector_R_vector_Z_vector_t_make_grid_True_each_t_True(self): @@ -880,15 +882,15 @@ def test_rz2phinorm_vector_R_vector_Z_vector_t_make_grid_True_each_t_True(self): out_t = et.rz2phinorm(vector_R, vector_Z, vector_t, make_grid=True) self.assertEqual(out.shape, (len(vector_t), len(vector_R), len(vector_Z))) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t), len(vector_R), len(vector_Z))) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) - diff = scipy.sqrt(((out[~scipy.isnan(out)] - out_t[~scipy.isnan(out)])**2).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) + diff = numpy.sqrt(((out[~numpy.isnan(out)] - out_t[~numpy.isnan(out)])**2).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_rz2phinorm_vector_R_vector_Z_vector_t_make_grid_False_each_t_False(self): @@ -909,15 +911,15 @@ def test_rz2phinorm_matrix_R_matrix_Z_vector_t_make_grid_False_each_t_True(self) out_t = et.rz2phinorm(matrix_R, matrix_Z, vector_t) self.assertEqual(out.shape, tuple([len(vector_t),] + list(matrix_R.shape))) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, tuple([len(vector_t),] + list(matrix_R.shape))) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) - diff = scipy.sqrt(((out[~scipy.isnan(out)] - out_t[~scipy.isnan(out)])**2).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) + diff = numpy.sqrt(((out[~numpy.isnan(out)] - out_t[~numpy.isnan(out)])**2).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_rz2phinorm_matrix_R_matrix_Z_vector_t_make_grid_True_each_t_True(self): @@ -956,19 +958,19 @@ def test_rz2phinorm_matrix_R_matrix_Z_matrix_t_make_grid_False_each_t_False(self out_t = et.rz2phinorm(matrix_R, matrix_Z, matrix_t, each_t=False) self.assertEqual(out.shape, matrix_R.shape) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_R.shape) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) # TODO: The trispline case has an extra non-NaN point here, appears to # be near a coil or something. # TODO: Only good to 2% - # self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, 0.02) def test_rz2phinorm_matrix_R_matrix_Z_matrix_t_make_grid_True_each_t_False(self): @@ -989,15 +991,15 @@ def test_rz2volnorm_scalar_R_scalar_Z_scalar_t_make_grid_False_each_t_True(self) with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_rz2volnorm_scalar_R_scalar_Z_scalar_t_make_grid_True_each_t_True(self): @@ -1012,15 +1014,15 @@ def test_rz2volnorm_scalar_R_scalar_Z_scalar_t_make_grid_False_each_t_False(self with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_rz2volnorm_scalar_R_scalar_Z_scalar_t_make_grid_True_each_t_False(self): @@ -1035,15 +1037,15 @@ def test_rz2volnorm_vector_R_vector_Z_scalar_t_make_grid_False_each_t_True(self) out_t = et.rz2volnorm(vector_R, vector_Z, scalar_t) self.assertEqual(out.shape, (len(vector_R),)) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_R),)) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) - diff = scipy.sqrt(((out[~scipy.isnan(out)] - out_t[~scipy.isnan(out)])**2).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) + diff = numpy.sqrt(((out[~numpy.isnan(out)] - out_t[~numpy.isnan(out)])**2).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_rz2volnorm_vector_R_vector_Z_scalar_t_make_grid_True_each_t_True(self): @@ -1051,15 +1053,15 @@ def test_rz2volnorm_vector_R_vector_Z_scalar_t_make_grid_True_each_t_True(self): out_t = et.rz2volnorm(vector_R, vector_Z, scalar_t, make_grid=True) self.assertEqual(out.shape, (len(vector_R), len(vector_Z))) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_R), len(vector_Z))) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) - diff = scipy.sqrt(((out[~scipy.isnan(out)] - out_t[~scipy.isnan(out)])**2).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) + diff = numpy.sqrt(((out[~numpy.isnan(out)] - out_t[~numpy.isnan(out)])**2).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_rz2volnorm_vector_R_vector_Z_scalar_t_make_grid_False_each_t_False(self): @@ -1067,15 +1069,15 @@ def test_rz2volnorm_vector_R_vector_Z_scalar_t_make_grid_False_each_t_False(self out_t = et.rz2volnorm(vector_R, vector_Z, scalar_t, each_t=False) self.assertEqual(out.shape, (len(vector_R),)) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_R),)) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) - diff = scipy.sqrt(((out[~scipy.isnan(out)] - out_t[~scipy.isnan(out)])**2).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) + diff = numpy.sqrt(((out[~numpy.isnan(out)] - out_t[~numpy.isnan(out)])**2).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_rz2volnorm_vector_R_vector_Z_scalar_t_make_grid_True_each_t_False(self): @@ -1083,15 +1085,15 @@ def test_rz2volnorm_vector_R_vector_Z_scalar_t_make_grid_True_each_t_False(self) out_t = et.rz2volnorm(vector_R, vector_Z, scalar_t, make_grid=True, each_t=False) self.assertEqual(out.shape, (len(vector_R), len(vector_Z))) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_R), len(vector_Z))) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) - diff = scipy.sqrt(((out[~scipy.isnan(out)] - out_t[~scipy.isnan(out)])**2).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) + diff = numpy.sqrt(((out[~numpy.isnan(out)] - out_t[~numpy.isnan(out)])**2).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) # matrix R, matrix Z, scalar t: @@ -1100,15 +1102,15 @@ def test_rz2volnorm_matrix_R_matrix_Z_scalar_t_make_grid_False_each_t_True(self) out_t = et.rz2volnorm(matrix_R, matrix_Z, scalar_t) self.assertEqual(out.shape, matrix_R.shape) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_R.shape) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) - diff = scipy.sqrt(((out[~scipy.isnan(out)] - out_t[~scipy.isnan(out)])**2).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) + diff = numpy.sqrt(((out[~numpy.isnan(out)] - out_t[~numpy.isnan(out)])**2).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_rz2volnorm_matrix_R_matrix_Z_scalar_t_make_grid_True_each_t_True(self): @@ -1122,15 +1124,15 @@ def test_rz2volnorm_matrix_R_matrix_Z_scalar_t_make_grid_False_each_t_False(self out_t = et.rz2volnorm(matrix_R, matrix_Z, scalar_t, each_t=False) self.assertEqual(out.shape, matrix_R.shape) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_R.shape) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) - diff = scipy.sqrt(((out[~scipy.isnan(out)] - out_t[~scipy.isnan(out)])**2).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) + diff = numpy.sqrt(((out[~numpy.isnan(out)] - out_t[~numpy.isnan(out)])**2).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_rz2volnorm_matrix_R_matrix_Z_scalar_t_make_grid_True_each_t_False(self): @@ -1145,14 +1147,14 @@ def test_rz2volnorm_scalar_R_scalar_Z_vector_t_make_grid_False_each_t_True(self) out_t = et.rz2volnorm(scalar_R, scalar_Z, vector_t) self.assertEqual(out.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_rz2volnorm_scalar_R_scalar_Z_vector_t_make_grid_True_each_t_True(self): @@ -1179,15 +1181,15 @@ def test_rz2volnorm_vector_R_vector_Z_vector_t_make_grid_False_each_t_True(self) out_t = et.rz2volnorm(vector_R, vector_Z, vector_t) self.assertEqual(out.shape, (len(vector_t), len(vector_R))) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t), len(vector_R))) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) - diff = scipy.sqrt(((out[~scipy.isnan(out)] - out_t[~scipy.isnan(out)])**2).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) + diff = numpy.sqrt(((out[~numpy.isnan(out)] - out_t[~numpy.isnan(out)])**2).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_rz2volnorm_vector_R_vector_Z_vector_t_make_grid_True_each_t_True(self): @@ -1195,15 +1197,15 @@ def test_rz2volnorm_vector_R_vector_Z_vector_t_make_grid_True_each_t_True(self): out_t = et.rz2volnorm(vector_R, vector_Z, vector_t, make_grid=True) self.assertEqual(out.shape, (len(vector_t), len(vector_R), len(vector_Z))) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t), len(vector_R), len(vector_Z))) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) - diff = scipy.sqrt(((out[~scipy.isnan(out)] - out_t[~scipy.isnan(out)])**2).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) + diff = numpy.sqrt(((out[~numpy.isnan(out)] - out_t[~numpy.isnan(out)])**2).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_rz2volnorm_vector_R_vector_Z_vector_t_make_grid_False_each_t_False(self): @@ -1224,15 +1226,15 @@ def test_rz2volnorm_matrix_R_matrix_Z_vector_t_make_grid_False_each_t_True(self) out_t = et.rz2volnorm(matrix_R, matrix_Z, vector_t) self.assertEqual(out.shape, tuple([len(vector_t),] + list(matrix_R.shape))) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, tuple([len(vector_t),] + list(matrix_R.shape))) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) - diff = scipy.sqrt(((out[~scipy.isnan(out)] - out_t[~scipy.isnan(out)])**2).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) + diff = numpy.sqrt(((out[~numpy.isnan(out)] - out_t[~numpy.isnan(out)])**2).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_rz2volnorm_matrix_R_matrix_Z_vector_t_make_grid_True_each_t_True(self): @@ -1271,19 +1273,19 @@ def test_rz2volnorm_matrix_R_matrix_Z_matrix_t_make_grid_False_each_t_False(self out_t = et.rz2volnorm(matrix_R, matrix_Z, matrix_t, each_t=False) self.assertEqual(out.shape, matrix_R.shape) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_R.shape) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) # TODO: The trispline case has an extra non-NaN point here, appears to # be near a coil or something. # TODO: Only good to 2%. - # self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, 0.02) def test_rz2volnorm_matrix_R_matrix_Z_matrix_t_make_grid_True_each_t_False(self): @@ -1304,15 +1306,15 @@ def test_rz2rmid_scalar_R_scalar_Z_scalar_t_make_grid_False_each_t_True_rho_Fals with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_rz2rmid_scalar_R_scalar_Z_scalar_t_make_grid_True_each_t_True_rho_False(self): @@ -1327,15 +1329,15 @@ def test_rz2rmid_scalar_R_scalar_Z_scalar_t_make_grid_False_each_t_False_rho_Fal with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_rz2rmid_scalar_R_scalar_Z_scalar_t_make_grid_True_each_t_False_rho_False(self): @@ -1350,15 +1352,15 @@ def test_rz2rmid_scalar_R_scalar_Z_scalar_t_make_grid_False_each_t_True_rho_True with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_rz2rmid_scalar_R_scalar_Z_scalar_t_make_grid_True_each_t_True_rho_True(self): @@ -1373,15 +1375,15 @@ def test_rz2rmid_scalar_R_scalar_Z_scalar_t_make_grid_False_each_t_False_rho_Tru with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_rz2rmid_scalar_R_scalar_Z_scalar_t_make_grid_True_each_t_False_rho_True(self): @@ -1396,15 +1398,15 @@ def test_rz2rmid_vector_R_vector_Z_scalar_t_make_grid_False_each_t_True_rho_Fals out_t = et.rz2rmid(vector_R, vector_Z, scalar_t) self.assertEqual(out.shape, (len(vector_R),)) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_R),)) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) - diff = scipy.sqrt(((out[~scipy.isnan(out)] - out_t[~scipy.isnan(out)])**2).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) + diff = numpy.sqrt(((out[~numpy.isnan(out)] - out_t[~numpy.isnan(out)])**2).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_rz2rmid_vector_R_vector_Z_scalar_t_make_grid_True_each_t_True_rho_False(self): @@ -1412,17 +1414,17 @@ def test_rz2rmid_vector_R_vector_Z_scalar_t_make_grid_True_each_t_True_rho_False out_t = et.rz2rmid(vector_R, vector_Z, scalar_t, make_grid=True) self.assertEqual(out.shape, (len(vector_R), len(vector_Z))) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_R), len(vector_Z))) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) # TODO: The trispline case has an extra non-NaN two points here. - # self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_rz2rmid_vector_R_vector_Z_scalar_t_make_grid_False_each_t_False_rho_False(self): @@ -1430,15 +1432,15 @@ def test_rz2rmid_vector_R_vector_Z_scalar_t_make_grid_False_each_t_False_rho_Fal out_t = et.rz2rmid(vector_R, vector_Z, scalar_t, each_t=False) self.assertEqual(out.shape, (len(vector_R),)) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_R),)) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) - diff = scipy.sqrt(((out[~scipy.isnan(out)] - out_t[~scipy.isnan(out)])**2).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) + diff = numpy.sqrt(((out[~numpy.isnan(out)] - out_t[~numpy.isnan(out)])**2).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_rz2rmid_vector_R_vector_Z_scalar_t_make_grid_True_each_t_False_rho_False(self): @@ -1446,17 +1448,17 @@ def test_rz2rmid_vector_R_vector_Z_scalar_t_make_grid_True_each_t_False_rho_Fals out_t = et.rz2rmid(vector_R, vector_Z, scalar_t, make_grid=True, each_t=False) self.assertEqual(out.shape, (len(vector_R), len(vector_Z))) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_R), len(vector_Z))) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) # TODO: The trispline case has an extra non-NaN two points here. - # self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_rz2rmid_vector_R_vector_Z_scalar_t_make_grid_False_each_t_True_rho_True(self): @@ -1464,15 +1466,15 @@ def test_rz2rmid_vector_R_vector_Z_scalar_t_make_grid_False_each_t_True_rho_True out_t = et.rz2rmid(vector_R, vector_Z, scalar_t, rho=True) self.assertEqual(out.shape, (len(vector_R),)) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_R),)) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) - diff = scipy.sqrt(((out[~scipy.isnan(out)] - out_t[~scipy.isnan(out)])**2).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) + diff = numpy.sqrt(((out[~numpy.isnan(out)] - out_t[~numpy.isnan(out)])**2).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_rz2rmid_vector_R_vector_Z_scalar_t_make_grid_True_each_t_True_rho_True(self): @@ -1480,17 +1482,17 @@ def test_rz2rmid_vector_R_vector_Z_scalar_t_make_grid_True_each_t_True_rho_True( out_t = et.rz2rmid(vector_R, vector_Z, scalar_t, make_grid=True, rho=True) self.assertEqual(out.shape, (len(vector_R), len(vector_Z))) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_R), len(vector_Z))) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) # TODO: The trispline case has an extra non-NaN two points here. - # self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_rz2rmid_vector_R_vector_Z_scalar_t_make_grid_False_each_t_False_rho_True(self): @@ -1498,15 +1500,15 @@ def test_rz2rmid_vector_R_vector_Z_scalar_t_make_grid_False_each_t_False_rho_Tru out_t = et.rz2rmid(vector_R, vector_Z, scalar_t, each_t=False, rho=True) self.assertEqual(out.shape, (len(vector_R),)) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_R),)) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) - diff = scipy.sqrt(((out[~scipy.isnan(out)] - out_t[~scipy.isnan(out)])**2).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) + diff = numpy.sqrt(((out[~numpy.isnan(out)] - out_t[~numpy.isnan(out)])**2).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_rz2rmid_vector_R_vector_Z_scalar_t_make_grid_True_each_t_False_rho_True(self): @@ -1514,17 +1516,17 @@ def test_rz2rmid_vector_R_vector_Z_scalar_t_make_grid_True_each_t_False_rho_True out_t = et.rz2rmid(vector_R, vector_Z, scalar_t, make_grid=True, each_t=False, rho=True) self.assertEqual(out.shape, (len(vector_R), len(vector_Z))) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_R), len(vector_Z))) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) # TODO: The trispline case has an extra non-NaN two points here. - # self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) # matrix R, matrix Z, scalar t: @@ -1533,17 +1535,17 @@ def test_rz2rmid_matrix_R_matrix_Z_scalar_t_make_grid_False_each_t_True_rho_Fals out_t = et.rz2rmid(matrix_R, matrix_Z, scalar_t) self.assertEqual(out.shape, matrix_R.shape) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_R.shape) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) # TODO: The trispline case has an extra non-NaN two points here. - # self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_rz2rmid_matrix_R_matrix_Z_scalar_t_make_grid_True_each_t_True_rho_False(self): @@ -1557,17 +1559,17 @@ def test_rz2rmid_matrix_R_matrix_Z_scalar_t_make_grid_False_each_t_False_rho_Fal out_t = et.rz2rmid(matrix_R, matrix_Z, scalar_t, each_t=False) self.assertEqual(out.shape, matrix_R.shape) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_R.shape) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) # TODO: The trispline case has an extra non-NaN two points here. - # self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_rz2rmid_matrix_R_matrix_Z_scalar_t_make_grid_True_each_t_False_rho_False(self): @@ -1581,17 +1583,17 @@ def test_rz2rmid_matrix_R_matrix_Z_scalar_t_make_grid_False_each_t_True_rho_True out_t = et.rz2rmid(matrix_R, matrix_Z, scalar_t, rho=True) self.assertEqual(out.shape, matrix_R.shape) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_R.shape) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) # TODO: The trispline case has an extra non-NaN two points here. - # self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_rz2rmid_matrix_R_matrix_Z_scalar_t_make_grid_True_each_t_True_rho_True(self): @@ -1605,17 +1607,17 @@ def test_rz2rmid_matrix_R_matrix_Z_scalar_t_make_grid_False_each_t_False_rho_Tru out_t = et.rz2rmid(matrix_R, matrix_Z, scalar_t, each_t=False, rho=True) self.assertEqual(out.shape, matrix_R.shape) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_R.shape) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) # TODO: The trispline case has an extra non-NaN two points here. - # self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_rz2rmid_matrix_R_matrix_Z_scalar_t_make_grid_True_each_t_False_rho_True(self): @@ -1630,14 +1632,14 @@ def test_rz2rmid_scalar_R_scalar_Z_vector_t_make_grid_False_each_t_True_rho_Fals out_t = et.rz2rmid(scalar_R, scalar_Z, vector_t) self.assertEqual(out.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_rz2rmid_scalar_R_scalar_Z_vector_t_make_grid_True_each_t_True_rho_False(self): @@ -1663,14 +1665,14 @@ def test_rz2rmid_scalar_R_scalar_Z_vector_t_make_grid_False_each_t_True_rho_True out_t = et.rz2rmid(scalar_R, scalar_Z, vector_t, rho=True) self.assertEqual(out.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_rz2rmid_scalar_R_scalar_Z_vector_t_make_grid_True_each_t_True_rho_True(self): @@ -1697,17 +1699,17 @@ def test_rz2rmid_vector_R_vector_Z_vector_t_make_grid_False_each_t_True_rho_Fals out_t = et.rz2rmid(vector_R, vector_Z, vector_t) self.assertEqual(out.shape, (len(vector_t), len(vector_R))) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t), len(vector_R))) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) # TODO: The trispline case has an extra non-NaN ten points here. - # self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_rz2rmid_vector_R_vector_Z_vector_t_make_grid_True_each_t_True_rho_False(self): @@ -1715,17 +1717,17 @@ def test_rz2rmid_vector_R_vector_Z_vector_t_make_grid_True_each_t_True_rho_False out_t = et.rz2rmid(vector_R, vector_Z, vector_t, make_grid=True) self.assertEqual(out.shape, (len(vector_t), len(vector_R), len(vector_Z))) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t), len(vector_R), len(vector_Z))) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) # TODO: The trispline case has an extra non-NaN 289 points here. - # self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_rz2rmid_vector_R_vector_Z_vector_t_make_grid_False_each_t_False_rho_False(self): @@ -1745,17 +1747,17 @@ def test_rz2rmid_vector_R_vector_Z_vector_t_make_grid_False_each_t_True_rho_True out_t = et.rz2rmid(vector_R, vector_Z, vector_t, rho=True) self.assertEqual(out.shape, (len(vector_t), len(vector_R))) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t), len(vector_R))) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) # TODO: The trispline case has an extra non-NaN ten points here. - # self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_rz2rmid_vector_R_vector_Z_vector_t_make_grid_True_each_t_True_rho_True(self): @@ -1763,17 +1765,17 @@ def test_rz2rmid_vector_R_vector_Z_vector_t_make_grid_True_each_t_True_rho_True( out_t = et.rz2rmid(vector_R, vector_Z, vector_t, make_grid=True, rho=True) self.assertEqual(out.shape, (len(vector_t), len(vector_R), len(vector_Z))) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t), len(vector_R), len(vector_Z))) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) # TODO: The trispline case has an extra non-NaN 289 points here. - # self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_rz2rmid_vector_R_vector_Z_vector_t_make_grid_False_each_t_False_rho_True(self): @@ -1794,17 +1796,17 @@ def test_rz2rmid_matrix_R_matrix_Z_vector_t_make_grid_False_each_t_True_rho_Fals out_t = et.rz2rmid(matrix_R, matrix_Z, vector_t) self.assertEqual(out.shape, tuple([len(vector_t),] + list(matrix_R.shape))) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, tuple([len(vector_t),] + list(matrix_R.shape))) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) # TODO: The trispline case has an extra non-NaN 289 points here. - # self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_rz2rmid_matrix_R_matrix_Z_vector_t_make_grid_True_each_t_True_rho_False(self): @@ -1830,17 +1832,17 @@ def test_rz2rmid_matrix_R_matrix_Z_vector_t_make_grid_False_each_t_True_rho_True out_t = et.rz2rmid(matrix_R, matrix_Z, vector_t, rho=True) self.assertEqual(out.shape, tuple([len(vector_t),] + list(matrix_R.shape))) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, tuple([len(vector_t),] + list(matrix_R.shape))) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) # TODO: The trispline case has an extra non-NaN 289 points here. - # self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_rz2rmid_matrix_R_matrix_Z_vector_t_make_grid_True_each_t_True_rho_True(self): @@ -1879,17 +1881,17 @@ def test_rz2rmid_matrix_R_matrix_Z_matrix_t_make_grid_False_each_t_False_rho_Fal out_t = et.rz2rmid(matrix_R, matrix_Z, matrix_t, each_t=False) self.assertEqual(out.shape, matrix_R.shape) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_R.shape) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) # TODO: The trispline case has an extra non-NaN seven points here. - # self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_rz2rmid_matrix_R_matrix_Z_matrix_t_make_grid_True_each_t_False_rho_False(self): @@ -1915,18 +1917,18 @@ def test_rz2rmid_matrix_R_matrix_Z_matrix_t_make_grid_False_each_t_False_rho_Tru out_t = et.rz2rmid(matrix_R, matrix_Z, matrix_t, each_t=False, rho=True) self.assertEqual(out.shape, matrix_R.shape) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_R.shape) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) # TODO: The trispline case has an extra non-NaN seven points here. # TODO: Why is this only good to 3%? - # self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, 0.03) def test_rz2rmid_matrix_R_matrix_Z_matrix_t_make_grid_True_each_t_False_rho_True(self): @@ -1947,15 +1949,15 @@ def test_rz2roa_scalar_R_scalar_Z_scalar_t_make_grid_False_each_t_True(self): with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_rz2roa_scalar_R_scalar_Z_scalar_t_make_grid_True_each_t_True(self): @@ -1970,15 +1972,15 @@ def test_rz2roa_scalar_R_scalar_Z_scalar_t_make_grid_False_each_t_False(self): with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_rz2roa_scalar_R_scalar_Z_scalar_t_make_grid_True_each_t_False(self): @@ -1993,15 +1995,15 @@ def test_rz2roa_vector_R_vector_Z_scalar_t_make_grid_False_each_t_True(self): out_t = et.rz2roa(vector_R, vector_Z, scalar_t) self.assertEqual(out.shape, (len(vector_R),)) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_R),)) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) - diff = scipy.sqrt(((out[~scipy.isnan(out)] - out_t[~scipy.isnan(out)])**2).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) + diff = numpy.sqrt(((out[~numpy.isnan(out)] - out_t[~numpy.isnan(out)])**2).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_rz2roa_vector_R_vector_Z_scalar_t_make_grid_True_each_t_True(self): @@ -2009,17 +2011,17 @@ def test_rz2roa_vector_R_vector_Z_scalar_t_make_grid_True_each_t_True(self): out_t = et.rz2roa(vector_R, vector_Z, scalar_t, make_grid=True) self.assertEqual(out.shape, (len(vector_R), len(vector_Z))) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_R), len(vector_Z))) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) # TODO: The trispline case has an extra non-NaN two points here. - # self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_rz2roa_vector_R_vector_Z_scalar_t_make_grid_False_each_t_False(self): @@ -2027,15 +2029,15 @@ def test_rz2roa_vector_R_vector_Z_scalar_t_make_grid_False_each_t_False(self): out_t = et.rz2roa(vector_R, vector_Z, scalar_t, each_t=False) self.assertEqual(out.shape, (len(vector_R),)) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_R),)) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) - diff = scipy.sqrt(((out[~scipy.isnan(out)] - out_t[~scipy.isnan(out)])**2).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) + diff = numpy.sqrt(((out[~numpy.isnan(out)] - out_t[~numpy.isnan(out)])**2).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_rz2roa_vector_R_vector_Z_scalar_t_make_grid_True_each_t_False(self): @@ -2043,17 +2045,17 @@ def test_rz2roa_vector_R_vector_Z_scalar_t_make_grid_True_each_t_False(self): out_t = et.rz2roa(vector_R, vector_Z, scalar_t, make_grid=True, each_t=False) self.assertEqual(out.shape, (len(vector_R), len(vector_Z))) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_R), len(vector_Z))) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) # TODO: The trispline case has an extra non-NaN two points here. - # self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) # matrix R, matrix Z, scalar t: @@ -2062,17 +2064,17 @@ def test_rz2roa_matrix_R_matrix_Z_scalar_t_make_grid_False_each_t_True(self): out_t = et.rz2roa(matrix_R, matrix_Z, scalar_t) self.assertEqual(out.shape, matrix_R.shape) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_R.shape) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) # TODO: The trispline case has an extra non-NaN two points here. - # self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_rz2roa_matrix_R_matrix_Z_scalar_t_make_grid_True_each_t_True(self): @@ -2086,17 +2088,17 @@ def test_rz2roa_matrix_R_matrix_Z_scalar_t_make_grid_False_each_t_False(self): out_t = et.rz2roa(matrix_R, matrix_Z, scalar_t, each_t=False) self.assertEqual(out.shape, matrix_R.shape) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_R.shape) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) # TODO: The trispline case has an extra non-NaN two points here. - # self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_rz2roa_matrix_R_matrix_Z_scalar_t_make_grid_True_each_t_False(self): @@ -2111,14 +2113,14 @@ def test_rz2roa_scalar_R_scalar_Z_vector_t_make_grid_False_each_t_True(self): out_t = et.rz2roa(scalar_R, scalar_Z, vector_t) self.assertEqual(out.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_rz2roa_scalar_R_scalar_Z_vector_t_make_grid_True_each_t_True(self): @@ -2145,17 +2147,17 @@ def test_rz2roa_vector_R_vector_Z_vector_t_make_grid_False_each_t_True(self): out_t = et.rz2roa(vector_R, vector_Z, vector_t) self.assertEqual(out.shape, (len(vector_t), len(vector_R))) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t), len(vector_R))) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) # TODO: The trispline case has an extra non-NaN ten points here. - # self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_rz2roa_vector_R_vector_Z_vector_t_make_grid_True_each_t_True(self): @@ -2163,17 +2165,17 @@ def test_rz2roa_vector_R_vector_Z_vector_t_make_grid_True_each_t_True(self): out_t = et.rz2roa(vector_R, vector_Z, vector_t, make_grid=True) self.assertEqual(out.shape, (len(vector_t), len(vector_R), len(vector_Z))) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t), len(vector_R), len(vector_Z))) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) # TODO: The trispline case has an extra non-NaN 289 points here. - # self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_rz2roa_vector_R_vector_Z_vector_t_make_grid_False_each_t_False(self): @@ -2194,17 +2196,17 @@ def test_rz2roa_matrix_R_matrix_Z_vector_t_make_grid_False_each_t_True(self): out_t = et.rz2roa(matrix_R, matrix_Z, vector_t) self.assertEqual(out.shape, tuple([len(vector_t),] + list(matrix_R.shape))) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, tuple([len(vector_t),] + list(matrix_R.shape))) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) # TODO: The trispline case has an extra non-NaN 289 points here. - # self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_rz2roa_matrix_R_matrix_Z_vector_t_make_grid_True_each_t_True(self): @@ -2243,18 +2245,18 @@ def test_rz2roa_matrix_R_matrix_Z_matrix_t_make_grid_False_each_t_False(self): out_t = et.rz2roa(matrix_R, matrix_Z, matrix_t, each_t=False) self.assertEqual(out.shape, matrix_R.shape) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_R.shape) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) # TODO: The trispline case has an extra non-NaN 7 points here. - # self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) # TODO: Why is this only good to 3%? res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, 0.03) def test_rz2roa_matrix_R_matrix_Z_matrix_t_make_grid_True_each_t_False(self): @@ -2275,15 +2277,15 @@ def test_rmid2roa_scalar_Rmid_scalar_t_each_t_True(self): with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_rmid2roa_scalar_Rmid_scalar_t_each_t_False(self): @@ -2292,15 +2294,15 @@ def test_rmid2roa_scalar_Rmid_scalar_t_each_t_False(self): with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) # vector Rmid, scalar t: @@ -2309,14 +2311,14 @@ def test_rmid2roa_vector_Rmid_scalar_t_each_t_True(self): out_t = et.rmid2roa(vector_Rmid, scalar_t) self.assertEqual(out.shape, (len(vector_Rmid),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_Rmid),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_rmid2roa_vector_Rmid_scalar_t_each_t_False(self): @@ -2324,14 +2326,14 @@ def test_rmid2roa_vector_Rmid_scalar_t_each_t_False(self): out_t = et.rmid2roa(vector_Rmid, scalar_t, each_t=False) self.assertEqual(out.shape, (len(vector_Rmid),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_Rmid),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) # matrix Rmid, scalar t: @@ -2340,14 +2342,14 @@ def test_rmid2roa_matrix_Rmid_scalar_t_each_t_True(self): out_t = et.rmid2roa(matrix_Rmid, scalar_t) self.assertEqual(out.shape, matrix_Rmid.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_Rmid.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_rmid2roa_matrix_Rmid_scalar_t_each_t_False(self): @@ -2355,14 +2357,14 @@ def test_rmid2roa_matrix_Rmid_scalar_t_each_t_False(self): out_t = et.rmid2roa(matrix_Rmid, scalar_t, each_t=False) self.assertEqual(out.shape, matrix_Rmid.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_Rmid.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) # scalar Rmid, vector t: @@ -2371,14 +2373,14 @@ def test_rmid2roa_scalar_Rmid_vector_t_each_t_True(self): out_t = et.rmid2roa(scalar_Rmid, vector_t) self.assertEqual(out.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_rmid2roa_scalar_Rmid_vector_t_each_t_False(self): @@ -2393,14 +2395,14 @@ def test_rmid2roa_vector_Rmid_vector_t_each_t_True(self): out_t = et.rmid2roa(vector_Rmid, vector_t) self.assertEqual(out.shape, (len(vector_t), len(vector_Rmid))) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t), len(vector_Rmid))) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_rmid2roa_vector_Rmid_vector_t_each_t_False(self): @@ -2415,14 +2417,14 @@ def test_rmid2roa_matrix_Rmid_vector_t_each_t_True(self): out_t = et.rmid2roa(matrix_Rmid, vector_t) self.assertEqual(out.shape, tuple([len(vector_t),] + list(matrix_Rmid.shape))) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, tuple([len(vector_t),] + list(matrix_Rmid.shape))) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_rmid2roa_matrix_Rmid_vector_t_each_t_False(self): @@ -2443,15 +2445,15 @@ def test_rmid2roa_matrix_Rmid_matrix_t_each_t_False(self): out_t = et.rmid2roa(matrix_Rmid, matrix_t, each_t=False) self.assertEqual(out.shape, matrix_Rmid.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_Rmid.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) # TODO: Only good to 2%. - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, 0.02) class rmid2psinormTestCase(unittest.TestCase): @@ -2466,15 +2468,15 @@ def test_rmid2psinorm_scalar_psinorm_scalar_t_each_t_True(self): with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_rmid2psinorm_scalar_psinorm_scalar_t_each_t_False(self): @@ -2483,15 +2485,15 @@ def test_rmid2psinorm_scalar_psinorm_scalar_t_each_t_False(self): with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) # vector Rmid, scalar t: @@ -2500,14 +2502,14 @@ def test_rmid2psinorm_vector_psinorm_scalar_t_each_t_True(self): out_t = et.rmid2psinorm(vector_Rmid, scalar_t) self.assertEqual(out.shape, (len(vector_Rmid),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_Rmid),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_rmid2psinorm_vector_psinorm_scalar_t_each_t_False(self): @@ -2515,14 +2517,14 @@ def test_rmid2psinorm_vector_psinorm_scalar_t_each_t_False(self): out_t = et.rmid2psinorm(vector_Rmid, scalar_t, each_t=False) self.assertEqual(out.shape, (len(vector_Rmid),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_Rmid),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) # matrix Rmid, scalar t: @@ -2531,14 +2533,14 @@ def test_rmid2psinorm_matrix_psinorm_scalar_t_each_t_True(self): out_t = et.rmid2psinorm(matrix_Rmid, scalar_t) self.assertEqual(out.shape, matrix_Rmid.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_Rmid.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_rmid2psinorm_matrix_psinorm_scalar_t_each_t_False(self): @@ -2546,14 +2548,14 @@ def test_rmid2psinorm_matrix_psinorm_scalar_t_each_t_False(self): out_t = et.rmid2psinorm(matrix_Rmid, scalar_t, each_t=False) self.assertEqual(out.shape, matrix_Rmid.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_Rmid.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) # scalar Rmid, vector t: @@ -2562,14 +2564,14 @@ def test_rmid2psinorm_scalar_psinorm_vector_t_each_t_True(self): out_t = et.rmid2psinorm(scalar_Rmid, vector_t) self.assertEqual(out.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_rmid2psinorm_scalar_psinorm_vector_t_each_t_False(self): @@ -2584,14 +2586,14 @@ def test_rmid2psinorm_vector_psinorm_vector_t_each_t_True(self): out_t = et.rmid2psinorm(vector_Rmid, vector_t) self.assertEqual(out.shape, (len(vector_t), len(vector_Rmid))) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t), len(vector_Rmid))) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_rmid2psinorm_vector_psinorm_vector_t_each_t_False(self): @@ -2606,14 +2608,14 @@ def test_rmid2psinorm_matrix_psinorm_vector_t_each_t_True(self): out_t = et.rmid2psinorm(matrix_Rmid, vector_t) self.assertEqual(out.shape, tuple([len(vector_t),] + list(matrix_Rmid.shape))) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, tuple([len(vector_t),] + list(matrix_Rmid.shape))) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_rmid2psinorm_matrix_psinorm_vector_t_each_t_False(self): @@ -2634,15 +2636,15 @@ def test_rmid2psinorm_matrix_psinorm_matrix_t_each_t_False(self): out_t = et.rmid2psinorm(matrix_Rmid, matrix_t, each_t=False) self.assertEqual(out.shape, matrix_Rmid.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_Rmid.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) # TODO: Only good to 2%. - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, 0.02) class rmid2phinormTestCase(unittest.TestCase): @@ -2657,15 +2659,15 @@ def test_rmid2phinorm_scalar_psinorm_scalar_t_each_t_True(self): with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_rmid2phinorm_scalar_psinorm_scalar_t_each_t_False(self): @@ -2674,15 +2676,15 @@ def test_rmid2phinorm_scalar_psinorm_scalar_t_each_t_False(self): with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) # vector Rmid, scalar t: @@ -2691,15 +2693,15 @@ def test_rmid2phinorm_vector_psinorm_scalar_t_each_t_True(self): out_t = et.rmid2phinorm(vector_Rmid, scalar_t) self.assertEqual(out.shape, (len(vector_Rmid),)) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_Rmid),)) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) - diff = scipy.sqrt(((out[~scipy.isnan(out)] - out_t[~scipy.isnan(out)])**2).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) + diff = numpy.sqrt(((out[~numpy.isnan(out)] - out_t[~numpy.isnan(out)])**2).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_rmid2phinorm_vector_psinorm_scalar_t_each_t_False(self): @@ -2707,15 +2709,15 @@ def test_rmid2phinorm_vector_psinorm_scalar_t_each_t_False(self): out_t = et.rmid2phinorm(vector_Rmid, scalar_t, each_t=False) self.assertEqual(out.shape, (len(vector_Rmid),)) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_Rmid),)) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) - diff = scipy.sqrt(((out[~scipy.isnan(out)] - out_t[~scipy.isnan(out)])**2).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) + diff = numpy.sqrt(((out[~numpy.isnan(out)] - out_t[~numpy.isnan(out)])**2).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) # matrix Rmid, scalar t: @@ -2724,15 +2726,15 @@ def test_rmid2phinorm_matrix_psinorm_scalar_t_each_t_True(self): out_t = et.rmid2phinorm(matrix_Rmid, scalar_t) self.assertEqual(out.shape, matrix_Rmid.shape) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out.shape, matrix_Rmid.shape) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) - diff = scipy.sqrt(((out[~scipy.isnan(out)] - out_t[~scipy.isnan(out)])**2).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) + diff = numpy.sqrt(((out[~numpy.isnan(out)] - out_t[~numpy.isnan(out)])**2).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_rmid2phinorm_matrix_psinorm_scalar_t_each_t_False(self): @@ -2740,15 +2742,15 @@ def test_rmid2phinorm_matrix_psinorm_scalar_t_each_t_False(self): out_t = et.rmid2phinorm(matrix_Rmid, scalar_t, each_t=False) self.assertEqual(out.shape, matrix_Rmid.shape) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_Rmid.shape) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) - diff = scipy.sqrt(((out[~scipy.isnan(out)] - out_t[~scipy.isnan(out)])**2).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) + diff = numpy.sqrt(((out[~numpy.isnan(out)] - out_t[~numpy.isnan(out)])**2).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) # scalar Rmid, vector t: @@ -2757,14 +2759,14 @@ def test_rmid2phinorm_scalar_psinorm_vector_t_each_t_True(self): out_t = et.rmid2phinorm(scalar_Rmid, vector_t) self.assertEqual(out.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_rmid2phinorm_scalar_psinorm_vector_t_each_t_False(self): @@ -2779,17 +2781,17 @@ def test_rmid2phinorm_vector_psinorm_vector_t_each_t_True(self): out_t = et.rmid2phinorm(vector_Rmid, vector_t) self.assertEqual(out.shape, (len(vector_t), len(vector_Rmid))) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t), len(vector_Rmid))) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) # TODO: The trispline case has an extra 1 non-NaN points here. - # self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_rmid2phinorm_vector_psinorm_vector_t_each_t_False(self): @@ -2804,17 +2806,17 @@ def test_rmid2phinorm_matrix_psinorm_vector_t_each_t_True(self): out_t = et.rmid2phinorm(matrix_Rmid, vector_t) self.assertEqual(out.shape, tuple([len(vector_t),] + list(matrix_Rmid.shape))) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, tuple([len(vector_t),] + list(matrix_Rmid.shape))) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) # TODO: The trispline case has an extra 25 non-NaN points here. - # self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_rmid2phinorm_matrix_psinorm_vector_t_each_t_False(self): @@ -2835,18 +2837,18 @@ def test_rmid2phinorm_matrix_psinorm_matrix_t_each_t_False(self): out_t = et.rmid2phinorm(matrix_Rmid, matrix_t, each_t=False) self.assertEqual(out.shape, matrix_Rmid.shape) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_Rmid.shape) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) # TODO: The trispline case has an extra 1 non-NaN points here. - # self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) # TODO: Only good to 2%. res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, 0.02) class rmid2volnormTestCase(unittest.TestCase): @@ -2861,15 +2863,15 @@ def test_rmid2volnorm_scalar_psinorm_scalar_t_each_t_True(self): with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_rmid2volnorm_scalar_psinorm_scalar_t_each_t_False(self): @@ -2878,15 +2880,15 @@ def test_rmid2volnorm_scalar_psinorm_scalar_t_each_t_False(self): with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) # vector Rmid, scalar t: @@ -2895,15 +2897,15 @@ def test_rmid2volnorm_vector_psinorm_scalar_t_each_t_True(self): out_t = et.rmid2volnorm(vector_Rmid, scalar_t) self.assertEqual(out.shape, (len(vector_Rmid),)) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_Rmid),)) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) - diff = scipy.sqrt(((out[~scipy.isnan(out)] - out_t[~scipy.isnan(out)])**2).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) + diff = numpy.sqrt(((out[~numpy.isnan(out)] - out_t[~numpy.isnan(out)])**2).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_rmid2volnorm_vector_psinorm_scalar_t_each_t_False(self): @@ -2911,15 +2913,15 @@ def test_rmid2volnorm_vector_psinorm_scalar_t_each_t_False(self): out_t = et.rmid2volnorm(vector_Rmid, scalar_t, each_t=False) self.assertEqual(out.shape, (len(vector_Rmid),)) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_Rmid),)) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) - diff = scipy.sqrt(((out[~scipy.isnan(out)] - out_t[~scipy.isnan(out)])**2).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) + diff = numpy.sqrt(((out[~numpy.isnan(out)] - out_t[~numpy.isnan(out)])**2).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) # matrix Rmid, scalar t: @@ -2928,15 +2930,15 @@ def test_rmid2volnorm_matrix_psinorm_scalar_t_each_t_True(self): out_t = et.rmid2volnorm(matrix_Rmid, scalar_t) self.assertEqual(out.shape, matrix_Rmid.shape) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_Rmid.shape) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) - diff = scipy.sqrt(((out[~scipy.isnan(out)] - out_t[~scipy.isnan(out)])**2).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) + diff = numpy.sqrt(((out[~numpy.isnan(out)] - out_t[~numpy.isnan(out)])**2).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_rmid2volnorm_matrix_psinorm_scalar_t_each_t_False(self): @@ -2944,15 +2946,15 @@ def test_rmid2volnorm_matrix_psinorm_scalar_t_each_t_False(self): out_t = et.rmid2volnorm(matrix_Rmid, scalar_t, each_t=False) self.assertEqual(out.shape, matrix_Rmid.shape) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_Rmid.shape) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) - diff = scipy.sqrt(((out[~scipy.isnan(out)] - out_t[~scipy.isnan(out)])**2).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) + diff = numpy.sqrt(((out[~numpy.isnan(out)] - out_t[~numpy.isnan(out)])**2).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) # scalar Rmid, vector t: @@ -2961,14 +2963,14 @@ def test_rmid2volnorm_scalar_psinorm_vector_t_each_t_True(self): out_t = et.rmid2volnorm(scalar_Rmid, vector_t) self.assertEqual(out.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_rmid2volnorm_scalar_psinorm_vector_t_each_t_False(self): @@ -2983,17 +2985,17 @@ def test_rmid2volnorm_vector_psinorm_vector_t_each_t_True(self): out_t = et.rmid2volnorm(vector_Rmid, vector_t) self.assertEqual(out.shape, (len(vector_t), len(vector_Rmid))) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t), len(vector_Rmid))) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) # TODO: The trispline case has an extra 1 non-NaN points here. - # self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_rmid2volnorm_vector_psinorm_vector_t_each_t_False(self): @@ -3008,17 +3010,17 @@ def test_rmid2volnorm_matrix_psinorm_vector_t_each_t_True(self): out_t = et.rmid2volnorm(matrix_Rmid, vector_t) self.assertEqual(out.shape, tuple([len(vector_t),] + list(matrix_Rmid.shape))) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, tuple([len(vector_t),] + list(matrix_Rmid.shape))) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) # TODO: The trispline case has an extra 25 non-NaN points here. - # self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_rmid2volnorm_matrix_psinorm_vector_t_each_t_False(self): @@ -3039,18 +3041,18 @@ def test_rmid2volnorm_matrix_psinorm_matrix_t_each_t_False(self): out_t = et.rmid2volnorm(matrix_Rmid, matrix_t, each_t=False) self.assertEqual(out.shape, matrix_Rmid.shape) - self.assertTrue(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertTrue(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_Rmid.shape) - self.assertTrue(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertTrue(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) # TODO: The trispline case has an extra 1 non-NaN points here. - # self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) # TODO: Only good to 2%. res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, 0.02) class roa2rmidTestCase(unittest.TestCase): @@ -3065,15 +3067,15 @@ def test_roa2rmid_scalar_psinorm_scalar_t_each_t_True(self): with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_roa2rmid_scalar_psinorm_scalar_t_each_t_False(self): @@ -3082,15 +3084,15 @@ def test_roa2rmid_scalar_psinorm_scalar_t_each_t_False(self): with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) # vector r/a, scalar t: @@ -3099,14 +3101,14 @@ def test_roa2rmid_vector_psinorm_scalar_t_each_t_True(self): out_t = et.roa2rmid(vector_psinorm, scalar_t) self.assertEqual(out.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_roa2rmid_vector_psinorm_scalar_t_each_t_False(self): @@ -3114,14 +3116,14 @@ def test_roa2rmid_vector_psinorm_scalar_t_each_t_False(self): out_t = et.roa2rmid(vector_psinorm, scalar_t, each_t=False) self.assertEqual(out.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) # matrix r/a, scalar t: @@ -3130,14 +3132,14 @@ def test_roa2rmid_matrix_psinorm_scalar_t_each_t_True(self): out_t = et.roa2rmid(matrix_psinorm, scalar_t) self.assertEqual(out.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_roa2rmid_matrix_psinorm_scalar_t_each_t_False(self): @@ -3145,14 +3147,14 @@ def test_roa2rmid_matrix_psinorm_scalar_t_each_t_False(self): out_t = et.roa2rmid(matrix_psinorm, scalar_t, each_t=False) self.assertEqual(out.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) # scalar r/a, vector t: @@ -3161,14 +3163,14 @@ def test_roa2rmid_scalar_psinorm_vector_t_each_t_True(self): out_t = et.roa2rmid(scalar_psinorm, vector_t) self.assertEqual(out.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_roa2rmid_scalar_psinorm_vector_t_each_t_False(self): @@ -3183,14 +3185,14 @@ def test_roa2rmid_vector_psinorm_vector_t_each_t_True(self): out_t = et.roa2rmid(vector_psinorm, vector_t) self.assertEqual(out.shape, (len(vector_t), len(vector_psinorm))) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t), len(vector_psinorm))) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_roa2rmid_vector_psinorm_vector_t_each_t_False(self): @@ -3205,14 +3207,14 @@ def test_roa2rmid_matrix_psinorm_vector_t_each_t_True(self): out_t = et.roa2rmid(matrix_psinorm, vector_t) self.assertEqual(out.shape, tuple([len(vector_t),] + list(matrix_psinorm.shape))) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, tuple([len(vector_t),] + list(matrix_psinorm.shape))) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_roa2rmid_matrix_psinorm_vector_t_each_t_False(self): @@ -3233,14 +3235,14 @@ def test_roa2rmid_matrix_psinorm_matrix_t_each_t_False(self): out_t = et.roa2rmid(matrix_psinorm, matrix_t, each_t=False) self.assertEqual(out.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) class roa2psinormTestCase(unittest.TestCase): @@ -3255,15 +3257,15 @@ def test_roa2psinorm_scalar_psinorm_scalar_t_each_t_True(self): with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_roa2psinorm_scalar_psinorm_scalar_t_each_t_False(self): @@ -3272,15 +3274,15 @@ def test_roa2psinorm_scalar_psinorm_scalar_t_each_t_False(self): with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) # vector r/a, scalar t: @@ -3289,14 +3291,14 @@ def test_roa2psinorm_vector_psinorm_scalar_t_each_t_True(self): out_t = et.roa2psinorm(vector_psinorm, scalar_t) self.assertEqual(out.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_roa2psinorm_vector_psinorm_scalar_t_each_t_False(self): @@ -3304,14 +3306,14 @@ def test_roa2psinorm_vector_psinorm_scalar_t_each_t_False(self): out_t = et.roa2psinorm(vector_psinorm, scalar_t, each_t=False) self.assertEqual(out.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) # matrix r/a, scalar t: @@ -3320,14 +3322,14 @@ def test_roa2psinorm_matrix_psinorm_scalar_t_each_t_True(self): out_t = et.roa2psinorm(matrix_psinorm, scalar_t) self.assertEqual(out.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_roa2psinorm_matrix_psinorm_scalar_t_each_t_False(self): @@ -3335,14 +3337,14 @@ def test_roa2psinorm_matrix_psinorm_scalar_t_each_t_False(self): out_t = et.roa2psinorm(matrix_psinorm, scalar_t, each_t=False) self.assertEqual(out.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) # scalar r/a, vector t: @@ -3351,14 +3353,14 @@ def test_roa2psinorm_scalar_psinorm_vector_t_each_t_True(self): out_t = et.roa2psinorm(scalar_psinorm, vector_t) self.assertEqual(out.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_roa2psinorm_scalar_psinorm_vector_t_each_t_False(self): @@ -3373,14 +3375,14 @@ def test_roa2psinorm_vector_psinorm_vector_t_each_t_True(self): out_t = et.roa2psinorm(vector_psinorm, vector_t) self.assertEqual(out.shape, (len(vector_t), len(vector_psinorm))) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t), len(vector_psinorm))) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_roa2psinorm_vector_psinorm_vector_t_each_t_False(self): @@ -3395,14 +3397,14 @@ def test_roa2psinorm_matrix_psinorm_vector_t_each_t_True(self): out_t = et.roa2psinorm(matrix_psinorm, vector_t) self.assertEqual(out.shape, tuple([len(vector_t),] + list(matrix_psinorm.shape))) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, tuple([len(vector_t),] + list(matrix_psinorm.shape))) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_roa2psinorm_matrix_psinorm_vector_t_each_t_False(self): @@ -3423,14 +3425,14 @@ def test_roa2psinorm_matrix_psinorm_matrix_t_each_t_False(self): out_t = et.roa2psinorm(matrix_psinorm, matrix_t, each_t=False) self.assertEqual(out.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) class roa2phinormTestCase(unittest.TestCase): @@ -3445,15 +3447,15 @@ def test_roa2phinorm_scalar_psinorm_scalar_t_each_t_True(self): with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_roa2phinorm_scalar_psinorm_scalar_t_each_t_False(self): @@ -3462,15 +3464,15 @@ def test_roa2phinorm_scalar_psinorm_scalar_t_each_t_False(self): with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) # vector r/a, scalar t: @@ -3479,14 +3481,14 @@ def test_roa2phinorm_vector_psinorm_scalar_t_each_t_True(self): out_t = et.roa2phinorm(vector_psinorm, scalar_t) self.assertEqual(out.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_roa2phinorm_vector_psinorm_scalar_t_each_t_False(self): @@ -3494,14 +3496,14 @@ def test_roa2phinorm_vector_psinorm_scalar_t_each_t_False(self): out_t = et.roa2phinorm(vector_psinorm, scalar_t, each_t=False) self.assertEqual(out.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) # matrix r/a, scalar t: @@ -3510,14 +3512,14 @@ def test_roa2phinorm_matrix_psinorm_scalar_t_each_t_True(self): out_t = et.roa2phinorm(matrix_psinorm, scalar_t) self.assertEqual(out.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_roa2phinorm_matrix_psinorm_scalar_t_each_t_False(self): @@ -3525,14 +3527,14 @@ def test_roa2phinorm_matrix_psinorm_scalar_t_each_t_False(self): out_t = et.roa2phinorm(matrix_psinorm, scalar_t, each_t=False) self.assertEqual(out.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) # scalar r/a, vector t: @@ -3541,14 +3543,14 @@ def test_roa2phinorm_scalar_psinorm_vector_t_each_t_True(self): out_t = et.roa2phinorm(scalar_psinorm, vector_t) self.assertEqual(out.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_roa2phinorm_scalar_psinorm_vector_t_each_t_False(self): @@ -3564,18 +3566,18 @@ def test_roa2phinorm_vector_psinorm_vector_t_each_t_True(self): self.assertEqual(out.shape, (len(vector_t), len(vector_psinorm))) # TODO: Fix boundaries! - # self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + # self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t), len(vector_psinorm))) # TODO: Fix boundaries! - # self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + # self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - # self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + # self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_roa2phinorm_vector_psinorm_vector_t_each_t_False(self): @@ -3591,18 +3593,18 @@ def test_roa2phinorm_matrix_psinorm_vector_t_each_t_True(self): self.assertEqual(out.shape, tuple([len(vector_t),] + list(matrix_psinorm.shape))) # TODO: Fix boundaries! - # self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + # self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, tuple([len(vector_t),] + list(matrix_psinorm.shape))) # TODO: Fix boundaries! - # self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + # self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - # self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + # self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_roa2phinorm_matrix_psinorm_vector_t_each_t_False(self): @@ -3624,18 +3626,18 @@ def test_roa2phinorm_matrix_psinorm_matrix_t_each_t_False(self): self.assertEqual(out.shape, matrix_psinorm.shape) # TODO: Fix boundaries! - # self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + # self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_psinorm.shape) # TODO: Fix boundaries! - # self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + # self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - # self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + # self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) class roa2volnormTestCase(unittest.TestCase): @@ -3650,15 +3652,15 @@ def test_roa2volnorm_scalar_psinorm_scalar_t_each_t_True(self): with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_roa2volnorm_scalar_psinorm_scalar_t_each_t_False(self): @@ -3667,15 +3669,15 @@ def test_roa2volnorm_scalar_psinorm_scalar_t_each_t_False(self): with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) # vector r/a, scalar t: @@ -3684,14 +3686,14 @@ def test_roa2volnorm_vector_psinorm_scalar_t_each_t_True(self): out_t = et.roa2volnorm(vector_psinorm, scalar_t) self.assertEqual(out.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_roa2volnorm_vector_psinorm_scalar_t_each_t_False(self): @@ -3699,14 +3701,14 @@ def test_roa2volnorm_vector_psinorm_scalar_t_each_t_False(self): out_t = et.roa2volnorm(vector_psinorm, scalar_t, each_t=False) self.assertEqual(out.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) # matrix r/a, scalar t: @@ -3715,14 +3717,14 @@ def test_roa2volnorm_matrix_psinorm_scalar_t_each_t_True(self): out_t = et.roa2volnorm(matrix_psinorm, scalar_t) self.assertEqual(out.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_roa2volnorm_matrix_psinorm_scalar_t_each_t_False(self): @@ -3730,14 +3732,14 @@ def test_roa2volnorm_matrix_psinorm_scalar_t_each_t_False(self): out_t = et.roa2volnorm(matrix_psinorm, scalar_t, each_t=False) self.assertEqual(out.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) # scalar r/a, vector t: @@ -3746,14 +3748,14 @@ def test_roa2volnorm_scalar_psinorm_vector_t_each_t_True(self): out_t = et.roa2volnorm(scalar_psinorm, vector_t) self.assertEqual(out.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_roa2volnorm_scalar_psinorm_vector_t_each_t_False(self): @@ -3769,18 +3771,18 @@ def test_roa2volnorm_vector_psinorm_vector_t_each_t_True(self): self.assertEqual(out.shape, (len(vector_t), len(vector_psinorm))) # TODO: Fix boundaries! - # self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + # self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t), len(vector_psinorm))) # TODO: Fix boundaries! - # self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + # self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - # self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + # self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_roa2volnorm_vector_psinorm_vector_t_each_t_False(self): @@ -3796,18 +3798,18 @@ def test_roa2volnorm_matrix_psinorm_vector_t_each_t_True(self): self.assertEqual(out.shape, tuple([len(vector_t),] + list(matrix_psinorm.shape))) # TODO: Fix boundaries! - # self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + # self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, tuple([len(vector_t),] + list(matrix_psinorm.shape))) # TODO: Fix boundaries! - # self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + # self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - # self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + # self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_roa2volnorm_matrix_psinorm_vector_t_each_t_False(self): @@ -3829,18 +3831,18 @@ def test_roa2volnorm_matrix_psinorm_matrix_t_each_t_False(self): self.assertEqual(out.shape, matrix_psinorm.shape) # TODO: Fix boundaries! - # self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + # self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_psinorm.shape) # TODO: Fix boundaries! - # self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + # self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - # self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + # self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) class psinorm2rmidTestCase(unittest.TestCase): @@ -3855,15 +3857,15 @@ def test_psinorm2rmid_scalar_psinorm_scalar_t_each_t_True_rho_False(self): with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_psinorm2rmid_scalar_psinorm_scalar_t_each_t_False_rho_False(self): @@ -3872,15 +3874,15 @@ def test_psinorm2rmid_scalar_psinorm_scalar_t_each_t_False_rho_False(self): with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_psinorm2rmid_scalar_psinorm_scalar_t_each_t_True_rho_True(self): @@ -3889,15 +3891,15 @@ def test_psinorm2rmid_scalar_psinorm_scalar_t_each_t_True_rho_True(self): with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_psinorm2rmid_scalar_psinorm_scalar_t_each_t_False_rho_True(self): @@ -3906,15 +3908,15 @@ def test_psinorm2rmid_scalar_psinorm_scalar_t_each_t_False_rho_True(self): with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) # vector psinorm, scalar t: @@ -3923,17 +3925,17 @@ def test_psinorm2rmid_vector_psinorm_scalar_t_each_t_True_rho_False(self): out_t = et.psinorm2rmid(vector_psinorm, scalar_t) self.assertEqual(out.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_psinorm2rmid_vector_psinorm_scalar_t_each_t_False_rho_False(self): @@ -3941,17 +3943,17 @@ def test_psinorm2rmid_vector_psinorm_scalar_t_each_t_False_rho_False(self): out_t = et.psinorm2rmid(vector_psinorm, scalar_t, each_t=False) self.assertEqual(out.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_psinorm2rmid_vector_psinorm_scalar_t_each_t_True_rho_True(self): @@ -3959,17 +3961,17 @@ def test_psinorm2rmid_vector_psinorm_scalar_t_each_t_True_rho_True(self): out_t = et.psinorm2rmid(vector_psinorm, scalar_t, rho=True) self.assertEqual(out.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_psinorm2rmid_vector_psinorm_scalar_t_each_t_False_rho_True(self): @@ -3977,17 +3979,17 @@ def test_psinorm2rmid_vector_psinorm_scalar_t_each_t_False_rho_True(self): out_t = et.psinorm2rmid(vector_psinorm, scalar_t, each_t=False, rho=True) self.assertEqual(out.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) # matrix psinorm, scalar t: @@ -3996,17 +3998,17 @@ def test_psinorm2rmid_matrix_psinorm_scalar_t_each_t_True_rho_False(self): out_t = et.psinorm2rmid(matrix_psinorm, scalar_t) self.assertEqual(out.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_psinorm2rmid_matrix_psinorm_scalar_t_each_t_False_rho_False(self): @@ -4014,17 +4016,17 @@ def test_psinorm2rmid_matrix_psinorm_scalar_t_each_t_False_rho_False(self): out_t = et.psinorm2rmid(matrix_psinorm, scalar_t, each_t=False) self.assertEqual(out.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_psinorm2rmid_matrix_psinorm_scalar_t_each_t_True_rho_True(self): @@ -4032,17 +4034,17 @@ def test_psinorm2rmid_matrix_psinorm_scalar_t_each_t_True_rho_True(self): out_t = et.psinorm2rmid(matrix_psinorm, scalar_t, rho=True) self.assertEqual(out.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_psinorm2rmid_matrix_psinorm_scalar_t_each_t_False_rho_True(self): @@ -4050,17 +4052,17 @@ def test_psinorm2rmid_matrix_psinorm_scalar_t_each_t_False_rho_True(self): out_t = et.psinorm2rmid(matrix_psinorm, scalar_t, each_t=False, rho=True) self.assertEqual(out.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) # scalar psinorm, vector t: @@ -4069,14 +4071,14 @@ def test_psinorm2rmid_scalar_psinorm_vector_t_each_t_True_rho_False(self): out_t = et.psinorm2rmid(scalar_psinorm, vector_t) self.assertEqual(out.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_psinorm2rmid_scalar_psinorm_vector_t_each_t_False_rho_False(self): @@ -4090,14 +4092,14 @@ def test_psinorm2rmid_scalar_psinorm_vector_t_each_t_True_rho_True(self): out_t = et.psinorm2rmid(scalar_psinorm, vector_t, rho=True) self.assertEqual(out.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_psinorm2rmid_scalar_psinorm_vector_t_each_t_False_rho_True(self): @@ -4112,17 +4114,17 @@ def test_psinorm2rmid_vector_psinorm_vector_t_each_t_True_rho_False(self): out_t = et.psinorm2rmid(vector_psinorm, vector_t) self.assertEqual(out.shape, (len(vector_t), len(vector_psinorm))) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t), len(vector_psinorm))) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_psinorm2rmid_vector_psinorm_vector_t_each_t_False_rho_False(self): @@ -4136,17 +4138,17 @@ def test_psinorm2rmid_vector_psinorm_vector_t_each_t_True_rho_True(self): out_t = et.psinorm2rmid(vector_psinorm, vector_t, rho=True) self.assertEqual(out.shape, (len(vector_t), len(vector_psinorm))) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t), len(vector_psinorm))) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_psinorm2rmid_vector_psinorm_vector_t_each_t_False_rho_True(self): @@ -4161,17 +4163,17 @@ def test_psinorm2rmid_matrix_psinorm_vector_t_each_t_True_rho_False(self): out_t = et.psinorm2rmid(matrix_psinorm, vector_t) self.assertEqual(out.shape, tuple([len(vector_t),] + list(matrix_psinorm.shape))) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, tuple([len(vector_t),] + list(matrix_psinorm.shape))) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_psinorm2rmid_matrix_psinorm_vector_t_each_t_False_rho_False(self): @@ -4185,17 +4187,17 @@ def test_psinorm2rmid_matrix_psinorm_vector_t_each_t_True_rho_True(self): out_t = et.psinorm2rmid(matrix_psinorm, vector_t, rho=True) self.assertEqual(out.shape, tuple([len(vector_t),] + list(matrix_psinorm.shape))) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, tuple([len(vector_t),] + list(matrix_psinorm.shape))) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_psinorm2rmid_matrix_psinorm_vector_t_each_t_False_rho_True(self): @@ -4216,17 +4218,17 @@ def test_psinorm2rmid_matrix_psinorm_matrix_t_each_t_False_rho_False(self): out_t = et.psinorm2rmid(matrix_psinorm, matrix_t, each_t=False) self.assertEqual(out.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_psinorm2rmid_matrix_psinorm_matrix_t_each_t_True_rho_True(self): @@ -4240,17 +4242,17 @@ def test_psinorm2rmid_matrix_psinorm_matrix_t_each_t_False_rho_True(self): out_t = et.psinorm2rmid(matrix_psinorm, matrix_t, each_t=False, rho=True) self.assertEqual(out.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) class psinorm2roaTestCase(unittest.TestCase): @@ -4265,15 +4267,15 @@ def test_psinorm2roa_scalar_psinorm_scalar_t_each_t_True(self): with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_psinorm2roa_scalar_psinorm_scalar_t_each_t_False(self): @@ -4282,15 +4284,15 @@ def test_psinorm2roa_scalar_psinorm_scalar_t_each_t_False(self): with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) # vector psinorm, scalar t: @@ -4299,17 +4301,17 @@ def test_psinorm2roa_vector_psinorm_scalar_t_each_t_True(self): out_t = et.psinorm2roa(vector_psinorm, scalar_t) self.assertEqual(out.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_psinorm2roa_vector_psinorm_scalar_t_each_t_False(self): @@ -4317,17 +4319,17 @@ def test_psinorm2roa_vector_psinorm_scalar_t_each_t_False(self): out_t = et.psinorm2roa(vector_psinorm, scalar_t, each_t=False) self.assertEqual(out.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) # matrix psinorm, scalar t: @@ -4336,17 +4338,17 @@ def test_psinorm2roa_matrix_psinorm_scalar_t_each_t_True(self): out_t = et.psinorm2roa(matrix_psinorm, scalar_t) self.assertEqual(out.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_psinorm2roa_matrix_psinorm_scalar_t_each_t_False(self): @@ -4354,17 +4356,17 @@ def test_psinorm2roa_matrix_psinorm_scalar_t_each_t_False(self): out_t = et.psinorm2roa(matrix_psinorm, scalar_t, each_t=False) self.assertEqual(out.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) # scalar psinorm, vector t: @@ -4373,14 +4375,14 @@ def test_psinorm2roa_scalar_psinorm_vector_t_each_t_True(self): out_t = et.psinorm2roa(scalar_psinorm, vector_t) self.assertEqual(out.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_psinorm2roa_scalar_psinorm_vector_t_each_t_False(self): @@ -4395,17 +4397,17 @@ def test_psinorm2roa_vector_psinorm_vector_t_each_t_True(self): out_t = et.psinorm2roa(vector_psinorm, vector_t) self.assertEqual(out.shape, (len(vector_t), len(vector_psinorm))) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t), len(vector_psinorm))) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_psinorm2roa_vector_psinorm_vector_t_each_t_False(self): @@ -4420,17 +4422,17 @@ def test_psinorm2roa_matrix_psinorm_vector_t_each_t_True(self): out_t = et.psinorm2roa(matrix_psinorm, vector_t) self.assertEqual(out.shape, tuple([len(vector_t),] + list(matrix_psinorm.shape))) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, tuple([len(vector_t),] + list(matrix_psinorm.shape))) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_psinorm2roa_matrix_psinorm_vector_t_each_t_False(self): @@ -4451,17 +4453,17 @@ def test_psinorm2roa_matrix_psinorm_matrix_t_each_t_False(self): out_t = et.psinorm2roa(matrix_psinorm, matrix_t, each_t=False) self.assertEqual(out.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) class psinorm2volnormTestCase(unittest.TestCase): @@ -4476,15 +4478,15 @@ def test_psinorm2volnorm_scalar_psinorm_scalar_t_each_t_True(self): with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_psinorm2volnorm_scalar_psinorm_scalar_t_each_t_False(self): @@ -4493,15 +4495,15 @@ def test_psinorm2volnorm_scalar_psinorm_scalar_t_each_t_False(self): with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) # vector psinorm, scalar t: @@ -4510,14 +4512,14 @@ def test_psinorm2volnorm_vector_psinorm_scalar_t_each_t_True(self): out_t = et.psinorm2volnorm(vector_psinorm, scalar_t) self.assertEqual(out.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_psinorm2volnorm_vector_psinorm_scalar_t_each_t_False(self): @@ -4525,14 +4527,14 @@ def test_psinorm2volnorm_vector_psinorm_scalar_t_each_t_False(self): out_t = et.psinorm2volnorm(vector_psinorm, scalar_t, each_t=False) self.assertEqual(out.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) # matrix psinorm, scalar t: @@ -4541,14 +4543,14 @@ def test_psinorm2volnorm_matrix_psinorm_scalar_t_each_t_True(self): out_t = et.psinorm2volnorm(matrix_psinorm, scalar_t) self.assertEqual(out.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_psinorm2volnorm_matrix_psinorm_scalar_t_each_t_False(self): @@ -4556,14 +4558,14 @@ def test_psinorm2volnorm_matrix_psinorm_scalar_t_each_t_False(self): out_t = et.psinorm2volnorm(matrix_psinorm, scalar_t, each_t=False) self.assertEqual(out.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) # scalar psinorm, vector t: @@ -4572,14 +4574,14 @@ def test_psinorm2volnorm_scalar_psinorm_vector_t_each_t_True(self): out_t = et.psinorm2volnorm(scalar_psinorm, vector_t) self.assertEqual(out.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_psinorm2volnorm_scalar_psinorm_vector_t_each_t_False(self): @@ -4594,14 +4596,14 @@ def test_psinorm2volnorm_vector_psinorm_vector_t_each_t_True(self): out_t = et.psinorm2volnorm(vector_psinorm, vector_t) self.assertEqual(out.shape, (len(vector_t), len(vector_psinorm))) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t), len(vector_psinorm))) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_psinorm2volnorm_vector_psinorm_vector_t_each_t_False(self): @@ -4616,14 +4618,14 @@ def test_psinorm2volnorm_matrix_psinorm_vector_t_each_t_True(self): out_t = et.psinorm2volnorm(matrix_psinorm, vector_t) self.assertEqual(out.shape, tuple([len(vector_t),] + list(matrix_psinorm.shape))) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, tuple([len(vector_t),] + list(matrix_psinorm.shape))) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_psinorm2volnorm_matrix_psinorm_vector_t_each_t_False(self): @@ -4644,14 +4646,14 @@ def test_psinorm2volnorm_matrix_psinorm_matrix_t_each_t_False(self): out_t = et.psinorm2volnorm(matrix_psinorm, matrix_t, each_t=False) self.assertEqual(out.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) class psinorm2phinormTestCase(unittest.TestCase): @@ -4666,15 +4668,15 @@ def test_psinorm2phinorm_scalar_psinorm_scalar_t_each_t_True(self): with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_psinorm2phinorm_scalar_psinorm_scalar_t_each_t_False(self): @@ -4683,15 +4685,15 @@ def test_psinorm2phinorm_scalar_psinorm_scalar_t_each_t_False(self): with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) # vector psinorm, scalar t: @@ -4700,14 +4702,14 @@ def test_psinorm2phinorm_vector_psinorm_scalar_t_each_t_True(self): out_t = e.psinorm2phinorm(vector_psinorm, scalar_t) self.assertEqual(out.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_psinorm2phinorm_vector_psinorm_scalar_t_each_t_False(self): @@ -4715,14 +4717,14 @@ def test_psinorm2phinorm_vector_psinorm_scalar_t_each_t_False(self): out_t = et.psinorm2phinorm(vector_psinorm, scalar_t, each_t=False) self.assertEqual(out.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) # matrix psinorm, scalar t: @@ -4731,14 +4733,14 @@ def test_psinorm2phinorm_matrix_psinorm_scalar_t_each_t_True(self): out_t = et.psinorm2phinorm(matrix_psinorm, scalar_t) self.assertEqual(out.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_psinorm2phinorm_matrix_psinorm_scalar_t_each_t_False(self): @@ -4746,14 +4748,14 @@ def test_psinorm2phinorm_matrix_psinorm_scalar_t_each_t_False(self): out_t = et.psinorm2phinorm(matrix_psinorm, scalar_t, each_t=False) self.assertEqual(out.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) # scalar psinorm, vector t: @@ -4762,14 +4764,14 @@ def test_psinorm2phinorm_scalar_psinorm_vector_t_each_t_True(self): out_t = et.psinorm2phinorm(scalar_psinorm, vector_t) self.assertEqual(out.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_psinorm2phinorm_scalar_psinorm_vector_t_each_t_False(self): @@ -4784,14 +4786,14 @@ def test_psinorm2phinorm_vector_psinorm_vector_t_each_t_True(self): out_t = et.psinorm2phinorm(vector_psinorm, vector_t) self.assertEqual(out.shape, (len(vector_t), len(vector_psinorm))) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t), len(vector_psinorm))) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_psinorm2phinorm_vector_psinorm_vector_t_each_t_False(self): @@ -4806,14 +4808,14 @@ def test_psinorm2phinorm_matrix_psinorm_vector_t_each_t_True(self): out_t = et.psinorm2phinorm(matrix_psinorm, vector_t) self.assertEqual(out.shape, tuple([len(vector_t),] + list(matrix_psinorm.shape))) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, tuple([len(vector_t),] + list(matrix_psinorm.shape))) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_psinorm2phinorm_matrix_psinorm_vector_t_each_t_False(self): @@ -4834,14 +4836,14 @@ def test_psinorm2phinorm_matrix_psinorm_matrix_t_each_t_False(self): out_t = et.psinorm2phinorm(matrix_psinorm, matrix_t, each_t=False) self.assertEqual(out.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) class phinorm2psinormTestCase(unittest.TestCase): @@ -4856,15 +4858,15 @@ def test_phinorm2psinorm_scalar_psinorm_scalar_t_each_t_True(self): with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_phinorm2psinorm_scalar_psinorm_scalar_t_each_t_False(self): @@ -4873,15 +4875,15 @@ def test_phinorm2psinorm_scalar_psinorm_scalar_t_each_t_False(self): with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) # vector psinorm, scalar t: @@ -4890,14 +4892,14 @@ def test_phinorm2psinorm_vector_psinorm_scalar_t_each_t_True(self): out_t = et.phinorm2psinorm(vector_psinorm, scalar_t) self.assertEqual(out.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_phinorm2psinorm_vector_psinorm_scalar_t_each_t_False(self): @@ -4905,14 +4907,14 @@ def test_phinorm2psinorm_vector_psinorm_scalar_t_each_t_False(self): out_t = et.phinorm2psinorm(vector_psinorm, scalar_t, each_t=False) self.assertEqual(out.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) # matrix psinorm, scalar t: @@ -4921,14 +4923,14 @@ def test_phinorm2psinorm_matrix_psinorm_scalar_t_each_t_True(self): out_t = et.phinorm2psinorm(matrix_psinorm, scalar_t) self.assertEqual(out.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_phinorm2psinorm_matrix_psinorm_scalar_t_each_t_False(self): @@ -4936,14 +4938,14 @@ def test_phinorm2psinorm_matrix_psinorm_scalar_t_each_t_False(self): out_t = et.phinorm2psinorm(matrix_psinorm, scalar_t, each_t=False) self.assertEqual(out.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) # scalar psinorm, vector t: @@ -4952,14 +4954,14 @@ def test_phinorm2psinorm_scalar_psinorm_vector_t_each_t_True(self): out_t = et.phinorm2psinorm(scalar_psinorm, vector_t) self.assertEqual(out.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_phinorm2psinorm_scalar_psinorm_vector_t_each_t_False(self): @@ -4974,14 +4976,14 @@ def test_phinorm2psinorm_vector_psinorm_vector_t_each_t_True(self): out_t = et.phinorm2psinorm(vector_psinorm, vector_t) self.assertEqual(out.shape, (len(vector_t), len(vector_psinorm))) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t), len(vector_psinorm))) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_phinorm2psinorm_vector_psinorm_vector_t_each_t_False(self): @@ -4996,14 +4998,14 @@ def test_phinorm2psinorm_matrix_psinorm_vector_t_each_t_True(self): out_t = et.phinorm2psinorm(matrix_psinorm, vector_t) self.assertEqual(out.shape, tuple([len(vector_t),] + list(matrix_psinorm.shape))) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, tuple([len(vector_t),] + list(matrix_psinorm.shape))) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_phinorm2psinorm_matrix_psinorm_vector_t_each_t_False(self): @@ -5024,14 +5026,14 @@ def test_phinorm2psinorm_matrix_psinorm_matrix_t_each_t_False(self): out_t = et.phinorm2psinorm(matrix_psinorm, matrix_t, each_t=False) self.assertEqual(out.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) class phinorm2volnormTestCase(unittest.TestCase): @@ -5046,15 +5048,15 @@ def test_phinorm2volnorm_scalar_psinorm_scalar_t_each_t_True(self): with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_phinorm2volnorm_scalar_psinorm_scalar_t_each_t_False(self): @@ -5063,15 +5065,15 @@ def test_phinorm2volnorm_scalar_psinorm_scalar_t_each_t_False(self): with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) # vector psinorm, scalar t: @@ -5080,17 +5082,17 @@ def test_phinorm2volnorm_vector_psinorm_scalar_t_each_t_True(self): out_t = et.phinorm2volnorm(vector_psinorm, scalar_t) self.assertEqual(out.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) # res2 = (out - out_t)**2 - # diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + # diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_phinorm2volnorm_vector_psinorm_scalar_t_each_t_False(self): @@ -5098,17 +5100,17 @@ def test_phinorm2volnorm_vector_psinorm_scalar_t_each_t_False(self): out_t = et.phinorm2volnorm(vector_psinorm, scalar_t, each_t=False) self.assertEqual(out.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) # res2 = (out - out_t)**2 - # diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + # diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) # matrix psinorm, scalar t: @@ -5117,17 +5119,17 @@ def test_phinorm2volnorm_matrix_psinorm_scalar_t_each_t_True(self): out_t = et.phinorm2volnorm(matrix_psinorm, scalar_t) self.assertEqual(out.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) # res2 = (out - out_t)**2 - # diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + # diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_phinorm2volnorm_matrix_psinorm_scalar_t_each_t_False(self): @@ -5135,17 +5137,17 @@ def test_phinorm2volnorm_matrix_psinorm_scalar_t_each_t_False(self): out_t = et.phinorm2volnorm(matrix_psinorm, scalar_t, each_t=False) self.assertEqual(out.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) # res2 = (out - out_t)**2 - # diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + # diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) # scalar psinorm, vector t: @@ -5154,14 +5156,14 @@ def test_phinorm2volnorm_scalar_psinorm_vector_t_each_t_True(self): out_t = et.phinorm2volnorm(scalar_psinorm, vector_t) self.assertEqual(out.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_phinorm2volnorm_scalar_psinorm_vector_t_each_t_False(self): @@ -5176,18 +5178,18 @@ def test_phinorm2volnorm_vector_psinorm_vector_t_each_t_True(self): out_t = et.phinorm2volnorm(vector_psinorm, vector_t) self.assertEqual(out.shape, (len(vector_t), len(vector_psinorm))) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t), len(vector_psinorm))) # TODO: Fix boundary! - # self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + # self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - # self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + # self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_phinorm2volnorm_vector_psinorm_vector_t_each_t_False(self): @@ -5202,18 +5204,18 @@ def test_phinorm2volnorm_matrix_psinorm_vector_t_each_t_True(self): out_t = et.phinorm2volnorm(matrix_psinorm, vector_t) self.assertEqual(out.shape, tuple([len(vector_t),] + list(matrix_psinorm.shape))) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, tuple([len(vector_t),] + list(matrix_psinorm.shape))) # TODO: Fix boundary! - # self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + # self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - # self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + # self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_phinorm2volnorm_matrix_psinorm_vector_t_each_t_False(self): @@ -5234,17 +5236,17 @@ def test_phinorm2volnorm_matrix_psinorm_matrix_t_each_t_False(self): out_t = et.phinorm2volnorm(matrix_psinorm, matrix_t, each_t=False) self.assertEqual(out.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) class phinorm2rmidTestCase(unittest.TestCase): @@ -5259,15 +5261,15 @@ def test_phinorm2rmid_scalar_psinorm_scalar_t_each_t_True_rho_False(self): with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_phinorm2rmid_scalar_psinorm_scalar_t_each_t_False_rho_False(self): @@ -5276,15 +5278,15 @@ def test_phinorm2rmid_scalar_psinorm_scalar_t_each_t_False_rho_False(self): with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_phinorm2rmid_scalar_psinorm_scalar_t_each_t_True_rho_True(self): @@ -5293,15 +5295,15 @@ def test_phinorm2rmid_scalar_psinorm_scalar_t_each_t_True_rho_True(self): with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_phinorm2rmid_scalar_psinorm_scalar_t_each_t_False_rho_True(self): @@ -5310,15 +5312,15 @@ def test_phinorm2rmid_scalar_psinorm_scalar_t_each_t_False_rho_True(self): with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) # vector psinorm, scalar t: @@ -5327,17 +5329,17 @@ def test_phinorm2rmid_vector_psinorm_scalar_t_each_t_True_rho_False(self): out_t = et.phinorm2rmid(vector_psinorm, scalar_t) self.assertEqual(out.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_phinorm2rmid_vector_psinorm_scalar_t_each_t_False_rho_False(self): @@ -5345,17 +5347,17 @@ def test_phinorm2rmid_vector_psinorm_scalar_t_each_t_False_rho_False(self): out_t = et.phinorm2rmid(vector_psinorm, scalar_t, each_t=False) self.assertEqual(out.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_phinorm2rmid_vector_psinorm_scalar_t_each_t_True_rho_True(self): @@ -5363,17 +5365,17 @@ def test_phinorm2rmid_vector_psinorm_scalar_t_each_t_True_rho_True(self): out_t = et.phinorm2rmid(vector_psinorm, scalar_t, rho=True) self.assertEqual(out.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_phinorm2rmid_vector_psinorm_scalar_t_each_t_False_rho_True(self): @@ -5381,17 +5383,17 @@ def test_phinorm2rmid_vector_psinorm_scalar_t_each_t_False_rho_True(self): out_t = et.phinorm2rmid(vector_psinorm, scalar_t, each_t=False, rho=True) self.assertEqual(out.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) # matrix psinorm, scalar t: @@ -5400,17 +5402,17 @@ def test_phinorm2rmid_matrix_psinorm_scalar_t_each_t_True_rho_False(self): out_t = et.phinorm2rmid(matrix_psinorm, scalar_t) self.assertEqual(out.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_phinorm2rmid_matrix_psinorm_scalar_t_each_t_False_rho_False(self): @@ -5418,17 +5420,17 @@ def test_phinorm2rmid_matrix_psinorm_scalar_t_each_t_False_rho_False(self): out_t = et.phinorm2rmid(matrix_psinorm, scalar_t, each_t=False) self.assertEqual(out.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_phinorm2rmid_matrix_psinorm_scalar_t_each_t_True_rho_True(self): @@ -5436,17 +5438,17 @@ def test_phinorm2rmid_matrix_psinorm_scalar_t_each_t_True_rho_True(self): out_t = et.phinorm2rmid(matrix_psinorm, scalar_t, rho=True) self.assertEqual(out.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_phinorm2rmid_matrix_psinorm_scalar_t_each_t_False_rho_True(self): @@ -5454,17 +5456,17 @@ def test_phinorm2rmid_matrix_psinorm_scalar_t_each_t_False_rho_True(self): out_t = et.phinorm2rmid(matrix_psinorm, scalar_t, each_t=False, rho=True) self.assertEqual(out.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) # scalar psinorm, vector t: @@ -5473,14 +5475,14 @@ def test_phinorm2rmid_scalar_psinorm_vector_t_each_t_True_rho_False(self): out_t = et.phinorm2rmid(scalar_psinorm, vector_t) self.assertEqual(out.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_phinorm2rmid_scalar_psinorm_vector_t_each_t_False_rho_False(self): @@ -5494,14 +5496,14 @@ def test_phinorm2rmid_scalar_psinorm_vector_t_each_t_True_rho_True(self): out_t = et.phinorm2rmid(scalar_psinorm, vector_t, rho=True) self.assertEqual(out.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_phinorm2rmid_scalar_psinorm_vector_t_each_t_False_rho_True(self): @@ -5516,17 +5518,17 @@ def test_phinorm2rmid_vector_psinorm_vector_t_each_t_True_rho_False(self): out_t = et.phinorm2rmid(vector_psinorm, vector_t) self.assertEqual(out.shape, (len(vector_t), len(vector_psinorm))) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t), len(vector_psinorm))) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) # res2 = (out - out_t)**2 - # diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + # diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_phinorm2rmid_vector_psinorm_vector_t_each_t_False_rho_False(self): @@ -5540,17 +5542,17 @@ def test_phinorm2rmid_vector_psinorm_vector_t_each_t_True_rho_True(self): out_t = et.phinorm2rmid(vector_psinorm, vector_t, rho=True) self.assertEqual(out.shape, (len(vector_t), len(vector_psinorm))) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t), len(vector_psinorm))) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) # res2 = (out - out_t)**2 - # diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + # diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_phinorm2rmid_vector_psinorm_vector_t_each_t_False_rho_True(self): @@ -5565,17 +5567,17 @@ def test_phinorm2rmid_matrix_psinorm_vector_t_each_t_True_rho_False(self): out_t = et.phinorm2rmid(matrix_psinorm, vector_t) self.assertEqual(out.shape, tuple([len(vector_t),] + list(matrix_psinorm.shape))) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, tuple([len(vector_t),] + list(matrix_psinorm.shape))) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) # res2 = (out - out_t)**2 - # diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + # diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_phinorm2rmid_matrix_psinorm_vector_t_each_t_False_rho_False(self): @@ -5589,17 +5591,17 @@ def test_phinorm2rmid_matrix_psinorm_vector_t_each_t_True_rho_True(self): out_t = et.phinorm2rmid(matrix_psinorm, vector_t, rho=True) self.assertEqual(out.shape, tuple([len(vector_t),] + list(matrix_psinorm.shape))) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, tuple([len(vector_t),] + list(matrix_psinorm.shape))) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) # res2 = (out - out_t)**2 - # diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + # diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_phinorm2rmid_matrix_psinorm_vector_t_each_t_False_rho_True(self): @@ -5620,17 +5622,17 @@ def test_phinorm2rmid_matrix_psinorm_matrix_t_each_t_False_rho_False(self): out_t = et.phinorm2rmid(matrix_psinorm, matrix_t, each_t=False) self.assertEqual(out.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_phinorm2rmid_matrix_psinorm_matrix_t_each_t_True_rho_True(self): @@ -5644,17 +5646,17 @@ def test_phinorm2rmid_matrix_psinorm_matrix_t_each_t_False_rho_True(self): out_t = et.phinorm2rmid(matrix_psinorm, matrix_t, each_t=False, rho=True) self.assertEqual(out.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) class phinorm2roaTestCase(unittest.TestCase): @@ -5669,15 +5671,15 @@ def test_phinorm2roa_scalar_psinorm_scalar_t_each_t_True(self): with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_phinorm2roa_scalar_psinorm_scalar_t_each_t_False(self): @@ -5686,15 +5688,15 @@ def test_phinorm2roa_scalar_psinorm_scalar_t_each_t_False(self): with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) # vector psinorm, scalar t: @@ -5703,17 +5705,17 @@ def test_phinorm2roa_vector_psinorm_scalar_t_each_t_True(self): out_t = et.phinorm2roa(vector_psinorm, scalar_t) self.assertEqual(out.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_phinorm2roa_vector_psinorm_scalar_t_each_t_False(self): @@ -5721,17 +5723,17 @@ def test_phinorm2roa_vector_psinorm_scalar_t_each_t_False(self): out_t = et.phinorm2roa(vector_psinorm, scalar_t, each_t=False) self.assertEqual(out.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) # matrix psinorm, scalar t: @@ -5740,17 +5742,17 @@ def test_phinorm2roa_matrix_psinorm_scalar_t_each_t_True(self): out_t = et.phinorm2roa(matrix_psinorm, scalar_t) self.assertEqual(out.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_phinorm2roa_matrix_psinorm_scalar_t_each_t_False(self): @@ -5758,17 +5760,17 @@ def test_phinorm2roa_matrix_psinorm_scalar_t_each_t_False(self): out_t = et.phinorm2roa(matrix_psinorm, scalar_t, each_t=False) self.assertEqual(out.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) # scalar psinorm, vector t: @@ -5777,14 +5779,14 @@ def test_phinorm2roa_scalar_psinorm_vector_t_each_t_True(self): out_t = et.phinorm2roa(scalar_psinorm, vector_t) self.assertEqual(out.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_phinorm2roa_scalar_psinorm_vector_t_each_t_False(self): @@ -5799,17 +5801,17 @@ def test_phinorm2roa_vector_psinorm_vector_t_each_t_True(self): out_t = et.phinorm2roa(vector_psinorm, vector_t) self.assertEqual(out.shape, (len(vector_t), len(vector_psinorm))) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t), len(vector_psinorm))) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) # res2 = (out - out_t)**2 - # diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + # diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_phinorm2roa_vector_psinorm_vector_t_each_t_False(self): @@ -5824,17 +5826,17 @@ def test_phinorm2roa_matrix_psinorm_vector_t_each_t_True(self): out_t = et.phinorm2roa(matrix_psinorm, vector_t) self.assertEqual(out.shape, tuple([len(vector_t),] + list(matrix_psinorm.shape))) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, tuple([len(vector_t),] + list(matrix_psinorm.shape))) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) # res2 = (out - out_t)**2 - # diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + # diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_phinorm2roa_matrix_psinorm_vector_t_each_t_False(self): @@ -5855,17 +5857,17 @@ def test_phinorm2roa_matrix_psinorm_matrix_t_each_t_False(self): out_t = et.phinorm2roa(matrix_psinorm, matrix_t, each_t=False) self.assertEqual(out.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) class volnorm2psinormTestCase(unittest.TestCase): @@ -5880,15 +5882,15 @@ def test_volnorm2psinorm_scalar_psinorm_scalar_t_each_t_True(self): with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_volnorm2psinorm_scalar_psinorm_scalar_t_each_t_False(self): @@ -5897,15 +5899,15 @@ def test_volnorm2psinorm_scalar_psinorm_scalar_t_each_t_False(self): with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) # vector psinorm, scalar t: @@ -5914,14 +5916,14 @@ def test_volnorm2psinorm_vector_psinorm_scalar_t_each_t_True(self): out_t = et.volnorm2psinorm(vector_psinorm, scalar_t) self.assertEqual(out.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_volnorm2psinorm_vector_psinorm_scalar_t_each_t_False(self): @@ -5929,14 +5931,14 @@ def test_volnorm2psinorm_vector_psinorm_scalar_t_each_t_False(self): out_t = et.volnorm2psinorm(vector_psinorm, scalar_t, each_t=False) self.assertEqual(out.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) # matrix psinorm, scalar t: @@ -5945,14 +5947,14 @@ def test_volnorm2psinorm_matrix_psinorm_scalar_t_each_t_True(self): out_t = et.volnorm2psinorm(matrix_psinorm, scalar_t) self.assertEqual(out.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_volnorm2psinorm_matrix_psinorm_scalar_t_each_t_False(self): @@ -5960,14 +5962,14 @@ def test_volnorm2psinorm_matrix_psinorm_scalar_t_each_t_False(self): out_t = et.volnorm2psinorm(matrix_psinorm, scalar_t, each_t=False) self.assertEqual(out.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) # scalar psinorm, vector t: @@ -5976,14 +5978,14 @@ def test_volnorm2psinorm_scalar_psinorm_vector_t_each_t_True(self): out_t = et.volnorm2psinorm(scalar_psinorm, vector_t) self.assertEqual(out.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_volnorm2psinorm_scalar_psinorm_vector_t_each_t_False(self): @@ -5998,14 +6000,14 @@ def test_volnorm2psinorm_vector_psinorm_vector_t_each_t_True(self): out_t = et.volnorm2psinorm(vector_psinorm, vector_t) self.assertEqual(out.shape, (len(vector_t), len(vector_psinorm))) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t), len(vector_psinorm))) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_volnorm2psinorm_vector_psinorm_vector_t_each_t_False(self): @@ -6020,14 +6022,14 @@ def test_volnorm2psinorm_matrix_psinorm_vector_t_each_t_True(self): out_t = et.volnorm2psinorm(matrix_psinorm, vector_t) self.assertEqual(out.shape, tuple([len(vector_t),] + list(matrix_psinorm.shape))) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, tuple([len(vector_t),] + list(matrix_psinorm.shape))) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_volnorm2psinorm_matrix_psinorm_vector_t_each_t_False(self): @@ -6048,14 +6050,14 @@ def test_volnorm2psinorm_matrix_psinorm_matrix_t_each_t_False(self): out_t = et.volnorm2psinorm(matrix_psinorm, matrix_t, each_t=False) self.assertEqual(out.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) class volnorm2phinormTestCase(unittest.TestCase): @@ -6070,15 +6072,15 @@ def test_volnorm2phinorm_scalar_psinorm_scalar_t_each_t_True(self): with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_volnorm2phinorm_scalar_psinorm_scalar_t_each_t_False(self): @@ -6087,15 +6089,15 @@ def test_volnorm2phinorm_scalar_psinorm_scalar_t_each_t_False(self): with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) # vector psinorm, scalar t: @@ -6104,17 +6106,17 @@ def test_volnorm2phinorm_vector_psinorm_scalar_t_each_t_True(self): out_t = et.volnorm2phinorm(vector_psinorm, scalar_t) self.assertEqual(out.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) # res2 = (out - out_t)**2 - # diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + # diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_volnorm2phinorm_vector_psinorm_scalar_t_each_t_False(self): @@ -6122,17 +6124,17 @@ def test_volnorm2phinorm_vector_psinorm_scalar_t_each_t_False(self): out_t = et.volnorm2phinorm(vector_psinorm, scalar_t, each_t=False) self.assertEqual(out.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) # res2 = (out - out_t)**2 - # diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + # diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) # matrix psinorm, scalar t: @@ -6141,17 +6143,17 @@ def test_volnorm2phinorm_matrix_psinorm_scalar_t_each_t_True(self): out_t = et.volnorm2phinorm(matrix_psinorm, scalar_t) self.assertEqual(out.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) # res2 = (out - out_t)**2 - # diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + # diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_volnorm2phinorm_matrix_psinorm_scalar_t_each_t_False(self): @@ -6159,17 +6161,17 @@ def test_volnorm2phinorm_matrix_psinorm_scalar_t_each_t_False(self): out_t = et.volnorm2phinorm(matrix_psinorm, scalar_t, each_t=False) self.assertEqual(out.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) # res2 = (out - out_t)**2 - # diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + # diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) # scalar psinorm, vector t: @@ -6178,14 +6180,14 @@ def test_volnorm2phinorm_scalar_psinorm_vector_t_each_t_True(self): out_t = et.volnorm2phinorm(scalar_psinorm, vector_t) self.assertEqual(out.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_volnorm2phinorm_scalar_psinorm_vector_t_each_t_False(self): @@ -6200,18 +6202,18 @@ def test_volnorm2phinorm_vector_psinorm_vector_t_each_t_True(self): out_t = et.volnorm2phinorm(vector_psinorm, vector_t) self.assertEqual(out.shape, (len(vector_t), len(vector_psinorm))) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t), len(vector_psinorm))) # TODO: Fix boundary! - # self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + # self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - # self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + # self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_volnorm2phinorm_vector_psinorm_vector_t_each_t_False(self): @@ -6226,18 +6228,18 @@ def test_volnorm2phinorm_matrix_psinorm_vector_t_each_t_True(self): out_t = et.volnorm2phinorm(matrix_psinorm, vector_t) self.assertEqual(out.shape, tuple([len(vector_t),] + list(matrix_psinorm.shape))) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, tuple([len(vector_t),] + list(matrix_psinorm.shape))) # TODO: Fix boundary! - # self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + # self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - # self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + # self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_volnorm2phinorm_matrix_psinorm_vector_t_each_t_False(self): @@ -6258,17 +6260,17 @@ def test_volnorm2phinorm_matrix_psinorm_matrix_t_each_t_False(self): out_t = et.volnorm2phinorm(matrix_psinorm, matrix_t, each_t=False) self.assertEqual(out.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) # res2 = (out - out_t)**2 - # diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + # diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) class volnorm2rmidTestCase(unittest.TestCase): @@ -6283,15 +6285,15 @@ def test_volnorm2rmid_scalar_psinorm_scalar_t_each_t_True_rho_False(self): with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_volnorm2rmid_scalar_psinorm_scalar_t_each_t_False_rho_False(self): @@ -6300,15 +6302,15 @@ def test_volnorm2rmid_scalar_psinorm_scalar_t_each_t_False_rho_False(self): with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_volnorm2rmid_scalar_psinorm_scalar_t_each_t_True_rho_True(self): @@ -6317,15 +6319,15 @@ def test_volnorm2rmid_scalar_psinorm_scalar_t_each_t_True_rho_True(self): with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_volnorm2rmid_scalar_psinorm_scalar_t_each_t_False_rho_True(self): @@ -6334,15 +6336,15 @@ def test_volnorm2rmid_scalar_psinorm_scalar_t_each_t_False_rho_True(self): with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) # vector psinorm, scalar t: @@ -6351,17 +6353,17 @@ def test_volnorm2rmid_vector_psinorm_scalar_t_each_t_True_rho_False(self): out_t = et.volnorm2rmid(vector_psinorm, scalar_t) self.assertEqual(out.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_volnorm2rmid_vector_psinorm_scalar_t_each_t_False_rho_False(self): @@ -6369,17 +6371,17 @@ def test_volnorm2rmid_vector_psinorm_scalar_t_each_t_False_rho_False(self): out_t = et.volnorm2rmid(vector_psinorm, scalar_t, each_t=False) self.assertEqual(out.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_volnorm2rmid_vector_psinorm_scalar_t_each_t_True_rho_True(self): @@ -6387,17 +6389,17 @@ def test_volnorm2rmid_vector_psinorm_scalar_t_each_t_True_rho_True(self): out_t = et.volnorm2rmid(vector_psinorm, scalar_t, rho=True) self.assertEqual(out.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_volnorm2rmid_vector_psinorm_scalar_t_each_t_False_rho_True(self): @@ -6405,17 +6407,17 @@ def test_volnorm2rmid_vector_psinorm_scalar_t_each_t_False_rho_True(self): out_t = et.volnorm2rmid(vector_psinorm, scalar_t, each_t=False, rho=True) self.assertEqual(out.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) # matrix psinorm, scalar t: @@ -6424,17 +6426,17 @@ def test_volnorm2rmid_matrix_psinorm_scalar_t_each_t_True_rho_False(self): out_t = et.volnorm2rmid(matrix_psinorm, scalar_t) self.assertEqual(out.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_volnorm2rmid_matrix_psinorm_scalar_t_each_t_False_rho_False(self): @@ -6442,17 +6444,17 @@ def test_volnorm2rmid_matrix_psinorm_scalar_t_each_t_False_rho_False(self): out_t = et.volnorm2rmid(matrix_psinorm, scalar_t, each_t=False) self.assertEqual(out.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_volnorm2rmid_matrix_psinorm_scalar_t_each_t_True_rho_True(self): @@ -6460,17 +6462,17 @@ def test_volnorm2rmid_matrix_psinorm_scalar_t_each_t_True_rho_True(self): out_t = et.volnorm2rmid(matrix_psinorm, scalar_t, rho=True) self.assertEqual(out.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_volnorm2rmid_matrix_psinorm_scalar_t_each_t_False_rho_True(self): @@ -6478,17 +6480,17 @@ def test_volnorm2rmid_matrix_psinorm_scalar_t_each_t_False_rho_True(self): out_t = et.volnorm2rmid(matrix_psinorm, scalar_t, each_t=False, rho=True) self.assertEqual(out.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) # scalar psinorm, vector t: @@ -6497,14 +6499,14 @@ def test_volnorm2rmid_scalar_psinorm_vector_t_each_t_True_rho_False(self): out_t = et.volnorm2rmid(scalar_psinorm, vector_t) self.assertEqual(out.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_volnorm2rmid_scalar_psinorm_vector_t_each_t_False_rho_False(self): @@ -6518,14 +6520,14 @@ def test_volnorm2rmid_scalar_psinorm_vector_t_each_t_True_rho_True(self): out_t = et.volnorm2rmid(scalar_psinorm, vector_t, rho=True) self.assertEqual(out.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_volnorm2rmid_scalar_psinorm_vector_t_each_t_False_rho_True(self): @@ -6540,17 +6542,17 @@ def test_volnorm2rmid_vector_psinorm_vector_t_each_t_True_rho_False(self): out_t = et.volnorm2rmid(vector_psinorm, vector_t) self.assertEqual(out.shape, (len(vector_t), len(vector_psinorm))) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t), len(vector_psinorm))) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) # res2 = (out - out_t)**2 - # diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + # diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_volnorm2rmid_vector_psinorm_vector_t_each_t_False_rho_False(self): @@ -6564,17 +6566,17 @@ def test_volnorm2rmid_vector_psinorm_vector_t_each_t_True_rho_True(self): out_t = et.volnorm2rmid(vector_psinorm, vector_t, rho=True) self.assertEqual(out.shape, (len(vector_t), len(vector_psinorm))) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t), len(vector_psinorm))) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) # res2 = (out - out_t)**2 - # diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + # diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_volnorm2rmid_vector_psinorm_vector_t_each_t_False_rho_True(self): @@ -6589,17 +6591,17 @@ def test_volnorm2rmid_matrix_psinorm_vector_t_each_t_True_rho_False(self): out_t = et.volnorm2rmid(matrix_psinorm, vector_t) self.assertEqual(out.shape, tuple([len(vector_t),] + list(matrix_psinorm.shape))) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, tuple([len(vector_t),] + list(matrix_psinorm.shape))) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) # res2 = (out - out_t)**2 - # diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + # diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_volnorm2rmid_matrix_psinorm_vector_t_each_t_False_rho_False(self): @@ -6613,17 +6615,17 @@ def test_volnorm2rmid_matrix_psinorm_vector_t_each_t_True_rho_True(self): out_t = et.volnorm2rmid(matrix_psinorm, vector_t, rho=True) self.assertEqual(out.shape, tuple([len(vector_t),] + list(matrix_psinorm.shape))) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, tuple([len(vector_t),] + list(matrix_psinorm.shape))) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) # res2 = (out - out_t)**2 - # diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + # diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_volnorm2rmid_matrix_psinorm_vector_t_each_t_False_rho_True(self): @@ -6644,17 +6646,17 @@ def test_volnorm2rmid_matrix_psinorm_matrix_t_each_t_False_rho_False(self): out_t = et.volnorm2rmid(matrix_psinorm, matrix_t, each_t=False) self.assertEqual(out.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_volnorm2rmid_matrix_psinorm_matrix_t_each_t_True_rho_True(self): @@ -6668,17 +6670,17 @@ def test_volnorm2rmid_matrix_psinorm_matrix_t_each_t_False_rho_True(self): out_t = et.volnorm2rmid(matrix_psinorm, matrix_t, each_t=False, rho=True) self.assertEqual(out.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) class volnorm2roaTestCase(unittest.TestCase): @@ -6693,15 +6695,15 @@ def test_volnorm2roa_scalar_psinorm_scalar_t_each_t_True(self): with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_volnorm2roa_scalar_psinorm_scalar_t_each_t_False(self): @@ -6710,15 +6712,15 @@ def test_volnorm2roa_scalar_psinorm_scalar_t_each_t_False(self): with self.assertRaises(TypeError): iter(out) - self.assertFalse(scipy.isnan(out)) - self.assertFalse(scipy.isinf(out)) + self.assertFalse(numpy.isnan(out)) + self.assertFalse(numpy.isinf(out)) with self.assertRaises(TypeError): iter(out_t) - self.assertFalse(scipy.isnan(out_t)) - self.assertFalse(scipy.isinf(out_t)) + self.assertFalse(numpy.isnan(out_t)) + self.assertFalse(numpy.isinf(out_t)) - diff = scipy.absolute(out - out_t) / scipy.absolute(out).max() + diff = numpy.absolute(out - out_t) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) # vector psinorm, scalar t: @@ -6727,17 +6729,17 @@ def test_volnorm2roa_vector_psinorm_scalar_t_each_t_True(self): out_t = et.volnorm2roa(vector_psinorm, scalar_t) self.assertEqual(out.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_volnorm2roa_vector_psinorm_scalar_t_each_t_False(self): @@ -6745,17 +6747,17 @@ def test_volnorm2roa_vector_psinorm_scalar_t_each_t_False(self): out_t = et.volnorm2roa(vector_psinorm, scalar_t, each_t=False) self.assertEqual(out.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_psinorm),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) # matrix psinorm, scalar t: @@ -6764,17 +6766,17 @@ def test_volnorm2roa_matrix_psinorm_scalar_t_each_t_True(self): out_t = et.volnorm2roa(matrix_psinorm, scalar_t) self.assertEqual(out.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_volnorm2roa_matrix_psinorm_scalar_t_each_t_False(self): @@ -6782,17 +6784,17 @@ def test_volnorm2roa_matrix_psinorm_scalar_t_each_t_False(self): out_t = et.volnorm2roa(matrix_psinorm, scalar_t, each_t=False) self.assertEqual(out.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) # scalar psinorm, vector t: @@ -6801,14 +6803,14 @@ def test_volnorm2roa_scalar_psinorm_vector_t_each_t_True(self): out_t = et.volnorm2roa(scalar_psinorm, vector_t) self.assertEqual(out.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t),)) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() self.assertLessEqual(diff, tol) def test_volnorm2roa_scalar_psinorm_vector_t_each_t_False(self): @@ -6823,17 +6825,17 @@ def test_volnorm2roa_vector_psinorm_vector_t_each_t_True(self): out_t = et.volnorm2roa(vector_psinorm, vector_t) self.assertEqual(out.shape, (len(vector_t), len(vector_psinorm))) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, (len(vector_t), len(vector_psinorm))) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) # res2 = (out - out_t)**2 - # diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + # diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_volnorm2roa_vector_psinorm_vector_t_each_t_False(self): @@ -6848,17 +6850,17 @@ def test_volnorm2roa_matrix_psinorm_vector_t_each_t_True(self): out_t = et.volnorm2roa(matrix_psinorm, vector_t) self.assertEqual(out.shape, tuple([len(vector_t),] + list(matrix_psinorm.shape))) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, tuple([len(vector_t),] + list(matrix_psinorm.shape))) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) def test_volnorm2roa_matrix_psinorm_vector_t_each_t_False(self): @@ -6879,17 +6881,17 @@ def test_volnorm2roa_matrix_psinorm_matrix_t_each_t_False(self): out_t = et.volnorm2roa(matrix_psinorm, matrix_t, each_t=False) self.assertEqual(out.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out).any()) - self.assertFalse(scipy.isinf(out).any()) + self.assertFalse(numpy.isnan(out).any()) + self.assertFalse(numpy.isinf(out).any()) self.assertEqual(out_t.shape, matrix_psinorm.shape) - self.assertFalse(scipy.isnan(out_t).any()) - self.assertFalse(scipy.isinf(out_t).any()) + self.assertFalse(numpy.isnan(out_t).any()) + self.assertFalse(numpy.isinf(out_t).any()) - # diff = scipy.sqrt(((out - out_t)**2).max()) / scipy.absolute(out).max() - self.assertTrue((scipy.isnan(out) == scipy.isnan(out_t)).all()) + # diff = numpy.sqrt(((out - out_t)**2).max()) / numpy.absolute(out).max() + self.assertTrue((numpy.isnan(out) == numpy.isnan(out_t)).all()) res2 = (out - out_t)**2 - diff = scipy.sqrt((res2[~scipy.isnan(res2)]).max()) / scipy.absolute(out[~scipy.isnan(out)]).max() + diff = numpy.sqrt((res2[~numpy.isnan(res2)]).max()) / numpy.absolute(out[~numpy.isnan(out)]).max() self.assertLessEqual(diff, tol) class SqrtTestCase(unittest.TestCase): @@ -7494,89 +7496,89 @@ class SelfConsistencyTestCase(unittest.TestCase): """Test the internal self-consistency of the basic conversions. """ def test_rz2psi(self): - R, Z = scipy.meshgrid(e.getRGrid(), e.getZGrid()) + R, Z = numpy.meshgrid(e.getRGrid(), e.getZGrid()) out = e.rz2psi(R, Z, e.getTimeBase()) out_t = et.rz2psi(R, Z, e.getTimeBase()) # Psi gets its sign reversed, so I use plus here. - diff = scipy.sqrt(((out + e.getFluxGrid())**2).max()) / scipy.absolute(e.getFluxGrid()).max() + diff = numpy.sqrt(((out + e.getFluxGrid())**2).max()) / numpy.absolute(e.getFluxGrid()).max() self.assertLessEqual(diff, tol) - diff = scipy.sqrt(((out_t + et.getFluxGrid())**2).max()) / scipy.absolute(et.getFluxGrid()).max() + diff = numpy.sqrt(((out_t + et.getFluxGrid())**2).max()) / numpy.absolute(et.getFluxGrid()).max() self.assertLessEqual(diff, tol) def test_rz2psinorm(self): - R, Z = scipy.meshgrid(e.getRGrid(), e.getZGrid()) + R, Z = numpy.meshgrid(e.getRGrid(), e.getZGrid()) out = e.rz2psinorm(R, Z, e.getTimeBase()) out_t = et.rz2psinorm(R, Z, e.getTimeBase()) psinorm_grid = ( - (-1 * e.getFluxGrid() - e.getFluxAxis()[:, scipy.newaxis, scipy.newaxis]) / - (e.getFluxLCFS()[:, scipy.newaxis, scipy.newaxis] - e.getFluxAxis()[:, scipy.newaxis, scipy.newaxis]) + (-1 * e.getFluxGrid() - e.getFluxAxis()[:, numpy.newaxis, numpy.newaxis]) / + (e.getFluxLCFS()[:, numpy.newaxis, numpy.newaxis] - e.getFluxAxis()[:, numpy.newaxis, numpy.newaxis]) ) psinorm_grid_t = ( - (-1 * et.getFluxGrid() - et.getFluxAxis()[:, scipy.newaxis, scipy.newaxis]) / - (et.getFluxLCFS()[:, scipy.newaxis, scipy.newaxis] - et.getFluxAxis()[:, scipy.newaxis, scipy.newaxis]) + (-1 * et.getFluxGrid() - et.getFluxAxis()[:, numpy.newaxis, numpy.newaxis]) / + (et.getFluxLCFS()[:, numpy.newaxis, numpy.newaxis] - et.getFluxAxis()[:, numpy.newaxis, numpy.newaxis]) ) - diff = scipy.sqrt(((out - psinorm_grid)**2).max()) / scipy.absolute(psinorm_grid).max() + diff = numpy.sqrt(((out - psinorm_grid)**2).max()) / numpy.absolute(psinorm_grid).max() self.assertLessEqual(diff, tol) - diff = scipy.sqrt(((out_t - psinorm_grid_t)**2).max()) / scipy.absolute(psinorm_grid_t).max() + diff = numpy.sqrt(((out_t - psinorm_grid_t)**2).max()) / numpy.absolute(psinorm_grid_t).max() self.assertLessEqual(diff, tol) def test_psinorm2volnorm(self): - psinorm_grid = scipy.linspace(0, 1, e.getFluxVol().shape[1]) - psinorm_grid_t = scipy.linspace(0, 1, et.getFluxVol().shape[1]) + psinorm_grid = numpy.linspace(0, 1, e.getFluxVol().shape[1]) + psinorm_grid_t = numpy.linspace(0, 1, et.getFluxVol().shape[1]) - volnorm_grid = e.getFluxVol() / e.getFluxVol()[:, -1, scipy.newaxis] - volnorm_grid_t = et.getFluxVol() / et.getFluxVol()[:, -1, scipy.newaxis] + volnorm_grid = e.getFluxVol() / e.getFluxVol()[:, -1, numpy.newaxis] + volnorm_grid_t = et.getFluxVol() / et.getFluxVol()[:, -1, numpy.newaxis] out = e.psinorm2volnorm(psinorm_grid, e.getTimeBase()) out_t = et.psinorm2volnorm(psinorm_grid, et.getTimeBase()) - diff = scipy.sqrt(((out - volnorm_grid)**2).max()) / scipy.absolute(volnorm_grid).max() + diff = numpy.sqrt(((out - volnorm_grid)**2).max()) / numpy.absolute(volnorm_grid).max() self.assertLessEqual(diff, tol) - diff = scipy.sqrt(((out_t - volnorm_grid_t)**2).max()) / scipy.absolute(volnorm_grid_t).max() + diff = numpy.sqrt(((out_t - volnorm_grid_t)**2).max()) / numpy.absolute(volnorm_grid_t).max() self.assertLessEqual(diff, tol) def test_psinorm2rmid(self): - psinorm_grid = scipy.linspace(0, 1, e.getRmidPsi().shape[1]) - psinorm_grid_t = scipy.linspace(0, 1, et.getRmidPsi().shape[1]) + psinorm_grid = numpy.linspace(0, 1, e.getRmidPsi().shape[1]) + psinorm_grid_t = numpy.linspace(0, 1, et.getRmidPsi().shape[1]) out = e.psinorm2rmid(psinorm_grid, e.getTimeBase()) out_t = et.psinorm2rmid(psinorm_grid, et.getTimeBase()) - diff = scipy.sqrt(((out - e.getRmidPsi())**2).max()) / scipy.absolute(e.getRmidPsi()).max() + diff = numpy.sqrt(((out - e.getRmidPsi())**2).max()) / numpy.absolute(e.getRmidPsi()).max() self.assertLessEqual(diff, tol) self.assertLessEqual(diff, tol) - diff = scipy.sqrt(((out_t - et.getRmidPsi())**2).max()) / scipy.absolute(et.getRmidPsi()).max() + diff = numpy.sqrt(((out_t - et.getRmidPsi())**2).max()) / numpy.absolute(et.getRmidPsi()).max() self.assertLessEqual(diff, tol) def test_roa2rmid(self): - roa_grid = scipy.linspace(0, 1, len(e.getRGrid())) + roa_grid = numpy.linspace(0, 1, len(e.getRGrid())) out = e.roa2rmid(roa_grid, e.getTimeBase()) rmid_grid = ( - roa_grid[scipy.newaxis, :] * (e.getRmidOut()[:, scipy.newaxis] - - e.getMagR()[:, scipy.newaxis]) + e.getMagR()[:, scipy.newaxis] + roa_grid[numpy.newaxis, :] * (e.getRmidOut()[:, numpy.newaxis] - + e.getMagR()[:, numpy.newaxis]) + e.getMagR()[:, numpy.newaxis] ) - diff = scipy.sqrt(((out - rmid_grid)**2).max()) / scipy.absolute(rmid_grid).max() + diff = numpy.sqrt(((out - rmid_grid)**2).max()) / numpy.absolute(rmid_grid).max() self.assertLessEqual(diff, tol) - roa_grid_t = scipy.linspace(0, 1, len(et.getRGrid())) + roa_grid_t = numpy.linspace(0, 1, len(et.getRGrid())) out_t = et.roa2rmid(roa_grid_t, et.getTimeBase()) rmid_grid_t = ( - roa_grid_t[scipy.newaxis, :] * (et.getRmidOut()[:, scipy.newaxis] - - et.getMagR()[:, scipy.newaxis]) + et.getMagR()[:, scipy.newaxis] + roa_grid_t[numpy.newaxis, :] * (et.getRmidOut()[:, numpy.newaxis] - + et.getMagR()[:, numpy.newaxis]) + et.getMagR()[:, numpy.newaxis] ) - diff = scipy.sqrt(((out_t - rmid_grid_t)**2).max()) / scipy.absolute(rmid_grid_t).max() + diff = numpy.sqrt(((out_t - rmid_grid_t)**2).max()) / numpy.absolute(rmid_grid_t).max() self.assertLessEqual(diff, tol) def test_psinorm2phinorm(self):