def simplify(self):
# type: (ResultSet) -> None
# Remove single points from the yup and ylow closures, i.e., rectangles rect with:
# rect.min_corner == rect.max_corner
# These kind of rectangles appear when the dicothomic search cannot find an intersection of the diagonal
# with the Pareto front
self.ylow = [li for li in self.ylow if li.norm() != 0.0]
self.yup = [li for li in self.yup if li.norm() != 0.0]
# Single points may appear in the boundary, so we don't remove them
# self.border = [li for li in self.border if li.norm() != 0]
# Get the highest (upper right) values of self.ylow; i.e., those points that are closer to self.yup
extended_ylow = [Rectangle(self.xspace.min_corner, r.max_corner) for r in self.ylow]
# extended_yup = [Rectangle(r.min_corner, self.xspace.max_corner) for r in self.yup]
# Get the lowest (lower left) values of self.yup; i.e., those points that are closer to self.ylow
# extended_ylow = [Rectangle(self.xspace.min_corner, ylow_point) for ylow_point in self.get_points_pareto_ylow()]
extended_yup = [Rectangle(yup_point, self.xspace.max_corner) for yup_point in self.get_points_pareto_yup()]
self.border = Rectangle.difference_rectangles(self.xspace, extended_ylow + extended_yup)
self.yup = Rectangle.difference_rectangles(self.xspace, extended_ylow + self.border)
self.ylow = Rectangle.difference_rectangles(self.xspace, extended_yup + self.border)
def multidim_search_opt_3(xspace,
oracle,
epsilon=EPS,
delta=DELTA,
max_step=STEPS,
blocking=False,
sleep=0.0,
logging=True):
# type: (Rectangle, Oracle, float, float, float, bool, float, bool) -> ResultSet
# xspace is a particular case of maximal rectangle
# xspace = [min_corner, max_corner]^n = [0, 1]^n
# xspace.min_corner = (0,) * n
# xspace.max_corner = (1,) * n
# Dimension
n = xspace.dim()
# Set of comparable and incomparable rectangles, represented by 'alpha' indices
comparable = comp(n)
incomparable = incomp(n)
# comparable = [zero, one]
# incomparable = list(set(alpha) - set(comparable))
# with:
# zero = (0_1,...,0_n)
# one = (1_1,...,1_n)
# List of incomparable rectangles
# border = [xspace]
# border = SortedListWithKey(key=Rectangle.volume)
border = SortedSet([], key=Rectangle.volume)
border.add(xspace)
lattice_border_ylow = Lattice(dim=xspace.dim(), key=lambda x: x.min_corner)
lattice_border_yup = Lattice(dim=xspace.dim(), key=lambda x: x.max_corner)
lattice_border_ylow.add(xspace)
lattice_border_yup.add(xspace)
ylow = []
yup = []
# x_minimal = points from 'x' that are strictly incomparable (Pareto optimal)
ylow_minimal = []
yup_minimal = []
# oracle function
f = oracle.membership()
error = (epsilon,) * n
vol_total = xspace.volume()
vol_yup = 0
vol_ylow = 0
vol_border = vol_total
step = 0
RootSearch.logger.debug('xspace: {0}'.format(xspace))
RootSearch.logger.debug('vol_border: {0}'.format(vol_border))
RootSearch.logger.debug('delta: {0}'.format(delta))
RootSearch.logger.debug('step: {0}'.format(step))
RootSearch.logger.debug('incomparable: {0}'.format(incomparable))
RootSearch.logger.debug('comparable: {0}'.format(comparable))
# Create temporary directory for storing the result of each step
tempdir = tempfile.mkdtemp()
RootSearch.logger.info(
'Report\nStep, Ylow, Yup, Border, Total, nYlow, nYup, nBorder, BinSearch, nBorder dominated by Ylow, nBorder dominated by Yup')
while (vol_border >= delta) and (step <= max_step) and (len(border) > 0):
step = step + 1
# if RootSearch.logger.isEnabledFor(RootSearch.logger.DEBUG):
# RootSearch.logger.debug('border: {0}'.format(border))
# l.sort(key=Rectangle.volume)
xrectangle = border.pop()
lattice_border_ylow.remove(xrectangle)
lattice_border_yup.remove(xrectangle)
RootSearch.logger.debug('xrectangle: {0}'.format(xrectangle))
RootSearch.logger.debug('xrectangle.volume: {0}'.format(xrectangle.volume()))
RootSearch.logger.debug('xrectangle.norm: {0}'.format(xrectangle.norm()))
# y, segment
# y = search(xrectangle.diag(), f, epsilon)
y, steps_binsearch = binary_search(xrectangle.diag(), f, error)
RootSearch.logger.debug('y: {0}'.format(y))
# discovered_segments.append(y)
# b0 = Rectangle(xrectangle.min_corner, y.low)
# b1 = Rectangle(y.high, xrectangle.max_corner)
#
# ylow.append(b0)
# yup.append(b1)
#
# vol_ylow += b0.volume()
# vol_yup += b1.volume()
################################
# Every Border rectangle that dominates B0 is included in Ylow
b0_extended = Rectangle(xspace.min_corner, y.low)
# border_overlapping_b0 = [rect for rect in border if rect.overlaps(b0_extended)]
# border_overlapping_b0 = [rect for rect in border_overlapping_b0 if rect.overlaps(b0_extended)]
ylow_rectangle = Rectangle(y.low, y.low)
border_overlapping_b0 = lattice_border_ylow.less_equal(ylow_rectangle)
# border_intersecting_b0 = [b0_extended.intersection(rect) for rect in border_overlapping_b0]
## border_nondominatedby_b0 = [rect - b0_extended for rect in border_overlapping_b0]
# border_nondominatedby_b0 = []
# for rect in border_overlapping_b0:
# border_nondominatedby_b0 += list(rect - b0_extended)
list_idwc = (idwc(b0_extended, rect) for rect in border_overlapping_b0)
border_nondominatedby_b0 = set(itertools.chain.from_iterable(list_idwc))
# border_nondominatedby_b0 = Rectangle.fusion_rectangles(border_nondominatedby_b0)
# if 'rect' is completely dominated by b0_extended (i.e., rect is strictly inside b0_extended), then
# set(rect - b0_extended) == {rect}
# Therefore, 'rect' must be removed from 'non dominated' borders
border |= border_nondominatedby_b0
border -= border_overlapping_b0
lattice_border_ylow.add_list(border_nondominatedby_b0)
lattice_border_ylow.remove_list(border_overlapping_b0)
lattice_border_yup.add_list(border_nondominatedby_b0)
lattice_border_yup.remove_list(border_overlapping_b0)
# Every Border rectangle that is dominated by B1 is included in Yup
b1_extended = Rectangle(y.high, xspace.max_corner)
# border_overlapping_b1 = [rect for rect in border if rect.overlaps(b1_extended)]
# border_overlapping_b1 = [rect for rect in border_overlapping_b1 if rect.overlaps(b1_extended)]
yup_rectangle = Rectangle(y.high, y.high)
border_overlapping_b1 = lattice_border_yup.greater_equal(yup_rectangle)
# border_intersecting_b1 = [b1_extended.intersection(rect) for rect in border_overlapping_b1]
## border_nondominatedby_b1 = [rect - b1_extended for rect in border_overlapping_b1]
# border_nondominatedby_b1 = []
# for rect in border_overlapping_b1:
# border_nondominatedby_b1 += list(rect - b1_extended)
list_iuwc = (iuwc(b1_extended, rect) for rect in border_overlapping_b1)
border_nondominatedby_b1 = set(itertools.chain.from_iterable(list_iuwc))
# border_nondominatedby_b1 = Rectangle.fusion_rectangles(border_nondominatedby_b1)
# if 'rect' is completely dominated by b1_extended (i.e., rect is strictly inside b1_extended), then
# set(rect - b1_extended) == {rect}
# Therefore, 'rect' must be removed from 'non dominated' borders
border |= border_nondominatedby_b1
border -= border_overlapping_b1
lattice_border_ylow.add_list(border_nondominatedby_b1)
lattice_border_ylow.remove_list(border_overlapping_b1)
lattice_border_yup.add_list(border_nondominatedby_b1)
lattice_border_yup.remove_list(border_overlapping_b1)
db0 = Rectangle.difference_rectangles(b0_extended, ylow_minimal)
db1 = Rectangle.difference_rectangles(b1_extended, yup_minimal)
vol_db0 = sum(b0.volume() for b0 in db0)
vol_db1 = sum(b1.volume() for b1 in db1)
# rs = ResultSet([], border_intersecting_b0 + [b0], border_intersecting_b1 + [b1], Rectangle())
# vol_db0 = rs.volume_ylow() - rs.overlapping_volume_ylow()
# vol_db1 = rs.volume_yup() - rs.overlapping_volume_yup()
vol_ylow += vol_db0
vol_yup += vol_db1
ylow.extend(db0)
yup.extend(db1)
ylow_minimal.append(b0_extended)
yup_minimal.append(b1_extended)
RootSearch.logger.debug('b0: {0}'.format(db0))
RootSearch.logger.debug('b1: {0}'.format(db1))
RootSearch.logger.debug('ylow: {0}'.format(ylow))
RootSearch.logger.debug('yup: {0}'.format(yup))
################################
# Every rectangle in 'i' is incomparable for current B0 and for all B0 included in Ylow
# Every rectangle in 'i' is incomparable for current B1 and for all B1 included in Yup
################################
yrectangle = Rectangle(y.low, y.high)
i = irect(incomparable, yrectangle, xrectangle)
# i = pirect(incomparable, yrectangle, xrectangle)
# l.extend(i)
border |= i
RootSearch.logger.debug('irect: {0}'.format(i))
lattice_border_ylow.add_list(i)
lattice_border_yup.add_list(i)
# Remove boxes in the boundary with volume 0
boxes_null_vol = border[:border.bisect_key_left(0.0)]
border -= boxes_null_vol
lattice_border_ylow.remove_list(boxes_null_vol)
lattice_border_yup.remove_list(boxes_null_vol)
vol_border = vol_total - vol_yup - vol_ylow
RootSearch.logger.info('{0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, {9}, {10}'
.format(step, vol_ylow, vol_yup, vol_border, vol_total, len(ylow), len(yup), len(border),
steps_binsearch,
len(border_overlapping_b0), len(border_overlapping_b1)))
if sleep > 0.0:
rs = ResultSet(border, ylow, yup, xspace)
if n == 2:
rs.plot_2D_light(blocking=blocking, sec=sleep, opacity=0.7)
elif n == 3:
rs.plot_3D_light(blocking=blocking, sec=sleep, opacity=0.7)
if logging:
rs = ResultSet(border, ylow, yup, xspace)
name = os.path.join(tempdir, str(step))
rs.to_file(name)
return ResultSet(border, ylow, yup, xspace)
def multidim_search_opt_1(xspace,
oracle,
epsilon=EPS,
delta=DELTA,
max_step=STEPS,
blocking=False,
sleep=0.0,
logging=True):
# type: (Rectangle, Oracle, float, float, float, bool, float, bool) -> ResultSet
# Xspace is a particular case of maximal rectangle
# Xspace = [min_corner, max_corner]^n = [0, 1]^n
# xspace.min_corner = (0,) * n
# xspace.max_corner = (1,) * n
# Dimension
n = xspace.dim()
# Set of comparable and incomparable rectangles, represented by 'alpha' indices
comparable = comp(n)
incomparable = incomp(n)
# comparable = [zero, one]
# incomparable = list(set(alpha) - set(comparable))
# with:
# zero = (0_1,...,0_n)
# one = (1_1,...,1_n)
# List of incomparable rectangles
# border = [xspace]
# border = SortedListWithKey(key=Rectangle.volume)
border = SortedSet([], key=Rectangle.volume)
border.add(xspace)
ylow = []
yup = []
# oracle function
f = oracle.membership()
error = (epsilon,) * n
vol_total = xspace.volume()
vol_yup = 0
vol_ylow = 0
vol_border = vol_total
step = 0
RootSearch.logger.debug('xspace: {0}'.format(xspace))
RootSearch.logger.debug('vol_border: {0}'.format(vol_border))
RootSearch.logger.debug('delta: {0}'.format(delta))
RootSearch.logger.debug('step: {0}'.format(step))
RootSearch.logger.debug('incomparable: {0}'.format(incomparable))
RootSearch.logger.debug('comparable: {0}'.format(comparable))
# Create temporary directory for storing the result of each step
tempdir = tempfile.mkdtemp()
RootSearch.logger.info(
'Report\nStep, Ylow, Yup, Border, Total, nYlow, nYup, nBorder, BinSearch, nBorder dominated by Ylow, nBorder dominated by Yup')
while (vol_border >= delta) and (step <= max_step) and (len(border) > 0):
step = step + 1
# if RootSearch.logger.isEnabledFor(RootSearch.logger.DEBUG):
# RootSearch.logger.debug('border: {0}'.format(border))
# l.sort(key=Rectangle.volume)
xrectangle = border.pop()
RootSearch.logger.debug('xrectangle: {0}'.format(xrectangle))
RootSearch.logger.debug('xrectangle.volume: {0}'.format(xrectangle.volume()))
RootSearch.logger.debug('xrectangle.norm: {0}'.format(xrectangle.norm()))
# y, segment
# y = search(xrectangle.diag(), f, epsilon)
y, steps_binsearch = binary_search(xrectangle.diag(), f, error)
RootSearch.logger.debug('y: {0}'.format(y))
# discovered_segments.append(y)
b0 = Rectangle(xrectangle.min_corner, y.low)
b1 = Rectangle(y.high, xrectangle.max_corner)
ylow.append(b0)
yup.append(b1)
vol_ylow += b0.volume()
vol_yup += b1.volume()
RootSearch.logger.debug('b0: {0}'.format(b0))
RootSearch.logger.debug('b1: {0}'.format(b1))
RootSearch.logger.debug('ylow: {0}'.format(ylow))
RootSearch.logger.debug('yup: {0}'.format(yup))
################################
# Every Border rectangle that dominates B0 is included in Ylow
# Every Border rectangle that is dominated by B1 is included in Yup
b0_extended = Rectangle(xspace.min_corner, y.low)
b1_extended = Rectangle(y.high, xspace.max_corner)
# Every cube in the boundary overlaps another cube in the boundary
# When cubes from the boundary are moved to ylow or yup, they may still have a complementary cube
# remaining in the boundary with a non-empty intersection.
border_overlapping_ylow = [r for r in ylow if r.overlaps(b0_extended)]
border_overlapping_yup = [r for r in yup if r.overlaps(b1_extended)]
border_overlapping_b0 = [rect for rect in border if rect.overlaps(b0_extended)]
# Warning: Be aware of the overlapping areas of the cubes in the border.
# If we calculate the intersection of b0_extended with all the cubes in the frontier, and two cubes
# 'a' and 'b' partially overlaps, then the volume of this overlapping portion will be counted twice
# border_dominatedby_b0 = [rect.intersection(b0_extended) for rect in border_overlapping_b0]
# Solution: Project the 'shadow' of the cubes in the border over b0_extended.
border_dominatedby_b0_shadow = Rectangle.difference_rectangles(b0_extended, border_overlapping_b0)
# The negative of this image returns a set of cubes in the boundary without overlapping.
# border_dominatedby_b0 will be appended to ylow.
# Remove the portion of the negative that overlaps any cube that is already appended to ylow
border_dominatedby_b0 = Rectangle.difference_rectangles(b0_extended,
border_dominatedby_b0_shadow + border_overlapping_ylow)
# border_nondominatedby_b0 = [rect - b0_extended for rect in border_overlapping_b0]
border_nondominatedby_b0 = []
for rect in border_overlapping_b0:
border_nondominatedby_b0 += list(rect - b0_extended)
# border_nondominatedby_b0 = set()
# for rect in border_overlapping_b0:
# border_nondominatedby_b0 |= set(rect - b0_extended)
# border_nondominatedby_b0 -= set(border_overlapping_b0)
# if 'rect' is completely dominated by b0_extended (i.e., rect is strictly inside b0_extended), then
# set(rect - b0_extended) == {rect}
# Therefore, 'rect' must be removed from 'non dominated' borders
# border -= border_overlapping_b0
border |= border_nondominatedby_b0
border -= border_overlapping_b0
border_overlapping_b1 = [rect for rect in border if rect.overlaps(b1_extended)]
# Warning: Be aware of the overlapping areas of the cubes in the border.
# If we calculate the intersection of b1_extended with all the cubes in the frontier, and two cubes
# 'a' and 'b' partially overlaps, then the volume of this overlapping portion will be considered twice
# border_dominatedby_b1 = [rect.intersection(b1_extended) for rect in border_overlapping_b1]
# Solution: Project the 'shadow' of the cubes in the border over b1_extended.
border_dominatedby_b1_shadow = Rectangle.difference_rectangles(b1_extended, border_overlapping_b1)
# The negative of this image returns a set of cubes in the boundary without overlapping.
# border_dominatedby_b1 will be appended to yup.
# Remove the portion of the negative that overlaps any cube that is already appended to yup
border_dominatedby_b1 = Rectangle.difference_rectangles(b1_extended,
border_dominatedby_b1_shadow + border_overlapping_yup)
# border_nondominatedby_b1 = [rect - b1_extended for rect in border_overlapping_b1]
border_nondominatedby_b1 = []
for rect in border_overlapping_b1:
border_nondominatedby_b1 += list(rect - b1_extended)
# border_nondominatedby_b1 = set()
# for rect in border_overlapping_b1:
# border_nondominatedby_b1 |= set(rect - b1_extended)
# border_nondominatedby_b1 -= set(border_overlapping_b1)
# if 'rect' is completely dominated by b1_extended (i.e., rect is strictly inside b1_extended), then
# set(rect - b1_extended) == {rect}
# Therefore, 'rect' must be removed from 'non dominated' borders
# border -= border_overlapping_b1
border |= border_nondominatedby_b1
border -= border_overlapping_b1
ylow.extend(border_dominatedby_b0)
yup.extend(border_dominatedby_b1)
vol_ylow += sum(b0.volume() for b0 in border_dominatedby_b0)
vol_yup += sum(b1.volume() for b1 in border_dominatedby_b1)
################################
# Every rectangle in 'i' is incomparable for current B0 and for all B0 included in Ylow
# Every rectangle in 'i' is incomparable for current B1 and for all B1 included in Yup
################################
yrectangle = Rectangle(y.low, y.high)
i = irect(incomparable, yrectangle, xrectangle)
# i = pirect(incomparable, yrectangle, xrectangle)
# l.extend(i)
border |= i
RootSearch.logger.debug('irect: {0}'.format(i))
# Remove boxes in the boundary with volume 0
border -= border[:border.bisect_key_left(0.0)]
vol_border = vol_total - vol_yup - vol_ylow
RootSearch.logger.info('{0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, {9}, {10}'
.format(step, vol_ylow, vol_yup, vol_border, vol_total, len(ylow), len(yup), len(border),
steps_binsearch,
len(border_overlapping_b0), len(border_overlapping_b1)))
if sleep > 0.0:
rs = ResultSet(border, ylow, yup, xspace)
if n == 2:
rs.plot_2D_light(blocking=blocking, sec=sleep, opacity=0.7)
elif n == 3:
rs.plot_3D_light(blocking=blocking, sec=sleep, opacity=0.7)
if logging:
rs = ResultSet(border, ylow, yup, xspace)
name = os.path.join(tempdir, str(step))
rs.to_file(name)
return ResultSet(border, ylow, yup, xspace)