rustalgos

check_numerical_data

Validates that all elements in a 2D numerical array are finite.

Raises

distances_from_betas

Convert decay parameters (betas) to distance thresholds ($d_{max}$). Requires betas > 0 and sorted in strictly decreasing order. Uses a default minimum weight threshold.

Parameters

Returns

Raises

Notes

from cityseer.metrics import networks

# a list of betas
distances = [400, 200]
# convert to betas
betas = networks.beta_from_distance(distances)
print(betas)  # prints: array([0.01, 0.02])

Most networks module methods can be invoked with either distances or betas parameters, but not both. If using the distances parameter, then this function will be called in order to extrapolate the decay parameters implicitly, using:

$\beta = -\frac{log(w_{min})}{d_{max}}$

The default min_threshold_wt of $w_{min}=0.01831563888873418$ yields conveniently rounded $\beta$ parameters, for example:

$d_{max}$	$\beta$
200m	0.02
400m	0.01
800m	0.005
1600m	0.0025

betas_from_distances

Convert distance thresholds ($d_{max}$) to decay parameters (betas). Requires distances > 0 and sorted in strictly increasing order. Uses a default minimum weight threshold.

Parameters

Returns

Raises

Notes

from cityseer import rustalgos

# a list of betas
betas = [0.01, 0.02]
# convert to distance thresholds
d_max = rustalgos.distances_from_betas(betas)
print(d_max)
# prints: [400, 200]

Weighted measures such as the gravity index, weighted betweenness, and weighted land-use accessibilities are computed using a negative exponential decay function in the form of:

$weight = exp(-\beta \cdot distance)$

The strength of the decay is controlled by the $\beta$ parameter, which reflects a decreasing willingness to walk correspondingly farther distances. For example, if $\beta=0.005$ were to represent a person’s willingness to walk to a bus stop, then a location 100m distant would be weighted at 60% and a location 400m away would be weighted at 13.5%. After an initially rapid decrease, the weightings decay ever more gradually in perpetuity; thus, once a sufficiently small weight is encountered it becomes computationally expensive to consider locations any farther away. The minimum weight at which this cutoff occurs is represented by $w_{min}$, and the corresponding maximum distance threshold by $d_{max}$.

Most networks module methods can be invoked with either distances or betas parameters, but not both. If using the betas parameter, then this function will be called in order to extrapolate the distance thresholds implicitly, using:

$d_{max} = \frac{log(w_{min})}{-\beta}$

The default min_threshold_wt of $w_{min}=0.01831563888873418$ yields conveniently rounded $d_{max}$ walking thresholds, for example:

$\beta$	$d_{max}$
0.02	200m
0.01	400m
0.005	800m
0.0025	1600m

Overriding the default $w_{min}$ will adjust the $d_{max}$ accordingly.

distances_from_seconds

Convert time in seconds to distance thresholds ($d_{max}$) based on speed.

The default speed_m_s of $1.333$ yields the following $d_{max}$ walking thresholds:

$seconds$	$d_{max}$
300	400m
600	800m
1200	1600m

Setting the speed_m_s to a higher or lower number will affect the $d_{max}$ accordingly.]

Parameters

Returns

seconds_from_distances

Convert distance thresholds ($d_{max}$) to time in seconds based on speed.

The default speed_m_s of $1.33333$ yields the following walking times:

$d_{max}$	$seconds$
400m	300
800m	600
1600m	1200

Setting the speed_m_s to a higher or lower number will affect the walking time accordingly.

Parameters

Returns

pair_distances_betas_time

Calculate distances, betas, and seconds, given exactly one of them. Requires exactly one of distances, betas, or minutes to be provided.

Parameters

Returns

Raises

Notes

avg_distances_for_betas

Calculate the mean distance corresponding to given beta parameters.

Parameters

Returns

Notes

from cityseer.metrics import networks
import numpy as np

distances = [100, 200, 400, 800, 1600]
print("distances", distances)
# distances [ 100  200  400  800 1600]

betas = networks.beta_from_distance(distances)
print("betas", betas)
# betas [0.04   0.02   0.01   0.005  0.0025]

print("avg", networks.avg_distance_for_beta(betas))

clip_wts_curve

Calculate upper weight bounds for clipping distance decay curves based on spatial tolerance. Used when data point location has uncertainty defined by spatial_tolerance. Determine the upper weights threshold of the distance decay curve for a given $\beta$ based on the spatial_tolerance parameter. This is used by downstream functions to determine the upper extent at which weights derived for spatial impedance functions are flattened and normalised. This functionality is only intended for situations where the location of datapoints is uncertain for a given spatial tolerance.

Parameters

Returns

clipped_beta_wt

Calculate a single weight using beta decay, clipped by a maximum weight. Applies $weight = exp(-\beta \cdot distance)$, ensuring the result does not exceed max_curve_wt.

Parameters

Returns