Avoid using full equality (==) to compare float, avoid assert_array_equal compare float array

[DanielYang59]

Summary

• Avoid using full equality == to compare float, to fix tests use equality to compare floating point numbers #4158
• Avoid assert_array_equal on int array:

  Assert fails with numerical imprecision with floats:
  Use assert_allclose or one of the nulp (number of floating point values) functions for these cases instead:

• Tweak _proj implementation, ~3x speedup
• (Partially) Replace sequence of float comparison with == (list/tuple/dict ...):

  pymatgen/tests/core/test_bonds.py

  Line 56 in bd9fba9

  assert obtain_all_bond_lengths("C", "C") == {1.0: 1.54, 2.0: 1.34, 3.0: 1.2}

• Other type/comment tweaks

[DanielYang59]

This new implementation is slightly more readable (personal taste) and gives ~4x speedup, reference (the following is a project to b):

Original Implementation Time: 420.86 ms
New Implementation Time: 101.28 ms

Test script (by GPT):

import numpy as np
from numpy.typing import NDArray
from time import perf_counter_ns


def _proj_original(b: NDArray, a: NDArray) -> NDArray:
    return (b.T @ (a / np.linalg.norm(a))) * (a / np.linalg.norm(a))

def _proj_new(b: NDArray, a: NDArray) -> NDArray:
    return (np.dot(b, a) / np.dot(a, a)) * a

def verify_projection():
    a = np.random.rand(3)
    b = np.random.rand(3)
    proj1 = _proj_original(b, a)
    proj2 = _proj_new(b, a)
    assert np.allclose(proj1, proj2)

def benchmark_projections(n_iter=100000):
    a = np.random.rand(3)
    b = np.random.rand(3)

    # Measure original implementation
    start_time = perf_counter_ns()
    for _ in range(n_iter):
        _proj_original(b, a)
    time_original = perf_counter_ns() - start_time

    # Measure new implementation
    start_time = perf_counter_ns()
    for _ in range(n_iter):
        _proj_new(b, a)
    time_new = perf_counter_ns() - start_time

    print(f"Original Implementation Time: {time_original / 1e6:.2f} ms")
    print(f"New Implementation Time: {time_new / 1e6:.2f} ms")

verify_projection()

print("Benchmarking both implementations...")
benchmark_projections()

[DanielYang59]

I believe a == pytest.approx(ref_val) is the recommended usage plus it's slightly more readable. However do note approx is asymmetric:

a == pytest.approx(b, rel=1e-6, abs=1e-12): True if the relative tolerance is met w.r.t. b or if the absolute tolerance is met. Because the relative tolerance is only calculated w.r.t. b, this test is asymmetric and you can think of b as the reference value. In the special case that you explicitly specify an absolute tolerance but not a relative tolerance, only the absolute tolerance is considered.