Renamed class.measure members to match paper

Author: panchoop

src/classes.py

@@ -340,33 +340,32 @@ class measure:
         List of member curves.
     weights : numpy.ndarray
         Array of positive weights associated to each curve.
-    intensities : numpy.ndarray
-        Array of the intensities associated to each curve.
+    energies : numpy.ndarray
+        Array of stored Benamou-Brenier energy associated to each curve.
     main_energy : float
         The Tikhonov energy of the measure.
     """
     def __init__(self):
         self.curves = []
         self.energies = np.array([])
-        self.intensities = np.array([])
+        self.weights = np.array([])
         self.main_energy = None
 
-    def add(self, new_curve, new_intensity):
-        # Input: new_curve is a curve class object. new_intensity > 0 real.
-        if new_intensity > config.measure_coefficient_too_low:
+    def add(self, new_curve, new_weight):
+        # Input: new_curve is a curve class object. new_weight > 0 real.
+        if new_weight > config.measure_coefficient_too_low:
             self.curves.extend([new_curve])
             self.energies = np.append(self.energies,
                                       new_curve.energy())
-            self.intensities = np.append(self.intensities, new_intensity)
+            self.weights = np.append(self.weights, new_weight)
             self.main_energy = None
 
     def __add__(self, measure2):
         new_measure = copy.deepcopy(self)
         new_measure.curves.extend(copy.deepcopy(measure2.curves))
         new_measure.energies = np.append(new_measure.energies,
                                          measure2.energies)
-        new_measure.intensities = np.append(new_measure.intensities,
-                                            measure2.intensities)
+        new_measure.weights = np.append(new_measure.weights, measure2.weights)
         new_measure.main_energy = None
         return new_measure
 
@@ -375,46 +374,46 @@ def __mul__(self, factor):
             raise Exception('Cannot use a negative factor for a measure')
         new_measure = copy.deepcopy(self)
         new_measure.main_energy = None
-        for i in range(len(self.intensities)):
-            new_measure.intensities[i] = new_measure.intensities[i]*factor
+        for i in range(len(self.weights)):
+            new_measure.weights[i] = new_measure.weights[i]*factor
         return new_measure
 
     def __rmul__(self, factor):
         return self*factor
 
-    def modify_intensity(self, curve_index, new_intensity):
+    def modify_weight(self, curve_index, new_weight):
         self.main_energy = None
         if curve_index >= len(self.curves):
             raise Exception('Trying to modify an unexistant curve! The given'
                             + 'curve index is too high for the current array')
-        if new_intensity < config.measure_coefficient_too_low:
+        if new_weight < config.measure_coefficient_too_low:
             del self.curves[curve_index]
-            self.intensities = np.delete(self.intensities, curve_index)
+            self.weights = np.delete(self.weights, curve_index)
             self.energies = np.delete(self.energies, curve_index)
         else:
-            self.intensities[curve_index] = new_intensity
+            self.weights[curve_index] = new_weight
 
     def integrate_against(self, w_t):
         assert isinstance(w_t, op.w_t)
         # Method to integrate against this measure. 
         integral = 0
         for i, curv in enumerate(self.curves):
-            integral += self.intensities[i]/self.energies[i] * \
+            integral += self.weights[i]/self.energies[i] * \
                     curv.integrate_against(w_t)
         return integral
 
     def spatial_integrate(self, t, target):
         # Method to integrate against this measure for a fixed time, target is
         # a function handle
         val = 0
-        for i in range(len(self.intensities)):
-            val = val + self.intensities[i]/self.energies[i] * \
+        for i in range(len(self.weights)):
+            val = val + self.weights[i]/self.energies[i] * \
                     target(self.curves[i].eval_discrete(t))
         return val
 
     def to_curve_product(self):
         # transforms the measure to a curve product object
-        return curve_product(self.curves, self.intensities)
+        return curve_product(self.curves, self.weights)
 
     def get_main_energy(self):
         if self.main_energy is None:
@@ -425,8 +424,8 @@ def get_main_energy(self):
 
 
     def draw(self, ax=None):
-        num_plots = len(self.intensities)
-        total_intensities = self.intensities/self.energies
+        num_plots = len(self.weights)
+        total_intensities = self.weights/self.energies
         'get the brg colormap for the intensities of curves'
         colors = plt.cm.brg(total_intensities/max(total_intensities))
         ax = ax or plt.gca()
@@ -467,13 +466,13 @@ def animate(self, filename=None, show=True, block=False):
     def reorder(self):
         # Script to reorder the curves inside the measure with an increasing
         # total energy.
-        total_intensities = self.intensities/self.energies
+        total_intensities = self.weights/self.energies
         new_order = np.argsort(total_intensities)
         new_measure = measure()
         for idx in new_order:
-            new_measure.add(self.curves[idx], self.intensities[idx])
+            new_measure.add(self.curves[idx], self.weights[idx])
         self.curves = new_measure.curves
-        self.intensities = new_measure.intensities
+        self.weights = new_measure.weights
         self.energies = new_measure.energies
 
 

src/misc.py

@@ -39,13 +39,13 @@ def __init__(self, measure, **kwargs):
         #
         measure.reorder()
         # Define the colors, these depends on the intensities
-        total_intensities = measure.intensities/measure.energies
+        total_intensities = measure.weights/measure.energies
         brg_cmap = plt.cm.get_cmap('brg')
         colors = brg_cmap(np.array(total_intensities)/max(total_intensities))
         # Get the family of segments and times
         segments = []
         times = []
-        for i in range(len(measure.intensities)):
+        for i in range(len(measure.weights)):
             supsamp_t, supsamp_x = supersample(measure.curves[i],
                                                max_jump=0.01)
             # Get segments and use as time the last part of each segment
@@ -74,12 +74,12 @@ def __init__(self, measure, **kwargs):
         self.show = show
         self.block = block
         # For colorbar
-        norm = mpl.colors.Normalize(vmin=0, vmax=max(measure.intensities))
+        norm = mpl.colors.Normalize(vmin=0, vmax=max(measure.weights))
         cmap = plt.get_cmap('brg', 100)
         sm = plt.cm.ScalarMappable(cmap=cmap, norm=norm)
         sm.set_array([])
         self.fig.colorbar(sm,
-                          ticks=np.linspace(0, max(measure.intensities), 9))
+                          ticks=np.linspace(0, max(measure.weights), 9))
 
 
     def animate(self, i):

src/operators.py

@@ -124,7 +124,7 @@ class w_t:
     def __init__(self, rho_t):
         assert isinstance(rho_t, classes.measure)
         # take the difference between the current curve and the problem's data.
-        if rho_t.intensities.size == 0:
+        if rho_t.weights.size == 0:
             if config.f_t is None:
                 # Case in which the data has not yet been set
                 self.data = None
@@ -213,8 +213,8 @@ def density_transformation(self, x):
 
     def as_density_get_params(self, t):
         if np.isnan(self.as_predensity_mass[t]):
-            # Produce, and store, the parameters needed to define a density with
-            # the dual variable. These parameters change for each time t.
+            # Produce, and store, the parameters needed to define a density
+            # with the dual variable. These parameters change for each time t.
             evaluations = misc.grid_evaluate(lambda x: self.eval(t, x),
                                              resolution=0.01)
             # extracting the epsilon support for rejection sampling
@@ -259,5 +259,5 @@ def main_energy(measure, f):
     # Output: positive number
     forward = K_t_star_full(measure)
     diff = forward - f
-    return int_time_H_t_product(diff, diff)/2 + sum(measure.intensities)
+    return int_time_H_t_product(diff, diff)/2 + sum(measure.weights)
 

src/optimization.py

@@ -109,14 +109,14 @@ def after_optimization_sparsifier(current_measure, energy_curves=None):
             curve_2 = output_measure.curves[id2]
             if (curve_1 - curve_2).H1_norm() < config.H1_tolerance:
                 # if the curves are close, we have 3 alternatives to test
-                weight_1 = output_measure.intensities[id1]
-                weight_2 = output_measure.intensities[id2]
+                weight_1 = output_measure.weights[id1]
+                weight_2 = output_measure.weights[id2]
                 measure_1 = copy.deepcopy(output_measure)
-                measure_1.modify_intensity(id1, weight_1 + weight_2)
-                measure_1.modify_intensity(id2, 0)
+                measure_1.modify_weight(id1, weight_1 + weight_2)
+                measure_1.modify_weight(id2, 0)
                 measure_2 = copy.deepcopy(output_measure)
-                measure_2.modify_intensity(id2, weight_1 + weight_2)
-                measure_2.modify_intensity(id1, 0)
+                measure_2.modify_weight(id2, weight_1 + weight_2)
+                measure_2.modify_weight(id1, 0)
                 energy_0 = output_measure.get_main_energy()
                 energy_1 = measure_1.get_main_energy()
                 energy_2 = measure_2.get_main_energy()
@@ -253,7 +253,7 @@ def full_gradient(current_measure):
         curve_list = []
         for curve in current_measure.curves:
             curve_list.append(grad_F(curve, w_t))
-        return classes.curve_product(curve_list, current_measure.intensities)
+        return classes.curve_product(curve_list, current_measure.weights)
     # Stop when stepsize get smaller than
     limit_stepsize = config.g_flow_limit_stepsize