Fractions used even when explicitly turned off

[ttusar]

As reported by @MLopez-Ibanez, the following code

import moocore
from moarchiving import get_mo_archive as moarch_get_mo_archive
moarch_get_mo_archive.hypervolume_computation_float_type = float
moarch_get_mo_archive.hypervolume_final_float_type = float

x = moocore.generate_ndset(500,4,method="L", seed=42)
a = moarch_get_mo_archive(x, reference_point=[1,1,1,1])
print(a.contributing_hypervolumes) 

still uses Fractions. I.e., when the code is interrupted during execution (Ctrl+C), he gets:

File ~/work/perfassess/moocore/r/test.py:8
      6 x = moocore.generate_ndset(500,4,method="L", seed=42)
      7 a = moarch_get_mo_archive(x, reference_point=[1,1,1,1])
----> 8 print(a.contributing_hypervolumes)

File ~/.local/lib/python3.12/site-packages/moarchiving/moarchiving_parent.py:205, in MOArchiveParent.contributing_hypervolumes(self)
    202 @property
    203 def contributing_hypervolumes(self):
    204     """`list` of hypervolume contributions of each point in the archive"""
--> 205     return [self.contributing_hypervolume(point[:self.n_obj]) for point in self]

File ~/.local/lib/python3.12/site-packages/moarchiving/moarchiving_parent.py:231, in MOArchiveParent.contributing_hypervolume(self, f_vals)
    229     removed_info = self.remove(f_vals)
    230     hv_after = self._hypervolume
--> 231     self.add(f_vals, info=removed_info)
    232     return hv_before - hv_after
    233 else:

File ~/.local/lib/python3.12/site-packages/moarchiving/moarchiving4obj.py:131, in MOArchive4obj.add(self, f_vals, info, update_hypervolume)
    128         self._hypervolume_plus = -dist_to_hv_area
    129     return False
--> 131 self.__init__(list(self) + [f_vals], self.reference_point, self.infos + [info])
    132 return True

File ~/.local/lib/python3.12/site-packages/moarchiving/moarchiving4obj.py:84, in MOArchive4obj.__init__(self, list_of_f_vals, reference_point, infos, hypervolume_final_float_type, hypervolume_computation_float_type)
     82 self._hypervolume_already_computed = False
     83 self.remove_dominated()
---> 84 hv = self._set_HV()
     85 self._length = len(list(self))
     86 self._hypervolume_already_computed = True

File ~/.local/lib/python3.12/site-packages/moarchiving/moarchiving_parent.py:300, in MOArchiveParent._set_HV(self)
    298 if self.reference_point is None:
    299     return None
--> 300 self._hypervolume = self.hypervolume_final_float_type(self.compute_hypervolume())
    301 if self._hypervolume > 0:
    302     self._hypervolume_plus = self._hypervolume

File ~/.local/lib/python3.12/site-packages/moarchiving/moarchiving4obj.py:288, in MOArchive4obj.compute_hypervolume(self, reference_point)
    285 if self._hypervolume_already_computed:
    286     return self._hypervolume
    287 return self.hypervolume_final_float_type(
--> 288     hv4dplusR(self.head, self.hypervolume_computation_float_type))

File ~/.local/lib/python3.12/site-packages/moarchiving/moarchiving_utils.py:456, in hv4dplusR(head, Fc)
    453 update_links(head, new, new.next[2])  # Update cx and cy of the points above 'new' in z
    454 # and remove dominated points
--> 456 volume = hv3dplus(head, Fc)  # Compute hv indicator in d=3 in linear time
    458 height = Fc(new.next[3].x[3]) - Fc(new.x[3])
    459 hv += volume * height  # Update hypervolume in d=4

File ~/.local/lib/python3.12/site-packages/moarchiving/moarchiving_utils.py:430, in hv3dplus(head, Fc)
    427 p.cnext[0] = p.closest[0]
    428 p.cnext[1] = p.closest[1]
--> 430 area += compute_area_simple(p.x, 1, p.cnext[0], p.cnext[0].cnext[1], Fc)
    431 p.cnext[0].cnext[1] = p
    432 p.cnext[1].cnext[0] = p

File ~/.local/lib/python3.12/site-packages/moarchiving/moarchiving_utils.py:255, in compute_area_simple(p, di, s, u, Fc)
    253     q = u
    254     u = u.cnext[di]
--> 255     area += (Fc(q.x[dj]) - Fc(p[dj])) * (Fc(u.x[di]) - Fc(q.x[di]))
    257 return area

File /usr/lib/python3.12/fractions.py:615, in Fraction._operator_fallbacks.<locals>.forward(a, b)
    613 def forward(a, b):
    614     if isinstance(b, Fraction):
--> 615         return monomorphic_operator(a, b)
    616     elif isinstance(b, int):
    617         return monomorphic_operator(a, Fraction(b))

File /usr/lib/python3.12/fractions.py:754, in Fraction._mul(a, b)
    752     nb //= g2
    753     da //= g2
--> 754 return Fraction._from_coprime_ints(na * nb, db * da)

File /usr/lib/python3.12/fractions.py:324, in Fraction._from_coprime_ints(cls, numerator, denominator)
    317 @classmethod
    318 def _from_coprime_ints(cls, numerator, denominator, /):
    319     """Convert a pair of ints to a rational number, for internal use.
    320 
    321     The ratio of integers should be in lowest terms and the denominator
    322     should be positive.
    323     """
--> 324     obj = super(Fraction, cls).__new__(cls)
    325     obj._numerator = numerator
    326     obj._denominator = denominator

[MLopez-Ibanez]

Actually, it already breaks with a smaller input:

import moocore
from moarchiving import get_mo_archive as moarch_get_mo_archive
moarch_get_mo_archive.hypervolume_computation_float_type = float
moarch_get_mo_archive.hypervolume_final_float_type = float

x = moocore.generate_ndset(5,4,method="L", seed=42)
a = moarch_get_mo_archive(x, reference_point=[1,1,1,1])
print(a.contributing_hypervolumes)

In [1]: 
[0.027548970795496674, Fraction(62093524807804584888377419723351498454610304293584343840398037745, 1684996666696914987166688442938726917102321526408785780068975640576), Fraction(29471158560451002355074626573839132381669618518899423177929365525, 842498333348457493583344221469363458551160763204392890034487820288), Fraction(393009500191273744916048702696915790127591830105159810372647206003, 6739986666787659948666753771754907668409286105635143120275902562304), Fraction(10105283860820093760084491323761864885403347610407195736161636129, 421249166674228746791672110734681729275580381602196445017243910144)]

[ttusar]

On the other hand, when I do

from moarchiving import get_mo_archive
from fractions import Fraction

get_mo_archive.hypervolume_computation_float_type = float
get_mo_archive.hypervolume_final_float_type = float

a = get_mo_archive([[1, 7], [2, 6.333], [3, 5]], [10, 10])
print(a.hypervolume)
print(a.contributing_hypervolumes)

get_mo_archive.hypervolume_computation_float_type = Fraction
get_mo_archive.hypervolume_final_float_type = Fraction

a = get_mo_archive([[1, 7], [2, 6.333], [3, 5]], [10, 10])
print(a.hypervolume)
print(a.contributing_hypervolumes)

I get the expected output, that is:

41.667
[3.0, 0.6669999999999998, 9.331000000000001]
23456435709205807/562949953421312
[Fraction(3, 1), Fraction(375487618932015, 562949953421312), Fraction(5252886015374263, 562949953421312)]

[MLopez-Ibanez]

It may be a problem with 3D and/or 4D? I cannot trigger it in 3D (but 3D is still very slow). Note the log scales in the following:

[ttusar]

It doesn't work correctly in 4-D (seems to work fine in 3-D).

This code

from moarchiving import get_mo_archive
from fractions import Fraction

get_mo_archive.hypervolume_computation_float_type = float
get_mo_archive.hypervolume_final_float_type = float

a = get_mo_archive([[1, 7, 1, 3], [2, 6.333, 2, 2], [3, 5, 3, 1]], [10, 10, 10, 10])
print(a.hypervolume)
print(a.contributing_hypervolumes)

get_mo_archive.hypervolume_computation_float_type = Fraction
get_mo_archive.hypervolume_final_float_type = Fraction

a = get_mo_archive([[1, 7, 1, 3], [2, 6.333, 2, 2], [3, 5, 3, 1]], [10, 10, 10, 10])
print(a.hypervolume)
print(a.contributing_hypervolumes)

produces the following output

3002.04
[767.5360000000001, Fraction(8798907771975105, 70368744177664), Fraction(357, 1)]
211249784771114433/70368744177664
[Fraction(54010544431147521, 70368744177664), Fraction(8798907771975105, 70368744177664), Fraction(357, 1)]

So the hypervolume and the first contribution in 4-D is a float, but the rest are fractions.

[nikohansen]

The offending code is the call of MOArchive4obj.__init__ within remove which sets the default type because it does not get through get_mo_archive to manage the type according to get_ma_archive.hyper..float_type.

I suspect passing self.hyper...float_type as arguments in this self.__init__ call should fix this specific issue.

A quick check reveals that self.__init__ is also called in MOArchive4obj.add, MOArchive4obj.add_list and indirectly in MOArchive4obj.copy which hence probably all have the same issue. In the 3D case, remove does not call self.__init__, but MOArchive3obj.add_list does conditionally.

EDIT: this seems to suggest that .__init__ is not the right method to call in these cases. We should consider to have something like a .reset_list or .reset_archive method?

[nikohansen]

The bug itself is resolved with commit d42d88f

Still to be done:

• improve the copy functions to copy all attributes as is the case in 2-D
• consider to factor out reset_archive from the __init__ functions