From 0602b96440732ce37981a87467a5c41dbe296797 Mon Sep 17 00:00:00 2001
From: Eddie McWhirter <emcwhirter@usgs.gov>
Date: Wed, 4 Mar 2015 14:04:16 -0700
Subject: [PATCH] Use assert_almost_equal instead of assert_equal to account
for floating point precision on different hardware...PCvsMAC
---
geomagio/ChannelConverterTest.py | 114 +++++++++++++++++++------------
geomagio/StreamConverter_test.py | 47 +++++++------
2 files changed, 92 insertions(+), 69 deletions(-)
diff --git a/geomagio/ChannelConverterTest.py b/geomagio/ChannelConverterTest.py
index 5c653142..00fe4bb6 100644
--- a/geomagio/ChannelConverterTest.py
+++ b/geomagio/ChannelConverterTest.py
@@ -4,7 +4,6 @@ import numpy
import math
import ChannelConverter as channel
-assert_equals = numpy.testing.assert_equal
assert_almost_equal = numpy.testing.assert_almost_equal
cos = math.cos
sin = math.sin
@@ -70,8 +69,10 @@ class ChannelConverterTest:
e = sin(15 * D2R)
d0 = 15 * D2R
(X, Y) = channel.get_geo_from_obs(h, e, d0)
- assert_equals(X, cos(30 * D2R), 'Expect X to equal cos(30)', True)
- assert_equals(Y, sin(30 * D2R), 'Expect Y to equal sin(30)', True)
+ assert_almost_equal(X, cos(30 * D2R), 8,
+ 'Expect X to equal cos(30)', True)
+ assert_almost_equal(Y, sin(30 * D2R), 8,
+ 'Expect Y to equal sin(30)', True)
# 3) Call get_geo_from_obs using h,e values of 1,0 with a d0 of 315
# degrees. The geographic X,Y will be cos(45), sin(-45)
@@ -92,8 +93,10 @@ class ChannelConverterTest:
e = sin(30 * D2R)
d0 = -60 * D2R
(X, Y) = channel.get_geo_from_obs(h, e, d0)
- assert_equals(X, cos(-30 * D2R), 'Expect X to equal cos(60).', True)
- assert_equals(Y, sin(-30 * D2R), 'Expect Y to equal sin(60).', True)
+ assert_almost_equal(X, cos(-30 * D2R), 8,
+ 'Expect X to equal cos(60).', True)
+ assert_almost_equal(Y, sin(-30 * D2R), 8,
+ 'Expect Y to equal sin(60).', True)
def test_get_geo_from_mag(self):
"""geomag.ChannelConverterTest.test_get_geo_from_mag()
@@ -107,8 +110,10 @@ class ChannelConverterTest:
h = 1
d = 30 * D2R
(X, Y) = channel.get_geo_from_mag(h, d)
- assert_equals(X, cos(30 * D2R), 'Expect X to be cos(30).', True)
- assert_equals(Y, sin(30 * D2R), 'Expect Y to be sin(30).', True)
+ assert_almost_equal(X, cos(30 * D2R), 8,
+ 'Expect X to be cos(30).', True)
+ assert_almost_equal(Y, sin(30 * D2R), 8,
+ 'Expect Y to be sin(30).', True)
def test_get_geo_x_from_mag(self):
"""geomag.ChannelConverterTest.test_get_geo_x_from_mag()
@@ -122,13 +127,14 @@ class ChannelConverterTest:
h = 2
d = 45 * D2R
X = channel.get_geo_x_from_mag(h, d)
- assert_equals(X, 2 * cos(d), 'Expect X to be cos(45).', True)
+ assert_almost_equal(X, 2 * cos(d), 8, 'Expect X to be cos(45).', True)
# 2) Call get_geo_x_from_mag using H,D of 1, 30 degrees. Expect
# X to be cos(30)
h = 2
d = 30 * D2R
X = channel.get_geo_x_from_mag(h, d)
- assert_equals(X, 2 * cos(d), 'Expect X to equal cos(30).', True)
+ assert_almost_equal(X, 2 * cos(d), 8,
+ 'Expect X to equal cos(30).', True)
def test_get_geo_y_from_mag(self):
"""geomag.ChannelConverterTest.test_get_geo_y_from_mag()
@@ -142,13 +148,15 @@ class ChannelConverterTest:
h = 2
d = 45 * D2R
Y = channel.get_geo_y_from_mag(h, d)
- assert_equals(Y, 2 * sin(45 * D2R), 'Expect Y to be 2sin(45).', True)
+ assert_almost_equal(Y, 2 * sin(45 * D2R), 8,
+ 'Expect Y to be 2sin(45).', True)
# 2) Call get_geo_x_from_mag using H,D of 1, 30 degrees. Expect
# X to be cos(30)
h = 2
d = 30 * D2R
Y = channel.get_geo_y_from_mag(h, d)
- assert_equals(Y, 2 * sin(30 * D2R), 'Expect Y to be 2sin(30).', True)
+ assert_almost_equal(Y, 2 * sin(30 * D2R), 8,
+ 'Expect Y to be 2sin(30).', True)
def test_get_mag_from_obs(self):
"""geomag.ChannelConverterTest.test_get_geo_y_from_obs()
@@ -166,8 +174,8 @@ class ChannelConverterTest:
e = sin(30 * D2R)
d0 = 15 * D2R
H, D = channel.get_mag_from_obs(h, e, d0)
- assert_equals(H, 1, 'Expect H to be 1.', True)
- assert_equals(D, 45 * D2R, 'Expect D to be 45.', True)
+ assert_almost_equal(H, 1, 8, 'Expect H to be 1.', True)
+ assert_almost_equal(D, 45 * D2R, 8, 'Expect D to be 45.', True)
def test_get_mag_from_geo(self):
"""geomag.ChannelConverterTest.test_get_geo_y_from_obs()
@@ -182,8 +190,8 @@ class ChannelConverterTest:
X = 3 * cos(30 * D2R)
Y = 3 * sin(30 * D2R)
H, D = channel.get_mag_from_geo(X, Y)
- assert_equals(H, 3, 'Expect H to equal 3.', True)
- assert_equals(D, 30 * D2R, 'Expect D to be 30.', True)
+ assert_almost_equal(H, 3, 8, 'Expect H to equal 3.', True)
+ assert_almost_equal(D, 30 * D2R, 8, 'Expect D to be 30.', True)
def test_get_mag_d_from_obs(self):
"""geomag.ChannelConverterTest.test_get_mag_d_from_obs()
@@ -199,41 +207,45 @@ class ChannelConverterTest:
h = 2
e = 2
D = channel.get_mag_d_from_obs(h, e)
- assert_equals(D, 45 * D2R, 'Expect D to be 45 degrees.', True)
+ assert_almost_equal(D, 45 * D2R, 8, 'Expect D to be 45 degrees.', True)
# 2) Call get_mag_d_from_obs using h,e cos(30), sin(30).
# Expect d of 30 degress.
h = cos(30 * D2R)
e = sin(30 * D2R)
D = channel.get_mag_d_from_obs(h, e)
- assert_equals(D, 30 * D2R, 'Expect D to equal 30 degrees', True)
+ assert_almost_equal(D, 30 * D2R, 8,
+ 'Expect D to equal 30 degrees', True)
# 3) Call get_mag_d_from_obs using h,e cos(30), sin(30),
# d0 = 30 degrees Expect d to be 60 degress.
h = cos(30 * D2R)
e = sin(30 * D2R)
d0 = 30 * D2R
D = channel.get_mag_d_from_obs(h, e, d0)
- assert_equals(D, 60 * D2R, 'Expect D to equal 60 degrees', True)
+ assert_almost_equal(D, 60 * D2R, 8,
+ 'Expect D to equal 60 degrees', True)
# 4) Call get_mag_d_from_obs using h,e cos(30), sin(30),
# d0 = 330 degrees Expect d of 360 degress.
h = cos(30 * D2R)
e = sin(30 * D2R)
d0 = 330 * D2R
D = channel.get_mag_d_from_obs(h, e, d0)
- assert_equals(D, 360 * D2R, 'Expect D to equal 360 degrees', True)
+ assert_almost_equal(D, 360 * D2R, 8,
+ 'Expect D to equal 360 degrees', True)
# 5) Call get_mag_d_from_obs using h,e cos(30), sin(30),
# d0 = -30 degrees Expect d of 0 degress.
h = cos(30 * D2R)
e = sin(30 * D2R)
d0 = -30 * D2R
D = channel.get_mag_d_from_obs(h, e, d0)
- assert_equals(D, 0, 'Expect D to equal 0 degrees', True)
+ assert_almost_equal(D, 0, 8, 'Expect D to equal 0 degrees', True)
# 6) Call get_mag_d_from_obs using h,e cos(30), -sin(30),
# d0 = -30 degrees. Expect d of -60 degress.
h = cos(30 * D2R)
e = sin(-30 * D2R)
d0 = -30 * D2R
D = channel.get_mag_d_from_obs(h, e, d0)
- assert_equals(D, -60 * D2R, 'Expect D to equal -60 degrees', True)
+ assert_almost_equal(D, -60 * D2R, 8,
+ 'Expect D to equal -60 degrees', True)
def test_get_mag_d_from_geo(self):
"""geomag.ChannelConverterTest.test_get_mag_d_from_geo()
@@ -247,19 +259,20 @@ class ChannelConverterTest:
X = 2
Y = 2
D = channel.get_mag_d_from_geo(X, Y)
- assert_equals(D, 45 * D2R, 'Expect D to be 45 degrees.', True)
+ assert_almost_equal(D, 45 * D2R, 8, 'Expect D to be 45 degrees.', True)
# 2) Call get_mag_d_from_geo using X,Y equal to cos(30), sin(30).
# Expect D to be 30 degrees.
X = cos(30 * D2R)
Y = sin(30 * D2R)
D = channel.get_mag_d_from_geo(X, Y)
- assert_equals(D, 30 * D2R, 'Expect D to be 30 degrees.', True)
+ assert_almost_equal(D, 30 * D2R, 8, 'Expect D to be 30 degrees.', True)
# 3) Call get_mag_d_from_geo using X,Y equal to cos(30), -sin(30).
# Expect D to be -30 degrees.
X = cos(30 * D2R)
Y = sin(-30 * D2R)
D = channel.get_mag_d_from_geo(X, Y)
- assert_equals(D, -30 * D2R, 'Expect D to equal -30 degrees', True)
+ assert_almost_equal(D, -30 * D2R, 8,
+ 'Expect D to equal -30 degrees', True)
def test_get_mag_h_from_obs(self):
"""geomag.ChannelConverterTest.test_get_mag_h_from_obs()
@@ -272,7 +285,7 @@ class ChannelConverterTest:
h = 3
e = 4
H = channel.get_mag_h_from_obs(h, e)
- assert_equals(H, 5, 'Expect H to be 5.', True)
+ assert_almost_equal(H, 5, 8, 'Expect H to be 5.', True)
def test_get_mag_h_from_geo(self):
"""geomag.ChannelConverterTest.test_get_mag_d_from_geo()
@@ -285,7 +298,7 @@ class ChannelConverterTest:
X = 3
Y = 4
H = channel.get_mag_h_from_geo(X, Y)
- assert_equals(H, 5, 'Expect H to be 5.', True)
+ assert_almost_equal(H, 5, 8, 'Expect H to be 5.', True)
def test_get_obs_from_geo(self):
"""geomag.io.channelTest.test_get_obs_from_geo()
@@ -312,7 +325,8 @@ class ChannelConverterTest:
d0 = 22.5 * D2R
(h, e) = channel.get_obs_from_geo(X, Y, d0)
d = channel.get_obs_d_from_obs(h, e)
- assert_equals(d, 22.5 * D2R, 'Expect d to be 22.5 degrees.', True)
+ assert_almost_equal(d, 22.5 * D2R, 8,
+ 'Expect d to be 22.5 degrees.', True)
# 3) Call get_obs_from_geo using equal X,Y values to create a 45
# degree angle (D), with a d0 of 315 degrees. The observatory
# declination (d) will be 90 degrees.
@@ -331,10 +345,12 @@ class ChannelConverterTest:
Y = sin(60 * D2R)
d0 = 30 * D2R
(h, e) = channel.get_obs_from_geo(X, Y, d0)
- assert_equals(h, cos(30 * D2R), 'Expect h to be cos(30).', True)
- assert_equals(e, sin(30 * D2R), 'Expect e to be sin(30).', True)
+ assert_almost_equal(h, cos(30 * D2R), 8,
+ 'Expect h to be cos(30).', True)
+ assert_almost_equal(e, sin(30 * D2R), 8,
+ 'Expect e to be sin(30).', True)
d = channel.get_obs_d_from_obs(h, e)
- assert_equals(d, 30 * D2R, 'Expect d to be 30 degrees.', True)
+ assert_almost_equal(d, 30 * D2R, 8, 'Expect d to be 30 degrees.', True)
def test_get_obs_from_mag(self):
"""geomag.ChannelConverterTest.test_get_obs_from_mag()
@@ -347,7 +363,8 @@ class ChannelConverterTest:
H = 1
D = -22.5 * D2R
(h, e) = channel.get_obs_from_mag(H, D, 22.5 * D2R)
- assert_equals(h, cos(45 * D2R), 'Expect h to be cos(45)', True)
+ assert_almost_equal(h, cos(45 * D2R), 8,
+ 'Expect h to be cos(45)', True)
assert_almost_equal(e, -cos(45 * D2R), 8,
'Expect e to be -cos(45).', True)
@@ -363,13 +380,14 @@ class ChannelConverterTest:
h = cos(30 * D2R)
e = sin(30 * D2R)
d = channel.get_obs_d_from_obs(h, e)
- assert_equals(d, 30 * D2R, 'Expect d to be 30 degrees.', True)
+ assert_almost_equal(d, 30 * D2R, 8, 'Expect d to be 30 degrees.', True)
# 2) Call get_obs_d_from_obs using h,e cos(30), -sin(30). Expect
# d to be 30.
h = cos(30 * D2R)
e = sin(-30 * D2R)
d = channel.get_obs_d_from_obs(h, e)
- assert_equals(d, -30 * D2R, 'Expect d to be 30 degrees.', True)
+ assert_almost_equal(d, -30 * D2R, 8,
+ 'Expect d to be 30 degrees.', True)
def test_get_obs_d_from_mag_d(self):
"""geomag.ChannelConverterTest.test_get_obs_d_from_mag()
@@ -383,25 +401,26 @@ class ChannelConverterTest:
# declination of 1 back.
D = 1
d = channel.get_obs_d_from_mag_d(D)
- assert_equals(d, 1, 'Expect d to be 1.', True)
+ assert_almost_equal(d, 1, 8, 'Expect d to be 1.', True)
# 2) Call get_obs_d_from_mag using d, d0 values of 22.5, 45. Expect
# observatory declination of -22.5 degrees.
D = 22.5 * D2R
d0 = 45 * D2R
d = channel.get_obs_d_from_mag_d(D, d0)
- assert_equals(d, -22.5 * D2R, 'Expect d to be -22.5 degrees.', True)
+ assert_almost_equal(d, -22.5 * D2R, 8,
+ 'Expect d to be -22.5 degrees.', True)
# 3) Call get_obs_d_from_mag using d, d0 values of 60, 30. Expect
# observatory declination of 30 degrees.
D = 60 * D2R
d0 = 30 * D2R
d = channel.get_obs_d_from_mag_d(D, d0)
- assert_equals(d, 30 * D2R, 'Expect d to be 30 degrees.', True)
+ assert_almost_equal(d, 30 * D2R, 8, 'Expect d to be 30 degrees.', True)
# 4) Call get_obs_d_from_mag using d, d0 values of 30, -30.
# Expect observatory declination of 60 degrees.
D = 30 * D2R
d0 = -30 * D2R
d = channel.get_obs_d_from_mag_d(D, d0)
- assert_equals(d, 60 * D2R, 'Expect d to be 60 degrees.', True)
+ assert_almost_equal(d, 60 * D2R, 8, 'Expect d to be 60 degrees.', True)
def test_get_obs_e_from_mag(self):
"""geomag.ChannelConverterTest.test_get_obs_e_from_mag()
@@ -417,19 +436,22 @@ class ChannelConverterTest:
H = 1
D = 45 * D2R
e = channel.get_obs_e_from_mag(H, D)
- assert_equals(e, sin(45 * D2R), 'Expect e to be sin(45).', True)
+ assert_almost_equal(e, sin(45 * D2R), 8,
+ 'Expect e to be sin(45).', True)
# 2) Call get_obs_e_from_mag using H,D of 1, 30. Expect e to be sin(30)
H = 1
D = 30 * D2R
e = channel.get_obs_e_from_mag(H, D)
- assert_equals(e, sin(30 * D2R), 'Expect e to be sin(30).', True)
+ assert_almost_equal(e, sin(30 * D2R), 8,
+ 'Expect e to be sin(30).', True)
# 3) Call get_obs_e_from_mag using H,D,d0 of 1, 15, -15. Expect e to
# be sin(30)
H = 1
D = 15 * D2R
d0 = -15 * D2R
e = channel.get_obs_e_from_mag(H, D, d0)
- assert_equals(e, sin(30 * D2R), 'Expect e to be sin(30)', True)
+ assert_almost_equal(e, sin(30 * D2R), 8,
+ 'Expect e to be sin(30)', True)
def test_get_obs_e_from_obs(self):
"""geomag.ChannelConverterTest.test_get_obs_e_from_obs()
@@ -444,7 +466,7 @@ class ChannelConverterTest:
h = 2
d = 30 * D2R
e = channel.get_obs_e_from_obs(h, d)
- assert_equals(e, 2 * tan(30 * D2R),
+ assert_almost_equal(e, 2 * tan(30 * D2R), 8,
'Expect e to be 2 * tan(30).', True)
def test_get_obs_h_from_mag(self):
@@ -460,14 +482,16 @@ class ChannelConverterTest:
H = 1
D = 45 * D2R
h = channel.get_obs_h_from_mag(H, D)
- assert_equals(h, cos(45 * D2R), 'Expect h to be cos(45).', True)
+ assert_almost_equal(h, cos(45 * D2R), 8,
+ 'Expect h to be cos(45).', True)
# 2) Call get_obs_h_from_mag using H,D,d0 1,30,15.
# Expect h to be cos(15)
H = 1
D = 30 * D2R
d0 = 15 * D2R
h = channel.get_obs_h_from_mag(H, D, d0)
- assert_equals(h, cos(15 * D2R), 'Expect h to be cos(15)', True)
+ assert_almost_equal(h, cos(15 * D2R), 8,
+ 'Expect h to be cos(15)', True)
def test_geo_to_obs_to_geo(self):
"""geomag.ChannelConverterTest.test_geo_to_obs_to_geo()
@@ -493,7 +517,7 @@ class ChannelConverterTest:
"""
minutes = 45 * 60
radians = channel.get_radians_from_minutes(minutes)
- assert_equals(radians, math.pi / 4.0,
+ assert_almost_equal(radians, math.pi / 4.0, 8,
'Expect radians to be pi/4', True)
def test_get_minutes_from_radians(self):
@@ -503,5 +527,5 @@ class ChannelConverterTest:
"""
radians = math.pi / 4.0
minutes = channel.get_minutes_from_radians(radians)
- assert_equals(minutes, 45 * 60,
+ assert_almost_equal(minutes, 45 * 60, 8,
'Expect minutes to be equal to 45 degrees', True)
diff --git a/geomagio/StreamConverter_test.py b/geomagio/StreamConverter_test.py
index d2252d5d..54699637 100644
--- a/geomagio/StreamConverter_test.py
+++ b/geomagio/StreamConverter_test.py
@@ -14,8 +14,7 @@ import numpy
import StreamConverter
import ChannelConverter
-assert_equals = numpy.testing.assert_equal
-assert_almost_equals = numpy.testing.assert_almost_equal
+assert_almost_equal = numpy.testing.assert_almost_equal
cos = numpy.cos
sin = numpy.sin
@@ -45,9 +44,9 @@ def test_get_geo_from_mag():
geo = StreamConverter.get_geo_from_mag(mag)
X = geo.select(channel='X')[0].data
Y = geo.select(channel='Y')[0].data
- assert_equals(X, [cos(15 * D2R), cos(30 * D2R)],
+ assert_almost_equal(X, [cos(15 * D2R), cos(30 * D2R)], 9,
'Expect X to equal [cos(15), cos(30)]', True)
- assert_equals(Y, [sin(15 * D2R), sin(30 * D2R)],
+ assert_almost_equal(Y, [sin(15 * D2R), sin(30 * D2R)], 9,
'Expect Y to equal [sin(15), sin(30)]', True)
@@ -69,9 +68,9 @@ def test_get_geo_from_obs():
geo = StreamConverter.get_geo_from_obs(obs)
X = geo.select(channel='X')[0].data
Y = geo.select(channel='Y')[0].data
- assert_almost_equals(X[0], 1, 9,
+ assert_almost_equal(X[0], 1, 9,
'Expect X to almost equal 1', True)
- assert_almost_equals(Y[0], 1, 9,
+ assert_almost_equal(Y[0], 1, 9,
'Expect Y to almost equal 1', True)
# 2) Call get_geo_from_obs using a decbas of 15 degrees, and streams
@@ -86,9 +85,9 @@ def test_get_geo_from_obs():
geo = StreamConverter.get_geo_from_obs(obs)
X = geo.select(channel='X')[0].data
Y = geo.select(channel='Y')[0].data
- assert_equals(X, [cos(30 * D2R), cos(45 * D2R)],
+ assert_almost_equal(X, [cos(30 * D2R), cos(45 * D2R)], 9,
'Expect X to equal [cos(30), cos(45)]', True)
- assert_equals(Y, [sin(30 * D2R), sin(45 * D2R)],
+ assert_almost_equal(Y, [sin(30 * D2R), sin(45 * D2R)], 9,
'Expect Y to equal [sin(30), sin(45)]', True)
@@ -112,9 +111,9 @@ def test_get_mag_from_geo():
mag = StreamConverter.get_mag_from_geo(geo)
H = mag.select(channel='H')[0].data
D = mag.select(channel='D')[0].data
- assert_equals(H, [1, 1],
+ assert_almost_equal(H, [1, 1], 9,
'Expect H to equal [1,1]', True)
- assert_equals(D, [15 * D2R, 30 * D2R],
+ assert_almost_equal(D, [15 * D2R, 30 * D2R], 9,
'Expect D to equal [15 degrees, 30 degrees]', True)
@@ -137,9 +136,9 @@ def test_get_mag_from_obs():
mag = StreamConverter.get_mag_from_obs(obs)
H = mag.select(channel='H')[0].data
D = mag.select(channel='D')[0].data
- assert_equals(H, [1, 1],
+ assert_almost_equal(H, [1, 1], 9,
'Expect H to equal [1,1]', True)
- assert_equals(D, [30 * D2R, 45 * D2R],
+ assert_almost_equal(D, [30 * D2R, 45 * D2R], 9,
'Expect D to equal [30 degrees, 45 degrees]', True)
@@ -165,11 +164,11 @@ def test_get_obs_from_geo():
H = obs.select(channel='H')[0].data
E = obs.select(channel='E')[0].data
D = obs.select(channel='D')[0].data
- assert_almost_equals(H, [cos(15 * D2R), cos(30 * D2R)], 9,
+ assert_almost_equal(H, [cos(15 * D2R), cos(30 * D2R)], 9,
'Expect H to equal [cos(15), cos(30)]', True)
- assert_almost_equals(E, [sin(15 * D2R), sin(30 * D2R)], 9,
+ assert_almost_equal(E, [sin(15 * D2R), sin(30 * D2R)], 9,
'Expect E to equal [sin(15), sin(30)', True)
- assert_almost_equals(D, [15 * D2R, 30 * D2R], 9,
+ assert_almost_equal(D, [15 * D2R, 30 * D2R], 9,
'Expect D to equal [15 degress, 30 degrees]', True)
@@ -195,11 +194,11 @@ def test_get_obs_from_mag():
H = obs.select(channel='H')[0].data
D = obs.select(channel='D')[0].data
E = obs.select(channel='E')[0].data
- assert_almost_equals(H, [cos(15 * D2R), cos(30 * D2R)], 9,
+ assert_almost_equal(H, [cos(15 * D2R), cos(30 * D2R)], 9,
'Expect H to equal [cos(15), cos(30)', True)
- assert_almost_equals(D, [15 * D2R, 30 * D2R], 9,
+ assert_almost_equal(D, [15 * D2R, 30 * D2R], 9,
'Expect D to equal [15 degrees, 30 degrees', True)
- assert_almost_equals(E, [sin(15 * D2R), sin(30 * D2R)], 9,
+ assert_almost_equal(E, [sin(15 * D2R), sin(30 * D2R)], 9,
'Expect E to equal [sin(15), sin(30)', True)
@@ -222,7 +221,7 @@ def test_get_obs_from_obs():
obs_e += __create_trace('F', [1, 1], DECBAS)
obs_D = StreamConverter.get_obs_from_obs(obs_e, False, True)
d = obs_D.select(channel='D')[0].data
- assert_almost_equals(d, [15 * D2R, 30 * D2R], 9,
+ assert_almost_equal(d, [15 * D2R, 30 * D2R], 9,
'Expect D to equal [15 degrees, 30 degrees]', True)
# 2) Call get_obs_from_obs using a decbase of 15 degrees, a H stream of
@@ -235,7 +234,7 @@ def test_get_obs_from_obs():
obs_d += __create_trace('F', [1, 1], DECBAS)
obs_E = StreamConverter.get_obs_from_obs(obs_d, True, False)
e = obs_E.select(channel='E')[0].data
- assert_almost_equals(e, [sin(15 * D2R), sin(30 * D2R)], 9,
+ assert_almost_equal(e, [sin(15 * D2R), sin(30 * D2R)], 9,
'Expect E to equal [sin(15), sin(30)', True)
@@ -246,7 +245,7 @@ def test_verification_data():
Since the small angle approximation was used in the other
converters, AND round off was done differently, we can't
get the exact results.
- Change the precision in assert_almost_equals to larger precision
+ Change the precision in assert_almost_equal to larger precision
(ie 2 to 8) to see how off the data is. Most are well within
expectations.
"""
@@ -264,7 +263,7 @@ def test_verification_data():
d = obs_V.select(channel='D')[0].data
d = ChannelConverter.get_minutes_from_radians(d)
# Using d values calculated using small angle approximation.
- assert_almost_equals(d,
+ assert_almost_equal(d,
[-3.47, -3.43, -3.40, -3.38, -3.35, -3.31], 2,
'Expect d to equal [-3.47, -3.43, -3.40, -3.38, -3.35, -3.31]', True)
@@ -282,9 +281,9 @@ def test_verification_data():
geo = StreamConverter.get_geo_from_mag(mag)
X = geo.select(channel='X')[0].data
Y = geo.select(channel='Y')[0].data
- assert_almost_equals(X,
+ assert_almost_equal(X,
[20611.00, 20610.40, 20610.30, 20610.30, 20609.90, 20609.60], 2)
- assert_almost_equals(Y,
+ assert_almost_equal(Y,
[3366.00, 3366.00, 3366.20, 3366.50, 3366.70, 3366.60], 1)
--
GitLab