Added centered_l2_discrepancy

Author: blankjul

.idea/inspectionProfiles/Project_Default.xml

@@ -0,0 +1,54 @@
+from pysample.util import cdist
+
+import numpy as np
+
+
+def minimum_distance(X):
+    D = cdist(X, X)
+    D = D + 1e12 * np.eye(X.shape[0])
+    return - np.min(D)
+
+
+def correlation(X):
+    M = np.corrcoef(X.T, rowvar=True)
+    return np.sum(np.tril(M, -1) ** 2)
+
+
+def centered_l2_discrepancy_slow(X, check_bounds=True):
+    if check_bounds and (np.any(np.min(X) < 0 or np.max(X) > 1)):
+        raise Exception("Make sure that all X are between 0 and 1.")
+
+    n_points, n_dim = X.shape
+
+    acmh = np.abs(X - 0.5)
+
+    val = 0
+
+    for k in range(n_points):
+        temp = 1
+        for i in range(n_dim):
+            temp = temp * (1 + 0.5 * (acmh[:, i] + acmh[k, i] - np.abs(X[:, i] - X[k, i])))
+        val += np.sum(temp)
+
+    val = ((13 / 12) ** n_dim - 2 / n_points * np.sum(
+        np.prod(1 + 0.5 * (acmh - acmh ** 2), axis=1)) + val / n_points ** 2) ** 0.5
+
+    return val
+
+
+def centered_l2_discrepancy(X, check_bounds=True):
+    if check_bounds and (np.any(np.min(X) < 0 or np.max(X) > 1)):
+        raise Exception("Make sure that all X are between 0 and 1.")
+
+    n_points, n_dim = X.shape
+
+    acmh = np.abs(X - 0.5)
+
+    _X = np.abs(X.T[..., None] - X.T[:, None, :])
+    _acmh = np.abs(acmh.T[..., None] + acmh.T[:, None, :])
+
+    val = np.sum(np.prod((1 + 0.5 * (_acmh - _X)), axis=0))
+    val = ((13 / 12) ** n_dim - 2 / n_points * np.sum(
+        np.prod(1 + 0.5 * (acmh - acmh ** 2), axis=1)) + val / n_points ** 2) ** 0.5
+
+    return val

.idea/other.xml

@@ -0,0 +1,58 @@
+import numpy as np
+
+from pysample.methods.sampling import Sampling
+from pysample.indicators import minimum_distance, correlation
+from pysample.optimization import random_search
+
+
+class LatinHypercubeSampling(Sampling):
+
+    def __init__(self, criterion="maxmin", optimizer="random_search", iterations=1000) -> None:
+        super().__init__()
+        self.criterion = criterion
+        self.iterations = iterations
+        self.optimizer = optimizer
+
+        if criterion == "maxmin":
+            self.fun_obj = minimum_distance
+        elif criterion == "correlation":
+            self.fun_obj = correlation
+        else:
+            raise Exception("Criterion not known.")
+
+    def _sample(self, n_samples, n_dim):
+
+        if self.optimizer == "random_trials":
+            fun_sample = lambda: _sample(n_samples, n_dim)
+            X = random_search(fun_sample, self.fun_obj, self.iterations)
+
+        elif self.optimizer == "simulated_annealing":
+
+            pass
+
+        elif self.optimizer == "ga":
+
+            n_generations = 100
+            pop_size = 20
+
+
+
+
+        else:
+            X = _sample(n_samples, n_dim)
+
+        return X
+
+
+def _sample(n_samples, n_var, smooth=True):
+    X = np.random.random(size=(n_samples, n_var))
+    val = X.argsort(axis=0) + 1
+
+    if smooth:
+        val = val - np.random.random(val.shape)
+    else:
+        val = val - 0.5
+    val /= n_samples
+    return val
+
+

.idea/workspace.xml

@@ -0,0 +1,9 @@
+import numpy as np
+
+from pysample.methods.sampling import Sampling
+
+
+class RandomSampling(Sampling):
+
+    def _sample(self, n_samples, n_dim):
+        return np.random.random((n_samples, n_dim))

docs/.DS_Store

@@ -0,0 +1,7 @@
+class Sampling:
+
+    def sample(self, n_samples, n_dim):
+        return self._sample(n_samples, n_dim)
+
+    def _sample(self, n_samples, n_dim):
+        pass