SearchLibrium 0.0.1__py3-none-any.whl

old_code/_device.py

@@ -0,0 +1,145 @@
+''' ---------------------------------------------------------- '''
+''' LIBRARIES                                                  '''
+''' ---------------------------------------------------------- '''
+
+import numpy as np
+
+''' ---------------------------------------------------------- '''
+''' LOCAL INITIALISATION                                       '''
+''' ---------------------------------------------------------- '''
+
+_gpu_available = False
+try:
+    import cupy
+    _gpu_available = False
+except ImportError:
+    pass
+
+''' ---------------------------------------------------------- '''
+''' CLASS                                                      '''
+''' ---------------------------------------------------------- '''
+class Device():
+# {
+    ''' ------------------------------------------------------ '''
+    ''' Function                                               '''
+    ''' ------------------------------------------------------ '''
+    # QUERY. WHAT DOES np STAND FOR?
+    def __init__(self):
+    # {
+        if _gpu_available:
+            self.np = cupy
+            self._using_gpu = True
+        else:
+            self.np = np
+            self._using_gpu = False
+    # }
+
+    ''' ------------------------------------------------------ '''
+    ''' Function                                               '''
+    ''' ------------------------------------------------------ '''
+    def enable_gpu_acceleration(self, device_id=0):
+    # {
+        if _gpu_available == False: raise Exception("CuPy not found. Verify installation")
+        self.np = cupy
+        self._using_gpu = True
+        cupy.cuda.Device(device_id).use()
+    # }
+
+    ''' ------------------------------------------------------ '''
+    ''' Function                                               '''
+    ''' ------------------------------------------------------ '''
+    def disable_gpu_acceleration(self):
+    # {
+        self.np = np
+        self._using_gpu = False
+    # }
+
+    ''' ------------------------------------------------------ '''
+    ''' Function.                                              '''
+    ''' ------------------------------------------------------ '''
+    def multiply_1(self, a, b):
+    # {
+        n, p, j, k = a.shape                # Extract the cardinality of each of the 4 dimensions of a
+        r = b.shape[-1]                     # Cardinality of last dimension of b
+
+        # return self.np.matmul(a.reshape(n, p*j, k), b).reshape(n, p, j, r)
+        # Equivalent to:
+        a = a.reshape(n, p * j, k)          # Collapse a into 3 dimensions
+        a_b = np.matmul(a, b)               # Compute a * b
+        a_b = a_b.reshape(n, p, j, r)       # Expand to 4 dimensions
+        return a_b
+
+    # }
+
+    def multiply_2(self, a, b):
+        return np.matmul(a, b)
+
+    def multiply_3(self, a, b):
+    # {
+        n, p, j, r = a.shape                        # Extract the cardinality of each of the 4 dimensions
+        k = b.shape[-1]                             # Cardinality of last dimension of b
+
+        return self.np.matmul(b.reshape(n, p * j, k).transpose([0, 2, 1]), a.reshape(n, p * j, r))
+        b_ = b.reshape(n, p * j, k)                     # Collapse into 3 dimensions
+        a_ = a.reshape(n, p * j, r)                     # Collapse into 3 dimensions
+        bT_a = np.matmul(b_.transpose([0, 2, 1]), a_)   # Compute b^T * a
+        return bT_a
+    # }
+
+    ''' ------------------------------------------------------ '''
+    ''' Function. Efficient einsum for common expressions      '''
+    ''' ------------------------------------------------------ '''
+    def cust_einsum(self, expr, a, b):
+    # {
+        #if True:    # QUERY: IS THIS NEEDED?
+
+        if expr == 'npjk,nkr -> npjr':
+            return self.multiply_1(a, b)
+        elif expr == 'npjk,k -> npj':
+            return self.multiply_2(a, b)
+        elif expr == 'npjr,npjk -> nkr':
+            return self.multiply_3(a,b)
+        else: raise Exception(f"The expression {expr} is not supported by custeinsum")
+
+        #QUERY. WHEN IS THIS CALLED? CODE IS UNREACHABLE
+        #return self.np.einsum(expr, a, b)
+    # }
+
+    ''' ------------------------------------------------------ '''
+    ''' Function                                               '''
+    ''' ------------------------------------------------------ '''
+    @property
+    def using_gpu(self): return self._using_gpu
+
+
+    def to_cpu(self, arr):
+        return cupy.asnumpy(arr)
+
+
+    def to_gpu(self, arr):
+        return cupy.asarray(arr)
+
+    ''' ------------------------------------------------------ '''
+    ''' Function                                               '''
+    ''' ------------------------------------------------------ '''
+    def convert_array_cpu(self, arr): return cupy.asnumpy(arr)
+
+    ''' ------------------------------------------------------ '''
+    ''' Function                                               '''
+    ''' ------------------------------------------------------ '''
+    def convert_array_gpu(self, arr): return cupy.asarray(arr)
+
+    ''' ------------------------------------------------------ '''
+    ''' Function                                               '''
+    ''' ------------------------------------------------------ '''
+    def get_device_count(self):
+    # {
+        if _gpu_available: return cupy.cuda.runtime.getDeviceCount()
+        else: return 0
+    # }
+# }
+
+''' ---------------------------------------------------------- '''
+''' GLOBAL OBJECT                                              '''
+''' ---------------------------------------------------------- '''
+device = Device()  # Create an object to use

old_code/akshay_test.py

@@ -0,0 +1,125 @@
+import numpy as np
+from harmony import *
+from siman import *
+from threshold import *
+from latent_class_mixed_model import LatentClassMixedModel
+from latent_class_model import LatentClassModel
+from mixed_logit import MixedLogit
+from multinomial_logit import MultinomialLogit
+import pandas as pd
+from scipy import stats
+
+##df_wide = pd.read_csv('dataMaaSInd_wide.csv')
+##df_wide =df_wide[df_wide['CHOICE'] !=0]
+##
+##from xlogit.utils import wide_to_long
+##df = wide_to_long(df_wide, id_col='indID', alt_list=[1, 2, 3, 4],
+##                       varying=['pref', 'purchase', 'useWork', 'useFamily', 'useMaintenance', 'useSocial',
+##                                'maasLocalPT-1', 'maasLDPT-1', 'maasTaxi-1', 'maasCarRental-1', 'maasCarshare-1', 'maasRideshare-1', 'maasBikeshare-1', 'maasTktInt-1', 'maasBkInt-1', 'maasRTInf-1', 'maasPers-1', 'maasPaymentType-1', 'maasCost-1',
+##                                'maasLocalPT-2', 'maasLDPT-2', 'maasTaxi-2', 'maasCarRental-2', 'maasCarshare-2', 'maasRideshare-2', 'maasBikeshare-2', 'maasTktInt-2', 'maasBkInt-2', 'maasRTInf-2', 'maasPers-2', 'maasPaymentType-2', 'maasCost-2'], alt_name='alt', sep= "_")
+##
+##df = wide_to_long(df, id_col='indID', alt_list=[1, 2],
+##                  varying=['maasLocalPT', 'maasLDPT', 'maasTaxi', 'maasCarRental', 'maasCarshare', 'maasRideshare', 'maasBikeshare', 'maasTktInt', 'maasBkInt', 'maasRTInf', 'maasPers', 'maasPaymentType', 'maasCost'], alt_name='alt2', sep= "-")
+##
+##df = df.fillna(0)
+##
+##df['CHOICE'] = 1 * (df['pref'] == df['alt2'] )
+##
+##df.to_csv("akshay_long.csv", index=False)
+
+df =pd.read_csv('akshay_long_true.csv')
+
+
+model = LatentClassModel()
+varnames=['InnerCity', 'InnerRegional', 'Under30', 'Over65', 'College', 'FullTime', 'PartTime', 'Male', 'Children', 'Income', 'NDI',
+          'LocalPTPayG', 'LDPTPayG', 'TaxiPayG', 'CarRentalPayG', 'CarsharePayG', 'RidesharePayG', 'BikesharePayG',
+          'LocalPTUnl', 'LDPTUnl', 'TaxiUnl', 'CarRentalUnl', 'CarshareUnl', 'RideshareUnl', 'BikeshareUnl',
+          'Cost', 'TktInt', 'BkInt', 'RTInf', 'Pers'
+          ]
+
+X = df[varnames].values
+y = df['CHOICE'].values
+member_params_spec = np.array([['_inter', 'InnerCity', 'InnerRegional', 'Under30', 'Over65', 'College', 'FullTime', 'PartTime', 'Male', 'Children', 'Income', 'NDI'],
+                               ['_inter', 'InnerCity', 'InnerRegional', 'Under30', 'Over65', 'College', 'FullTime', 'PartTime', 'Male', 'Children', 'Income', 'NDI'],
+                               ['_inter', 'InnerCity', 'InnerRegional', 'Under30', 'Over65', 'College', 'FullTime', 'PartTime', 'Male', 'Children', 'Income', 'NDI'],
+                               ['_inter', 'InnerCity', 'InnerRegional', 'Under30', 'Over65', 'College', 'FullTime', 'PartTime', 'Male', 'Children', 'Income', 'NDI']],
+                              dtype='object')
+
+class_params_spec = np.array([['LocalPTPayG', 'LDPTPayG', 'TaxiPayG', 'CarRentalPayG', 'CarsharePayG', 'RidesharePayG', 'BikesharePayG',
+                               'LocalPTUnl', 'LDPTUnl', 'TaxiUnl', 'CarRentalUnl', 'CarshareUnl', 'RideshareUnl', 'BikeshareUnl',
+                               'Cost', 'TktInt', 'BkInt', 'RTInf', 'Pers'],
+                              ['LocalPTPayG', 'LDPTPayG', 'TaxiPayG', 'CarRentalPayG', 'CarsharePayG', 'RidesharePayG', 'BikesharePayG',
+                               'LocalPTUnl', 'LDPTUnl', 'TaxiUnl', 'CarRentalUnl', 'CarshareUnl', 'RideshareUnl', 'BikeshareUnl',
+                               'Cost', 'TktInt', 'BkInt', 'RTInf', 'Pers'],
+                              ['LocalPTPayG', 'LDPTPayG', 'TaxiPayG', 'CarRentalPayG', 'CarsharePayG', 'RidesharePayG', 'BikesharePayG',
+                               'LocalPTUnl', 'LDPTUnl', 'TaxiUnl', 'CarRentalUnl', 'CarshareUnl', 'RideshareUnl', 'BikeshareUnl',
+                               'Cost', 'TktInt', 'BkInt', 'RTInf', 'Pers'],
+                              ['LocalPTPayG', 'LDPTPayG', 'TaxiPayG', 'CarRentalPayG', 'CarsharePayG', 'RidesharePayG', 'BikesharePayG',
+                               'LocalPTUnl', 'LDPTUnl', 'TaxiUnl', 'CarRentalUnl', 'CarshareUnl', 'RideshareUnl', 'BikeshareUnl',
+                               'Cost', 'TktInt', 'BkInt', 'RTInf', 'Pers'],
+                              ['LocalPTPayG', 'LDPTPayG', 'TaxiPayG', 'CarRentalPayG', 'CarsharePayG', 'RidesharePayG', 'BikesharePayG',
+                               'LocalPTUnl', 'LDPTUnl', 'TaxiUnl', 'CarRentalUnl', 'CarshareUnl', 'RideshareUnl', 'BikeshareUnl',
+                               'Cost', 'TktInt', 'BkInt', 'RTInf', 'Pers']],
+                              dtype='object')
+
+
+init_class_thetas = np.array([-1.321318, -0.254239, -0.137624, -9.159877, 0.009594, 1.189211, -0.084255, 0.437849, 0.222736, -2.338727, -0.220732, 0.206103,
+                              0.293479, 0.17829, -0.293836, -0.499868, -0.336, 0.588949, 0.0357, 0.393709, -0.215125, -0.28694, -0.264146, -0.871409,
+                              -1.160788, 0.752398, -0.054771, 0.554518, -0.559022, 0.633359, -0.150176, 0.020715, -0.23028, 0.185878, -0.219888, -1.531753,
+                              -0.833134, -0.168312, -2.27768, 1.136705, 0.093996, 1.672507, 1.29167, 1.49679, 0.423603, 0.249344, -0.832107, -2.778636])
+
+
+init_class_betas = [np.array([0.441269, 0.448334, 0.288787, 0.35502, 0.216816, 0.198564, 0.069477,
+                              0.346543, 0.233089, 0.323059, 0.333928, 0.149546, 0.124614, 0.0443181,
+                              -0.00741137, 0.036144, -0.00298227, 0.140595, 0.046312]), #Class 1
+                    np.array([0.801542, 0.483616, 0.546757, 0.498264, 0.206961, 0.367382, 0.00124702,
+                              0.587733, 0.398037, 0.5319, 0.369294, 0.246564, -0.100532, -0.141248,
+                              -0.019849, 0.038627, -0.104714, 0.173183, 0.0905047]), #Class 2
+                    np.array([1.28245, 0.704765, 0.8016, 0.145479, 0.340825, 0.554092, -0.0942558,
+                              12.6054, 83.2791, 27.7743, -14.1763, 26.7106, 21.6308, -2.87297,
+                              -32.6663, 0.528885, 0.375195, 0.367734, 0.343927]), #Class 3
+                    np.array([1.18916, 0.562234, 0.58024, -0.00850272, 0.122827, 0.619118, 0.0330975,
+                              0.970455, 0.24954, 0.698946, 0.172871, 0.64793, -0.395843, 0.00472563,
+                              -0.425557, 0.157351, 0.0453663, 0.194574, 0.0677801]), #Class 4
+                    np.array([0, 0, 0, 0, 0, 0, 0,
+                              0, 0, 0, 0, 0, 0, 0,
+                              0, 0, 0, 0, 0])] #Class 5
+                
+bounds_thetas = ((-1.321318, -1.321318), (-0.254239, -0.254239), (-0.137624, -0.137624), (-9.159877, -9.159877), (0.009594, 0.009594), (1.189211, 1.189211), (-0.084255, -0.084255), (0.437849, 0.437849), (0.222736, 0.222736), (-2.338727,-2.338727), (-0.220732, -0.220732), (0.206103,0.206103),
+                 (0.293479, 0.293479), (0.17829, 0.17829), (-0.293836, -0.293836), (-0.499868, -0.499868), (-0.336, -0.336), (0.588949, 0.588949), (0.0357, 0.0357), (0.393709, 0.393709), (-0.215125, -0.215125), (-0.28694,-0.28694), (-0.264146, -0.264146), (-0.871409,-0.871409),
+                 (-1.160788, -1.160788), (0.752398, 0.752398), (-0.054771, -0.054771), (0.554518, 0.554518), (-0.559022, -0.559022), (0.633359, 0.633359), ( -0.150176,  -0.150176), (0.020715, 0.020715), (-0.23028, -0.23028), (0.185878,0.185878), (-0.219888, -0.219888), (-1.531753, -1.531753),
+                 (-0.833134, -0.833134), (-0.168312, -0.168312), (-2.27768, -2.27768), (1.136705, 1.136705), (0.093996, 0.093996), (1.672507, 1.672507), (1.29167, 1.29167), (1.49679, 1.49679), (0.423603, 0.423603), (0.249344, 0.249344), (-0.832107, -0.832107), (-2.778636, -2.778636))
+bounds_betas = [((-100, 100), (-100, 100) , (-100, 100) , (-100, 100) , (-100, 100) , (-100, 100) , (-100, 100),
+                 (-100, 100), (-100, 100) , (-100, 100) , (-100, 100) , (-100, 100) , (-100, 100) , (-100, 100),
+                 (-100, 100), (-100, 100) , (-100, 100) , (-100, 100) , (-100, 100) ,),
+                ((-100, 100), (-100, 100) , (-100, 100) , (-100, 100) , (-100, 100) , (-100, 100) , (-100, 100),
+                 (-100, 100), (-100, 100) , (-100, 100) , (-100, 100) , (-100, 100) , (-100, 100) , (-100, 100),
+                 (-100, 100), (-100, 100) , (-100, 100) , (-100, 100) , (-100, 100) ,),
+                ((-100, 100), (-100, 100) , (-100, 100) , (-100, 100) , (-100, 100) , (-100, 100) , (-100, 100),
+                 (-100, 100), (-100, 100) , (-100, 100) , (-100, 100) , (-100, 100) , (-100, 100) , (-100, 100),
+                 (-100, 100), (-100, 100) , (-100, 100) , (-100, 100) , (-100, 100) ,),
+                ((-100, 100), (-100, 100) , (-100, 100) , (-100, 100) , (-100, 100) , (-100, 100) , (-100, 100),
+                 (-100, 100), (-100, 100) , (-100, 100) , (-100, 100) , (-100, 100) , (-100, 100) , (-100, 100),
+                 (-100, 100), (-100, 100) , (-100, 100) , (-100, 100) , (-100, 100) ,),
+                ((-100, 100), (-100, 100) , (-100, 100) , (-100, 100) , (-100, 100) , (-100, 100) , (-100, 100),
+                 (-100, 100), (-100, 100) , (-100, 100) , (-100, 100) , (-100, 100) , (-100, 100) , (-100, 100),
+                 (-100, 100), (-100, 100) , (-100, 100) , (-100, 100) , (-100, 100) ,),]
+
+
+
+model.setup(X, y, ids=df['CHID'].values, panels=df['indID'].values,
+          varnames=varnames,
+          num_classes=5,
+          class_params_spec=class_params_spec,
+          member_params_spec=member_params_spec,
+            init_class_betas=init_class_betas,
+            init_class_thetas = init_class_thetas,
+          alts=[1,2],
+          ftol_lccm=1e-4,
+          gtol=1e-5,
+          #verbose = 2
+          )
+model.reassign_penalty(0.05)
+model.fit()
+model.summarise()
+

old_code/boxcox_functions.py

@@ -0,0 +1,116 @@
+"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+FUNCTIONS FOR BOX-COX TRANSFORMATION
+"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+
+''' ----------------------------------------------------------- '''
+'''  MAIN PARAMETERS:                                           '''
+''' ----------------------------------------------------------- '''
+#  X_matrix: Matrix to transform / array-like
+#  lmdas: lambda parameters for boxcox transformation/ array-like
+#  bxcx_X: Matrix after boxcox transformation / array-like
+
+''' ---------------------------------------------------------- '''
+''' LIBRARIES                                                  '''
+''' ---------------------------------------------------------- '''
+import numpy as np
+
+''' ---------------------------------------------------------- '''
+''' CONSTANTS                                                  '''
+''' ---------------------------------------------------------- '''
+min_val = 1e-30  # Define smallest value
+
+''' ---------------------------------------------------------- '''
+''' FUNCTION                                                   '''
+''' ---------------------------------------------------------- '''
+def truncate_lower(x, minval):
+    x[np.where(x < minval)] = minval
+    return x
+
+def truncate_higher(x, maxval):
+    x[np.where(x > maxval)] = maxval
+    return x
+
+def truncate(x, minval, maxval): # {
+    x = truncate_lower(x, minval)
+    x = truncate_higher(x, maxval)
+    return x
+# }
+
+''' ---------------------------------------------------------- '''
+''' Function. x is an ndarray, lamda is a scalar               '''
+''' ---------------------------------------------------------- '''
+def transform(x, lmda):
+# {
+    if lmda == 0:
+        #return np.log(x)
+        return np.log1p(x)
+    else:
+        val = (np.power(x, lmda) - 1) / lmda
+        return np.nan_to_num(val)
+# }
+
+''' ---------------------------------------------------------- '''
+''' Function. x is an ndarray, lamda is a scalar               '''
+''' ---------------------------------------------------------- '''
+def transform_derivative(x, lmda):
+# {
+    """ Derivative of log likelihood with respect to lmda """
+    ln_x = np.log1p(x) # Evaluate ln(1+x) because elements of x are close to zero
+    # Note: original code was ln_x = np.log(x)
+
+    if lmda == 0:
+        return 0.5*(ln_x)**2  # i.e., 0.5 * ln(x)^2
+    else:
+    # {
+        x_lmda = np.nan_to_num(np.power(x, lmda))
+        val = (lmda * x_lmda * ln_x - x_lmda + 1) / np.power(lmda, 2)
+        return np.nan_to_num(val) # Return zero
+    # }
+# }
+
+def prep(X_matrix, lmdas):
+# {
+    lmdas = truncate(lmdas, -5, 5)
+    X_matrix = truncate_lower(X_matrix, min_val)
+    bxcx = np.zeros_like(X_matrix)  # initialise to zero
+    bxcx = bxcx.astype("float64") # cast each element as a float
+    return X_matrix, lmdas, bxcx
+# }
+
+''' ---------------------------------------------------------- '''
+''' Function.Returns boxcox transformed matrix                 '''
+''' ---------------------------------------------------------- '''
+def boxcox_transformation(X_matrix, lmdas):
+# {
+    X_matrix, lmdas, bxcx_X = prep(X_matrix, lmdas)
+    for i, lmda in enumerate(lmdas):
+        bxcx_X[:, :, i] = transform(X_matrix[:, :, i], lmda)
+    return bxcx_X
+# }
+
+def boxcox_transformation_mixed(X_matrix, lmdas):
+# {
+    X_matrix, lmdas, bxcx_X = prep(X_matrix, lmdas)
+    for i, lmda in enumerate(lmdas):
+        bxcx_X[:, :, :, i] = transform(X_matrix[:, :, :, i], lmda)
+    return bxcx_X
+# }
+
+''' ---------------------------------------------------------------------- '''
+''' Function. Estimate derivative of boxcox transformation parameter (lambda)'''
+''' ---------------------------------------------------------------------- '''
+def boxcox_param_deriv(X_matrix, lmdas):
+# {
+    X_matrix, lmdas, der_bxcx_X = prep(X_matrix, lmdas)
+    for i, lmda in enumerate(lmdas):
+        der_bxcx_X[:, :, i] = transform_derivative(X_matrix[:, :, i], lmda)
+    return der_bxcx_X
+# }
+
+def boxcox_param_deriv_mixed(X_matrix, lmdas):
+# {
+    X_matrix, lmdas, der_bxcx_X = prep(X_matrix, lmdas)
+    for i, lmda in enumerate(lmdas):
+        der_bxcx_X[:, :, :, i] = transform_derivative(X_matrix[:, :, :, i], lmda)
+    return der_bxcx_X
+# }

old_code/draws.py

@@ -0,0 +1,128 @@
+import numpy as np
+import scipy.stats as ss
+
+class Draws:
+    ''' ---------------------------------------------------------- '''
+    ''' Class. Generate draws based on the given mixing distributions '''
+    ''' ---------------------------------------------------------- '''
+    def __init__(self, k = 0, halton = 1, rvdist=None, rvtransdist=None):  # {
+    # {
+        self.k = k  # Number of random variables
+        self.fn_generate_draws = self.generate_draws_halton if halton else self.generate_draws_random
+        if rvdist is None:
+            rvdist = ['n'] * k
+        if rvtransdist is None:
+            rvtransdist = ['n'] * k
+        self.rvdist = rvdist
+        self.rvtransdist = rvtransdist
+    # }
+
+    ''' ---------------------------------------------------------------- '''
+    ''' Function. Generate draws based on the given mixing distributions '''
+    ''' ---------------------------------------------------------------- '''
+    def generate_draws(self, sample_size, n_draws, halton=True, chol_mat=None):
+    # {
+        args = (sample_size, n_draws)
+        draws, drawstrans = self.fn_generate_draws(*args)
+
+        # Filter out any False values from the lists
+        self.rvdist = [item for item in self.rvdist if item is not False]
+        self.rvtransdist = [item for item in self.rvtransdist if item is not False]
+        draws = self.evaluate_distribution(self.rvdist, draws)  # Evaluate distributions
+        draws = np.atleast_3d(draws)
+        drawstrans = self.evaluate_distribution(self.rvtransdist, drawstrans)     # Evaluate distributions
+        drawstrans = np.atleast_3d(drawstrans)
+        return draws, drawstrans  # (N,Kr,R)
+    # }
+
+    ''' ---------------------------------------------------------------- '''
+    ''' Function.                                                        '''
+    ''' ---------------------------------------------------------------- '''
+    def evaluate_distribution(self, distr, values):
+    # {
+        for k, distr_k in enumerate(distr):  # {
+
+            if distr_k in ['n', 'ln', 'tn']:  # Normal based
+                values[:, k, :] = ss.norm.ppf(values[:, k, :])
+            elif distr_k == 't':  # Triangular
+            # {
+                values_k = values[:, k, :]
+
+                # This code transforms elements based on whether the corresponding elements
+                # in values_k are less than or equal to 0.5 or greater than 0.5.
+                values[:, k, :] = (np.sqrt(2 * values_k) - 1) * (values_k <= .5) + \
+                                  (1 - np.sqrt(2 * (1 - values_k))) * (values_k > .5)
+            # }
+            elif distr_k == 'u':  # Uniform
+                values[:, k, :] = 2 * values[:, k, :] - 1
+        # }
+        return values
+    # }
+
+    ''' ---------------------------------------------------------- '''
+    ''' Function. Generate random uniform draws between 0 and 1    '''
+    ''' ---------------------------------------------------------- '''
+    def get_random_draws(self, sample_size, n_draws, n_vars):  # {
+        return np.random.uniform(size=(sample_size, n_vars, n_draws))
+    # }
+
+    ''' -------------------------------------------------------------- '''
+    ''' Function. Generate Halton draws for multiple random variables  '''
+    ''' using different primes as base                                 '''
+    ''' -------------------------------------------------------------- '''
+    def generate_halton_draws(self, sample_size, n_draws, n_vars, shuffled=False, drop=100, primes=None):
+    # {
+        if primes is None:  # {
+            primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47,
+                      53, 59, 61, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109,
+                      113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173,
+                      179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233,
+                      239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293,
+                      307, 311]
+        # }
+
+        draws = [self.halton_seq(sample_size * n_draws, prime=primes[i % len(primes)],
+            shuffled=shuffled, drop=drop).reshape(sample_size, n_draws) for i in range(n_vars)]
+        draws = np.stack(draws, axis=1)
+        return draws  # (N,Kr,R)
+    # }
+
+    ''' ---------------------------------------------------------- '''
+    ''' Function. Generates a halton sequence efficiently          '''
+    ''' ---------------------------------------------------------- '''
+    def halton_seq(self, length, prime=3, drop=100, shuffled=False):
+    # {
+        """ Memory is efficiently handled by creating a single array ``seq`` that is iteratively
+        filled without using intermediate arrays. """
+
+        # This code generates a sequence based on a prime number and then optionally shuffles it
+        req_length = length + drop
+        seq = np.zeros(req_length)
+        seq_idx, t = 1, 1
+        while seq_idx < req_length:
+        # {
+            d = 1/prime**t  # Calculate the decrement based on the prime number and t
+            seq_size = seq_idx # Keep track of the current size of the sequence
+
+            # Iterate over the sequence to fill it
+            for i in range(1, prime):
+            # {
+                if seq_idx >= req_length: break
+
+                # Calculate the maximum sequence to copy based on the remaining length
+                max_seq = min(req_length - seq_idx, seq_size)
+
+                # Fill the sequence with the new values
+                seq[seq_idx: seq_idx+max_seq] = seq[:max_seq] + d*i
+
+                # Update the sequence index
+                seq_idx += max_seq
+                i += 1
+            # }
+            t += 1  # Increment t for the next iteration
+        # }
+        seq = seq[drop:length+drop] # Trim the sequence to the desired length
+        if shuffled: # Shuffle the sequence if required
+            np.random.shuffle(seq)
+        return seq
+    # }