assertAlmostEqual in Python floatのコレクションの単体テスト

Question

assertAlmostEqual（x、y）Pythonの単体テストフレームワーク のメソッドは、xとyがfloatであると仮定してほぼ等しいかどうかをテストします。

assertAlmostEqual()の問題は、floatでのみ機能することです。私は、フロートのリスト、フロートのセット、フロートの辞書、フロートのタプル、フロートのタプルのリスト、フロートのリストのセットなどで機能するassertAlmostEqual()のようなメソッドを探しています。

たとえば、_x = 0.1234567890_、_y = 0.1234567891_としましょう。 xとyは、最後の数字を除くすべての数字で一致するため、ほぼ等しいです。したがって、self.assertAlmostEqual(x, y)はTrueになります。これは、assertAlmostEqual()がfloatに対して機能するためです。

次のTrueへの呼び出しも評価する、より一般的なassertAlmostEquals()を探しています。

• self.assertAlmostEqual_generic([x, x, x], [y, y, y])。
• self.assertAlmostEqual_generic({1: x, 2: x, 3: x}, {1: y, 2: y, 3: y})。
• self.assertAlmostEqual_generic([(x,x)], [(y,y)])。

そのような方法はありますか、それとも自分で実装する必要がありますか？

明確化：

• assertAlmostEquals()にはplacesというオプションのパラメーターがあり、10進数placesに丸められた差を計算することで数値が比較されます。デフォルトでは_places=7_であるため、self.assertAlmostEqual(0.5, 0.4)はFalseで、self.assertAlmostEqual(0.12345678, 0.12345679)はTrueです。投機的なassertAlmostEqual_generic()にも同じ機能が必要です。

• 2つのリストは、それらがまったく同じ順序でほぼ等しい数を持つ場合、ほぼ等しいと見なされます。正式には、for i in range(n): self.assertAlmostEqual(list1[i], list2[i])。

• 同様に、2つのセットが（各セットに順序を割り当てることにより）ほぼ等しいリストに変換できる場合、ほぼ等しいと見なされます。

• 同様に、各辞書のキーセットが他の辞書のキーセットとほぼ等しい場合、2つの辞書はほぼ等しいと見なされ、そのようなほぼ等しいキーペアごとに、対応するほぼ等しい値があります。

• 一般的に、2つのコレクションは、互いにほぼ等しいいくつかの対応するフロートを除いて、等しい場合、ほぼ等しいと見なします。言い換えると、実際にオブジェクトを比較したいのですが、途中でフロートを比較するときは低い（カスタマイズされた）精度でしたいと思います。

Answer 1

汎用is_almost_equal(first, second) functionを実装した方法は次のとおりです。

最初に、比較する必要のあるオブジェクト（firstとsecond）を複製しますが、正確なコピーを作成しないでください。

firstとsecondのコピーがあり、重要でない10進数がなくなったので、_==_を使用してfirstとsecondを比較するだけです。オペレーター。

objを複製するが、元のplacesの各フロートのobj最上位10進数字のみを残すcut_insignificant_digits_recursively(obj, places)関数があると仮定します。 is_almost_equals(first, second, places)の実際の実装は次のとおりです。

_from insignificant_digit_cutter import cut_insignificant_digits_recursively

def is_almost_equal(first, second, places):
    '''returns True if first and second equal. 
    returns true if first and second aren't equal but have exactly the same
    structure and values except for a bunch of floats which are just almost
    equal (floats are almost equal if they're equal when we consider only the
    [places] most significant digits of each).'''
    if first == second: return True
    cut_first = cut_insignificant_digits_recursively(first, places)
    cut_second = cut_insignificant_digits_recursively(second, places)
    return cut_first == cut_second
_

そして、これはcut_insignificant_digits_recursively(obj, places)の実用的な実装です：

_def cut_insignificant_digits(number, places):
    '''cut the least significant decimal digits of a number, 
    leave only [places] decimal digits'''
    if  type(number) != float: return number
    number_as_str = str(number)
    end_of_number = number_as_str.find('.')+places+1
    if end_of_number > len(number_as_str): return number
    return float(number_as_str[:end_of_number])

def cut_insignificant_digits_lazy(iterable, places):
    for obj in iterable:
        yield cut_insignificant_digits_recursively(obj, places)

def cut_insignificant_digits_recursively(obj, places):
    '''return a copy of obj except that every float loses its least significant 
    decimal digits remaining only [places] decimal digits'''
    t = type(obj)
    if t == float: return cut_insignificant_digits(obj, places)
    if t in (list, Tuple, set):
        return t(cut_insignificant_digits_lazy(obj, places))
    if t == dict:
        return {cut_insignificant_digits_recursively(key, places):
                cut_insignificant_digits_recursively(val, places)
                for key,val in obj.items()}
    return obj
_

コードとその単体テストは、ここで入手できます： https://github.com/snakile/approximate_comparator 。改善とバグ修正を歓迎します。

Answer 2

numPy（Python（x、y）に付属）の使用を気にしない場合は、特に_np.testing_関数を定義する_assert_almost_equal_モジュールをご覧ください。

署名はnp.testing.assert_almost_equal(actual, desired, decimal=7, err_msg='', verbose=True)です

_>>> x = 1.000001
>>> y = 1.000002
>>> np.testing.assert_almost_equal(x, y)
AssertionError: 
Arrays are not almost equal to 7 decimals
ACTUAL: 1.000001
DESIRED: 1.000002
>>> np.testing.assert_almost_equal(x, y, 5)
>>> np.testing.assert_almost_equal([x, x, x], [y, y, y], 5)
>>> np.testing.assert_almost_equal((x, x, x), (y, y, y), 5)
_

Answer 3

python 3.5の時点で、

math.isclose(a, b, rel_tol=1e-9, abs_tol=0.0)

pep-0485 で説明されています。実装は次と同等である必要があります

abs(a-b) <= max( rel_tol * max(abs(a), abs(b)), abs_tol )

Answer 4

numpyパッケージを使用してもかまわない場合は、numpy.testingにはassert_array_almost_equal 方法。

これはarray_likeオブジェクト。したがって、floatの配列、リスト、タプルには適していますが、セットや辞書には機能しません。

ドキュメントは here です。

Answer 5

そのような方法はありません。自分でやらなければなりません。

リストとタプルの定義は明らかですが、あなたが言及する他のケースは明白ではないので、そのような関数が提供されないのも不思議ではありません。たとえば、{1.00001: 1.00002}ほぼ等しい{1.00002: 1.00001}？そのようなケースを処理するには、キーまたは値、あるいはその両方に依存するかどうかを選択する必要があります。セットには順序がないため、意味のある定義を見つけることはまずありません。そのため、「対応する」要素の概念はありません。

Answer 6

あなたはそれを自分で実装しなければならないかもしれませんが、リストとセットは同じ方法で繰り返すことができ、辞書は異なるストーリーであり、値ではなくキーを繰り返し、3番目の例は私には少しあいまいですセット内の各値、または各セットの各値を比較します。

簡単なコードスニペットを示します。

def almost_equal(value_1, value_2, accuracy = 10**-8):
    return abs(value_1 - value_2) < accuracy

x = [1,2,3,4]
y = [1,2,4,5]
assert all(almost_equal(*values) for values in Zip(x, y))

Answer 7

私はまだself.assertEqual()を使用します。なぜなら、たわごとがファンに当たったとき、それが最も有益なままであるからです。あなたは、例えば、丸めることによってそれを行うことができます.

self.assertEqual(round_Tuple((13.949999999999999, 1.121212), 2), (13.95, 1.12))

ここで、round_Tupleは

def round_Tuple(t: Tuple, ndigits: int) -> Tuple:
    return Tuple(round(e, ndigits=ndigits) for e in t)

def round_list(l: list, ndigits: int) -> list:
    return [round(e, ndigits=ndigits) for e in l]

python docs（ https://stackoverflow.com/a/41407651/1031191 を参照）によれば、13.94999999 == 13.95はTrueです。

Answer 8

これらの答えはどれも私には役に立たない。次のコードは、pythonコレクション、クラス、データクラス、および名前付きタプルに対して機能するはずです。

import unittest
from collections import namedtuple, OrderedDict
from dataclasses import dataclass
from typing import Any


def are_almost_equal(o1: Any, o2: Any, max_abs_ratio_diff: float, max_abs_diff: float) -> bool:
    """
    Compares two objects by recursively walking them trough. Equality is as usual except for floats.
    Floats are compared according to the two measures defined below.

    :param o1: The first object.
    :param o2: The second object.
    :param max_abs_ratio_diff: The maximum allowed absolute value of the difference.
    `abs(1 - (o1 / o2)` and vice-versa if o2 == 0.0. Ignored if < 0.
    :param max_abs_diff: The maximum allowed absolute difference `abs(o1 - o2)`. Ignored if < 0.
    :return: Whether the two objects are almost equal.
    """
    if type(o1) != type(o2):
        return False

    composite_type_passed = False

    if hasattr(o1, '__slots__'):
        if len(o1.__slots__) != len(o2.__slots__):
            return False
        if any(not are_almost_equal(getattr(o1, s1), getattr(o2, s2),
                                    max_abs_ratio_diff, max_abs_diff)
            for s1, s2 in Zip(sorted(o1.__slots__), sorted(o2.__slots__))):
            return False
        else:
            composite_type_passed = True

    if hasattr(o1, '__dict__'):
        if len(o1.__dict__) != len(o2.__dict__):
            return False
        if any(not are_almost_equal(k1, k2, max_abs_ratio_diff, max_abs_diff)
            or not are_almost_equal(v1, v2, max_abs_ratio_diff, max_abs_diff)
            for ((k1, v1), (k2, v2))
            in Zip(sorted(o1.__dict__.items()), sorted(o2.__dict__.items()))
            if not k1.startswith('__')):  # avoid infinite loops
            return False
        else:
            composite_type_passed = True

    if isinstance(o1, dict):
        if len(o1) != len(o2):
            return False
        if any(not are_almost_equal(k1, k2, max_abs_ratio_diff, max_abs_diff)
            or not are_almost_equal(v1, v2, max_abs_ratio_diff, max_abs_diff)
            for ((k1, v1), (k2, v2)) in Zip(sorted(o1.items()), sorted(o2.items()))):
            return False

    Elif any(issubclass(o1.__class__, c) for c in (list, Tuple, set)):
        if len(o1) != len(o2):
            return False
        if any(not are_almost_equal(v1, v2, max_abs_ratio_diff, max_abs_diff)
            for v1, v2 in Zip(o1, o2)):
            return False

    Elif isinstance(o1, float):
        if o1 == o2:
            return True
        else:
            if max_abs_ratio_diff > 0:  # if max_abs_ratio_diff < 0, max_abs_ratio_diff is ignored
                if o2 != 0:
                    if abs(1.0 - (o1 / o2)) > max_abs_ratio_diff:
                        return False
                else:  # if both == 0, we already returned True
                    if abs(1.0 - (o2 / o1)) > max_abs_ratio_diff:
                        return False
            if 0 < max_abs_diff < abs(o1 - o2):  # if max_abs_diff < 0, max_abs_diff is ignored
                return False
            return True

    else:
        if not composite_type_passed:
            return o1 == o2

    return True


class EqualityTest(unittest.TestCase):

    def test_floats(self) -> None:
        o1 = ('hi', 3, 3.4)
        o2 = ('hi', 3, 3.400001)
        self.assertTrue(are_almost_equal(o1, o2, 0.0001, 0.0001))
        self.assertFalse(are_almost_equal(o1, o2, 0.00000001, 0.00000001))

    def test_ratio_only(self):
        o1 = ['hey', 10000, 123.12]
        o2 = ['hey', 10000, 123.80]
        self.assertTrue(are_almost_equal(o1, o2, 0.01, -1))
        self.assertFalse(are_almost_equal(o1, o2, 0.001, -1))

    def test_diff_only(self):
        o1 = ['hey', 10000, 1234567890.12]
        o2 = ['hey', 10000, 1234567890.80]
        self.assertTrue(are_almost_equal(o1, o2, -1, 1))
        self.assertFalse(are_almost_equal(o1, o2, -1, 0.1))

    def test_both_ignored(self):
        o1 = ['hey', 10000, 1234567890.12]
        o2 = ['hey', 10000, 0.80]
        o3 = ['hi', 10000, 0.80]
        self.assertTrue(are_almost_equal(o1, o2, -1, -1))
        self.assertFalse(are_almost_equal(o1, o3, -1, -1))

    def test_different_lengths(self):
        o1 = ['hey', 1234567890.12, 10000]
        o2 = ['hey', 1234567890.80]
        self.assertFalse(are_almost_equal(o1, o2, 1, 1))

    def test_classes(self):
        class A:
            d = 12.3

            def __init__(self, a, b, c):
                self.a = a
                self.b = b
                self.c = c

        o1 = A(2.34, 'str', {1: 'hey', 345.23: [123, 'hi', 890.12]})
        o2 = A(2.34, 'str', {1: 'hey', 345.231: [123, 'hi', 890.121]})
        self.assertTrue(are_almost_equal(o1, o2, 0.1, 0.1))
        self.assertFalse(are_almost_equal(o1, o2, 0.0001, 0.0001))

        o2.hello = 'hello'
        self.assertFalse(are_almost_equal(o1, o2, -1, -1))

    def test_namedtuples(self):
        B = namedtuple('B', ['x', 'y'])
        o1 = B(3.3, 4.4)
        o2 = B(3.4, 4.5)
        self.assertTrue(are_almost_equal(o1, o2, 0.2, 0.2))
        self.assertFalse(are_almost_equal(o1, o2, 0.001, 0.001))

    def test_classes_with_slots(self):
        class C(object):
            __slots__ = ['a', 'b']

            def __init__(self, a, b):
                self.a = a
                self.b = b

        o1 = C(3.3, 4.4)
        o2 = C(3.4, 4.5)
        self.assertTrue(are_almost_equal(o1, o2, 0.3, 0.3))
        self.assertFalse(are_almost_equal(o1, o2, -1, 0.01))

    def test_dataclasses(self):
        @dataclass
        class D:
            s: str
            i: int
            f: float

        @dataclass
        class E:
            f2: float
            f4: str
            d: D

        o1 = E(12.3, 'hi', D('hello', 34, 20.01))
        o2 = E(12.1, 'hi', D('hello', 34, 20.0))
        self.assertTrue(are_almost_equal(o1, o2, -1, 0.4))
        self.assertFalse(are_almost_equal(o1, o2, -1, 0.001))

        o3 = E(12.1, 'hi', D('ciao', 34, 20.0))
        self.assertFalse(are_almost_equal(o2, o3, -1, -1))

    def test_ordereddict(self):
        o1 = OrderedDict({1: 'hey', 345.23: [123, 'hi', 890.12]})
        o2 = OrderedDict({1: 'hey', 345.23: [123, 'hi', 890.0]})
        self.assertTrue(are_almost_equal(o1, o2, 0.01, -1))
        self.assertFalse(are_almost_equal(o1, o2, 0.0001, -1))

Answer 9

別のアプローチは、例えば各フロートを固定精度の文字列に変換することにより、データを比較可能な形式に変換することです。

def comparable(data):
    """Converts `data` to a comparable structure by converting any floats to a string with fixed precision."""
    if isinstance(data, (int, str)):
        return data
    if isinstance(data, float):
        return '{:.4f}'.format(data)
    if isinstance(data, list):
        return [comparable(el) for el in data]
    if isinstance(data, Tuple):
        return Tuple([comparable(el) for el in data])
    if isinstance(data, dict):
        return {k: comparable(v) for k, v in data.items()}

その後、次のことができます。

self.assertEquals(comparable(value1), comparable(value2))