SYMBOL INDEX (1082 symbols across 66 files)

FILE: docs/source/examples/modules/mpi/network_large.py
  function master (line 4) | def master():

FILE: docs/source/examples/modules/mpi/network_mc.py
  function do_one (line 4) | def do_one():
  function master (line 9) | def master():

FILE: src/pyunicorn/climate/climate_data.py
  class ClimateData (line 29) | class ClimateData(Data, Cached):
    method __init__ (line 46) | def __init__(self, observable, grid, time_cycle, anomalies=False,
    method __cache_state__ (line 91) | def __cache_state__(self) -> Tuple[Hashable, ...]:
    method __str__ (line 96) | def __str__(self):
    method Load (line 108) | def Load(cls, file_name, observable_name, file_type="NetCDF",
    method SmallTestData (line 169) | def SmallTestData():
    method phase_indices (line 199) | def phase_indices(self):
    method indices_selected_phases (line 233) | def indices_selected_phases(self, selected_phases):
    method indices_selected_months (line 261) | def indices_selected_months(self, selected_months):
    method phase_mean (line 289) | def phase_mean(self):
    method anomaly (line 324) | def anomaly(self):
    method anomaly_selected_months (line 358) | def anomaly_selected_months(self, selected_months):
    method shuffled_anomaly (line 375) | def shuffled_anomaly(self):
    method set_window (line 408) | def set_window(self, window):
    method set_global_window (line 446) | def set_global_window(self):

FILE: src/pyunicorn/climate/climate_network.py
  class ClimateNetwork (line 29) | class ClimateNetwork(GeoNetwork):
    method __init__ (line 45) | def __init__(self, grid: GeoGrid, similarity_measure: np.ndarray,
    method __cache_state__ (line 107) | def __cache_state__(self) -> Tuple[Hashable, ...]:
    method __str__ (line 110) | def __str__(self):
    method _regenerate_network (line 131) | def _regenerate_network(self):
    method save (line 150) | def save(self, filename, fileformat=None, *args, **kwds):
    method Load (line 209) | def Load(filename, fileformat=None, silence_level=0, *args, **kwds):
    method SmallTestNetwork (line 288) | def SmallTestNetwork():
    method link_density_function (line 323) | def link_density_function(self, n_bins):
    method threshold_from_link_density (line 361) | def threshold_from_link_density(self, link_density):
    method _calculate_threshold_adjacency (line 396) | def _calculate_threshold_adjacency(self, similarity_measure, threshold):
    method _calculate_non_local_adjacency (line 437) | def _calculate_non_local_adjacency(self, similarity_measure, threshold,
    method similarity_measure (line 492) | def similarity_measure(self):
    method non_local (line 510) | def non_local(self):
    method set_non_local (line 524) | def set_non_local(self, non_local):
    method threshold (line 545) | def threshold(self):
    method set_threshold (line 559) | def set_threshold(self, threshold):
    method set_link_density (line 592) | def set_link_density(self, link_density):
    method correlation_distance (line 616) | def correlation_distance(self):
    method inv_correlation_distance (line 648) | def inv_correlation_distance(self):
    method correlation_distance_weighted_closeness (line 663) | def correlation_distance_weighted_closeness(self):
    method local_correlation_distance_weighted_vulnerability (line 686) | def local_correlation_distance_weighted_vulnerability(self):
    method _weighted_metric (line 709) | def _weighted_metric(self, attr: str, calc: Callable, metric: str):

FILE: src/pyunicorn/climate/coupled_climate_network.py
  class CoupledClimateNetwork (line 25) | class CoupledClimateNetwork(InteractingNetworks, ClimateNetwork):
    method __init__ (line 47) | def __init__(self, grid_1, grid_2, similarity_measure, threshold=None,
    method __str__ (line 130) | def __str__(self):
    method network_1 (line 141) | def network_1(self):
    method network_2 (line 157) | def network_2(self):
    method similarity_measure_1 (line 173) | def similarity_measure_1(self):
    method similarity_measure_2 (line 182) | def similarity_measure_2(self):
    method cross_similarity_measure (line 191) | def cross_similarity_measure(self):
    method adjacency_1 (line 204) | def adjacency_1(self):
    method adjacency_2 (line 213) | def adjacency_2(self):
    method cross_layer_adjacency (line 222) | def cross_layer_adjacency(self):
    method path_lengths_1 (line 242) | def path_lengths_1(self, link_attribute=None):
    method path_lengths_2 (line 262) | def path_lengths_2(self, link_attribute=None):
    method cross_path_lengths (line 282) | def cross_path_lengths(self, link_attribute=None):
    method cross_link_distance (line 299) | def cross_link_distance(self):
    method number_cross_layer_links (line 314) | def number_cross_layer_links(self):
    method number_internal_links (line 323) | def number_internal_links(self):
    method cross_link_density (line 337) | def cross_link_density(self):
    method internal_link_density (line 346) | def internal_link_density(self):
    method internal_global_clustering (line 360) | def internal_global_clustering(self):
    method cross_global_clustering (line 386) | def cross_global_clustering(self):
    method cross_transitivity (line 405) | def cross_transitivity(self):
    method cross_average_link_distance (line 425) | def cross_average_link_distance(self, reverse=False):
    method cross_average_path_length (line 449) | def cross_average_path_length(self, link_attribute=None):
    method internal_average_path_length (line 464) | def internal_average_path_length(self, link_attribute=None):
    method cross_degree (line 495) | def cross_degree(self):
    method internal_degree (line 511) | def internal_degree(self):
    method cross_local_clustering (line 527) | def cross_local_clustering(self):
    method cross_closeness (line 545) | def cross_closeness(self, link_attribute=None):
    method internal_closeness (line 565) | def internal_closeness(self, link_attribute=None):
    method cross_betweenness (line 589) | def cross_betweenness(self):
    method internal_betweenness_1 (line 605) | def internal_betweenness_1(self):
    method internal_betweenness_2 (line 622) | def internal_betweenness_2(self):

FILE: src/pyunicorn/climate/coupled_tsonis.py
  class CoupledTsonisClimateNetwork (line 25) | class CoupledTsonisClimateNetwork(CoupledClimateNetwork):
    method __init__ (line 52) | def __init__(self, data_1, data_2, threshold=None, link_density=None,
    method __str__ (line 115) | def __str__(self):
    method _calculate_correlation (line 126) | def _calculate_correlation(self, anomaly_1, anomaly_2):
    method calculate_similarity_measure (line 153) | def calculate_similarity_measure(self, anomaly_1, anomaly_2):
    method correlation (line 170) | def correlation(self):

FILE: src/pyunicorn/climate/eventseries_climatenetwork.py
  class EventSeriesClimateNetwork (line 33) | class EventSeriesClimateNetwork(EventSeries, ClimateNetwork):
    method __init__ (line 44) | def __init__(self, data, method='ES', p_value=None, **kwargs):
    method __str__ (line 198) | def __str__(self):
    method SmallTestData (line 233) | def SmallTestData():

FILE: src/pyunicorn/climate/havlin.py
  class HavlinClimateNetwork (line 29) | class HavlinClimateNetwork(ClimateNetwork):
    method __init__ (line 54) | def __init__(self, data, max_delay, threshold=None, link_density=None,
    method __cache_state__ (line 103) | def __cache_state__(self) -> Tuple[Hashable, ...]:
    method __str__ (line 106) | def __str__(self):
    method clear_cache (line 115) | def clear_cache(self):
    method _calculate_correlation_strength (line 129) | def _calculate_correlation_strength(self, anomaly, max_delay, gamma=0.2):
    method get_max_delay (line 185) | def get_max_delay(self):
    method _set_max_delay (line 193) | def _set_max_delay(self, max_delay):
    method set_max_delay (line 206) | def set_max_delay(self, max_delay):
    method correlation_strength (line 217) | def correlation_strength(self):
    method correlation_lag (line 226) | def correlation_lag(self):
    method correlation_strength_weighted_average_path_length (line 239) | def correlation_strength_weighted_average_path_length(self):
    method correlation_strength_weighted_closeness (line 250) | def correlation_strength_weighted_closeness(self):
    method correlation_lag_weighted_average_path_length (line 262) | def correlation_lag_weighted_average_path_length(self):
    method correlation_lag_weighted_closeness (line 273) | def correlation_lag_weighted_closeness(self):
    method local_correlation_strength_weighted_vulnerability (line 285) | def local_correlation_strength_weighted_vulnerability(self):
    method local_correlation_lag_weighted_vulnerability (line 297) | def local_correlation_lag_weighted_vulnerability(self):

FILE: src/pyunicorn/climate/hilbert.py
  class HilbertClimateNetwork (line 38) | class HilbertClimateNetwork(ClimateNetwork):
    method __init__ (line 59) | def __init__(self, data, threshold=None, link_density=None,
    method __cache_state__ (line 110) | def __cache_state__(self) -> Tuple[Hashable, ...]:
    method __str__ (line 113) | def __str__(self):
    method clear_cache (line 119) | def clear_cache(self):
    method _set_directed (line 132) | def _set_directed(self, directed, calculate_coherence=True):
    method set_directed (line 152) | def set_directed(self, directed):
    method _calculate_hilbert_correlation (line 165) | def _calculate_hilbert_correlation(self, anomaly):
    method coherence (line 210) | def coherence(self):
    method phase_shift (line 219) | def phase_shift(self):

FILE: src/pyunicorn/climate/map_plot.py
  class MapPlot (line 38) | class MapPlot:
    method __init__ (line 43) | def __init__(self, grid: Grid, title: str):
    method plot (line 77) | def plot(self, data: np.ndarray, label: str):

FILE: src/pyunicorn/climate/mutual_info.py
  class MutualInfoClimateNetwork (line 30) | class MutualInfoClimateNetwork(ClimateNetwork):
    method __init__ (line 48) | def __init__(self, data, threshold=None, link_density=None,
    method __cache_state__ (line 105) | def __cache_state__(self) -> Tuple[Hashable, ...]:
    method __str__ (line 108) | def __str__(self):
    method _cython_calculate_mutual_information (line 114) | def _cython_calculate_mutual_information(self, anomaly, n_bins=32):
    method calculate_similarity_measure (line 158) | def calculate_similarity_measure(self, anomaly):
    method mutual_information (line 173) | def mutual_information(self, anomaly=None, dump=True):
    method winter_only (line 218) | def winter_only(self):
    method _set_winter_only (line 227) | def _set_winter_only(self, winter_only, dump=False):
    method set_winter_only (line 243) | def set_winter_only(self, winter_only, dump=True):
    method mutual_information_weighted_average_path_length (line 260) | def mutual_information_weighted_average_path_length(self):
    method mutual_information_weighted_closeness (line 271) | def mutual_information_weighted_closeness(self):
    method local_mutual_information_weighted_vulnerability (line 283) | def local_mutual_information_weighted_vulnerability(self):

FILE: src/pyunicorn/climate/partial_correlation.py
  class PartialCorrelationClimateNetwork (line 33) | class PartialCorrelationClimateNetwork(TsonisClimateNetwork):
    method __init__ (line 47) | def __init__(self, data, threshold=None, link_density=None,
    method __str__ (line 87) | def __str__(self):
    method _calculate_correlation (line 98) | def _calculate_correlation(self, anomaly):

FILE: src/pyunicorn/climate/rainfall.py
  class RainfallClimateNetwork (line 36) | class RainfallClimateNetwork(ClimateNetwork):
    method __init__ (line 60) | def __init__(self, data, threshold=None, link_density=None,
    method __str__ (line 119) | def __str__(self):
    method _calculate_correlation (line 129) | def _calculate_correlation(self, event_threshold, scale_fac, offset):
    method calculate_rainfall (line 177) | def calculate_rainfall(observable, scale_fac, offset):
    method calculate_top_events (line 200) | def calculate_top_events(rainfall, event_threshold):
    method rank_time_series (line 244) | def rank_time_series(anomaly):
    method spearman_corr (line 257) | def spearman_corr(self, final_mask, anomaly):

FILE: src/pyunicorn/climate/spearman.py
  class SpearmanClimateNetwork (line 34) | class SpearmanClimateNetwork(TsonisClimateNetwork):
    method __init__ (line 53) | def __init__(self, data, threshold=None, link_density=None,
    method __str__ (line 94) | def __str__(self):
    method rank_time_series (line 106) | def rank_time_series(anomaly):
    method _calculate_correlation (line 123) | def _calculate_correlation(self, anomaly):

FILE: src/pyunicorn/climate/tsonis.py
  class TsonisClimateNetwork (line 27) | class TsonisClimateNetwork(ClimateNetwork):
    method __init__ (line 46) | def __init__(self, data, threshold=None, link_density=None,
    method __str__ (line 94) | def __str__(self):
    method SmallTestNetwork (line 122) | def SmallTestNetwork():
    method _calculate_correlation (line 142) | def _calculate_correlation(self, anomaly):
    method calculate_similarity_measure (line 162) | def calculate_similarity_measure(self, anomaly):
    method correlation (line 193) | def correlation(self):
    method winter_only (line 220) | def winter_only(self):
    method _set_winter_only (line 234) | def _set_winter_only(self, winter_only):
    method set_winter_only (line 249) | def set_winter_only(self, winter_only):
    method correlation_weighted_average_path_length (line 272) | def correlation_weighted_average_path_length(self):
    method correlation_weighted_closeness (line 287) | def correlation_weighted_closeness(self):
    method local_correlation_weighted_vulnerability (line 303) | def local_correlation_weighted_vulnerability(self):

FILE: src/pyunicorn/core/_ext/types.py
  function to_cy (line 37) | def to_cy(arr, ty):

FILE: src/pyunicorn/core/cache.py
  class CacheRef (line 29) | class CacheRef:
    method __init__ (line 88) | def __init__(self, obj, attr: str):
    method cache (line 94) | def cache(self) -> _lru_cache_wrapper:
    method __del__ (line 97) | def __del__(self):
  class Cached (line 103) | class Cached(ABC):
    method __cache_state__ (line 147) | def __cache_state__(self) -> Tuple[Hashable, ...]:
    method __eq__ (line 164) | def __eq__(self, other):
    method __hash__ (line 168) | def __hash__(self):
    method method (line 172) | def method(cls, name: Optional[str] = None,
    method is_global_cache (line 268) | def is_global_cache(attr) -> bool:
    method cache_clear (line 272) | def cache_clear(self, prefix: Optional[str] = None) -> None:

FILE: src/pyunicorn/core/data.py
  class Data (line 35) | class Data:
    method __init__ (line 51) | def __init__(self, observable: np.ndarray, grid: GeoGrid,
    method __str__ (line 106) | def __str__(self):
    method set_silence_level (line 115) | def set_silence_level(self, silence_level):
    method Load (line 134) | def Load(cls, file_name, observable_name, file_type, dimension_names=N...
    method SmallTestData (line 192) | def SmallTestData():
    method _get_netcdf_data (line 238) | def _get_netcdf_data(cls, file_name, file_type, observable_name,
    method _load_data (line 344) | def _load_data(cls, file_name, file_type, observable_name,
    method print_data_info (line 375) | def print_data_info(self):
    method observable (line 387) | def observable(self):
    method window (line 406) | def window(self):
    method set_window (line 423) | def set_window(self, window):
    method set_global_window (line 501) | def set_global_window(self):
    method rescale (line 532) | def rescale(array, var_type):
    method normalize_time_series_array (line 588) | def normalize_time_series_array(time_series_array):
    method next_power_2 (line 623) | def next_power_2(i):
    method zero_pad_data (line 645) | def zero_pad_data(data):
    method cos_window (line 680) | def cos_window(data, gamma):

FILE: src/pyunicorn/core/geo_grid.py
  class GeoGrid (line 33) | class GeoGrid(Grid):
    method __init__ (line 46) | def __init__(self, time_seq: np.ndarray,
    method __str__ (line 67) | def __str__(self):
    method save_txt (line 78) | def save_txt(self, filename):
    method LoadTXT (line 103) | def LoadTXT(filename):
    method SmallTestGrid (line 130) | def SmallTestGrid():
    method RegularGrid (line 144) | def RegularGrid(time_seq, space_grid, silence_level=0):
    method coord_sequence_from_rect_grid (line 193) | def coord_sequence_from_rect_grid(lat_grid, lon_grid):
    method lat_sequence (line 218) | def lat_sequence(self):
    method lon_sequence (line 232) | def lon_sequence(self):
    method convert_lon_coordinates (line 246) | def convert_lon_coordinates(self, lon_seq):
    method node_number (line 276) | def node_number(self, lat_node, lon_node):
    method cos_lat (line 321) | def cos_lat(self):
    method sin_lat (line 335) | def sin_lat(self):
    method cos_lon (line 349) | def cos_lon(self):
    method sin_lon (line 363) | def sin_lon(self):
    method distance (line 377) | def distance(self):
    method angular_distance (line 388) | def angular_distance(self):
    method boundaries (line 421) | def boundaries(self):
    method print_boundaries (line 444) | def print_boundaries(self):
    method grid (line 464) | def grid(self):
    method region_indices (line 492) | def region_indices(self, region):
    method region (line 523) | def region(name):

FILE: src/pyunicorn/core/geo_network.py
  class GeoNetwork (line 26) | class GeoNetwork(SpatialNetwork):
    method __init__ (line 42) | def __init__(self, grid: GeoGrid, adjacency=None, edge_list=None,
    method __str__ (line 83) | def __str__(self):
    method set_node_weight_type (line 90) | def set_node_weight_type(self, node_weight_type):
    method Load (line 124) | def Load(filename, fileformat=None, silence_level=0, *args, **kwds):
    method save_for_cgv (line 192) | def save_for_cgv(self, filename, fileformat="graphml"):
    method SmallTestNetwork (line 231) | def SmallTestNetwork():
    method Model (line 254) | def Model(network_model, grid, node_weight_type="surface", **kwargs):
    method geographical_distribution (line 269) | def geographical_distribution(self, sequence, n_bins):
    method geographical_cumulative_distribution (line 339) | def geographical_cumulative_distribution(self, sequence, n_bins):
    method area_weighted_connectivity (line 381) | def area_weighted_connectivity(self):
    method inarea_weighted_connectivity (line 406) | def inarea_weighted_connectivity(self):
    method outarea_weighted_connectivity (line 436) | def outarea_weighted_connectivity(self):
    method area_weighted_connectivity_distribution (line 467) | def area_weighted_connectivity_distribution(self, n_bins):
    method inarea_weighted_connectivity_distribution (line 493) | def inarea_weighted_connectivity_distribution(self, n_bins):
    method outarea_weighted_connectivity_distribution (line 519) | def outarea_weighted_connectivity_distribution(self, n_bins):
    method area_weighted_connectivity_cumulative_distribution (line 545) | def area_weighted_connectivity_cumulative_distribution(self, n_bins):
    method inarea_weighted_connectivity_cumulative_distribution (line 572) | def inarea_weighted_connectivity_cumulative_distribution(self, n_bins):
    method outarea_weighted_connectivity_cumulative_distribution (line 599) | def outarea_weighted_connectivity_cumulative_distribution(self, n_bins):
    method average_neighbor_area_weighted_connectivity (line 626) | def average_neighbor_area_weighted_connectivity(self):
    method max_neighbor_area_weighted_connectivity (line 654) | def max_neighbor_area_weighted_connectivity(self):
    method total_link_distance (line 686) | def total_link_distance(self, geometry_corrected=False):
    method intotal_link_distance (line 711) | def intotal_link_distance(self, geometry_corrected=False):
    method outtotal_link_distance (line 733) | def outtotal_link_distance(self, geometry_corrected=False):
    method _calculate_general_connectivity_weighted_distance (line 757) | def _calculate_general_connectivity_weighted_distance(self, adjacency,
    method connectivity_weighted_distance (line 788) | def connectivity_weighted_distance(self):
    method inconnectivity_weighted_distance (line 812) | def inconnectivity_weighted_distance(self):
    method outconnectivity_weighted_distance (line 834) | def outconnectivity_weighted_distance(self):
    method local_geographical_clustering (line 860) | def local_geographical_clustering(self):
    method cartesian2latlon (line 891) | def cartesian2latlon(pos):
    method latlon2cartesian (line 896) | def latlon2cartesian(lat, lon):

FILE: src/pyunicorn/core/grid.py
  class Grid (line 30) | class Grid(Cached):
    method __init__ (line 42) | def __init__(self, time_seq: np.ndarray, space_seq: np.ndarray,
    method __cache_state__ (line 82) | def __cache_state__(self) -> Tuple[Hashable, ...]:
    method __str__ (line 87) | def __str__(self):
    method save (line 98) | def save(self, filename):
    method Load (line 113) | def Load(filename):
    method SmallTestGrid (line 132) | def SmallTestGrid():
    method RegularGrid (line 146) | def RegularGrid(time_seq, space_grid, silence_level=0):
    method coord_sequence_from_rect_grid (line 186) | def coord_sequence_from_rect_grid(space_grid):
    method sequence (line 208) | def sequence(self, dimension):
    method node_number (line 227) | def node_number(self, x):
    method node_coordinates (line 259) | def node_coordinates(self, index):
    method distance (line 276) | def distance(self):
    method euclidean_distance (line 287) | def euclidean_distance(self):
    method boundaries (line 317) | def boundaries(self):
    method grid (line 332) | def grid(self):
    method grid_size (line 352) | def grid_size(self):
    method print_grid_size (line 371) | def print_grid_size(self):
    method geometric_distance_distribution (line 378) | def geometric_distance_distribution(self, n_bins):

FILE: src/pyunicorn/core/interacting_networks.py
  class InteractingNetworks (line 31) | class InteractingNetworks(Network):
    method __init__ (line 51) | def __init__(self, adjacency, directed=False, node_weights=None,
    method __str__ (line 72) | def __str__(self):
    method SmallTestNetwork (line 83) | def SmallTestNetwork():
    method SmallDirectedTestNetwork (line 115) | def SmallDirectedTestNetwork():
    method RandomlySetCrossLinks (line 142) | def RandomlySetCrossLinks(network, node_list1, node_list2,
    method RandomlySetCrossLinks_sparse (line 204) | def RandomlySetCrossLinks_sparse(network, node_list1, node_list2,
    method RandomlyRewireCrossLinks (line 281) | def RandomlyRewireCrossLinks(network, node_list1, node_list2, swaps):
    method subnetwork (line 365) | def subnetwork(self, node_list):
    method internal_adjacency (line 381) | def internal_adjacency(self, node_list):
    method cross_adjacency (line 404) | def cross_adjacency(self, node_list1, node_list2):
    method cross_adjacency_sparse (line 436) | def cross_adjacency_sparse(self, node_list1, node_list2):
    method internal_link_attribute (line 466) | def internal_link_attribute(self, attribute_name, node_list):
    method cross_link_attribute (line 498) | def cross_link_attribute(self, attribute_name, node_list1, node_list2):
    method internal_path_lengths (line 531) | def internal_path_lengths(self, node_list, link_attribute=None):
    method cross_path_lengths (line 562) | def cross_path_lengths(self, node_list1, node_list2, link_attribute=No...
    method number_cross_links (line 593) | def number_cross_links(self, node_list1, node_list2):
    method total_cross_degree (line 618) | def total_cross_degree(self, node_list1, node_list2):
    method number_internal_links (line 639) | def number_internal_links(self, node_list):
    method cross_degree_density (line 661) | def cross_degree_density(self, node_list1, node_list2):
    method cross_link_density (line 686) | def cross_link_density(self, node_list1, node_list2):
    method internal_link_density (line 712) | def internal_link_density(self, node_list):
    method internal_global_clustering (line 735) | def internal_global_clustering(self, node_list):
    method cross_global_clustering (line 768) | def cross_global_clustering(self, node_list1, node_list2):
    method cross_global_clustering_sparse (line 802) | def cross_global_clustering_sparse(self, node_list1, node_list2):
    method cross_transitivity (line 835) | def cross_transitivity(self, node_list1, node_list2):
    method cross_transitivity_sparse (line 868) | def cross_transitivity_sparse(self, node_list1, node_list2):
    method _calculate_general_average_path_length (line 926) | def _calculate_general_average_path_length(path_lengths, internal=False):
    method cross_average_path_length (line 961) | def cross_average_path_length(self, node_list1, node_list2,
    method internal_average_path_length (line 993) | def internal_average_path_length(self, node_list, link_attribute=None):
    method average_cross_closeness (line 1029) | def average_cross_closeness(self, node_list1, node_list2,
    method global_efficiency (line 1051) | def global_efficiency(self, node_list1, node_list2, link_attribute=None):
    method cross_degree (line 1077) | def cross_degree(self, node_list1, node_list2, link_attribute=None):
    method cross_indegree (line 1115) | def cross_indegree(self, node_list1, node_list2, link_attribute=None):
    method cross_outdegree (line 1146) | def cross_outdegree(self, node_list1, node_list2, link_attribute=None):
    method internal_degree (line 1175) | def internal_degree(self, node_list, link_attribute=None):
    method internal_indegree (line 1201) | def internal_indegree(self, node_list, link_attribute=None):
    method internal_outdegree (line 1226) | def internal_outdegree(self, node_list, link_attribute=None):
    method cross_local_clustering (line 1251) | def cross_local_clustering(self, node_list1, node_list2):
    method cross_local_clustering_sparse (line 1293) | def cross_local_clustering_sparse(self, node_list1, node_list2):
    method _calculate_general_closeness (line 1351) | def _calculate_general_closeness(self, path_lengths, internal=True):
    method cross_closeness (line 1394) | def cross_closeness(self, node_list1, node_list2, link_attribute=None):
    method internal_closeness (line 1424) | def internal_closeness(self, node_list, link_attribute=None):
    method cross_betweenness (line 1456) | def cross_betweenness(self, node_list1, node_list2):
    method internal_betweenness (line 1486) | def internal_betweenness(self, node_list):
    method local_efficiency (line 1508) | def local_efficiency(self, node_list1, node_list2, link_attribute=None):
    method nsi_cross_degree (line 1531) | def nsi_cross_degree(self, node_list1, node_list2):
    method nsi_cross_mean_degree (line 1556) | def nsi_cross_mean_degree(self, node_list1, node_list2):
    method nsi_internal_degree (line 1578) | def nsi_internal_degree(self, node_list):
    method nsi_cross_local_clustering (line 1597) | def nsi_cross_local_clustering(self, node_list1, node_list2):
    method nsi_cross_closeness_centrality (line 1628) | def nsi_cross_closeness_centrality(self, node_list1, node_list2):
    method nsi_internal_closeness_centrality (line 1657) | def nsi_internal_closeness_centrality(self, node_list):
    method nsi_cross_global_clustering (line 1677) | def nsi_cross_global_clustering(self, node_list1, node_list2):
    method nsi_internal_local_clustering (line 1697) | def nsi_internal_local_clustering(self, node_list):
    method nsi_cross_betweenness (line 1719) | def nsi_cross_betweenness(self, node_list1, node_list2):
    method nsi_cross_edge_density (line 1746) | def nsi_cross_edge_density(self, node_list1, node_list2):
    method nsi_cross_transitivity (line 1769) | def nsi_cross_transitivity(self, node_list1, node_list2):
    method nsi_cross_average_path_length (line 1796) | def nsi_cross_average_path_length(self, node_list1, node_list2):

FILE: src/pyunicorn/core/netcdf_dictionary.py
  class NetCDFDictionary (line 41) | class NetCDFDictionary:
    method __init__ (line 50) | def __init__(self, data_dict=None, silence_level=0):
    method __str__ (line 80) | def __str__(self):
    method from_file (line 97) | def from_file(file_name, with_array='all'):
    method to_file (line 178) | def to_file(self, file_name, compress=False, comp_level=6,

FILE: src/pyunicorn/core/network.py
  function nz_coords (line 50) | def nz_coords(matrix):
  class NetworkError (line 60) | class NetworkError(Exception):
    method __init__ (line 64) | def __init__(self, value):
    method __str__ (line 68) | def __str__(self):
  function r (line 76) | def r(obj, decimals=4):
  function rr (line 101) | def rr(obj, decimals=4):
  class Network (line 111) | class Network(Cached):
    method __init__ (line 141) | def __init__(self, adjacency=None, n_nodes=None, edge_list=None,
    method __cache_state__ (line 218) | def __cache_state__(self) -> Tuple[Hashable, ...]:
    method __str__ (line 221) | def __str__(self):
    method __len__ (line 237) | def __len__(self):
    method copy (line 250) | def copy(self):
    method undirected_copy (line 258) | def undirected_copy(self):
    method permuted_copy (line 278) | def permuted_copy(self, permutation):
    method splitted_copy (line 297) | def splitted_copy(self, node=-1, proportion=0.5):
    method adjacency (line 366) | def adjacency(self):
    method adjacency (line 381) | def adjacency(self, adjacency):
    method set_edge_list (line 427) | def set_edge_list(self, edge_list, n_nodes=None):
    method node_weights (line 460) | def node_weights(self):
    method node_weights (line 465) | def node_weights(self, weights: Optional[np.ndarray]):
    method sp_Aplus (line 496) | def sp_Aplus(self):
    method sp_diag_w (line 500) | def sp_diag_w(self):
    method sp_diag_w_inv (line 505) | def sp_diag_w_inv(self):
    method sp_diag_sqrt_w (line 510) | def sp_diag_sqrt_w(self):
    method save (line 520) | def save(self, filename, fileformat=None, *args, **kwds):
    method Load (line 562) | def Load(filename, fileformat=None, silence_level=0, *args, **kwds):
    method FromIGraph (line 603) | def FromIGraph(graph, silence_level=0):
    method SmallTestNetwork (line 651) | def SmallTestNetwork():
    method SmallDirectedTestNetwork (line 683) | def SmallDirectedTestNetwork():
    method Model (line 712) | def Model(network_model, **kwargs):
    method ErdosRenyi (line 738) | def ErdosRenyi(n_nodes=100, link_probability=None, n_links=None,
    method BarabasiAlbert_igraph (line 791) | def BarabasiAlbert_igraph(n_nodes=100, n_links_each=5):
    method BarabasiAlbert (line 828) | def BarabasiAlbert(n_nodes=100, n_links_each=5):
    method Configuration (line 870) | def Configuration(degree):
    method WattsStrogatz (line 902) | def WattsStrogatz(N, k, p):
    method GrowWeights (line 936) | def GrowWeights(n_nodes=100, n_initials=1, exponent=1,
    method randomly_rewire (line 985) | def randomly_rewire(self, iterations):
    method edge_list (line 1013) | def edge_list(self):
    method undirected_adjacency (line 1026) | def undirected_adjacency(self):
    method laplacian (line 1042) | def laplacian(self, direction="out", link_attribute=None):
    method nsi_laplacian (line 1080) | def nsi_laplacian(self):
    method _histogram (line 1109) | def _histogram(values, n_bins, interval=None):
    method _cum_histogram (line 1153) | def _cum_histogram(values, n_bins, interval=None):
    method set_node_attribute (line 1188) | def set_node_attribute(self, attribute_name: str, values):
    method node_attribute (line 1207) | def node_attribute(self, attribute_name: str):
    method del_node_attribute (line 1220) | def del_node_attribute(self, attribute_name: str):
    method find_link_attribute (line 1233) | def find_link_attribute(self, attribute_name: str):
    method average_link_attribute (line 1236) | def average_link_attribute(self, attribute_name: str):
    method link_attribute (line 1247) | def link_attribute(self, attribute_name: str):
    method del_link_attribute (line 1269) | def del_link_attribute(self, attribute_name: str):
    method set_link_attribute (line 1280) | def set_link_attribute(self, attribute_name, values):
    method degree (line 1305) | def degree(self, link_attribute=None):
    method indegree (line 1325) | def indegree(self, link_attribute=None):
    method outdegree (line 1346) | def outdegree(self, link_attribute=None):
    method bildegree (line 1367) | def bildegree(self, link_attribute=None):
    method sp_nsi_diag_k (line 1389) | def sp_nsi_diag_k(self):
    method sp_nsi_diag_k_inv (line 1394) | def sp_nsi_diag_k_inv(self):
    method nsi_degree (line 1400) | def nsi_degree(self, link_attribute=None, typical_weight=None):
    method nsi_indegree (line 1453) | def nsi_indegree(self, link_attribute=None, typical_weight=None):
    method nsi_outdegree (line 1494) | def nsi_outdegree(self, link_attribute=None, typical_weight=None):
    method nsi_bildegree (line 1535) | def nsi_bildegree(self, link_attribute=None, typical_weight=None):
    method degree_distribution (line 1559) | def degree_distribution(self):
    method indegree_distribution (line 1576) | def indegree_distribution(self):
    method outdegree_distribution (line 1593) | def outdegree_distribution(self):
    method degree_cdf (line 1610) | def degree_cdf(self):
    method indegree_cdf (line 1627) | def indegree_cdf(self):
    method outdegree_cdf (line 1644) | def outdegree_cdf(self):
    method nsi_degree_histogram (line 1662) | def nsi_degree_histogram(self, typical_weight=None):
    method nsi_degree_cumulative_histogram (line 1688) | def nsi_degree_cumulative_histogram(self, typical_weight=None):
    method average_neighbors_degree (line 1712) | def average_neighbors_degree(self):
    method max_neighbors_degree (line 1730) | def max_neighbors_degree(self):
    method nsi_average_neighbors_degree (line 1749) | def nsi_average_neighbors_degree(self):
    method nsi_max_neighbors_degree (line 1789) | def nsi_max_neighbors_degree(self):
    method local_clustering (line 1824) | def local_clustering(self):
    method global_clustering (line 1846) | def global_clustering(self):
    method _motif_clustering_helper (line 1865) | def _motif_clustering_helper(self, t_func, T, link_attribute=None, nsi...
    method local_cyclemotif_clustering (line 1908) | def local_cyclemotif_clustering(self, link_attribute=None):
    method local_midmotif_clustering (line 1931) | def local_midmotif_clustering(self, link_attribute=None):
    method local_inmotif_clustering (line 1954) | def local_inmotif_clustering(self, link_attribute=None):
    method local_outmotif_clustering (line 1977) | def local_outmotif_clustering(self, link_attribute=None):
    method nsi_local_cyclemotif_clustering (line 2001) | def nsi_local_cyclemotif_clustering(self, link_attribute=None, typical...
    method nsi_local_midmotif_clustering (line 2049) | def nsi_local_midmotif_clustering(self, link_attribute=None, typical_w...
    method nsi_local_inmotif_clustering (line 2097) | def nsi_local_inmotif_clustering(self, link_attribute=None, typical_we...
    method nsi_local_outmotif_clustering (line 2145) | def nsi_local_outmotif_clustering(self, link_attribute=None, typical_w...
    method transitivity (line 2191) | def transitivity(self):
    method higher_order_transitivity (line 2209) | def higher_order_transitivity(self, order, estimate=False):
    method local_cliquishness (line 2259) | def local_cliquishness(self, order):
    method weighted_local_clustering (line 2306) | def weighted_local_clustering(weighted_A):
    method nsi_twinness (line 2345) | def nsi_twinness(self):
    method assortativity (line 2385) | def assortativity(self):
    method nsi_local_clustering (line 2415) | def nsi_local_clustering(self, typical_weight=None):
    method nsi_global_clustering (line 2473) | def nsi_global_clustering(self):
    method nsi_transitivity (line 2502) | def nsi_transitivity(self):
    method nsi_local_soffer_clustering (line 2523) | def nsi_local_soffer_clustering(self):
    method path_lengths (line 2570) | def path_lengths(self, link_attribute=None):
    method average_path_length (line 2615) | def average_path_length(self, link_attribute=None):
    method nsi_average_path_length (line 2664) | def nsi_average_path_length(self):
    method diameter (line 2709) | def diameter(self, directed=True, only_connected=True):
    method matching_index (line 2732) | def matching_index(self):
    method link_betweenness (line 2757) | def link_betweenness(self):
    method edge_betweenness (line 2796) | def edge_betweenness(self):
    method betweenness (line 2824) | def betweenness(self, link_attribute=None):
    method interregional_betweenness (line 2849) | def interregional_betweenness(self, sources=None, targets=None):
    method nsi_interregional_betweenness (line 2885) | def nsi_interregional_betweenness(self, sources, targets):
    method nsi_betweenness (line 2912) | def nsi_betweenness(self, sources=None, targets=None,
    method _nsi_betweenness (line 2959) | def _nsi_betweenness(self, is_source: Tuple[MASK], targets: Tuple[NODE],
    method eigenvector_centrality (line 3000) | def eigenvector_centrality(self):
    method nsi_eigenvector_centrality (line 3024) | def nsi_eigenvector_centrality(self):
    method pagerank (line 3064) | def pagerank(self, link_attribute=None, use_directed=True):
    method closeness (line 3097) | def closeness(self, link_attribute=None):
    method nsi_closeness (line 3154) | def nsi_closeness(self):
    method nsi_harmonic_closeness (line 3191) | def nsi_harmonic_closeness(self):
    method nsi_exponential_closeness (line 3220) | def nsi_exponential_closeness(self):
    method arenas_betweenness (line 3248) | def arenas_betweenness(self):
    method _mpi_nsi_arenas_betweenness (line 3347) | def _mpi_nsi_arenas_betweenness(
    method nsi_arenas_betweenness (line 3392) | def nsi_arenas_betweenness(self, exclude_neighbors=True,
    method newman_betweenness (line 3584) | def newman_betweenness(self):
    method nsi_newman_betweenness (line 3706) | def nsi_newman_betweenness(self, add_local_ends=False):
    method global_efficiency (line 3888) | def global_efficiency(self, link_attribute=None):
    method nsi_global_efficiency (line 3926) | def nsi_global_efficiency(self):
    method distance_based_measures (line 3944) | def distance_based_measures(self, replace_inf_by=None):
    method local_vulnerability (line 4013) | def local_vulnerability(self, link_attribute=None):
    method coreness (line 4067) | def coreness(self):
    method msf_synchronizability (line 4091) | def msf_synchronizability(self):
    method hamming_distance_from (line 4146) | def hamming_distance_from(self, other_network):
    method spreading (line 4173) | def spreading(self, alpha=None):
    method nsi_spreading (line 4188) | def nsi_spreading(self, alpha=None):

FILE: src/pyunicorn/core/resistive_network.py
  class ResNetwork (line 53) | class ResNetwork(GeoNetwork):
    method __init__ (line 75) | def __init__(self, resistances, grid=None, adjacency=None, edge_list=N...
    method __str__ (line 145) | def __str__(self):
    method SmallTestNetwork (line 156) | def SmallTestNetwork():
    method SmallComplexNetwork (line 202) | def SmallComplexNetwork():
    method update_resistances (line 248) | def update_resistances(self, resistances):
    method update_admittance (line 314) | def update_admittance(self):
    method get_admittance (line 360) | def get_admittance(self):
    method update_R (line 378) | def update_R(self):
    method get_R (line 401) | def get_R(self):
    method admittance_lapacian (line 423) | def admittance_lapacian(self):
    method admittive_degree (line 444) | def admittive_degree(self):
    method average_neighbors_admittive_degree (line 461) | def average_neighbors_admittive_degree(self):
    method local_admittive_clustering (line 506) | def local_admittive_clustering(self):
    method global_admittive_clustering (line 566) | def global_admittive_clustering(self):
    method effective_resistance (line 583) | def effective_resistance(self, a, b):
    method average_effective_resistance (line 622) | def average_effective_resistance(self):
    method diameter_effective_resistance (line 653) | def diameter_effective_resistance(self):
    method effective_resistance_closeness_centrality (line 682) | def effective_resistance_closeness_centrality(self, a):
    method vertex_current_flow_betweenness (line 712) | def vertex_current_flow_betweenness(self, i):
    method edge_current_flow_betweenness (line 752) | def edge_current_flow_betweenness(self):

FILE: src/pyunicorn/core/spatial_network.py
  class SpatialNetwork (line 34) | class SpatialNetwork(Network):
    method __init__ (line 47) | def __init__(self, grid: Grid, adjacency=None, edge_list=None,
    method __cache_state__ (line 71) | def __cache_state__(self) -> Tuple[Hashable, ...]:
    method __str__ (line 74) | def __str__(self):
    method save (line 85) | def save(self, filename, fileformat=None, *args, **kwds):
    method Load (line 135) | def Load(filename, fileformat=None, silence_level=0, *args, **kwds):
    method SmallTestNetwork (line 203) | def SmallTestNetwork():
    method Model (line 224) | def Model(network_model, grid, **kwargs):
    method randomly_rewire_geomodel_I (line 237) | def randomly_rewire_geomodel_I(self, distance_matrix, iterations,
    method randomly_rewire_geomodel_II (line 298) | def randomly_rewire_geomodel_II(self, distance_matrix,
    method randomly_rewire_geomodel_III (line 349) | def randomly_rewire_geomodel_III(self, distance_matrix,
    method set_random_links_by_distance (line 403) | def set_random_links_by_distance(self, a, b):
    method link_distance_distribution (line 447) | def link_distance_distribution(self, n_bins, grid_type="euclidean",
    method _calculate_general_average_link_distance (line 510) | def _calculate_general_average_link_distance(self, adjacency, degree,
    method average_link_distance (line 551) | def average_link_distance(self, geometry_corrected=False):
    method inaverage_link_distance (line 581) | def inaverage_link_distance(self, geometry_corrected=False):
    method outaverage_link_distance (line 607) | def outaverage_link_distance(self, geometry_corrected=False):
    method max_link_distance (line 633) | def max_link_distance(self):
    method distance (line 662) | def distance(self):
    method average_distance_weighted_path_length (line 671) | def average_distance_weighted_path_length(self):
    method distance_weighted_closeness (line 690) | def distance_weighted_closeness(self):
    method local_distance_weighted_vulnerability (line 709) | def local_distance_weighted_vulnerability(self):

FILE: src/pyunicorn/eventseries/event_series.py
  class EventSeries (line 39) | class EventSeries(Cached):
    method __init__ (line 42) | def __init__(self, data, timestamps=None, taumax=np.inf, lag=0.0,
    method __cache_state__ (line 158) | def __cache_state__(self) -> Tuple[Hashable, ...]:
    method __str__ (line 163) | def __str__(self):
    method get_event_matrix (line 171) | def get_event_matrix(self):
    method _symmetrization_directed (line 175) | def _symmetrization_directed(matrix):
    method _symmetrization_symmetric (line 187) | def _symmetrization_symmetric(matrix):
    method _symmetrization_antisym (line 199) | def _symmetrization_antisym(matrix):
    method _symmetrization_mean (line 211) | def _symmetrization_mean(matrix):
    method _symmetrization_max (line 224) | def _symmetrization_max(matrix):
    method _symmetrization_min (line 237) | def _symmetrization_min(matrix):
    method make_event_matrix (line 250) | def make_event_matrix(data, threshold_method='quantile',
    method event_synchronization (line 429) | def event_synchronization(eventseriesx, eventseriesy, ts1=None, ts2=None,
    method event_coincidence_analysis (line 515) | def event_coincidence_analysis(eventseriesx, eventseriesy, taumax,
    method _eca_coincidence_rate (line 587) | def _eca_coincidence_rate(self, eventseriesx, eventseriesy,
    method event_series_analysis (line 704) | def event_series_analysis(self, method='ES', symmetrization='directed',
    method _ndim_event_synchronization (line 776) | def _ndim_event_synchronization(self):
    method _ndim_event_coincidence_analysis (line 801) | def _ndim_event_coincidence_analysis(self, window_type='symmetric'):
    method _empirical_percentiles (line 830) | def _empirical_percentiles(self, method=None, n_surr=1000,
    method event_analysis_significance (line 911) | def event_analysis_significance(self, method=None,

FILE: src/pyunicorn/funcnet/coupling_analysis.py
  class CouplingAnalysis (line 36) | class CouplingAnalysis:
    method __init__ (line 49) | def __init__(self, data, silence_level=0):
    method __str__ (line 71) | def __str__(self):
    method test_data (line 77) | def test_data():
    method symmetrize_by_absmax (line 91) | def symmetrize_by_absmax(self, similarity_matrix, lag_matrix):
    method cross_correlation (line 139) | def cross_correlation(self, tau_max=0, lag_mode='max'):
    method mutual_information (line 225) | def mutual_information(self, tau_max=0, estimator='knn',
    method information_transfer (line 414) | def information_transfer(self, tau_max=0, estimator='knn',
    method _par_corr_to_cmi (line 619) | def _par_corr_to_cmi(par_corr):
    method get_nearest_neighbors (line 634) | def get_nearest_neighbors(array, xyz, k, standardize=True):
    method _quantile_bin_array (line 679) | def _quantile_bin_array(array, bins=6):
    method bincount_hist (line 713) | def bincount_hist(symb_array):
    method create_plogp (line 750) | def create_plogp(T):

FILE: src/pyunicorn/funcnet/coupling_analysis_pure_python.py
  class CouplingAnalysisPurePython (line 31) | class CouplingAnalysisPurePython:
    method __init__ (line 45) | def __init__(self, dataarray, only_tri=False, silence_level=0):
    method __str__ (line 100) | def __str__(self):
    method cross_correlation (line 117) | def cross_correlation(self, tau_max=0, lag_mode='all'):
    method shuffled_surrogate_for_cc (line 168) | def shuffled_surrogate_for_cc(self, fourier=False, tau_max=1,
    method time_surrogate_for_cc (line 215) | def time_surrogate_for_cc(self, sample_range=100, tau_max=1,
    method _calculate_cc (line 248) | def _calculate_cc(self, array, tau_max, lag_mode):
    method mutual_information (line 325) | def mutual_information(self, bins=16, tau_max=0, lag_mode='all'):
    method mutual_information_edges (line 393) | def mutual_information_edges(self, bins=16, tau=0):
    method shuffled_surrogate_for_mi (line 430) | def shuffled_surrogate_for_mi(self, fourier=False, bins=16, tau_max=0,
    method time_surrogate_for_mi (line 494) | def time_surrogate_for_mi(self, bins=16, sample_range=100, tau_max=1,
    method _calculate_mi (line 545) | def _calculate_mi(self, array, corr_range, bins, tau_max, lag_mode):
    method correlatedNoiseSurrogates (line 650) | def correlatedNoiseSurrogates(self, original):

FILE: src/pyunicorn/timeseries/cross_recurrence_plot.py
  class CrossRecurrencePlot (line 30) | class CrossRecurrencePlot(RecurrencePlot):
    method __init__ (line 65) | def __init__(self, x, y, metric="supremum", normalize=False,
    method __str__ (line 157) | def __str__(self):
    method x_embedded (line 167) | def x_embedded(self) -> np.ndarray:
    method x_embedded (line 174) | def x_embedded(self, embedding: np.ndarray):
    method y_embedded (line 179) | def y_embedded(self) -> np.ndarray:
    method y_embedded (line 186) | def y_embedded(self, embedding: np.ndarray):
    method recurrence_matrix (line 194) | def recurrence_matrix(self):
    method distance_matrix (line 203) | def distance_matrix(self, metric):
    method manhattan_distance_matrix (line 221) | def manhattan_distance_matrix(self):
    method euclidean_distance_matrix (line 239) | def euclidean_distance_matrix(self):
    method supremum_distance_matrix (line 253) | def supremum_distance_matrix(self):
    method set_fixed_threshold (line 266) | def set_fixed_threshold(self, threshold):
    method set_fixed_recurrence_rate (line 286) | def set_fixed_recurrence_rate(self, recurrence_rate):
    method recurrence_rate (line 313) | def recurrence_rate(self):
    method cross_recurrence_rate (line 326) | def cross_recurrence_rate(self):
    method balance (line 335) | def balance(self):
    method diagline_dist (line 357) | def diagline_dist(self):
    method vertline_dist (line 363) | def vertline_dist(self):
    method white_vertline_dist (line 369) | def white_vertline_dist(self):

FILE: src/pyunicorn/timeseries/inter_system_recurrence_network.py
  class InterSystemRecurrenceNetwork (line 36) | class InterSystemRecurrenceNetwork(InteractingNetworks):
    method __init__ (line 71) | def __init__(self, x, y, metric="supremum", normalize=False,
    method __str__ (line 204) | def __str__(self):
    method __cache_state__ (line 218) | def __cache_state__(self) -> Tuple[Hashable, ...]:
    method inter_system_recurrence_matrix (line 225) | def inter_system_recurrence_matrix(self):
    method set_fixed_threshold (line 247) | def set_fixed_threshold(self, threshold):
    method set_fixed_recurrence_rate (line 278) | def set_fixed_recurrence_rate(self, density):
    method internal_recurrence_rates (line 314) | def internal_recurrence_rates(self):
    method cross_recurrence_rate (line 324) | def cross_recurrence_rate(self):
    method cross_global_clustering_xy (line 333) | def cross_global_clustering_xy(self):
    method cross_global_clustering_yx (line 346) | def cross_global_clustering_yx(self):
    method cross_transitivity_xy (line 359) | def cross_transitivity_xy(self):
    method cross_transitivity_yx (line 372) | def cross_transitivity_yx(self):

FILE: src/pyunicorn/timeseries/joint_recurrence_network.py
  class JointRecurrenceNetwork (line 32) | class JointRecurrenceNetwork(JointRecurrencePlot, Network):
    method __init__ (line 72) | def __init__(self, x, y, metric=("supremum", "supremum"),
    method __str__ (line 154) | def __str__(self):
    method set_fixed_threshold (line 165) | def set_fixed_threshold(self, threshold):
    method set_fixed_threshold_std (line 186) | def set_fixed_threshold_std(self, threshold_std):
    method set_fixed_recurrence_rate (line 209) | def set_fixed_recurrence_rate(self, recurrence_rate):

FILE: src/pyunicorn/timeseries/joint_recurrence_plot.py
  class JointRecurrencePlot (line 26) | class JointRecurrencePlot(RecurrencePlot):
    method __init__ (line 68) | def __init__(self, x, y, metric=("supremum", "supremum"),
    method __str__ (line 215) | def __str__(self):
    method recurrence_matrix (line 228) | def recurrence_matrix(self):
    method set_fixed_threshold (line 241) | def set_fixed_threshold(self, threshold):
    method set_fixed_threshold_std (line 278) | def set_fixed_threshold_std(self, threshold_std):
    method set_fixed_recurrence_rate (line 299) | def set_fixed_recurrence_rate(self, recurrence_rate):

FILE: src/pyunicorn/timeseries/recurrence_network.py
  class RecurrenceNetwork (line 32) | class RecurrenceNetwork(RecurrencePlot, Network):
    method __init__ (line 60) | def __init__(self, time_series, metric="supremum", normalize=False,
    method __str__ (line 148) | def __str__(self):
    method set_fixed_threshold (line 159) | def set_fixed_threshold(self, threshold):
    method set_fixed_threshold_std (line 179) | def set_fixed_threshold_std(self, threshold_std):
    method set_fixed_recurrence_rate (line 201) | def set_fixed_recurrence_rate(self, recurrence_rate):
    method set_fixed_local_recurrence_rate (line 221) | def set_fixed_local_recurrence_rate(self, local_recurrence_rate):
    method set_adaptive_neighborhood_size (line 247) | def set_adaptive_neighborhood_size(self, adaptive_neighborhood_size,
    method transitivity_dim_single_scale (line 281) | def transitivity_dim_single_scale(self):
    method local_clustering_dim_single_scale (line 300) | def local_clustering_dim_single_scale(self):

FILE: src/pyunicorn/timeseries/recurrence_plot.py
  class RecurrencePlot (line 42) | class RecurrencePlot(Cached):
    method __init__ (line 82) | def __init__(self, time_series: NDArray, metric: str = "supremum",
    method __cache_state__ (line 230) | def __cache_state__(self) -> Tuple[Hashable, ...]:
    method __str__ (line 233) | def __str__(self):
    method embedding (line 243) | def embedding(self) -> np.ndarray:
    method embedding (line 251) | def embedding(self, embedding: np.ndarray):
    method recurrence_matrix (line 260) | def recurrence_matrix(self):
    method distance_matrix (line 274) | def distance_matrix(self, metric: str):
    method normalize_time_series (line 292) | def normalize_time_series(time_series):
    method legendre_coordinates (line 319) | def legendre_coordinates(x, dim=3, t=None, p=None, tau_w="est"):
    method embed_time_series (line 400) | def embed_time_series(time_series, dim, tau):
    method permutation_entropy (line 427) | def permutation_entropy(self, normalize=True):
    method complexity_entropy (line 456) | def complexity_entropy(self):
    method manhattan_distance_matrix (line 515) | def manhattan_distance_matrix(self):
    method euclidean_distance_matrix (line 527) | def euclidean_distance_matrix(self):
    method supremum_distance_matrix (line 539) | def supremum_distance_matrix(self):
    method set_fixed_threshold (line 549) | def set_fixed_threshold(self, threshold):
    method set_fixed_threshold_std (line 573) | def set_fixed_threshold_std(self, threshold_std):
    method set_fixed_recurrence_rate (line 591) | def set_fixed_recurrence_rate(self, recurrence_rate):
    method set_fixed_local_recurrence_rate (line 611) | def set_fixed_local_recurrence_rate(self, local_recurrence_rate):
    method set_adaptive_neighborhood_size (line 640) | def set_adaptive_neighborhood_size(self, adaptive_neighborhood_size,
    method threshold_from_recurrence_rate (line 685) | def threshold_from_recurrence_rate(distance, recurrence_rate: float):
    method threshold_from_recurrence_rate_fast (line 715) | def threshold_from_recurrence_rate_fast(distance, recurrence_rate,
    method bootstrap_distance_matrix (line 751) | def bootstrap_distance_matrix(embedding, metric, M):
    method rqa_summary (line 786) | def rqa_summary(self, l_min=2, v_min=2):
    method recurrence_rate (line 806) | def recurrence_rate(self):
    method recurrence_probability (line 826) | def recurrence_probability(self, lag=0):
    method diagline_dist (line 847) | def diagline_dist(self):
    method rejection_sampling (line 910) | def rejection_sampling(dist, M):
    method resample_diagline_dist (line 937) | def resample_diagline_dist(self, M):
    method max_diaglength (line 969) | def max_diaglength(self):
    method determinism (line 981) | def determinism(self, l_min=2, resampled_dist=None):
    method average_diaglength (line 1010) | def average_diaglength(self, l_min=2, resampled_dist=None):
    method diag_entropy (line 1037) | def diag_entropy(self, l_min=2, resampled_dist=None):
    method vertline_dist (line 1072) | def vertline_dist(self):
    method resample_vertline_dist (line 1128) | def resample_vertline_dist(self, M):
    method max_vertlength (line 1160) | def max_vertlength(self):
    method laminarity (line 1172) | def laminarity(self, v_min=2, resampled_dist=None):
    method average_vertlength (line 1199) | def average_vertlength(self, v_min=2, resampled_dist=None):
    method trapping_time (line 1227) | def trapping_time(self, v_min=2, resampled_dist=None):
    method vert_entropy (line 1233) | def vert_entropy(self, v_min=2, resampled_dist=None):
    method white_vertline_dist (line 1268) | def white_vertline_dist(self):
    method max_white_vertlength (line 1294) | def max_white_vertlength(self):
    method average_white_vertlength (line 1307) | def average_white_vertlength(self, w_min=1):
    method mean_recurrence_time (line 1332) | def mean_recurrence_time(self, w_min=1):
    method white_vert_entropy (line 1338) | def white_vert_entropy(self, w_min=1):
    method twins (line 1367) | def twins(self, min_dist=7):
    method twin_surrogates (line 1397) | def twin_surrogates(self, n_surrogates=1, min_dist=7):

FILE: src/pyunicorn/timeseries/surrogates.py
  class Surrogates (line 42) | class Surrogates(Cached):
    method __init__ (line 58) | def __init__(self, original_data, silence_level=1):
    method __str__ (line 89) | def __str__(self):
    method __cache_state__ (line 95) | def __cache_state__(self) -> Tuple[Hashable, ...]:
    method embedding (line 99) | def embedding(self) -> np.ndarray:
    method embedding (line 107) | def embedding(self, embedding: np.ndarray):
    method SmallTestData (line 116) | def SmallTestData():
    method embed_time_series_array (line 138) | def embed_time_series_array(time_series_array, dimension, delay,
    method normalize_original_data (line 175) | def normalize_original_data(self):
    method recurrence_plot (line 203) | def recurrence_plot(embedding, threshold, silence_level=1):
    method twins (line 240) | def twins(self, threshold, min_dist=7):
    method original_data_fft (line 281) | def original_data_fft(self):
    method white_noise_surrogates (line 290) | def white_noise_surrogates(self):
    method correlated_noise_surrogates (line 324) | def correlated_noise_surrogates(self):
    method AAFT_surrogates (line 382) | def AAFT_surrogates(self):
    method refined_AAFT_surrogates (line 419) | def refined_AAFT_surrogates(self, n_iterations, output="true_amplitude...
    method twin_surrogates (line 478) | def twin_surrogates(self, dimension, delay, threshold, min_dist=7):
    method eval_fast_code (line 522) | def eval_fast_code(function, original_data, surrogates):
    method test_pearson_correlation (line 551) | def test_pearson_correlation(original_data, surrogates):
    method test_mutual_information (line 576) | def test_mutual_information(original_data, surrogates, n_bins=32):
    method original_distribution (line 610) | def original_distribution(self, test_function, n_bins=100):
    method test_threshold_significance (line 642) | def test_threshold_significance(self, surrogate_function, test_function,

FILE: src/pyunicorn/timeseries/visibility_graph.py
  class VisibilityGraph (line 36) | class VisibilityGraph(InteractingNetworks):
    method __init__ (line 50) | def __init__(self, time_series, timings=None, missing_values=False,
    method __str__ (line 104) | def __str__(self):
    method visibility_relations (line 116) | def visibility_relations(self):
    method visibility_relations_horizontal (line 140) | def visibility_relations_horizontal(self):
    method visibility (line 160) | def visibility(self, node1, node2):
    method visibility_single (line 169) | def visibility_single(self, node):
    method retarded_degree (line 178) | def retarded_degree(self):
    method advanced_degree (line 189) | def advanced_degree(self):
    method retarded_local_clustering (line 200) | def retarded_local_clustering(self):
    method advanced_local_clustering (line 221) | def advanced_local_clustering(self):
    method retarded_closeness (line 242) | def retarded_closeness(self):
    method advanced_closeness (line 253) | def advanced_closeness(self):
    method retarded_betweenness (line 264) | def retarded_betweenness(self):
    method advanced_betweenness (line 279) | def advanced_betweenness(self):
    method trans_betweenness (line 294) | def trans_betweenness(self):
    method boundary_corrected_degree (line 314) | def boundary_corrected_degree(self):
    method boundary_corrected_closeness (line 325) | def boundary_corrected_closeness(self):

FILE: src/pyunicorn/utils/mpi.py
  class MPIException (line 70) | class MPIException(Exception):
    method __init__ (line 71) | def __init__(self, value):
    method __str__ (line 75) | def __str__(self):
  function submit_call (line 160) | def submit_call(name_to_call, args=(), kwargs={},
  function get_result (line 291) | def get_result(id):
  function get_next_result (line 334) | def get_next_result():
  function info (line 353) | def info():
  function terminate (line 413) | def terminate():
  function abort (line 429) | def abort():
  function serve (line 449) | def serve():
  function abort (line 500) | def abort():
  function run (line 511) | def run(verbose=False):

FILE: tests/conftest.py
  function metric (line 23) | def metric(request) -> str:
  function reanalysis_data (line 32) | def reanalysis_data() -> Path:

FILE: tests/test_climate/test_climate_data.py
  function test_SmallTestData (line 27) | def test_SmallTestData():
  function test_phase_indices (line 42) | def test_phase_indices():
  function test_indices_selected_phases (line 48) | def test_indices_selected_phases():
  function test_phase_mean (line 54) | def test_phase_mean():
  function test_anomaly (line 64) | def test_anomaly():
  function test_shuffled_anomaly (line 71) | def test_shuffled_anomaly():
  function test_window (line 81) | def test_window():
  function test_set_global_window (line 94) | def test_set_global_window():

FILE: tests/test_climate/test_climate_network.py
  function test_str (line 22) | def test_str(capsys):
  function test_SmallTestNetwork (line 38) | def test_SmallTestNetwork():
  function test_link_density_function (line 46) | def test_link_density_function():
  function test_threshold_from_link_density (line 55) | def test_threshold_from_link_density():
  function test_similarity_measure (line 62) | def test_similarity_measure():
  function test_non_local (line 68) | def test_non_local():
  function test_set_non_local (line 74) | def test_set_non_local():
  function test_threshold (line 85) | def test_threshold():
  function test_set_threshold (line 91) | def test_set_threshold():
  function test_set_link_density (line 104) | def test_set_link_density():
  function test_correlation_distance (line 117) | def test_correlation_distance():
  function test_correlation_distance_weighted_closeness (line 128) | def test_correlation_distance_weighted_closeness():
  function test_local_correlation_distance_weighted_vulnerability (line 135) | def test_local_correlation_distance_weighted_vulnerability():

FILE: tests/test_climate/test_coupled_climate_network.py
  function test_internal_link_density (line 22) | def test_internal_link_density():

FILE: tests/test_climate/test_eventseries_climatenetwork.py
  function test_str (line 25) | def test_str(capsys):
  function test_SmallTestData (line 53) | def test_SmallTestData():

FILE: tests/test_climate/test_map_plot.py
  class TestMapPlot (line 28) | class TestMapPlot:
    method test_plot (line 34) | def test_plot(reanalysis_data: Path):

FILE: tests/test_climate/test_tsonis.py
  function test_str (line 23) | def test_str(capsys):
  function test_SmallTestNetwork (line 41) | def test_SmallTestNetwork():
  function test_calculate_similarity_measure (line 49) | def test_calculate_similarity_measure():
  function test_correlation (line 62) | def test_correlation():
  function test_winter_only (line 74) | def test_winter_only():
  function test_set_winter_only (line 80) | def test_set_winter_only():
  function test_correlation_weighted_average_path_length (line 89) | def test_correlation_weighted_average_path_length():
  function test_correlation_weighted_closeness (line 96) | def test_correlation_weighted_closeness():
  function test_local_correlation_weighted_vulnerability (line 103) | def test_local_correlation_weighted_vulnerability():

FILE: tests/test_core/ResistiveNetwork_utils.py
  function makeNW (line 12) | def makeNW(idI, idJ, val=None):
  function parallelCopy (line 39) | def parallelCopy(nw, a, b):
  function serialCopy (line 84) | def serialCopy(nw):
  function nx2nw (line 110) | def nx2nw(G):

FILE: tests/test_core/TestResistiveNetwork-circuits.py
  function testParallelTrivial (line 21) | def testParallelTrivial():
  function testParallelLessTrivial (line 58) | def testParallelLessTrivial():
  function testParallelRandom (line 157) | def testParallelRandom():
  function testSerialTrivial (line 197) | def testSerialTrivial():
  function testSerialRandom (line 240) | def testSerialRandom():

FILE: tests/test_core/TestResistiveNetwork-complexInput.py
  function testComplexAdmittance (line 28) | def testComplexAdmittance():
  function testPinvSymmetry (line 36) | def testPinvSymmetry():
  function testAdmittiveDegree (line 43) | def testAdmittiveDegree():

FILE: tests/test_core/TestResistiveNetwork-cython.py
  function testVCFB (line 18) | def testVCFB():
  function testECFB (line 41) | def testECFB():

FILE: tests/test_core/TestResistiveNetwork-types.py
  function testAdmittiveDegreeType (line 17) | def testAdmittiveDegreeType():

FILE: tests/test_core/test_cache.py
  function check_wrefc (line 28) | def check_wrefc(referent: object, count: int):
  function check_srefc (line 35) | def check_srefc(referent: object, count: int):
  function check_single_sref (line 42) | def check_single_sref(referent: object, obj: object, attr: str):
  class TestCached (line 58) | class TestCached:
    class Foo (line 63) | class Foo(Cached):
      method __cache_state__ (line 66) | def __cache_state__(self):
      method foo1 (line 70) | def foo1(self, a: int):
      method foo2 (line 75) | def foo2(self, *args):
      method bar (line 80) | def bar(self):
    class Bar (line 84) | class Bar(Cached):
      method __init__ (line 85) | def __init__(self):
      method __cache_state__ (line 88) | def __cache_state__(self):
    method test_args (line 92) | def test_args(cls, capfd: pytest.CaptureFixture):
    method test_instance_immutable (line 170) | def test_instance_immutable(cls):
    method test_instance_mutable (line 201) | def test_instance_mutable(cls):
    method test_instance_rec (line 242) | def test_instance_rec(cls):
    method test_attributes (line 290) | def test_attributes(cls):
    method test_disable (line 367) | def test_disable(cls):
    method test_refcount (line 403) | def test_refcount(cls):

FILE: tests/test_core/test_data.py
  function test_observable (line 22) | def test_observable():
  function test_window (line 49) | def test_window():
  function test_set_window (line 59) | def test_set_window():
  function test_set_global_window (line 74) | def test_set_global_window():
  function test_normalize_time_series_array (line 91) | def test_normalize_time_series_array():
  function test_next_power_2 (line 108) | def test_next_power_2():
  function test_zero_pad_data (line 113) | def test_zero_pad_data():
  function test_cos_window (line 126) | def test_cos_window():

FILE: tests/test_core/test_geo_grid.py
  function test_RegularGrid (line 22) | def test_RegularGrid():
  function test_coord_sequence_from_rect_grid (line 38) | def test_coord_sequence_from_rect_grid():
  function test_lat_sequence (line 45) | def test_lat_sequence():
  function test_lon_sequence (line 51) | def test_lon_sequence():
  function test_convert_lon_coordinates (line 57) | def test_convert_lon_coordinates():
  function test_node_number2d (line 64) | def test_node_number2d():
  function test_cos_lat (line 70) | def test_cos_lat():
  function test_sin_lat (line 76) | def test_sin_lat():
  function test_cos_lon (line 82) | def test_cos_lon():
  function test_sin_lon (line 88) | def test_sin_lon():
  function test_angular_distance (line 94) | def test_angular_distance():
  function test_boundaries (line 105) | def test_boundaries():
  function test_geometric_distance_distribution (line 112) | def test_geometric_distance_distribution():
  function test_region_indices (line 122) | def test_region_indices():

FILE: tests/test_core/test_geo_network.py
  function test_ErdosRenyi (line 24) | def test_ErdosRenyi(capsys):
  function test_ConfigurationModel (line 39) | def test_ConfigurationModel():
  function test_randomly_rewire_geomodel_I (line 50) | def test_randomly_rewire_geomodel_I():
  function test_set_random_links_by_distance (line 59) | def test_set_random_links_by_distance():
  function test_geographical_distribution (line 68) | def test_geographical_distribution():
  function test_geographical_cumulative_distribution (line 75) | def test_geographical_cumulative_distribution():
  function test_link_distance_distribution (line 83) | def test_link_distance_distribution():
  function test_area_weighted_connectivity (line 101) | def test_area_weighted_connectivity():
  function test_inarea_weighted_connectivity (line 108) | def test_inarea_weighted_connectivity():
  function test_outarea_weighted_connectivity (line 115) | def test_outarea_weighted_connectivity():
  function test_area_weighted_connectivity_distribution (line 122) | def test_area_weighted_connectivity_distribution():
  function test_inarea_weighted_connectivity_distribution (line 129) | def test_inarea_weighted_connectivity_distribution():
  function test_outarea_weighted_connectivity_distribution (line 136) | def test_outarea_weighted_connectivity_distribution():
  function test_area_weighted_connectivity_cumulative_distribution (line 143) | def test_area_weighted_connectivity_cumulative_distribution():
  function test_inarea_weighted_connectivity_cumulative_distribution (line 150) | def test_inarea_weighted_connectivity_cumulative_distribution():
  function test_outarea_weighted_connectivity_cumulative_distribution (line 157) | def test_outarea_weighted_connectivity_cumulative_distribution():
  function test_average_neighbor_area_weighted_connectivity (line 165) | def test_average_neighbor_area_weighted_connectivity():
  function test_max_neighbor_area_weighted_connectivity (line 173) | def test_max_neighbor_area_weighted_connectivity():
  function test_average_link_distance (line 181) | def test_average_link_distance():
  function test_inaverage_link_distance (line 194) | def test_inaverage_link_distance():
  function test_outaverage_link_distance (line 202) | def test_outaverage_link_distance():
  function test_total_link_distance (line 210) | def test_total_link_distance():
  function test_intotal_link_distance (line 218) | def test_intotal_link_distance():
  function test_outtotal_link_distance (line 226) | def test_outtotal_link_distance():
  function test_connectivity_weighted_distance (line 234) | def test_connectivity_weighted_distance():
  function test_inconnectivity_weighted_distance (line 242) | def test_inconnectivity_weighted_distance():
  function test_outconnectivity_weighted_distance (line 250) | def test_outconnectivity_weighted_distance():
  function test_max_link_distance (line 258) | def test_max_link_distance():
  function test_average_distance_weighted_path_length (line 265) | def test_average_distance_weighted_path_length():
  function test_distance_weighted_closeness (line 271) | def test_distance_weighted_closeness():
  function test_local_distance_weighted_vulnerability (line 278) | def test_local_distance_weighted_vulnerability():
  function test_local_geographical_clustering (line 285) | def test_local_geographical_clustering():

FILE: tests/test_core/test_grid.py
  function test_RegularGrid (line 22) | def test_RegularGrid():
  function test_coord_sequence_from_rect_grid (line 36) | def test_coord_sequence_from_rect_grid():
  function test_sequence (line 43) | def test_sequence():
  function test_node_number (line 49) | def test_node_number():
  function test_node_coordinates (line 55) | def test_node_coordinates():
  function test_grid (line 61) | def test_grid():
  function test_grid_size (line 71) | def test_grid_size():
  function test_geometric_distance_distribution (line 77) | def test_geometric_distance_distribution():
  function test_euclidean_distance (line 87) | def test_euclidean_distance():

FILE: tests/test_core/test_interacting_networks.py
  function test_RandomlyRewireCrossLinks (line 22) | def test_RandomlyRewireCrossLinks():
  function test_internal_adjacency (line 37) | def test_internal_adjacency():
  function test_cross_adjacency (line 48) | def test_cross_adjacency():
  function test_cross_adjacency_sparse (line 60) | def test_cross_adjacency_sparse():
  function test_internal_link_attribute (line 68) | def test_internal_link_attribute():
  function test_cross_link_attribute (line 78) | def test_cross_link_attribute():
  function test_internal_path_lengths (line 88) | def test_internal_path_lengths():
  function test_cross_path_lengths (line 100) | def test_cross_path_lengths():
  function test_number_cross_links (line 112) | def test_number_cross_links():
  function test_total_cross_degree (line 124) | def test_total_cross_degree():
  function test_number_internal_links (line 136) | def test_number_internal_links():
  function test_cross_degree_density (line 148) | def test_cross_degree_density():
  function test_cross_link_density (line 156) | def test_cross_link_density():
  function test_internal_link_density (line 168) | def test_internal_link_density():
  function test_internal_global_clustering (line 180) | def test_internal_global_clustering():
  function test_cross_global_clustering (line 192) | def test_cross_global_clustering():
  function test_cross_global_clustering_sparse (line 208) | def test_cross_global_clustering_sparse():
  function test_cross_transitivity (line 224) | def test_cross_transitivity():
  function test_cross_transitivity_sparse (line 239) | def test_cross_transitivity_sparse():
  function test_cross_average_path_length (line 255) | def test_cross_average_path_length():
  function test_internal_average_path_length (line 267) | def test_internal_average_path_length():
  function test_average_cross_closeness (line 279) | def test_average_cross_closeness():
  function test_global_efficiency (line 287) | def test_global_efficiency():
  function test_cross_degree (line 295) | def test_cross_degree():
  function test_cross_indegree (line 311) | def test_cross_indegree():
  function test_cross_outdegree (line 319) | def test_cross_outdegree():
  function test_internal_degree (line 327) | def test_internal_degree():
  function test_internal_indegree (line 339) | def test_internal_indegree():
  function test_internal_outdegree (line 347) | def test_internal_outdegree():
  function test_cross_local_clustering (line 355) | def test_cross_local_clustering():
  function test_cross_local_clustering_sparse (line 371) | def test_cross_local_clustering_sparse():
  function test_cross_closeness (line 387) | def test_cross_closeness():
  function test_internal_closeness (line 399) | def test_internal_closeness():
  function test_cross_betweenness (line 411) | def test_cross_betweenness():
  function test_internal_betweenness (line 423) | def test_internal_betweenness():
  function test_local_efficiency (line 431) | def test_local_efficiency():
  function test_nsi_cross_degree (line 439) | def test_nsi_cross_degree():
  function test_nsi_cross_mean_degree (line 451) | def test_nsi_cross_mean_degree():
  function test_nsi_internal_degree (line 463) | def test_nsi_internal_degree():
  function test_nsi_cross_local_clustering (line 475) | def test_nsi_cross_local_clustering():
  function test_nsi_cross_closeness_centrality (line 487) | def test_nsi_cross_closeness_centrality():
  function test_nsi_internal_closeness_centrality (line 499) | def test_nsi_internal_closeness_centrality():
  function test_nsi_cross_global_clustering (line 511) | def test_nsi_cross_global_clustering():
  function test_nsi_internal_local_clustering (line 519) | def test_nsi_internal_local_clustering():
  function test_nsi_cross_betweenness (line 531) | def test_nsi_cross_betweenness():
  function test_nsi_cross_edge_density (line 543) | def test_nsi_cross_edge_density():
  function test_nsi_cross_transitivity (line 555) | def test_nsi_cross_transitivity():
  function test_nsi_cross_average_path_length (line 567) | def test_nsi_cross_average_path_length():

FILE: tests/test_core/test_network.py
  function compare_results (line 36) | def compare_results(desired, actual, rev_perm=None):
  function compare_measures (line 51) | def compare_measures(orig, pnets, rev_perms, tasks):
  function compare_permutations (line 58) | def compare_permutations(net, permutations, measures):
  function compare_nsi (line 73) | def compare_nsi(net, nsi_measures):
  function test_int_overflow (line 96) | def test_int_overflow():
  function test_permutations (line 112) | def test_permutations():
  function test_nsi (line 140) | def test_nsi():
  function test_r (line 184) | def test_r():
  function test_r_type_error (line 189) | def test_r_type_error():
  function test_init (line 200) | def test_init():
  function test_str (line 207) | def test_str(capsys):
  function test_len (line 214) | def test_len():
  function test_undirected_copy (line 218) | def test_undirected_copy(capsys):
  function test_splitted_copy (line 232) | def test_splitted_copy(capsys):
  function test_adjacency (line 247) | def test_adjacency():
  function test_set_adjacency (line 254) | def test_set_adjacency(capsys):
  function test_set_node_weights (line 263) | def test_set_node_weights():
  function test_ErdosRenyi (line 273) | def test_ErdosRenyi(capsys):
  function test_BarabasiAlbert_igraph (line 282) | def test_BarabasiAlbert_igraph():
  function test_BarabasiAlbert (line 287) | def test_BarabasiAlbert():
  function test_ConfigurationModel (line 292) | def test_ConfigurationModel():
  function test_WattsStrogatz (line 297) | def test_WattsStrogatz():
  function test_GrowWeights (line 302) | def test_GrowWeights():
  function test_randomly_rewire (line 308) | def test_randomly_rewire(capsys):
  function test_edge_list (line 321) | def test_edge_list():
  function test_undirected_adjacency (line 328) | def test_undirected_adjacency():
  function test_laplacian (line 334) | def test_laplacian():
  function test_laplacian_value_error (line 341) | def test_laplacian_value_error():
  function test_nsi_laplacian (line 346) | def test_nsi_laplacian():
  function test_degree (line 356) | def test_degree():
  function test_indegree (line 367) | def test_indegree(link_attribute, deg_ref):
  function test_outdegree (line 378) | def test_outdegree(link_attribute, deg_ref):
  function test_bildegree (line 389) | def test_bildegree(link_attribute, deg_ref):
  function test_nsi_degree (line 398) | def test_nsi_degree():
  function test_nsi_indegree (line 423) | def test_nsi_indegree(tw, exp, exp_split):
  function test_nsi_outdegree (line 438) | def test_nsi_outdegree(tw, exp, exp_split):
  function test_nsi_bildegree (line 453) | def test_nsi_bildegree(tw, exp, exp_split):
  function test_degree_distribution (line 460) | def test_degree_distribution():
  function test_indegree_distribution (line 466) | def test_indegree_distribution():
  function test_outdegree_distribution (line 472) | def test_outdegree_distribution():
  function test_degree_cdf (line 478) | def test_degree_cdf():
  function test_indegree_cdf (line 483) | def test_indegree_cdf():
  function test_outdegree_cdf (line 488) | def test_outdegree_cdf():
  function test_nsi_degree_histogram (line 493) | def test_nsi_degree_histogram():
  function test_nsi_degree_cumulative_histogram (line 501) | def test_nsi_degree_cumulative_histogram():
  function test_average_neighbors_degree (line 508) | def test_average_neighbors_degree():
  function test_max_neighbors_degree (line 514) | def test_max_neighbors_degree():
  function test_nsi_average_neighbors_degree (line 520) | def test_nsi_average_neighbors_degree():
  function test_nsi_max_neighbors_degree (line 532) | def test_nsi_max_neighbors_degree():
  function test_local_clustering (line 538) | def test_local_clustering():
  function test_global_clustering (line 544) | def test_global_clustering():
  function test_local_cyclemotif_clustering (line 550) | def test_local_cyclemotif_clustering():
  function test_local_midmotif_clustering (line 556) | def test_local_midmotif_clustering():
  function test_local_inmotif_clustering (line 562) | def test_local_inmotif_clustering():
  function test_local_outmotif_clustering (line 568) | def test_local_outmotif_clustering():
  function test_nsi_local_cyclemotif_clustering (line 586) | def test_nsi_local_cyclemotif_clustering(tw, exp, exp_split):
  function test_nsi_local_midmotif_clustering (line 596) | def test_nsi_local_midmotif_clustering():
  function test_nsi_local_inmotif_clustering (line 608) | def test_nsi_local_inmotif_clustering():
  function test_nsi_local_outmotif_clustering (line 622) | def test_nsi_local_outmotif_clustering():
  function test_transitivity (line 636) | def test_transitivity():
  function test_weighted_local_clustering (line 642) | def test_weighted_local_clustering():
  function test_nsi_twinness (line 654) | def test_nsi_twinness():
  function test_assortativity (line 677) | def test_assortativity():
  function test_nsi_local_clustering (line 691) | def test_nsi_local_clustering(tw, exp, exp_split):
  function test_nsi_global_clustering (line 700) | def test_nsi_global_clustering():
  function test_nsi_local_soffer_clustering (line 706) | def test_nsi_local_soffer_clustering():
  function test_path_lengths (line 719) | def test_path_lengths():
  function test_average_path_length (line 730) | def test_average_path_length():
  function test_nsi_average_path_length (line 736) | def test_nsi_average_path_length():
  function test_diameter (line 748) | def test_diameter():
  function test_matching_index (line 754) | def test_matching_index():
  function test_link_betweenness (line 765) | def test_link_betweenness():
  function test_edge_betweenness (line 776) | def test_edge_betweenness():
  function test_betweenness (line 787) | def test_betweenness():
  function test_interregional_betweenness (line 799) | def test_interregional_betweenness():
  function test_nsi_interregional_betweenness (line 811) | def test_nsi_interregional_betweenness():
  function test_nsi_betweenness (line 819) | def test_nsi_betweenness(parallelize):
  function test_nsi_betweenness_directed (line 831) | def test_nsi_betweenness_directed():
  function test_eigenvector_centrality (line 840) | def test_eigenvector_centrality():
  function test_nsi_eigenvector_centrality (line 847) | def test_nsi_eigenvector_centrality():
  function test_pagerank (line 861) | def test_pagerank():
  function test_closeness (line 868) | def test_closeness():
  function test_nsi_closeness (line 875) | def test_nsi_closeness():
  function test_nsi_harmonic_closeness (line 889) | def test_nsi_harmonic_closeness():
  function test_nsi_exponential_closeness (line 903) | def test_nsi_exponential_closeness():
  function test_arenas_betweenness (line 917) | def test_arenas_betweenness():
  function test_nsi_arenas_betweenness (line 924) | def test_nsi_arenas_betweenness():
  function test_newman_betweenness (line 948) | def test_newman_betweenness():
  function test_nsi_newman_betweenness (line 955) | def test_nsi_newman_betweenness():
  function test_global_efficiency (line 978) | def test_global_efficiency():
  function test_nsi_global_efficiency (line 984) | def test_nsi_global_efficiency():
  function test_local_vulnerability (line 990) | def test_local_vulnerability():
  function test_coreness (line 997) | def test_coreness():
  function test_msf_synchronizability (line 1003) | def test_msf_synchronizability():

FILE: tests/test_core/test_resistive_networks.py
  function test_init (line 26) | def test_init(capsys):
  function test_SmallTestNetwork (line 39) | def test_SmallTestNetwork():
  function test_SmallComplexNetwork (line 43) | def test_SmallComplexNetwork():
  function test_update_resistances (line 66) | def test_update_resistances():
  function test_update_admittance (line 87) | def test_update_admittance():
  function test_get_admittance (line 93) | def test_get_admittance():
  function test_update_R (line 105) | def test_update_R():
  function test_get_R (line 111) | def test_get_R():
  function test_admittance_laplacian (line 121) | def test_admittance_laplacian():
  function test_admittive_degree (line 131) | def test_admittive_degree():
  function test_average_neighbors_admittive_degree (line 137) | def test_average_neighbors_admittive_degree():
  function test_local_admittive_clustering (line 143) | def test_local_admittive_clustering():
  function test_global_admittive_clustering (line 149) | def test_global_admittive_clustering():
  function test_effective_resistance (line 155) | def test_effective_resistance():
  function test_average_effective_resistance (line 167) | def test_average_effective_resistance():
  function test_diameter_effective_resistance (line 173) | def test_diameter_effective_resistance():
  function test_effective_resistance_closeness_centrality (line 179) | def test_effective_resistance_closeness_centrality():
  function test_vertex_current_flow_betweenness (line 191) | def test_vertex_current_flow_betweenness():
  function test_edge_current_flow_betweenness (line 199) | def test_edge_current_flow_betweenness():

FILE: tests/test_core/test_spatial_network.py
  function test_randomly_rewire_geomodel_I (line 22) | def test_randomly_rewire_geomodel_I():
  function test_set_random_links_by_distance (line 31) | def test_set_random_links_by_distance():
  function test_link_distance_distribution (line 40) | def test_link_distance_distribution():
  function test_average_link_distance (line 52) | def test_average_link_distance():
  function test_inaverage_link_distance (line 65) | def test_inaverage_link_distance():
  function test_outaverage_link_distance (line 73) | def test_outaverage_link_distance():
  function test_max_link_distance (line 81) | def test_max_link_distance():
  function test_average_distance_weighted_path_length (line 88) | def test_average_distance_weighted_path_length():
  function test_distance_weighted_closeness (line 95) | def test_distance_weighted_closeness():
  function test_local_distance_weighted_vulnerability (line 102) | def test_local_distance_weighted_vulnerability():

FILE: tests/test_eventseries/test_event_series.py
  function create_test_data (line 22) | def create_test_data():
  function test_EventSeries_init (line 32) | def test_EventSeries_init():
  function test_make_event_matrix (line 39) | def test_make_event_matrix():
  function eca_second_implementaion (line 84) | def eca_second_implementaion(eventseriesx, eventseriesy, *, ts1=None,
  function test_eca (line 171) | def test_eca():
  function eca_implementation_for_symmetric_window (line 191) | def eca_implementation_for_symmetric_window(es1, es2, *, ts1=None, ts2=N...
  function es_second_implementation (line 234) | def es_second_implementation(es1, es2, *, ts1=None, ts2=None, taumax=np....
  function test_es (line 312) | def test_es():
  function eca_matrix_second_implementation (line 333) | def eca_matrix_second_implementation(eventmatrix, taumax,
  function test_vectorized_eca (line 370) | def test_vectorized_eca():
  function es_matrix_second_implementation (line 415) | def es_matrix_second_implementation(eventmatrix, taumax):
  function test_vectorized_es (line 427) | def test_vectorized_es():
  function test_significance (line 489) | def test_significance():

FILE: tests/test_funcnet/test_coupling_analysis.py
  function create_test_data (line 27) | def create_test_data():
  function test_symmetrize_by_absmax (line 37) | def test_symmetrize_by_absmax():
  function test_cross_correlation_max (line 72) | def test_cross_correlation_max():
  function test_cross_correlation_all (line 85) | def test_cross_correlation_all():
  function test_mutual_information_knn (line 96) | def test_mutual_information_knn():
  function test_mutual_information_binning (line 112) | def test_mutual_information_binning():
  function test_mutual_information_gauss (line 129) | def test_mutual_information_gauss():
  function test_mutual_information_value_error (line 145) | def test_mutual_information_value_error():
  function test_information_transfer_knn (line 152) | def test_information_transfer_knn():
  function test_information_transfer_gauss (line 166) | def test_information_transfer_gauss():
  function test_information_transfer_value_error (line 182) | def test_information_transfer_value_error():

FILE: tests/test_funcnet/test_coupling_analysis_pure_python.py
  function test_cross_correlation_all (line 24) | def test_cross_correlation_all():
  function test_cross_correlation_sum (line 42) | def test_cross_correlation_sum():
  function test_cross_correlation_max (line 57) | def test_cross_correlation_max():
  function test_shuffled_surrogate_for_cc_all (line 71) | def test_shuffled_surrogate_for_cc_all():
  function test_shuffled_surrogate_for_cc_sum (line 89) | def test_shuffled_surrogate_for_cc_sum():
  function test_shuffled_surrogate_for_cc_max (line 103) | def test_shuffled_surrogate_for_cc_max():
  function test_shuffled_surrogate_for_cc_value_error (line 119) | def test_shuffled_surrogate_for_cc_value_error():
  function test_shuffled_surrogate_for_mi_all (line 126) | def test_shuffled_surrogate_for_mi_all():
  function test_shuffled_surrogate_for_mi_sum (line 144) | def test_shuffled_surrogate_for_mi_sum():
  function test_shuffled_surrogate_for_mi_max (line 158) | def test_shuffled_surrogate_for_mi_max():
  function test_shuffled_surrogate_for_mi_value_error (line 174) | def test_shuffled_surrogate_for_mi_value_error():
  function test_mutual_information_all (line 181) | def test_mutual_information_all():
  function test_mutual_information_sum (line 200) | def test_mutual_information_sum():
  function test_mutual_information_max (line 215) | def test_mutual_information_max():

FILE: tests/test_generic.py
  function test_version (line 22) | def test_version():
  function test_init_str (line 29) | def test_init_str():
  function simple_instances (line 37) | def simple_instances():

FILE: tests/test_timeseries/test_joint_recurrence_plot.py
  function test_recurrence (line 28) | def test_recurrence(metric: str, n: int):
  function test_exceptions (line 41) | def test_exceptions():

FILE: tests/test_timeseries/test_recurrence_plot.py
  function test_RP_euclidean (line 35) | def test_RP_euclidean():
  function test_RP_manhattan (line 55) | def test_RP_manhattan():
  function test_RP_threshold_std (line 77) | def test_RP_threshold_std():
  function test_RP_recurrence_rate (line 97) | def test_RP_recurrence_rate():
  function test_RP_local_recurrence_rate (line 117) | def test_RP_local_recurrence_rate():
  function recurrence_crit_fixture (line 145) | def recurrence_crit_fixture(request):
  function small_RP_fixture (line 152) | def small_RP_fixture(metric, recurrence_crit):
  function small_RP_basic_fixture (line 163) | def small_RP_basic_fixture(request):
  function test_line_dist (line 195) | def test_line_dist(measure: str, small_RP):
  function test_line_dist_numeric (line 207) | def test_line_dist_numeric(measure: str, small_RP_basic, exp):
  function test_line_dist_edgecases (line 217) | def test_line_dist_edgecases(sparse):
  function test_rqa_summary (line 233) | def test_rqa_summary(small_RP):
  function test_rqa_summary_numeric (line 239) | def test_rqa_summary_numeric(small_RP_basic):
  function test_resample_line_dist (line 248) | def test_resample_line_dist(measure: str, M: int, small_RP):
  function test_time (line 257) | def test_time(small_RP_basic, var, exp):
  function test_entropy (line 271) | def test_entropy(ts: np.ndarray, measure: str, value: float):
  function test_line_dist_entropy (line 279) | def test_line_dist_entropy(measure: str, exp: float, small_RP_basic):

FILE: tests/test_timeseries/test_timeseries.py
  function create_test_data (line 30) | def create_test_data():
  function testCrossRecurrencePlot (line 46) | def testCrossRecurrencePlot(thresh, rr, metric: str):
  function testRecurrenceNetwork (line 79) | def testRecurrenceNetwork(thresh, rr, metric: str):
  function testRecurrenceNetwork_setters (line 99) | def testRecurrenceNetwork_setters():
  function testJointRecurrenceNetwork (line 121) | def testJointRecurrenceNetwork(metric: str):
  function testInterSystemRecurrenceNetwork (line 143) | def testInterSystemRecurrenceNetwork(thresh, rr, metric: str):
  function testNormalizeOriginalData (line 172) | def testNormalizeOriginalData():
  function testEmbedTimeSeriesArray (line 185) | def testEmbedTimeSeriesArray():
  function testSurrogatesRecurrencePlot (line 199) | def testSurrogatesRecurrencePlot():
  function testWhiteNoiseSurrogates (line 214) | def testWhiteNoiseSurrogates():
  function testCorrelatedNoiseSurrogates (line 222) | def testCorrelatedNoiseSurrogates():
  function testTwinSurrogates (line 229) | def testTwinSurrogates():
  function testAAFTSurrogates (line 239) | def testAAFTSurrogates():
  function testPearsonCorrelation (line 251) | def testPearsonCorrelation():
  function testMutualInformation (line 264) | def testMutualInformation():
  function testOriginalDistribution (line 271) | def testOriginalDistribution():
  function testThresholdSignificance (line 280) | def testThresholdSignificance():
  function create_test_timeseries (line 298) | def create_test_timeseries():
  function testVisibility (line 337) | def testVisibility():
  function testVisibilityHorizontal (line 346) | def testVisibilityHorizontal():
  function testRetardedLocalClustering (line 355) | def testRetardedLocalClustering():
  function testAdvancedLocalClustering (line 364) | def testAdvancedLocalClustering():