huff 1.5.0__py3-none-any.whl → 1.5.2__py3-none-any.whl

huff/models.py

@@ -4,8 +4,8 @@
 # Author:      Thomas Wieland 
 #              ORCID: 0000-0001-5168-9846
 #              mail: geowieland@googlemail.com              
-# Version:     1.5.0
-# Last update: 2025-06-25 18:32
+# Version:     1.5.2
+# Last update: 2025-07-02 21:09
 # Copyright (c) 2025 Thomas Wieland
 #-----------------------------------------------------------------------
 
@@ -528,15 +528,23 @@ class InteractionMatrix:
         if supply_locations_metadata["weighting"][0]["func"] is None and supply_locations_metadata["weighting"][0]["param"] is None:
             print("Attraction          not defined")
         else:
-            print("Attraction          " + str(round(supply_locations_metadata["weighting"][0]["param"],3)) + " (" + supply_locations_metadata["weighting"][0]["func"] + ")")
+            if supply_locations_metadata["weighting"][0]["param"] is not None:
+                print("Attraction          " + str(round(supply_locations_metadata["weighting"][0]["param"],3)) + " (" + supply_locations_metadata["weighting"][0]["func"] + ")")
+            else:
+                print("Attraction          NA" + " (" + supply_locations_metadata["weighting"][0]["func"] + ")")   
 
         if customer_origins_metadata["weighting"][0]["func"] is None and customer_origins_metadata["weighting"][0]["param"] is None:
             print("Transport costs     not defined")
         elif customer_origins_metadata["weighting"][0]["func"] in ["power", "exponential"]:
-            print("Transport costs    " + str(round(customer_origins_metadata["weighting"][0]["param"],3)) + " (" + customer_origins_metadata["weighting"][0]["func"] + ")")
+            if customer_origins_metadata["weighting"][0]["param"] is not None:
+                print("Transport costs     " + str(round(customer_origins_metadata["weighting"][0]["param"],3)) + " (" + customer_origins_metadata["weighting"][0]["func"] + ")")
+            else:
+                print("Transport costs     NA" + " (" + customer_origins_metadata["weighting"][0]["func"] + ")")
         elif customer_origins_metadata["weighting"][0]["func"] == "logistic":
-            print("Transport costs    " + str(round(customer_origins_metadata["weighting"][0]["param"][0],3)) + ", " + str(round(customer_origins_metadata["weighting"][0]["param"][1],3)) + " (" + customer_origins_metadata["weighting"][0]["func"] + ")")
-      
+            if customer_origins_metadata["weighting"][0]["param"] is not None:
+                print("Transport costs    " + str(round(customer_origins_metadata["weighting"][0]["param"][0],3)) + ", " + str(round(customer_origins_metadata["weighting"][0]["param"][1],3)) + " (" + customer_origins_metadata["weighting"][0]["func"] + ")")
+            else:
+                print("Transport costs     NA" + " (" + customer_origins_metadata["weighting"][0]["func"] + ")")
 
         attrac_vars = supply_locations_metadata["attraction_col"]
         attrac_vars_no = len(attrac_vars)
@@ -553,12 +561,25 @@ class InteractionMatrix:
                     print(f"{attrac_vars[key][:16]:16}    not defined")
                     
                 else:
+                    
+                    if supply_locations_metadata["weighting"][key]["func"] is None and supply_locations_metadata["weighting"][key]["param"]:
+                        
+                        print(f"{attrac_vars[key][:16]:16}    not defined")
 
-                    name = supply_locations_metadata["weighting"][key]["name"]
-                    param = supply_locations_metadata["weighting"][key]["param"]
-                    func = supply_locations_metadata["weighting"][key]["func"]
+                    else:
+
+                        if supply_locations_metadata["weighting"][key]["param"] is not None:
+
+                            name = supply_locations_metadata["weighting"][key]["name"]
+                            param = supply_locations_metadata["weighting"][key]["param"]
+                            func = supply_locations_metadata["weighting"][key]["func"]
+                            
+                            print(f"{name[:16]:16}    {round(param, 3)} ({func})")
+
+                        else:
+
+                            print(f"{attrac_vars[key][:16]:16}    NA" + " (" + supply_locations_metadata["weighting"][0]["func"] + ")") 
 
-                    print(f"{name[:16]:16}    {round(param, 3)} ({func})")
 
         print("----------------------------------")
 
@@ -566,6 +587,8 @@ class InteractionMatrix:
             print("Parameter estimation")
             print("Fit function        " + interaction_matrix_metadata["fit"]["function"])
             print("Fit by              " + interaction_matrix_metadata["fit"]["fit_by"])
+            if interaction_matrix_metadata["fit"]["function"] == "huff_ml_fit":
+                print("Fit method          " + interaction_matrix_metadata["fit"]["method"] + " (Converged: " + str(interaction_matrix_metadata["fit"]["minimize_success"]) + ")")
 
     def transport_costs(
         self,
@@ -688,7 +711,8 @@ class InteractionMatrix:
         vars_funcs = {
             0: {
                 "name": "A_j",
-                "func": "power"
+                "func": "power",
+                "param": 1
             },
             1: {
                 "name": "t_ij",
@@ -711,9 +735,13 @@ class InteractionMatrix:
 
         supply_locations_metadata["weighting"][0]["name"] = vars_funcs[0]["name"]
         supply_locations_metadata["weighting"][0]["func"] = vars_funcs[0]["func"]
+        if "param" in vars_funcs[0]:
+            supply_locations_metadata["weighting"][0]["param"] = vars_funcs[0]["param"]
     
         customer_origins_metadata["weighting"][0]["name"] = vars_funcs[1]["name"]
         customer_origins_metadata["weighting"][0]["func"] = vars_funcs[1]["func"]
+        if "param" in vars_funcs[1]:
+            customer_origins_metadata["weighting"][0]["param"] = vars_funcs[1]["param"]
 
         if len(vars_funcs) > 2:
             
@@ -731,7 +759,9 @@ class InteractionMatrix:
 
                 supply_locations_metadata["weighting"][key-1]["name"] = var["name"]
                 supply_locations_metadata["weighting"][key-1]["func"] = var["func"]
-                supply_locations_metadata["weighting"][key-1]["param"] = None
+
+                if "param" in var:
+                    supply_locations_metadata["weighting"][key-1]["param"] = var["param"]
 
         self.supply_locations.metadata = supply_locations_metadata
         self.customer_origins.metadata = customer_origins_metadata
@@ -876,7 +906,8 @@ class InteractionMatrix:
         
         check_vars(
             df = interaction_matrix_df,
-            cols = ["E_ij"]
+            cols = ["E_ij"],
+            check_zero = False
             )
         
         market_areas_df = pd.DataFrame(interaction_matrix_df.groupby("j")["E_ij"].sum())
@@ -1057,7 +1088,8 @@ class InteractionMatrix:
         if len(params) < 2:
             raise ValueError("Parameter 'params' must be a list or np.ndarray with at least 2 parameter values")
         
-        customer_origins_metadata = self.customer_origins.get_metadata()
+        customer_origins = self.customer_origins
+        customer_origins_metadata = customer_origins.get_metadata()
         
         param_gamma, param_lambda = params[0], params[1]
             
@@ -1071,10 +1103,7 @@ class InteractionMatrix:
         interaction_matrix_df = self.interaction_matrix_df
         
         supply_locations = self.supply_locations
-        supply_locations_metadata = supply_locations.get_metadata()
-
-        customer_origins = self.customer_origins
-        customer_origins_metadata = customer_origins.get_metadata()
+        supply_locations_metadata = supply_locations.get_metadata()        
 
         supply_locations_metadata["weighting"][0]["param"] = float(param_gamma)
         supply_locations.metadata = supply_locations_metadata
@@ -1119,8 +1148,15 @@ class InteractionMatrix:
 
         customer_origins.metadata = customer_origins_metadata
 
-        p_ij_emp = interaction_matrix_df["p_ij"]
-        E_ij_emp = interaction_matrix_df["E_ij"]         
+        if "p_ij_emp" not in interaction_matrix_df.columns:
+            p_ij_emp = interaction_matrix_df["p_ij"]
+        else:
+            p_ij_emp = interaction_matrix_df["p_ij_emp"]
+
+        if "E_ij_emp" not in interaction_matrix_df.columns:
+            E_ij_emp = interaction_matrix_df["E_ij"]         
+        else:
+            E_ij_emp = interaction_matrix_df["E_ij_emp"]
         
         interaction_matrix_copy = copy.deepcopy(self)
 
@@ -1144,10 +1180,12 @@ class InteractionMatrix:
             observed = p_ij_emp
             expected = p_ij
         
-        LL = loglik(
+        modelfit_metrics = modelfit(
             observed = observed,
             expected = expected
-            )        
+        )
+
+        LL = modelfit_metrics[1]["LL"]       
        
         return -LL
     
@@ -1171,7 +1209,10 @@ class InteractionMatrix:
             params_metadata_customer_origins = 1            
         else:            
             if customer_origins_metadata["weighting"][0]["param"] is not None:
-                params_metadata_customer_origins = len(customer_origins_metadata["weighting"][0]["param"])
+                if isinstance(customer_origins_metadata["weighting"][0]["param"], (int, float)):
+                    params_metadata_customer_origins = 1
+                else:
+                    params_metadata_customer_origins = len(customer_origins_metadata["weighting"][0]["param"])
             
         if customer_origins_metadata["weighting"][0]["func"] == "logistic":
             params_metadata_customer_origins = 2
@@ -1251,45 +1292,57 @@ class InteractionMatrix:
             print(f"Optimization via {method} algorithm succeeded with parameters: {', '.join(str(round(par, 3)) for par in param_results)}.")
    
         else:
-
-            param_gamma = None
-            param_lambda = None
-            
-            supply_locations_metadata["weighting"][0]["param"] = param_gamma            
-            
-            if customer_origins_metadata["weighting"][0]["func"] == "logistic":
-                               
-                param_lambda2 = None                
-                customer_origins_metadata["weighting"][0]["param"][0] = param_lambda
-                customer_origins_metadata["weighting"][0]["param"][1] = param_lambda2
-            
-            else:
-                
-                customer_origins_metadata["weighting"][0]["param"] = param_lambda
                 
             print(f"Optimiziation via {method} algorithm failed with error message: '{ml_result.message}'. See https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize.html for all available algorithms.")
 
         self.supply_locations.metadata = supply_locations_metadata    
-        self.customer_origins.metadata = customer_origins_metadata
+        self.customer_origins.metadata = customer_origins_metadata       
         
-        if ml_result.success and update_estimates:
-            
-            self.metadata["fit"] = {
-                "function": "huff_ml_fit",
-                "fit_by": fit_by,
-                "initial_params": initial_params,
-                "method": method,
-                "bounds": bounds,
-                "constraints": constraints
-                }
+        if update_estimates:
+
+            if "p_ij_emp" not in self.interaction_matrix_df.columns:
                 
-            
-            self.interaction_matrix_df["p_ij_emp"] = self.interaction_matrix_df["p_ij"]
-            self.interaction_matrix_df["E_ij_emp"] = self.interaction_matrix_df["E_ij"]
-            
-            self = self.utility()
-            self = self.probabilities()
-            self = self.flows()            
+                self.interaction_matrix_df["p_ij_emp"] = self.interaction_matrix_df["p_ij"]
+                
+                print("NOTE: Probabilities in interaction matrix are treated as empirical probabilities")
+                
+            else:
+                
+                print("NOTE: Interaction matrix contains empirical probabilities")
+
+            if "E_ij_emp" not in self.interaction_matrix_df.columns:
+                
+                self.interaction_matrix_df["E_ij_emp"] = self.interaction_matrix_df["E_ij"]
+                
+                print("NOTE: Customer interactions in interaction matrix are treated as empirical interactions")
+                
+            else:
+                
+                print("NOTE: Interaction matrix contains empirical customer interactions")
+
+            if np.isnan(ml_result.x).any():
+
+                print("WARNING: No update of estimates because fit parameters contain NaN")
+
+                update_estimates = False
+
+            else:
+
+                self = self.utility()
+                self = self.probabilities()
+                self = self.flows()            
+        
+        self.metadata["fit"] = {
+            "function": "huff_ml_fit",
+            "fit_by": fit_by,
+            "initial_params": initial_params,
+            "method": method,
+            "bounds": bounds,
+            "constraints": constraints,
+            "minimize_success": ml_result.success,
+            "minimize_fittedparams": ml_result.x,
+            "update_estimates": update_estimates
+            }
         
         return self
 
@@ -1331,7 +1384,7 @@ class InteractionMatrix:
      
         if "transport_costs" not in interaction_matrix_metadata:
             
-            print("New destination(s) included. No transport costs calculation because not defined in original interaction matrix.")
+            print("WARNING: New destination(s) included. No transport costs calculation because not defined in original interaction matrix.")
             
             interaction_matrix_df = pd.concat(
                 [
@@ -1400,11 +1453,12 @@ class MarketAreas:
     
     def add_to_model(
         self,
-        model_object
+        model_object,
+        output_model = "Huff"
         ):
         
-        if not isinstance(model_object, (HuffModel, MCIModel)):
-            raise ValueError("Parameter 'interaction_matrix' must be of class HuffModel or MCIModel")
+        if not isinstance(model_object, (HuffModel, MCIModel, InteractionMatrix)):
+            raise ValueError("Parameter 'interaction_matrix' must be of class HuffModel,  MCIModel, or InteractionMatrix")
         
         if isinstance(model_object, MCIModel):
                         
@@ -1415,15 +1469,35 @@ class MarketAreas:
                 market_areas_df = self.market_areas_df
                 )            
     
-        if isinstance(model_object, HuffModel):
+        elif isinstance(model_object, HuffModel):
             
             model = HuffModel(
                 interaction_matrix = model_object.interaction_matrix,
                 market_areas_df = self.market_areas_df
             )
+
+        elif isinstance(model_object, InteractionMatrix):
+
+            if output_model not in ["Huff", "MCI"]:
+                raise ValueError("Parameter 'output_model' must be either 'Huff' or 'MCI'")
             
+            if output_model == "Huff":
+
+                model = HuffModel(
+                    interaction_matrix=model_object,
+                    market_areas_df=self.market_areas_df
+                )
+
+            if output_model == "MCI":
+
+                model = MCIModel(
+                    coefs=model_object.coefs,
+                    mci_ols_model=model_object.mci_ols_model,
+                    market_areas_df=self.market_areas_df
+                )
+
         return model
-            
+
 class HuffModel:
 
     def __init__(
@@ -1457,14 +1531,16 @@ class HuffModel:
         return customer_origins
 
     def get_market_areas_df(self):
+
         return self.market_areas_df
-    
+        
     def summary(self):
 
         interaction_matrix = self.interaction_matrix
 
         customer_origins_metadata = interaction_matrix.get_customer_origins().get_metadata()
         supply_locations_metadata = interaction_matrix.get_supply_locations().get_metadata()
+        interaction_matrix_metadata = interaction_matrix.get_metadata()
 
         print("Huff Model")
         print("----------------------------------")
@@ -1486,14 +1562,23 @@ class HuffModel:
         if supply_locations_metadata["weighting"][0]["func"] is None and supply_locations_metadata["weighting"][0]["param"] is None:
             print("Attraction          not defined")
         else:
-            print("Attraction          " + str(round(supply_locations_metadata["weighting"][0]["param"], 3)) + " (" + supply_locations_metadata["weighting"][0]["func"] + ")")
+            if supply_locations_metadata["weighting"][0]["param"] is not None:
+                print("Attraction          " + str(round(supply_locations_metadata["weighting"][0]["param"],3)) + " (" + supply_locations_metadata["weighting"][0]["func"] + ")")
+            else:
+                print("Attraction          NA" + " (" + supply_locations_metadata["weighting"][0]["func"] + ")")   
 
         if customer_origins_metadata["weighting"][0]["func"] is None and customer_origins_metadata["weighting"][0]["param"] is None:
             print("Transport costs     not defined")
         elif customer_origins_metadata["weighting"][0]["func"] in ["power", "exponential"]:
-            print("Transport costs    " + str(round(customer_origins_metadata["weighting"][0]["param"],3)) + " (" + customer_origins_metadata["weighting"][0]["func"] + ")")
+            if customer_origins_metadata["weighting"][0]["param"] is not None:
+                print("Transport costs     " + str(round(customer_origins_metadata["weighting"][0]["param"],3)) + " (" + customer_origins_metadata["weighting"][0]["func"] + ")")
+            else:
+                print("Transport costs     NA" + " (" + customer_origins_metadata["weighting"][0]["func"] + ")")
         elif customer_origins_metadata["weighting"][0]["func"] == "logistic":
-            print("Transport costs    " + str(round(customer_origins_metadata["weighting"][0]["param"][0],3)) + ", " + str(round(customer_origins_metadata["weighting"][0]["param"][1],3)) + " (" + customer_origins_metadata["weighting"][0]["func"] + ")")
+            if customer_origins_metadata["weighting"][0]["param"] is not None:
+                print("Transport costs    " + str(round(customer_origins_metadata["weighting"][0]["param"][0],3)) + ", " + str(round(customer_origins_metadata["weighting"][0]["param"][1],3)) + " (" + customer_origins_metadata["weighting"][0]["func"] + ")")
+            else:
+                print("Transport costs     NA" + " (" + customer_origins_metadata["weighting"][0]["func"] + ")")
 
         attrac_vars = supply_locations_metadata["attraction_col"]
         attrac_vars_no = len(attrac_vars)
@@ -1518,39 +1603,46 @@ class HuffModel:
                     print(f"{name[:16]:16}    {round(param, 3)} ({func})")
                     
         print("----------------------------------")
-        
-        huff_modelfit = self.modelfit()
-        if huff_modelfit is not None:
+
+        if interaction_matrix_metadata != {} and "fit" in interaction_matrix_metadata and interaction_matrix_metadata["fit"]["function"] is not None:
+            print("Parameter estimation")
+            print("Fit function        " + interaction_matrix_metadata["fit"]["function"])
+            print("Fit by              " + interaction_matrix_metadata["fit"]["fit_by"])
+            if interaction_matrix_metadata["fit"]["function"] == "huff_ml_fit":
+                print("Fit method          " + interaction_matrix_metadata["fit"]["method"] + " (Converged: " + str(interaction_matrix_metadata["fit"]["minimize_success"]) + ")")
+
+            huff_modelfit = self.modelfit(by = interaction_matrix_metadata["fit"]["fit_by"])
             
-            print ("Goodness-of-fit for probabilities")
+            if huff_modelfit is not None:
+                
+                print ("Goodness-of-fit for " + interaction_matrix_metadata["fit"]["fit_by"])
+                        
+                print("Sum of squared residuals       ", round(huff_modelfit[1]["SQR"], 2))
+                print("R-squared                      ", round(huff_modelfit[1]["Rsq"], 2))
+                print("Mean squared error             ", round(huff_modelfit[1]["MSE"], 2))
+                print("Root mean squared error        ", round(huff_modelfit[1]["RMSE"], 2))
+                print("Mean absolute error            ", round(huff_modelfit[1]["MAE"], 2))
+                if huff_modelfit[1]["MAPE"] is not None:
+                    print("Mean absolute percentage error ", round(huff_modelfit[1]["MAPE"], 2))
+                else:
+                    print("Mean absolute percentage error  Not calculated")
+                print("Symmetric MAPE                 ", round(huff_modelfit[1]["sMAPE"], 2))
+                print("Absolute percentage errors")
+                
+                APE_list = [
+                    ["< 5 % ", round(huff_modelfit[1]["APE"]["resid_below5"], 2), "  < 30 % ", round(huff_modelfit[1]["APE"]["resid_below30"], 2)],
+                    ["< 10 % ", round(huff_modelfit[1]["APE"]["resid_below10"], 2), "  < 35 % ", round(huff_modelfit[1]["APE"]["resid_below35"], 2)],
+                    ["< 15 % ", round(huff_modelfit[1]["APE"]["resid_below15"], 2), "  < 40 % ", round(huff_modelfit[1]["APE"]["resid_below40"], 2)],
+                    ["< 20 % ", round(huff_modelfit[1]["APE"]["resid_below20"], 2), "  < 45 % ", round(huff_modelfit[1]["APE"]["resid_below45"], 2)],
+                    ["< 25% ", round(huff_modelfit[1]["APE"]["resid_below25"], 2), "  < 50 % ", round(huff_modelfit[1]["APE"]["resid_below50"], 2)]
+                    ]
+                APE_df = pd.DataFrame(
+                    APE_list,
+                    columns=["Resid.", "%", "Resid.", "%"]
+                    )
+                print(APE_df.to_string(index=False))
                     
-            print("Sum of squared residuals       ", round(huff_modelfit[1]["SQR"], 2))
-            print("Sum of squares                 ", round(huff_modelfit[1]["SQT"], 2))
-            print("R-squared                      ", round(huff_modelfit[1]["Rsq"], 2))
-            print("Mean squared error             ", round(huff_modelfit[1]["MSE"], 2))
-            print("Root mean squared error        ", round(huff_modelfit[1]["RMSE"], 2))
-            print("Mean absolute error            ", round(huff_modelfit[1]["MAE"], 2))
-            if huff_modelfit[1]["MAPE"] is not None:
-                print("Mean absolute percentage error ", round(huff_modelfit[1]["MAPE"], 2))
-            else:
-                print("Mean absolute percentage error  Not calculated")
-            print("Symmetric MAPE                 ", round(huff_modelfit[1]["sMAPE"], 2))
-            print("Absolute percentage errors")
-            
-            APE_list = [
-                ["< 5 % ", round(huff_modelfit[1]["APE"]["resid_below5"], 2), "  < 30 % ", round(huff_modelfit[1]["APE"]["resid_below30"], 2)],
-                ["< 10 % ", round(huff_modelfit[1]["APE"]["resid_below10"], 2), "  < 35 % ", round(huff_modelfit[1]["APE"]["resid_below35"], 2)],
-                ["< 15 % ", round(huff_modelfit[1]["APE"]["resid_below15"], 2), "  < 40 % ", round(huff_modelfit[1]["APE"]["resid_below40"], 2)],
-                ["< 20 % ", round(huff_modelfit[1]["APE"]["resid_below20"], 2), "  < 45 % ", round(huff_modelfit[1]["APE"]["resid_below45"], 2)],
-                ["< 25% ", round(huff_modelfit[1]["APE"]["resid_below25"], 2), "  < 50 % ", round(huff_modelfit[1]["APE"]["resid_below50"], 2)]
-                ]
-            APE_df = pd.DataFrame(
-                APE_list,
-                columns=["Resid.", "%", "Resid.", "%"]
-                )
-            print(APE_df.to_string(index=False))
-                  
-            print("----------------------------------")
+                print("----------------------------------")
 
     def mci_fit(
         self,
@@ -1642,6 +1734,287 @@ class HuffModel:
         
         return mci_model
 
+    def loglik(
+        self,
+        params
+        ):
+
+        if not isinstance(params, list):
+            if isinstance(params, np.ndarray):
+                params = params.tolist()
+            else:
+                raise ValueError("Parameter 'params' must be a list or np.ndarray with at least 2 parameter values")
+        
+        if len(params) < 2:
+            raise ValueError("Parameter 'params' must be a list or np.ndarray with at least 2 parameter values")
+        
+        market_areas_df = self.market_areas_df
+        
+        customer_origins = self.interaction_matrix.customer_origins
+        customer_origins_metadata = customer_origins.get_metadata()
+        
+        param_gamma, param_lambda = params[0], params[1]
+            
+        if customer_origins_metadata["weighting"][0]["func"] == "logistic":
+            
+            if len(params) < 3:
+                raise ValueError("When using logistic weighting, parameter 'params' must be a list or np.ndarray with at least 3 parameter values")
+        
+            param_gamma, param_lambda, param_lambda2 = params[0], params[1], params[2]
+
+        supply_locations = self.interaction_matrix.supply_locations
+        supply_locations_metadata = supply_locations.get_metadata()        
+
+        supply_locations_metadata["weighting"][0]["param"] = float(param_gamma)
+        supply_locations.metadata = supply_locations_metadata
+
+        if customer_origins_metadata["weighting"][0]["func"] in ["power", "exponential"]:
+            
+            if len(params) >= 2:
+
+                customer_origins_metadata["weighting"][0]["param"] = float(param_lambda)
+            
+            else:
+                
+                raise ValueError ("Huff Model with transport cost weighting of type " + customer_origins_metadata["weighting"][0]["func"] + " must have >= 2 input parameters")
+        
+        elif customer_origins_metadata["weighting"][0]["func"] == "logistic":
+            
+            if len(params) >= 3:
+                
+                customer_origins_metadata["weighting"][0]["param"] = [float(param_lambda), float(param_lambda2)]
+            
+            else:
+
+                raise ValueError("Huff Model with transport cost weightig of type " + customer_origins_metadata["weighting"][0]["func"] + " must have >= 3 input parameters")
+
+        if (customer_origins_metadata["weighting"][0]["func"] in ["power", "exponential"] and len(params) > 2): 
+            
+            for key, param in enumerate(params):
+
+                if key <= 1:
+                    continue
+
+                supply_locations_metadata["weighting"][key-1]["param"] = float(param)
+
+        if (customer_origins_metadata["weighting"][0]["func"] == "logistic" and len(params) > 3):
+
+            for key, param in enumerate(params):
+
+                if key <= 2:
+                    continue
+
+                supply_locations_metadata["weighting"][key-2]["param"] = float(param)
+
+        customer_origins.metadata = customer_origins_metadata        
+       
+        if "T_j_emp" not in market_areas_df.columns:
+            T_j_emp = market_areas_df["T_j"]
+        else:
+            T_j_emp = market_areas_df["T_j_emp"]
+
+
+        huff_model_copy = copy.deepcopy(self)
+
+        interaction_matrix_copy = copy.deepcopy(huff_model_copy.interaction_matrix)
+
+        interaction_matrix_copy = interaction_matrix_copy.utility()
+        interaction_matrix_copy = interaction_matrix_copy.probabilities()
+        interaction_matrix_copy = interaction_matrix_copy.flows()
+
+        huff_model_copy = interaction_matrix_copy.marketareas()
+
+        market_areas_df_copy = huff_model_copy.market_areas_df
+
+        observed = T_j_emp
+        expected = market_areas_df_copy["T_j"]
+        
+        modelfit_metrics = modelfit(
+            observed = observed,
+            expected = expected
+        )
+
+        LL = modelfit_metrics[1]["LL"]
+      
+        return -LL
+
+    def ml_fit(
+        self,
+        initial_params: list = [1.0, -2.0],
+        method: str = "L-BFGS-B",
+        bounds: list = [(0.5, 1), (-3, -1)],        
+        constraints: list = [],
+        fit_by = "probabilities",
+        update_estimates: bool = True,
+        check_numbers: bool = True
+        ):
+        
+        if fit_by in ["probabilities", "flows"]:
+
+            self.interaction_matrix.huff_ml_fit(
+                initial_params = initial_params,
+                method = method,
+                bounds = bounds,        
+                constraints = constraints,
+                fit_by = fit_by,
+                update_estimates = update_estimates
+                )
+        
+        elif fit_by == "totals":
+            
+            if check_numbers:
+                
+                market_areas_df = self.market_areas_df
+                interaction_matrix_df = self.get_interaction_matrix_df()
+                T_j_market_areas_df = sum(market_areas_df["T_j"])
+                T_j_interaction_matrix_df = sum(interaction_matrix_df["E_ij"])
+                
+                if T_j_market_areas_df != T_j_interaction_matrix_df:
+                    print("WARNING: Sum of total market areas (" + str(int(T_j_market_areas_df)) + ") is not equal to sum of customer flows (" + str(int(T_j_interaction_matrix_df)) + ")")
+            
+            supply_locations = self.interaction_matrix.supply_locations
+            supply_locations_metadata = supply_locations.get_metadata()
+        
+            customer_origins = self.interaction_matrix.customer_origins
+            customer_origins_metadata = customer_origins.get_metadata()
+
+            if customer_origins_metadata["weighting"][0]["param"] is None:            
+                params_metadata_customer_origins = 1            
+            else:            
+                if customer_origins_metadata["weighting"][0]["param"] is not None:
+                    if isinstance(customer_origins_metadata["weighting"][0]["param"], (int, float)):
+                        params_metadata_customer_origins = 1
+                    else:
+                        params_metadata_customer_origins = len(customer_origins_metadata["weighting"][0]["param"])
+            
+            if customer_origins_metadata["weighting"][0]["func"] == "logistic":
+                params_metadata_customer_origins = 2
+            else:
+                params_metadata_customer_origins = 1
+                
+            params_metadata_supply_locations = len(supply_locations_metadata["weighting"])
+            
+            params_metadata = params_metadata_customer_origins+params_metadata_supply_locations
+
+            if len(initial_params) < 2 or len(initial_params) != params_metadata:
+                raise ValueError("Parameter 'initial_params' must be a list with " + str(params_metadata) + " entries (Attaction: " + str(params_metadata_supply_locations) + ", Transport costs: " + str(params_metadata_customer_origins) + ")")
+            
+            if len(bounds) != len(initial_params):            
+                raise ValueError("Parameter 'bounds' must have the same length as parameter 'initial_params' (" + str(len(bounds)) + ", " + str(len(initial_params)) + ")")
+
+            ml_result = minimize(
+                self.loglik,
+                initial_params,
+                method = method,
+                bounds = bounds,
+                constraints = constraints,
+                options={'disp': 3}
+                )
+            
+            attrac_vars = len(supply_locations_metadata["weighting"])
+
+            if ml_result.success:
+                
+                fitted_params = ml_result.x
+                
+                param_gamma = fitted_params[0]
+                supply_locations_metadata["weighting"][0]["param"] = float(param_gamma)
+                
+                if customer_origins_metadata["weighting"][0]["func"] in ["power", "exponential"]:
+                                
+                    param_lambda = fitted_params[1]                
+                    param_results = [
+                        float(param_gamma), 
+                        float(param_lambda)
+                        ]
+                                    
+                    customer_origins_metadata["weighting"][0]["param"] = float(param_lambda)
+                    
+                elif customer_origins_metadata["weighting"][0]["func"] == "logistic":
+            
+                    param_lambda = fitted_params[1]
+                    param_lambda2 = fitted_params[2]                
+                    param_results = [
+                        float(param_gamma), 
+                        float(param_lambda), 
+                        float(param_lambda2)
+                        ]
+                    
+                    customer_origins_metadata["weighting"][0]["param"][0] = float(param_lambda)
+                    customer_origins_metadata["weighting"][0]["param"][1] = float(param_lambda2)
+                    
+                if attrac_vars > 1:
+
+                    if customer_origins_metadata["weighting"][0]["func"] == "logistic":
+                        fitted_params_add = 3
+                    else:
+                        fitted_params_add = 2 
+
+                    for key, var in supply_locations_metadata["weighting"].items():
+
+                        if key > len(supply_locations_metadata["weighting"])-fitted_params_add:
+                            break
+                        
+                        param = float(fitted_params[key+fitted_params_add])
+                        
+                        param_results = param_results + [param]
+
+                        supply_locations_metadata["weighting"][(key+1)]["param"] = float(param)
+                        
+                print(f"Optimization via {method} algorithm succeeded with parameters: {', '.join(str(round(par, 3)) for par in param_results)}.")
+    
+            else:
+                   
+                print(f"Optimiziation via {method} algorithm failed with error message: '{ml_result.message}'. See https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize.html for all available algorithms.")
+
+            self.interaction_matrix.supply_locations.metadata = supply_locations_metadata    
+            self.interaction_matrix.customer_origins.metadata = customer_origins_metadata
+
+            if update_estimates:
+
+                if "T_j_emp" not in self.market_areas_df.columns:
+
+                    self.market_areas_df["T_j_emp"] = self.market_areas_df["T_j"]
+                    
+                    print("NOTE: Total values in market areas df are treated as empirical total values")
+                
+                else:
+
+                    print("NOTE: Total market areas df contains empirical total values")
+
+                if np.isnan(ml_result.x).any():
+
+                    print("WARNING: No update of estimates because fit parameters contain NaN")
+
+                    update_estimates = False
+
+                else:
+                                       
+                    self.interaction_matrix.utility()
+                    self.interaction_matrix.probabilities()
+                    self.interaction_matrix.flows()                    
+                    
+                    huff_model_new_marketareas = self.interaction_matrix.marketareas()
+                    self.market_areas_df["T_j"] = huff_model_new_marketareas.get_market_areas_df()["T_j"]
+            
+            self.interaction_matrix.metadata["fit"] = {
+                "function": "huff_ml_fit",
+                "fit_by": fit_by,
+                "initial_params": initial_params,
+                "method": method,
+                "bounds": bounds,
+                "constraints": constraints,
+                "minimize_success": ml_result.success,
+                "minimize_fittedparams": ml_result.x,
+                "update_estimates": update_estimates
+                }
+            
+        else:
+
+            raise ValueError("Parameter 'fit_by' must be 'probabilities', 'flows' or 'totals'")
+
+        return self
+
     def update(self):
         
         self.interaction_matrix = self.interaction_matrix.update()
@@ -1652,31 +2025,92 @@ class HuffModel:
     
     def modelfit(
         self,
-        by = "p_ij"
-        ):
-        
-        interaction_matrix = self.interaction_matrix        
-        interaction_matrix_df = interaction_matrix.get_interaction_matrix_df()
+        by = "probabilities"
+        ):       
         
-        if (by in interaction_matrix_df.columns and by+"_emp" in interaction_matrix_df.columns):
+        if by == "probabilities":
+
+            interaction_matrix = self.interaction_matrix        
+            interaction_matrix_df = interaction_matrix.get_interaction_matrix_df()
+
+            if ("p_ij" in interaction_matrix_df.columns and "p_ij_emp" in interaction_matrix_df.columns):
+                
+                try:
+                
+                    huff_modelfit = modelfit(
+                        interaction_matrix_df["p_ij_emp"],
+                        interaction_matrix_df["p_ij"]
+                    )
+                    
+                    return huff_modelfit
+                    
+                except:
+                    
+                    print("WARNING: Goodness-of-fit metrics could not be calculated due to NaN values.")
+                    return None
             
-            try:
+            else:
+                
+                print("WARNING: Goodness-of-fit metrics could not be calculated. No empirical values of probabilities in interaction matrix.")
+
+                return None
             
-                huff_modelfit = modelfit(
-                    interaction_matrix_df[by+"_emp"],
-                    interaction_matrix_df[by]
-                )
+        elif by == "flows":
+
+            interaction_matrix = self.interaction_matrix        
+            interaction_matrix_df = interaction_matrix.get_interaction_matrix_df()
+
+            if ("E_ij" in interaction_matrix_df.columns and "E_ij_emp" in interaction_matrix_df.columns):
                 
-                return huff_modelfit
+                try:
                 
-            except:
+                    huff_modelfit = modelfit(
+                        interaction_matrix_df["E_ij_emp"],
+                        interaction_matrix_df["E_ij"]
+                    )
+                    
+                    return huff_modelfit
+                    
+                except:
+                    
+                    print("WARNING: Goodness-of-fit metrics could not be calculated due to NaN values.")
+                    return None
+            
+            else:
                 
-                print("Goodness-of-fit metrics could not be calculated due to NaN values.")
+                print("WARNING: Goodness-of-fit metrics could not be calculated. No empirical values of customer flows in interaction matrix.")
+
                 return None
-        
-        else:
             
-            return None
+        elif by == "totals":
+
+            market_areas_df = self.market_areas_df
+
+            if ("T_j" in market_areas_df.columns and "T_j_emp" in market_areas_df.columns):
+                
+                try:
+                
+                    huff_modelfit = modelfit(
+                        market_areas_df["T_j_emp"],
+                        market_areas_df["T_j"]
+                    )
+                    
+                    return huff_modelfit
+                    
+                except:
+                    
+                    print("WARNING: Goodness-of-fit metrics could not be calculated due to NaN values.")
+                    return None
+                
+            else:
+                
+                print("WARNING: Goodness-of-fit metrics could not be calculated. No empirical values of T_j in market areas data.")
+
+                return None
+
+        else:
+
+            raise ValueError("Parameter 'by' must be 'probabilities', 'flows', or 'totals'")
     
 class MCIModel:
 
@@ -1744,7 +2178,7 @@ class MCIModel:
                 
             except:
                 
-                print("Goodness-of-fit metrics could not be calculated due to NaN values.")
+                print("WARNING: Goodness-of-fit metrics could not be calculated due to NaN values.")
                 return None
         
         else:
@@ -1794,7 +2228,6 @@ class MCIModel:
             print ("Goodness-of-fit for probabilities")
                     
             print("Sum of squared residuals       ", round(mci_modelfit[1]["SQR"], 2))
-            print("Sum of squares                 ", round(mci_modelfit[1]["SQT"], 2))
             print("R-squared                      ", round(mci_modelfit[1]["Rsq"], 2))
             print("Mean squared error             ", round(mci_modelfit[1]["MSE"], 2))
             print("Root mean squared error        ", round(mci_modelfit[1]["RMSE"], 2))
@@ -1890,8 +2323,11 @@ class MCIModel:
         interaction_matrix = self.interaction_matrix        
         interaction_matrix_df = interaction_matrix.get_interaction_matrix_df()
         
-        if "p_ij" in interaction_matrix_df.columns:
+        if "p_ij" in interaction_matrix_df.columns and "p_ij_emp" not in interaction_matrix_df.columns:
+            print("NOTE: Probabilities in interaction matrix are treated as empirical probabilities")
             interaction_matrix_df["p_ij_emp"] = interaction_matrix_df["p_ij"]
+        else:
+            print("NOTE: Interaction matrix contains empirical probabilities")
 
         if "U_ij" not in interaction_matrix_df.columns:
             self.utility(transformation = transformation)
@@ -2666,7 +3102,8 @@ def get_isochrones(
 def modelfit(
     observed, 
     expected,
-    remove_nan: bool = True 
+    remove_nan: bool = True,
+    verbose: bool = False
     ):
 
     observed_no = len(observed)
@@ -2692,6 +3129,10 @@ def modelfit(
             )
         
         obs_exp_clean = obs_exp.dropna(subset=["observed", "expected"])
+
+        if len(obs_exp_clean) < len(observed) or len(obs_exp_clean) < len(expected):
+            if verbose:
+                print("NOTE: Vectors 'observed' and/or 'expected' contain zeros which are dropped.")
         
         observed = obs_exp_clean["observed"].to_numpy()
         expected = obs_exp_clean["expected"].to_numpy()
@@ -2708,7 +3149,8 @@ def modelfit(
     residuals_abs = abs(residuals)
  
     if any(observed == 0):
-        print ("Vector 'observed' contains values equal to zero. No APE/MAPE calculated.")
+        if verbose:
+            print ("Vector 'observed' contains values equal to zero. No APE/MAPE calculated.")
         APE = np.full_like(observed, np.nan)
         MAPE = None
     else:
@@ -2735,6 +3177,7 @@ def modelfit(
     MSE = float(SQR/observed_no)
     RMSE = float(sqrt(MSE))
     MAE = float(SAR/observed_no)
+    LL = np.sum(np.log(residuals_sq))
     
     sMAPE = float(np.mean(sAPE))
 
@@ -2759,6 +3202,7 @@ def modelfit(
         "MAE": MAE,
         "MAPE": MAPE,
         "sMAPE": sMAPE,
+        "LL": -LL,
         "APE": {
             "resid_below5": resid_below5,
             "resid_below10": resid_below10,
@@ -2780,34 +3224,23 @@ def modelfit(
 
     return modelfit_results
 
-def loglik(
-    observed,
-    expected    
-    ):
-
-        model_fit = modelfit(
-            observed, 
-            expected
-            )    
-        residuals_sq = model_fit[0]["residuals_sq"]        
-        
-        LL = np.sum(np.log(residuals_sq))
-
-        return -LL
-
 def check_vars(
     df: pd.DataFrame,
-    cols: list
+    cols: list,
+    check_numeric: bool = True,
+    check_zero: bool = True
     ):
 
     for col in cols:
         if col not in df.columns:
             raise KeyError(f"Column '{col}' not in dataframe.")
     
-    for col in cols:
-        if not pd.api.types.is_numeric_dtype(df[col]):
-            raise ValueError(f"Column '{col}' is not numeric. All stated columns must be numeric.")
+    if check_numeric:
+        for col in cols:
+            if not pd.api.types.is_numeric_dtype(df[col]):
+                raise ValueError(f"Column '{col}' is not numeric. All stated columns must be numeric.")
     
-    for col in cols:
-        if (df[col] <= 0).any():
-            raise ValueError(f"Column '{col}' includes values <= 0. All values must be numeric and positive.")
+    if check_zero:
+        for col in cols:
+            if (df[col] <= 0).any():
+                raise ValueError(f"Column '{col}' includes values <= 0. All values must be numeric and positive.")

huff/tests/tests_huff.py

@@ -4,18 +4,17 @@
 # Author:      Thomas Wieland 
 #              ORCID: 0000-0001-5168-9846
 #              mail: geowieland@googlemail.com              
-# Version:     1.5.0
-# Last update: 2025-06-25 18:32
+# Version:     1.5.2
+# Last update: 2025-07-02 21:10
 # Copyright (c) 2025 Thomas Wieland
 #-----------------------------------------------------------------------
 
-
 from huff.models import create_interaction_matrix, get_isochrones, load_geodata, load_interaction_matrix, load_marketareas, market_shares, modelfit
 from huff.osm import map_with_basemap
 from huff.gistools import buffers, point_spatial_join
 
 
-# Customer origins (statistical districts):
+# Dealing with customer origins (statistical districts):
 
 Haslach = load_geodata(
     "data/Haslach.shp",
@@ -39,10 +38,8 @@ Haslach.define_marketsize("pop")
 # Definition of market size variable
 
 Haslach.define_transportcosts_weighting(
-    # param_lambda = -2.2,    
-    # # one weighting parameter for power function (default)
-    param_lambda = [10, -0.5],    
-    func="logistic"
+    param_lambda = -2.2,    
+    # one weighting parameter for power function (default)
     # two weighting parameters for logistic function
     )
 # Definition of transport costs weighting (lambda)
@@ -51,7 +48,7 @@ Haslach.summary()
 # Summary after update
 
 
-# Supply locations (supermarkets):
+# Dealing with upply locations (supermarkets):
 
 Haslach_supermarkets = load_geodata(
     "data/Haslach_supermarkets.shp",
@@ -87,9 +84,7 @@ Haslach_supermarkets.summary()
 # Summary of updated customer origins
 
 Haslach_supermarkets_isochrones = Haslach_supermarkets.get_isochrones_gdf()
-# Extracting isochrones
-
-print(Haslach_supermarkets_isochrones)
+# Extracting isochrones as gdf
 
 
 # Using customer origins and supply locations for building interaction matrix:
@@ -101,8 +96,8 @@ haslach_interactionmatrix = create_interaction_matrix(
 # Creating interaction matrix
 
 haslach_interactionmatrix.transport_costs(
-    #ors_auth="5b3ce3597851110001cf62480a15aafdb5a64f4d91805929f8af6abd"
-    network=False,
+    ors_auth="5b3ce3597851110001cf62480a15aafdb5a64f4d91805929f8af6abd",
+    network=True,
     #distance_unit="meters",
     # set network = True to calculate transport costs matrix via ORS API (default)
     )
@@ -132,11 +127,9 @@ print(huff_model.get_market_areas_df())
 # Maximum Likelihood fit for Huff Model:
 
 haslach_interactionmatrix.huff_ml_fit(
-    #initial_params=[1, -2],
-    initial_params=[1, 9, -0.6],
+    initial_params=[1, -2],
     method="trust-constr",
-    #bounds = [(0.8, 0.9999),(-2.5, -1.5)],
-    bounds = [(0.8, 0.9999),(7, 11),(-0.9, -0.4)],
+    bounds = [(0.8, 0.9999),(-2.5, -1.5)]    
 )
 # Maximum Likelihood fit for Huff Model
 
@@ -218,10 +211,14 @@ Wieland2015_interaction_matrix = load_interaction_matrix(
     probabilities_col="MA_Anb1",
     data_type="xlsx"
     )
+# Loading interaction matrix from XLSX file
 
 Wieland2015_interaction_matrix.summary()
 # Summary of interaction matrix
 
+
+# Parameter estimation via MCI model:
+
 Wieland2015_fit = Wieland2015_interaction_matrix.mci_fit(
     cols=[
         "A_j", 
@@ -289,15 +286,16 @@ Wieland2015_interaction_matrix2.define_weightings(
 
 Wieland2015_interaction_matrix2.huff_ml_fit(
     # Power TC function
-    initial_params=[0.9, -0.5, 0.5, 0.3],
-    bounds=[(0.5, 1), (-0.7, -0.2), (0.2, 0.7), (0.2, 0.7)],
+    initial_params=[0.9, -1.5, 0.5, 0.3],
+    bounds=[(0.5, 1), (-2, -1), (0.2, 0.7), (0.2, 0.7)],
     # # Logistic TC function:
     # initial_params=[0.9, 10, -0.5, 0.5, 0.3],
     # bounds=[(0.5, 1), (8, 12), (-0.7, -0.2), (0.2, 0.7), (0.2, 0.7)],
-    fit_by="flows",
-    method = "trust-constr"
+    fit_by="probabilities",
+    #method = "trust-constr"
 )
-# ML fit with power transport cost function
+# ML fit with power transport cost function based on probabilities
+# from InteractionMatrix object
 
 Wieland2015_interaction_matrix2.summary()
 # Summary of interaction matrix
@@ -305,6 +303,19 @@ Wieland2015_interaction_matrix2.summary()
 huff_model_fit2 = Wieland2015_interaction_matrix2.marketareas()
 # Calculation of market areas
 
+huff_model_fit2 = huff_model_fit2.ml_fit(
+    # Power TC function
+    initial_params=[0.9, -1.5, 0.5, 0.3],
+    bounds=[(0.5, 1), (-2, -1), (0.2, 0.7), (0.2, 0.7)],
+    # # Logistic TC function:
+    # initial_params=[0.9, 10, -0.5, 0.5, 0.3],
+    # bounds=[(0.5, 1), (8, 12), (-0.7, -0.2), (0.2, 0.7), (0.2, 0.7)],
+    fit_by="probabilities",
+    #method = "trust-constr"
+    )
+# ML fit with power transport cost function based on probabilities
+# from HuffModel object
+
 huff_model_fit2.summary()
 # Summary of Hudd model
 
@@ -328,6 +339,24 @@ huff_model_fit2 = Wieland2025_totalmarketareas.add_to_model(
 print(huff_model_fit2.get_market_areas_df())
 # Showing total market areas of HuffModel object
 
+huff_model_fit3 = huff_model_fit2.ml_fit(
+    # Power TC function
+    initial_params=[0.9, -1.5, 0.5, 0.3],
+    bounds=[(0.5, 1), (-2, -1), (0.2, 0.7), (0.2, 0.7)],
+    # # Logistic TC function:
+    # initial_params=[0.9, 10, -0.5, 0.5, 0.3],
+    # bounds=[(0.5, 1), (8, 12), (-0.7, -0.2), (0.2, 0.7), (0.2, 0.7)],
+    fit_by="totals",
+    #method = "trust-constr"
+    )
+# Fit Huff model by totals
+
+huff_model_fit3.summary()
+# Show summary
+
+print(huff_model_fit3.get_market_areas_df())
+# Show market areas df
+
 
 # Buffer analysis:
 

{huff-1.5.0.dist-info → huff-1.5.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: huff
-Version: 1.5.0
+Version: 1.5.2
 Summary: huff: Huff Model Market Area Analysis
 Author: Thomas Wieland
 Author-email: geowieland@googlemail.com
@@ -28,16 +28,11 @@ Thomas Wieland [ORCID](https://orcid.org/0000-0001-5168-9846) [EMail](mailto:geo
 See the /tests directory for usage examples of most of the included functions.
 
 
-## Updates v1.5.0
-- Extensions:
-  - Huff model utility via InteractionMatrix.utility() extended to >2 variables
-  - Huff Model Maximum Likelihood fit via InteractionMatrix.huff_ml_fit() extended: >2 variables, fit by flows or probabilities
-  - Loading total market areas data as class MarketAreas
-  - Extended output of InteractionMatrix.summary()
+## Updates v1.5.2
 - Bugfixes:
-  - InteractionMatrix.utility(): Tests for availability of relevant columns
-  - InteractionMatrix.flows(): Tests for availability of relevant columns
-  - modelfit(): Symmetrical (M)APE instead of (M)APE when observed contains zeros
+  - HuffModel.ml_fit(): Correct values of expected T_j, corrected calculation of model fit metrices when fit_by="totals"
+  - HuffModel.ml_fit(): Check if sum of E_ij != sum of T_j
+  
 
 ## Features
 
@@ -45,7 +40,7 @@ See the /tests directory for usage examples of most of the included functions.
   - Defining origins and destinations with weightings
   - Creating interaction matrix from origins and destinations
   - Different function types: power, exponential, logistic
-  - Huff model parameter estimation via Maximum Likelihood (ML) by probalities and customer flows
+  - Huff model parameter estimation via Maximum Likelihood (ML) by probalities, customer flows, and total market areas
   - Huff model market simulation
 - **Multiplicative Competitive Interaction Model**: 
   - Log-centering transformation of interaction matrix

{huff-1.5.0.dist-info → huff-1.5.2.dist-info}/RECORD

@@ -1,10 +1,10 @@
 huff/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 huff/gistools.py,sha256=fgeE1IsUO7UIaawb23kuiz_Rlxn7T18iLLTA5yvgp74,7038
-huff/models.py,sha256=fGQP6eZOkV9wRVNw_0jYY8zIW74VAR0MMQ9YR8Vjcn4,105491
+huff/models.py,sha256=e8aILi45qcJ9tvHJfKIFKWfD-DYXjZQ0gXOS4MpG7Ks,125430
 huff/ors.py,sha256=JlO2UEishQX87PIiktksOrVT5QdB-GEWgjXcxoR_KuA,11929
 huff/osm.py,sha256=9A-7hxeZyjA2r8w2_IqqwH14qq2Y9AS1GxVKOD7utqs,7747
 huff/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-huff/tests/tests_huff.py,sha256=xhJcUYQ6dJIg6cPMez8yRIcicvuXkww8NPHXmt-Qrjg,11955
+huff/tests/tests_huff.py,sha256=xHCR087rqLNWDFfZhi1giKDzffCx3IemWQmHrAUYxFw,12956
 huff/tests/data/Haslach.cpg,sha256=OtMDH1UDpEBK-CUmLugjLMBNTqZoPULF3QovKiesmCQ,5
 huff/tests/data/Haslach.dbf,sha256=GVPIt05OzDO7UrRDcsMhiYWvyXAPg6Z-qkiysFzj-fc,506
 huff/tests/data/Haslach.prj,sha256=2Jy1Vlzh7UxQ1MXpZ9UYLs2SxfrObj2xkEkZyLqmGTY,437
@@ -23,8 +23,8 @@ huff/tests/data/Haslach_supermarkets.prj,sha256=2Jy1Vlzh7UxQ1MXpZ9UYLs2SxfrObj2x
 huff/tests/data/Haslach_supermarkets.qmd,sha256=JlcOYzG4vI1NH1IuOpxwIPnJsCyC-pDRAI00TzEvNf0,2522
 huff/tests/data/Haslach_supermarkets.shp,sha256=X7QbQ0BTMag_B-bDRbpr-go2BQIXo3Y8zMAKpYZmlps,324
 huff/tests/data/Haslach_supermarkets.shx,sha256=j23QHX-SmdAeN04rw0x8nUOran-OCg_T6r_LvzzEPWs,164
-huff/tests/data/Wieland2015.xlsx,sha256=jUt9YcRrYL99AjxzXKMXD3o5erjd9r_jYfnALdrTQ3o,24333
-huff-1.5.0.dist-info/METADATA,sha256=Ig_hu8ssyzbtuAUUxMw3ykAHpthSoyMeSxAgeSw3P9o,6319
-huff-1.5.0.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-huff-1.5.0.dist-info/top_level.txt,sha256=nlzX-PxZNFmIxANIJMySuIFPihd6qOBkRlhIC28NEsQ,5
-huff-1.5.0.dist-info/RECORD,,
+huff/tests/data/Wieland2015.xlsx,sha256=H4rxCFlctn44-O6mIyeFf67FlgvznLX7xZqpoWYS41A,25788
+huff-1.5.2.dist-info/METADATA,sha256=XnlmcfscK8c1P3EN40W8JcQnFE7AkWDT4NqLR9skTIY,5956
+huff-1.5.2.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+huff-1.5.2.dist-info/top_level.txt,sha256=nlzX-PxZNFmIxANIJMySuIFPihd6qOBkRlhIC28NEsQ,5
+huff-1.5.2.dist-info/RECORD,,