Add files using upload-large-folder tool

shared/package-files/06/06003cce6773f4dc3e5dbbb8fb0dd4001796ca9a8bbe6cbd5732fbe3812662d1/test_rewrite.py

@@ -0,0 +1,74 @@
+from sympy.unify.rewrite import rewriterule
+from sympy.core.basic import Basic
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.functions.elementary.trigonometric import sin
+from sympy.abc import x, y
+from sympy.strategies.rl import rebuild
+from sympy.assumptions import Q
+
+p, q = Symbol('p'), Symbol('q')
+
+def test_simple():
+    rl = rewriterule(Basic(p, S(1)), Basic(p, S(2)), variables=(p,))
+    assert list(rl(Basic(S(3), S(1)))) == [Basic(S(3), S(2))]
+
+    p1 = p**2
+    p2 = p**3
+    rl = rewriterule(p1, p2, variables=(p,))
+
+    expr = x**2
+    assert list(rl(expr)) == [x**3]
+
+def test_simple_variables():
+    rl = rewriterule(Basic(x, S(1)), Basic(x, S(2)), variables=(x,))
+    assert list(rl(Basic(S(3), S(1)))) == [Basic(S(3), S(2))]
+
+    rl = rewriterule(x**2, x**3, variables=(x,))
+    assert list(rl(y**2)) == [y**3]
+
+def test_moderate():
+    p1 = p**2 + q**3
+    p2 = (p*q)**4
+    rl = rewriterule(p1, p2, (p, q))
+
+    expr = x**2 + y**3
+    assert list(rl(expr)) == [(x*y)**4]
+
+def test_sincos():
+    p1 = sin(p)**2 + sin(p)**2
+    p2 = 1
+    rl = rewriterule(p1, p2, (p, q))
+
+    assert list(rl(sin(x)**2 + sin(x)**2)) == [1]
+    assert list(rl(sin(y)**2 + sin(y)**2)) == [1]
+
+def test_Exprs_ok():
+    rl = rewriterule(p+q, q+p, (p, q))
+    next(rl(x+y)).is_commutative
+    str(next(rl(x+y)))
+
+def test_condition_simple():
+    rl = rewriterule(x, x+1, [x], lambda x: x < 10)
+    assert not list(rl(S(15)))
+    assert rebuild(next(rl(S(5)))) == 6
+
+
+def test_condition_multiple():
+    rl = rewriterule(x + y, x**y, [x,y], lambda x, y: x.is_integer)
+
+    a = Symbol('a')
+    b = Symbol('b', integer=True)
+    expr = a + b
+    assert list(rl(expr)) == [b**a]
+
+    c = Symbol('c', integer=True)
+    d = Symbol('d', integer=True)
+    assert set(rl(c + d)) == {c**d, d**c}
+
+def test_assumptions():
+    rl = rewriterule(x + y, x**y, [x, y], assume=Q.integer(x))
+
+    a, b = map(Symbol, 'ab')
+    expr = a + b
+    assert list(rl(expr, Q.integer(b))) == [b**a]

shared/package-files/06/060f52bfcb8d3df3376c3b56ac879a8675da71dc864a396221e70fc870aa9937/test_pprint.py

@@ -0,0 +1,695 @@
+import re
+from pprint import PrettyPrinter
+
+import numpy as np
+import pytest
+
+from sklearn import config_context
+from sklearn.base import BaseEstimator, TransformerMixin
+from sklearn.feature_selection import SelectKBest, chi2
+from sklearn.linear_model import LogisticRegressionCV
+from sklearn.pipeline import make_pipeline
+from sklearn.utils._pprint import _EstimatorPrettyPrinter
+
+
+# Constructors excerpted to test pprinting
+class LogisticRegression(BaseEstimator):
+    def __init__(
+        self,
+        penalty="l2",
+        dual=False,
+        tol=1e-4,
+        C=1.0,
+        fit_intercept=True,
+        intercept_scaling=1,
+        class_weight=None,
+        random_state=None,
+        solver="warn",
+        max_iter=100,
+        multi_class="warn",
+        verbose=0,
+        warm_start=False,
+        n_jobs=None,
+        l1_ratio=None,
+    ):
+        self.penalty = penalty
+        self.dual = dual
+        self.tol = tol
+        self.C = C
+        self.fit_intercept = fit_intercept
+        self.intercept_scaling = intercept_scaling
+        self.class_weight = class_weight
+        self.random_state = random_state
+        self.solver = solver
+        self.max_iter = max_iter
+        self.multi_class = multi_class
+        self.verbose = verbose
+        self.warm_start = warm_start
+        self.n_jobs = n_jobs
+        self.l1_ratio = l1_ratio
+
+    def fit(self, X, y):
+        return self
+
+
+class StandardScaler(TransformerMixin, BaseEstimator):
+    def __init__(self, copy=True, with_mean=True, with_std=True):
+        self.with_mean = with_mean
+        self.with_std = with_std
+        self.copy = copy
+
+    def transform(self, X, copy=None):
+        return self
+
+
+class RFE(BaseEstimator):
+    def __init__(self, estimator, n_features_to_select=None, step=1, verbose=0):
+        self.estimator = estimator
+        self.n_features_to_select = n_features_to_select
+        self.step = step
+        self.verbose = verbose
+
+
+class GridSearchCV(BaseEstimator):
+    def __init__(
+        self,
+        estimator,
+        param_grid,
+        scoring=None,
+        n_jobs=None,
+        iid="warn",
+        refit=True,
+        cv="warn",
+        verbose=0,
+        pre_dispatch="2*n_jobs",
+        error_score="raise-deprecating",
+        return_train_score=False,
+    ):
+        self.estimator = estimator
+        self.param_grid = param_grid
+        self.scoring = scoring
+        self.n_jobs = n_jobs
+        self.iid = iid
+        self.refit = refit
+        self.cv = cv
+        self.verbose = verbose
+        self.pre_dispatch = pre_dispatch
+        self.error_score = error_score
+        self.return_train_score = return_train_score
+
+
+class CountVectorizer(BaseEstimator):
+    def __init__(
+        self,
+        input="content",
+        encoding="utf-8",
+        decode_error="strict",
+        strip_accents=None,
+        lowercase=True,
+        preprocessor=None,
+        tokenizer=None,
+        stop_words=None,
+        token_pattern=r"(?u)\b\w\w+\b",
+        ngram_range=(1, 1),
+        analyzer="word",
+        max_df=1.0,
+        min_df=1,
+        max_features=None,
+        vocabulary=None,
+        binary=False,
+        dtype=np.int64,
+    ):
+        self.input = input
+        self.encoding = encoding
+        self.decode_error = decode_error
+        self.strip_accents = strip_accents
+        self.preprocessor = preprocessor
+        self.tokenizer = tokenizer
+        self.analyzer = analyzer
+        self.lowercase = lowercase
+        self.token_pattern = token_pattern
+        self.stop_words = stop_words
+        self.max_df = max_df
+        self.min_df = min_df
+        self.max_features = max_features
+        self.ngram_range = ngram_range
+        self.vocabulary = vocabulary
+        self.binary = binary
+        self.dtype = dtype
+
+
+class Pipeline(BaseEstimator):
+    def __init__(self, steps, memory=None):
+        self.steps = steps
+        self.memory = memory
+
+
+class SVC(BaseEstimator):
+    def __init__(
+        self,
+        C=1.0,
+        kernel="rbf",
+        degree=3,
+        gamma="auto_deprecated",
+        coef0=0.0,
+        shrinking=True,
+        probability=False,
+        tol=1e-3,
+        cache_size=200,
+        class_weight=None,
+        verbose=False,
+        max_iter=-1,
+        decision_function_shape="ovr",
+        random_state=None,
+    ):
+        self.kernel = kernel
+        self.degree = degree
+        self.gamma = gamma
+        self.coef0 = coef0
+        self.tol = tol
+        self.C = C
+        self.shrinking = shrinking
+        self.probability = probability
+        self.cache_size = cache_size
+        self.class_weight = class_weight
+        self.verbose = verbose
+        self.max_iter = max_iter
+        self.decision_function_shape = decision_function_shape
+        self.random_state = random_state
+
+
+class PCA(BaseEstimator):
+    def __init__(
+        self,
+        n_components=None,
+        copy=True,
+        whiten=False,
+        svd_solver="auto",
+        tol=0.0,
+        iterated_power="auto",
+        random_state=None,
+    ):
+        self.n_components = n_components
+        self.copy = copy
+        self.whiten = whiten
+        self.svd_solver = svd_solver
+        self.tol = tol
+        self.iterated_power = iterated_power
+        self.random_state = random_state
+
+
+class NMF(BaseEstimator):
+    def __init__(
+        self,
+        n_components=None,
+        init=None,
+        solver="cd",
+        beta_loss="frobenius",
+        tol=1e-4,
+        max_iter=200,
+        random_state=None,
+        alpha=0.0,
+        l1_ratio=0.0,
+        verbose=0,
+        shuffle=False,
+    ):
+        self.n_components = n_components
+        self.init = init
+        self.solver = solver
+        self.beta_loss = beta_loss
+        self.tol = tol
+        self.max_iter = max_iter
+        self.random_state = random_state
+        self.alpha = alpha
+        self.l1_ratio = l1_ratio
+        self.verbose = verbose
+        self.shuffle = shuffle
+
+
+class SimpleImputer(BaseEstimator):
+    def __init__(
+        self,
+        missing_values=np.nan,
+        strategy="mean",
+        fill_value=None,
+        verbose=0,
+        copy=True,
+    ):
+        self.missing_values = missing_values
+        self.strategy = strategy
+        self.fill_value = fill_value
+        self.verbose = verbose
+        self.copy = copy
+
+
+def test_basic(print_changed_only_false):
+    # Basic pprint test
+    lr = LogisticRegression()
+    expected = """
+LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,
+                   intercept_scaling=1, l1_ratio=None, max_iter=100,
+                   multi_class='warn', n_jobs=None, penalty='l2',
+                   random_state=None, solver='warn', tol=0.0001, verbose=0,
+                   warm_start=False)"""
+
+    expected = expected[1:]  # remove first \n
+    assert lr.__repr__() == expected
+
+
+def test_changed_only():
+    # Make sure the changed_only param is correctly used when True (default)
+    lr = LogisticRegression(C=99)
+    expected = """LogisticRegression(C=99)"""
+    assert lr.__repr__() == expected
+
+    # Check with a repr that doesn't fit on a single line
+    lr = LogisticRegression(
+        C=99, class_weight=0.4, fit_intercept=False, tol=1234, verbose=True
+    )
+    expected = """
+LogisticRegression(C=99, class_weight=0.4, fit_intercept=False, tol=1234,
+                   verbose=True)"""
+    expected = expected[1:]  # remove first \n
+    assert lr.__repr__() == expected
+
+    imputer = SimpleImputer(missing_values=0)
+    expected = """SimpleImputer(missing_values=0)"""
+    assert imputer.__repr__() == expected
+
+    # Defaults to np.nan, trying with float('NaN')
+    imputer = SimpleImputer(missing_values=float("NaN"))
+    expected = """SimpleImputer()"""
+    assert imputer.__repr__() == expected
+
+    # make sure array parameters don't throw error (see #13583)
+    repr(LogisticRegressionCV(Cs=np.array([0.1, 1])))
+
+
+def test_pipeline(print_changed_only_false):
+    # Render a pipeline object
+    pipeline = make_pipeline(StandardScaler(), LogisticRegression(C=999))
+    expected = """
+Pipeline(memory=None,
+         steps=[('standardscaler',
+                 StandardScaler(copy=True, with_mean=True, with_std=True)),
+                ('logisticregression',
+                 LogisticRegression(C=999, class_weight=None, dual=False,
+                                    fit_intercept=True, intercept_scaling=1,
+                                    l1_ratio=None, max_iter=100,
+                                    multi_class='warn', n_jobs=None,
+                                    penalty='l2', random_state=None,
+                                    solver='warn', tol=0.0001, verbose=0,
+                                    warm_start=False))],
+         transform_input=None, verbose=False)"""
+
+    expected = expected[1:]  # remove first \n
+    assert pipeline.__repr__() == expected
+
+
+def test_deeply_nested(print_changed_only_false):
+    # Render a deeply nested estimator
+    rfe = RFE(RFE(RFE(RFE(RFE(RFE(RFE(LogisticRegression())))))))
+    expected = """
+RFE(estimator=RFE(estimator=RFE(estimator=RFE(estimator=RFE(estimator=RFE(estimator=RFE(estimator=LogisticRegression(C=1.0,
+                                                                                                                     class_weight=None,
+                                                                                                                     dual=False,
+                                                                                                                     fit_intercept=True,
+                                                                                                                     intercept_scaling=1,
+                                                                                                                     l1_ratio=None,
+                                                                                                                     max_iter=100,
+                                                                                                                     multi_class='warn',
+                                                                                                                     n_jobs=None,
+                                                                                                                     penalty='l2',
+                                                                                                                     random_state=None,
+                                                                                                                     solver='warn',
+                                                                                                                     tol=0.0001,
+                                                                                                                     verbose=0,
+                                                                                                                     warm_start=False),
+                                                                                        n_features_to_select=None,
+                                                                                        step=1,
+                                                                                        verbose=0),
+                                                                          n_features_to_select=None,
+                                                                          step=1,
+                                                                          verbose=0),
+                                                            n_features_to_select=None,
+                                                            step=1, verbose=0),
+                                              n_features_to_select=None, step=1,
+                                              verbose=0),
+                                n_features_to_select=None, step=1, verbose=0),
+                  n_features_to_select=None, step=1, verbose=0),
+    n_features_to_select=None, step=1, verbose=0)"""
+
+    expected = expected[1:]  # remove first \n
+    assert rfe.__repr__() == expected
+
+
+@pytest.mark.parametrize(
+    ("print_changed_only", "expected"),
+    [
+        (True, "RFE(estimator=RFE(...))"),
+        (
+            False,
+            "RFE(estimator=RFE(...), n_features_to_select=None, step=1, verbose=0)",
+        ),
+    ],
+)
+def test_print_estimator_max_depth(print_changed_only, expected):
+    with config_context(print_changed_only=print_changed_only):
+        pp = _EstimatorPrettyPrinter(depth=1)
+
+        rfe = RFE(RFE(RFE(RFE(RFE(LogisticRegression())))))
+        assert pp.pformat(rfe) == expected
+
+
+def test_gridsearch(print_changed_only_false):
+    # render a gridsearch
+    param_grid = [
+        {"kernel": ["rbf"], "gamma": [1e-3, 1e-4], "C": [1, 10, 100, 1000]},
+        {"kernel": ["linear"], "C": [1, 10, 100, 1000]},
+    ]
+    gs = GridSearchCV(SVC(), param_grid, cv=5)
+
+    expected = """
+GridSearchCV(cv=5, error_score='raise-deprecating',
+             estimator=SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,
+                           decision_function_shape='ovr', degree=3,
+                           gamma='auto_deprecated', kernel='rbf', max_iter=-1,
+                           probability=False, random_state=None, shrinking=True,
+                           tol=0.001, verbose=False),
+             iid='warn', n_jobs=None,
+             param_grid=[{'C': [1, 10, 100, 1000], 'gamma': [0.001, 0.0001],
+                          'kernel': ['rbf']},
+                         {'C': [1, 10, 100, 1000], 'kernel': ['linear']}],
+             pre_dispatch='2*n_jobs', refit=True, return_train_score=False,
+             scoring=None, verbose=0)"""
+
+    expected = expected[1:]  # remove first \n
+    assert gs.__repr__() == expected
+
+
+def test_gridsearch_pipeline(print_changed_only_false):
+    # render a pipeline inside a gridsearch
+    pp = _EstimatorPrettyPrinter(compact=True, indent=1, indent_at_name=True)
+
+    pipeline = Pipeline([("reduce_dim", PCA()), ("classify", SVC())])
+    N_FEATURES_OPTIONS = [2, 4, 8]
+    C_OPTIONS = [1, 10, 100, 1000]
+    param_grid = [
+        {
+            "reduce_dim": [PCA(iterated_power=7), NMF()],
+            "reduce_dim__n_components": N_FEATURES_OPTIONS,
+            "classify__C": C_OPTIONS,
+        },
+        {
+            "reduce_dim": [SelectKBest(chi2)],
+            "reduce_dim__k": N_FEATURES_OPTIONS,
+            "classify__C": C_OPTIONS,
+        },
+    ]
+    gspipline = GridSearchCV(pipeline, cv=3, n_jobs=1, param_grid=param_grid)
+    expected = """
+GridSearchCV(cv=3, error_score='raise-deprecating',
+             estimator=Pipeline(memory=None,
+                                steps=[('reduce_dim',
+                                        PCA(copy=True, iterated_power='auto',
+                                            n_components=None,
+                                            random_state=None,
+                                            svd_solver='auto', tol=0.0,
+                                            whiten=False)),
+                                       ('classify',
+                                        SVC(C=1.0, cache_size=200,
+                                            class_weight=None, coef0=0.0,
+                                            decision_function_shape='ovr',
+                                            degree=3, gamma='auto_deprecated',
+                                            kernel='rbf', max_iter=-1,
+                                            probability=False,
+                                            random_state=None, shrinking=True,
+                                            tol=0.001, verbose=False))]),
+             iid='warn', n_jobs=1,
+             param_grid=[{'classify__C': [1, 10, 100, 1000],
+                          'reduce_dim': [PCA(copy=True, iterated_power=7,
+                                             n_components=None,
+                                             random_state=None,
+                                             svd_solver='auto', tol=0.0,
+                                             whiten=False),
+                                         NMF(alpha=0.0, beta_loss='frobenius',
+                                             init=None, l1_ratio=0.0,
+                                             max_iter=200, n_components=None,
+                                             random_state=None, shuffle=False,
+                                             solver='cd', tol=0.0001,
+                                             verbose=0)],
+                          'reduce_dim__n_components': [2, 4, 8]},
+                         {'classify__C': [1, 10, 100, 1000],
+                          'reduce_dim': [SelectKBest(k=10,
+                                                     score_func=<function chi2 at some_address>)],
+                          'reduce_dim__k': [2, 4, 8]}],
+             pre_dispatch='2*n_jobs', refit=True, return_train_score=False,
+             scoring=None, verbose=0)"""  # noqa: E501
+
+    expected = expected[1:]  # remove first \n
+    repr_ = pp.pformat(gspipline)
+    # Remove address of '<function chi2 at 0x.....>' for reproducibility
+    repr_ = re.sub("function chi2 at 0x.*>", "function chi2 at some_address>", repr_)
+    assert repr_ == expected
+
+
+def test_n_max_elements_to_show(print_changed_only_false):
+    n_max_elements_to_show = 30
+    pp = _EstimatorPrettyPrinter(
+        compact=True,
+        indent=1,
+        indent_at_name=True,
+        n_max_elements_to_show=n_max_elements_to_show,
+    )
+
+    # No ellipsis
+    vocabulary = {i: i for i in range(n_max_elements_to_show)}
+    vectorizer = CountVectorizer(vocabulary=vocabulary)
+
+    expected = r"""
+CountVectorizer(analyzer='word', binary=False, decode_error='strict',
+                dtype=<class 'numpy.int64'>, encoding='utf-8', input='content',
+                lowercase=True, max_df=1.0, max_features=None, min_df=1,
+                ngram_range=(1, 1), preprocessor=None, stop_words=None,
+                strip_accents=None, token_pattern='(?u)\\b\\w\\w+\\b',
+                tokenizer=None,
+                vocabulary={0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7,
+                            8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14,
+                            15: 15, 16: 16, 17: 17, 18: 18, 19: 19, 20: 20,
+                            21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26,
+                            27: 27, 28: 28, 29: 29})"""
+
+    expected = expected[1:]  # remove first \n
+    assert pp.pformat(vectorizer) == expected
+
+    # Now with ellipsis
+    vocabulary = {i: i for i in range(n_max_elements_to_show + 1)}
+    vectorizer = CountVectorizer(vocabulary=vocabulary)
+
+    expected = r"""
+CountVectorizer(analyzer='word', binary=False, decode_error='strict',
+                dtype=<class 'numpy.int64'>, encoding='utf-8', input='content',
+                lowercase=True, max_df=1.0, max_features=None, min_df=1,
+                ngram_range=(1, 1), preprocessor=None, stop_words=None,
+                strip_accents=None, token_pattern='(?u)\\b\\w\\w+\\b',
+                tokenizer=None,
+                vocabulary={0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7,
+                            8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14,
+                            15: 15, 16: 16, 17: 17, 18: 18, 19: 19, 20: 20,
+                            21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26,
+                            27: 27, 28: 28, 29: 29, ...})"""
+
+    expected = expected[1:]  # remove first \n
+    assert pp.pformat(vectorizer) == expected
+
+    # Also test with lists
+    param_grid = {"C": list(range(n_max_elements_to_show))}
+    gs = GridSearchCV(SVC(), param_grid)
+    expected = """
+GridSearchCV(cv='warn', error_score='raise-deprecating',
+             estimator=SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,
+                           decision_function_shape='ovr', degree=3,
+                           gamma='auto_deprecated', kernel='rbf', max_iter=-1,
+                           probability=False, random_state=None, shrinking=True,
+                           tol=0.001, verbose=False),
+             iid='warn', n_jobs=None,
+             param_grid={'C': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
+                               15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
+                               27, 28, 29]},
+             pre_dispatch='2*n_jobs', refit=True, return_train_score=False,
+             scoring=None, verbose=0)"""
+
+    expected = expected[1:]  # remove first \n
+    assert pp.pformat(gs) == expected
+
+    # Now with ellipsis
+    param_grid = {"C": list(range(n_max_elements_to_show + 1))}
+    gs = GridSearchCV(SVC(), param_grid)
+    expected = """
+GridSearchCV(cv='warn', error_score='raise-deprecating',
+             estimator=SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,
+                           decision_function_shape='ovr', degree=3,
+                           gamma='auto_deprecated', kernel='rbf', max_iter=-1,
+                           probability=False, random_state=None, shrinking=True,
+                           tol=0.001, verbose=False),
+             iid='warn', n_jobs=None,
+             param_grid={'C': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
+                               15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
+                               27, 28, 29, ...]},
+             pre_dispatch='2*n_jobs', refit=True, return_train_score=False,
+             scoring=None, verbose=0)"""
+
+    expected = expected[1:]  # remove first \n
+    assert pp.pformat(gs) == expected
+
+
+def test_bruteforce_ellipsis(print_changed_only_false):
+    # Check that the bruteforce ellipsis (used when the number of non-blank
+    # characters exceeds N_CHAR_MAX) renders correctly.
+
+    lr = LogisticRegression()
+
+    # test when the left and right side of the ellipsis aren't on the same
+    # line.
+    expected = """
+LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,
+                   in...
+                   multi_class='warn', n_jobs=None, penalty='l2',
+                   random_state=None, solver='warn', tol=0.0001, verbose=0,
+                   warm_start=False)"""
+
+    expected = expected[1:]  # remove first \n
+    assert expected == lr.__repr__(N_CHAR_MAX=150)
+
+    # test with very small N_CHAR_MAX
+    # Note that N_CHAR_MAX is not strictly enforced, but it's normal: to avoid
+    # weird reprs we still keep the whole line of the right part (after the
+    # ellipsis).
+    expected = """
+Lo...
+                   warm_start=False)"""
+
+    expected = expected[1:]  # remove first \n
+    assert expected == lr.__repr__(N_CHAR_MAX=4)
+
+    # test with N_CHAR_MAX == number of non-blank characters: In this case we
+    # don't want ellipsis
+    full_repr = lr.__repr__(N_CHAR_MAX=float("inf"))
+    n_nonblank = len("".join(full_repr.split()))
+    assert lr.__repr__(N_CHAR_MAX=n_nonblank) == full_repr
+    assert "..." not in full_repr
+
+    # test with N_CHAR_MAX == number of non-blank characters - 10: the left and
+    # right side of the ellispsis are on different lines. In this case we
+    # want to expend the whole line of the right side
+    expected = """
+LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,
+                   intercept_scaling=1, l1_ratio=None, max_i...
+                   multi_class='warn', n_jobs=None, penalty='l2',
+                   random_state=None, solver='warn', tol=0.0001, verbose=0,
+                   warm_start=False)"""
+    expected = expected[1:]  # remove first \n
+    assert expected == lr.__repr__(N_CHAR_MAX=n_nonblank - 10)
+
+    # test with N_CHAR_MAX == number of non-blank characters - 10: the left and
+    # right side of the ellispsis are on the same line. In this case we don't
+    # want to expend the whole line of the right side, just add the ellispsis
+    # between the 2 sides.
+    expected = """
+LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,
+                   intercept_scaling=1, l1_ratio=None, max_iter...,
+                   multi_class='warn', n_jobs=None, penalty='l2',
+                   random_state=None, solver='warn', tol=0.0001, verbose=0,
+                   warm_start=False)"""
+    expected = expected[1:]  # remove first \n
+    assert expected == lr.__repr__(N_CHAR_MAX=n_nonblank - 4)
+
+    # test with N_CHAR_MAX == number of non-blank characters - 2: the left and
+    # right side of the ellispsis are on the same line, but adding the ellipsis
+    # would actually make the repr longer. So we don't add the ellipsis.
+    expected = """
+LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,
+                   intercept_scaling=1, l1_ratio=None, max_iter=100,
+                   multi_class='warn', n_jobs=None, penalty='l2',
+                   random_state=None, solver='warn', tol=0.0001, verbose=0,
+                   warm_start=False)"""
+    expected = expected[1:]  # remove first \n
+    assert expected == lr.__repr__(N_CHAR_MAX=n_nonblank - 2)
+
+
+def test_builtin_prettyprinter():
+    # non regression test than ensures we can still use the builtin
+    # PrettyPrinter class for estimators (as done e.g. by joblib).
+    # Used to be a bug
+
+    PrettyPrinter().pprint(LogisticRegression())
+
+
+def test_kwargs_in_init():
+    # Make sure the changed_only=True mode is OK when an argument is passed as
+    # kwargs.
+    # Non-regression test for
+    # https://github.com/scikit-learn/scikit-learn/issues/17206
+
+    class WithKWargs(BaseEstimator):
+        # Estimator with a kwargs argument. These need to hack around
+        # set_params and get_params. Here we mimic what LightGBM does.
+        def __init__(self, a="willchange", b="unchanged", **kwargs):
+            self.a = a
+            self.b = b
+            self._other_params = {}
+            self.set_params(**kwargs)
+
+        def get_params(self, deep=True):
+            params = super().get_params(deep=deep)
+            params.update(self._other_params)
+            return params
+
+        def set_params(self, **params):
+            for key, value in params.items():
+                setattr(self, key, value)
+                self._other_params[key] = value
+            return self
+
+    est = WithKWargs(a="something", c="abcd", d=None)
+
+    expected = "WithKWargs(a='something', c='abcd', d=None)"
+    assert expected == est.__repr__()
+
+    with config_context(print_changed_only=False):
+        expected = "WithKWargs(a='something', b='unchanged', c='abcd', d=None)"
+        assert expected == est.__repr__()
+
+
+def test_complexity_print_changed_only():
+    # Make sure `__repr__` is called the same amount of times
+    # whether `print_changed_only` is True or False
+    # Non-regression test for
+    # https://github.com/scikit-learn/scikit-learn/issues/18490
+
+    class DummyEstimator(TransformerMixin, BaseEstimator):
+        nb_times_repr_called = 0
+
+        def __init__(self, estimator=None):
+            self.estimator = estimator
+
+        def __repr__(self):
+            DummyEstimator.nb_times_repr_called += 1
+            return super().__repr__()
+
+        def transform(self, X, copy=None):  # pragma: no cover
+            return X
+
+    estimator = DummyEstimator(
+        make_pipeline(DummyEstimator(DummyEstimator()), DummyEstimator(), "passthrough")
+    )
+    with config_context(print_changed_only=False):
+        repr(estimator)
+        nb_repr_print_changed_only_false = DummyEstimator.nb_times_repr_called
+
+    DummyEstimator.nb_times_repr_called = 0
+    with config_context(print_changed_only=True):
+        repr(estimator)
+        nb_repr_print_changed_only_true = DummyEstimator.nb_times_repr_called
+
+    assert nb_repr_print_changed_only_false == nb_repr_print_changed_only_true

shared/package-files/06/061232ee06f86f807af33de374eda5936133334c56c62c9a55ef1210e45700e1/margins.py

@@ -0,0 +1,303 @@
+"""
+Margin implementations for a :class:`~prompt_toolkit.layout.containers.Window`.
+"""
+from __future__ import annotations
+
+from abc import ABCMeta, abstractmethod
+from typing import TYPE_CHECKING, Callable
+
+from prompt_toolkit.filters import FilterOrBool, to_filter
+from prompt_toolkit.formatted_text import (
+    StyleAndTextTuples,
+    fragment_list_to_text,
+    to_formatted_text,
+)
+from prompt_toolkit.utils import get_cwidth
+
+from .controls import UIContent
+
+if TYPE_CHECKING:
+    from .containers import WindowRenderInfo
+
+__all__ = [
+    "Margin",
+    "NumberedMargin",
+    "ScrollbarMargin",
+    "ConditionalMargin",
+    "PromptMargin",
+]
+
+
+class Margin(metaclass=ABCMeta):
+    """
+    Base interface for a margin.
+    """
+
+    @abstractmethod
+    def get_width(self, get_ui_content: Callable[[], UIContent]) -> int:
+        """
+        Return the width that this margin is going to consume.
+
+        :param get_ui_content: Callable that asks the user control to create
+            a :class:`.UIContent` instance. This can be used for instance to
+            obtain the number of lines.
+        """
+        return 0
+
+    @abstractmethod
+    def create_margin(
+        self, window_render_info: WindowRenderInfo, width: int, height: int
+    ) -> StyleAndTextTuples:
+        """
+        Creates a margin.
+        This should return a list of (style_str, text) tuples.
+
+        :param window_render_info:
+            :class:`~prompt_toolkit.layout.containers.WindowRenderInfo`
+            instance, generated after rendering and copying the visible part of
+            the :class:`~prompt_toolkit.layout.controls.UIControl` into the
+            :class:`~prompt_toolkit.layout.containers.Window`.
+        :param width: The width that's available for this margin. (As reported
+            by :meth:`.get_width`.)
+        :param height: The height that's available for this margin. (The height
+            of the :class:`~prompt_toolkit.layout.containers.Window`.)
+        """
+        return []
+
+
+class NumberedMargin(Margin):
+    """
+    Margin that displays the line numbers.
+
+    :param relative: Number relative to the cursor position. Similar to the Vi
+                     'relativenumber' option.
+    :param display_tildes: Display tildes after the end of the document, just
+        like Vi does.
+    """
+
+    def __init__(
+        self, relative: FilterOrBool = False, display_tildes: FilterOrBool = False
+    ) -> None:
+        self.relative = to_filter(relative)
+        self.display_tildes = to_filter(display_tildes)
+
+    def get_width(self, get_ui_content: Callable[[], UIContent]) -> int:
+        line_count = get_ui_content().line_count
+        return max(3, len("%s" % line_count) + 1)
+
+    def create_margin(
+        self, window_render_info: WindowRenderInfo, width: int, height: int
+    ) -> StyleAndTextTuples:
+        relative = self.relative()
+
+        style = "class:line-number"
+        style_current = "class:line-number.current"
+
+        # Get current line number.
+        current_lineno = window_render_info.ui_content.cursor_position.y
+
+        # Construct margin.
+        result: StyleAndTextTuples = []
+        last_lineno = None
+
+        for y, lineno in enumerate(window_render_info.displayed_lines):
+            # Only display line number if this line is not a continuation of the previous line.
+            if lineno != last_lineno:
+                if lineno is None:
+                    pass
+                elif lineno == current_lineno:
+                    # Current line.
+                    if relative:
+                        # Left align current number in relative mode.
+                        result.append((style_current, "%i" % (lineno + 1)))
+                    else:
+                        result.append(
+                            (style_current, ("%i " % (lineno + 1)).rjust(width))
+                        )
+                else:
+                    # Other lines.
+                    if relative:
+                        lineno = abs(lineno - current_lineno) - 1
+
+                    result.append((style, ("%i " % (lineno + 1)).rjust(width)))
+
+            last_lineno = lineno
+            result.append(("", "\n"))
+
+        # Fill with tildes.
+        if self.display_tildes():
+            while y < window_render_info.window_height:
+                result.append(("class:tilde", "~\n"))
+                y += 1
+
+        return result
+
+
+class ConditionalMargin(Margin):
+    """
+    Wrapper around other :class:`.Margin` classes to show/hide them.
+    """
+
+    def __init__(self, margin: Margin, filter: FilterOrBool) -> None:
+        self.margin = margin
+        self.filter = to_filter(filter)
+
+    def get_width(self, get_ui_content: Callable[[], UIContent]) -> int:
+        if self.filter():
+            return self.margin.get_width(get_ui_content)
+        else:
+            return 0
+
+    def create_margin(
+        self, window_render_info: WindowRenderInfo, width: int, height: int
+    ) -> StyleAndTextTuples:
+        if width and self.filter():
+            return self.margin.create_margin(window_render_info, width, height)
+        else:
+            return []
+
+
+class ScrollbarMargin(Margin):
+    """
+    Margin displaying a scrollbar.
+
+    :param display_arrows: Display scroll up/down arrows.
+    """
+
+    def __init__(
+        self,
+        display_arrows: FilterOrBool = False,
+        up_arrow_symbol: str = "^",
+        down_arrow_symbol: str = "v",
+    ) -> None:
+        self.display_arrows = to_filter(display_arrows)
+        self.up_arrow_symbol = up_arrow_symbol
+        self.down_arrow_symbol = down_arrow_symbol
+
+    def get_width(self, get_ui_content: Callable[[], UIContent]) -> int:
+        return 1
+
+    def create_margin(
+        self, window_render_info: WindowRenderInfo, width: int, height: int
+    ) -> StyleAndTextTuples:
+        content_height = window_render_info.content_height
+        window_height = window_render_info.window_height
+        display_arrows = self.display_arrows()
+
+        if display_arrows:
+            window_height -= 2
+
+        try:
+            fraction_visible = len(window_render_info.displayed_lines) / float(
+                content_height
+            )
+            fraction_above = window_render_info.vertical_scroll / float(content_height)
+
+            scrollbar_height = int(
+                min(window_height, max(1, window_height * fraction_visible))
+            )
+            scrollbar_top = int(window_height * fraction_above)
+        except ZeroDivisionError:
+            return []
+        else:
+
+            def is_scroll_button(row: int) -> bool:
+                "True if we should display a button on this row."
+                return scrollbar_top <= row <= scrollbar_top + scrollbar_height
+
+            # Up arrow.
+            result: StyleAndTextTuples = []
+            if display_arrows:
+                result.extend(
+                    [
+                        ("class:scrollbar.arrow", self.up_arrow_symbol),
+                        ("class:scrollbar", "\n"),
+                    ]
+                )
+
+            # Scrollbar body.
+            scrollbar_background = "class:scrollbar.background"
+            scrollbar_background_start = "class:scrollbar.background,scrollbar.start"
+            scrollbar_button = "class:scrollbar.button"
+            scrollbar_button_end = "class:scrollbar.button,scrollbar.end"
+
+            for i in range(window_height):
+                if is_scroll_button(i):
+                    if not is_scroll_button(i + 1):
+                        # Give the last cell a different style, because we
+                        # want to underline this.
+                        result.append((scrollbar_button_end, " "))
+                    else:
+                        result.append((scrollbar_button, " "))
+                else:
+                    if is_scroll_button(i + 1):
+                        result.append((scrollbar_background_start, " "))
+                    else:
+                        result.append((scrollbar_background, " "))
+                result.append(("", "\n"))
+
+            # Down arrow
+            if display_arrows:
+                result.append(("class:scrollbar.arrow", self.down_arrow_symbol))
+
+            return result
+
+
+class PromptMargin(Margin):
+    """
+    [Deprecated]
+
+    Create margin that displays a prompt.
+    This can display one prompt at the first line, and a continuation prompt
+    (e.g, just dots) on all the following lines.
+
+    This `PromptMargin` implementation has been largely superseded in favor of
+    the `get_line_prefix` attribute of `Window`. The reason is that a margin is
+    always a fixed width, while `get_line_prefix` can return a variable width
+    prefix in front of every line, making it more powerful, especially for line
+    continuations.
+
+    :param get_prompt: Callable returns formatted text or a list of
+        `(style_str, type)` tuples to be shown as the prompt at the first line.
+    :param get_continuation: Callable that takes three inputs. The width (int),
+        line_number (int), and is_soft_wrap (bool). It should return formatted
+        text or a list of `(style_str, type)` tuples for the next lines of the
+        input.
+    """
+
+    def __init__(
+        self,
+        get_prompt: Callable[[], StyleAndTextTuples],
+        get_continuation: None
+        | (Callable[[int, int, bool], StyleAndTextTuples]) = None,
+    ) -> None:
+        self.get_prompt = get_prompt
+        self.get_continuation = get_continuation
+
+    def get_width(self, get_ui_content: Callable[[], UIContent]) -> int:
+        "Width to report to the `Window`."
+        # Take the width from the first line.
+        text = fragment_list_to_text(self.get_prompt())
+        return get_cwidth(text)
+
+    def create_margin(
+        self, window_render_info: WindowRenderInfo, width: int, height: int
+    ) -> StyleAndTextTuples:
+        get_continuation = self.get_continuation
+        result: StyleAndTextTuples = []
+
+        # First line.
+        result.extend(to_formatted_text(self.get_prompt()))
+
+        # Next lines.
+        if get_continuation:
+            last_y = None
+
+            for y in window_render_info.displayed_lines[1:]:
+                result.append(("", "\n"))
+                result.extend(
+                    to_formatted_text(get_continuation(width, y, y == last_y))
+                )
+                last_y = y
+
+        return result

shared/package-files/06/069ed4c1f7c830eee873c527155d75c9819c5d48d26b4361b2e3a041a35132df/test_rv.py

@@ -0,0 +1,441 @@
+from sympy.concrete.summations import Sum
+from sympy.core.basic import Basic
+from sympy.core.containers import Tuple
+from sympy.core.function import Lambda
+from sympy.core.numbers import (Rational, nan, oo, pi)
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.combinatorial.factorials import (FallingFactorial, binomial)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.functions.special.delta_functions import DiracDelta
+from sympy.integrals.integrals import integrate
+from sympy.logic.boolalg import (And, Or)
+from sympy.matrices.dense import Matrix
+from sympy.sets.sets import Interval
+from sympy.tensor.indexed import Indexed
+from sympy.stats import (Die, Normal, Exponential, FiniteRV, P, E, H, variance,
+        density, given, independent, dependent, where, pspace, GaussianUnitaryEnsemble,
+        random_symbols, sample, Geometric, factorial_moment, Binomial, Hypergeometric,
+        DiscreteUniform, Poisson, characteristic_function, moment_generating_function,
+        BernoulliProcess, Variance, Expectation, Probability, Covariance, covariance, cmoment,
+        moment, median)
+from sympy.stats.rv import (IndependentProductPSpace, rs_swap, Density, NamedArgsMixin,
+        RandomSymbol, sample_iter, PSpace, is_random, RandomIndexedSymbol, RandomMatrixSymbol)
+from sympy.testing.pytest import raises, skip, XFAIL, warns_deprecated_sympy
+from sympy.external import import_module
+from sympy.core.numbers import comp
+from sympy.stats.frv_types import BernoulliDistribution
+from sympy.core.symbol import Dummy
+from sympy.functions.elementary.piecewise import Piecewise
+
+def test_where():
+    X, Y = Die('X'), Die('Y')
+    Z = Normal('Z', 0, 1)
+
+    assert where(Z**2 <= 1).set == Interval(-1, 1)
+    assert where(Z**2 <= 1).as_boolean() == Interval(-1, 1).as_relational(Z.symbol)
+    assert where(And(X > Y, Y > 4)).as_boolean() == And(
+        Eq(X.symbol, 6), Eq(Y.symbol, 5))
+
+    assert len(where(X < 3).set) == 2
+    assert 1 in where(X < 3).set
+
+    X, Y = Normal('X', 0, 1), Normal('Y', 0, 1)
+    assert where(And(X**2 <= 1, X >= 0)).set == Interval(0, 1)
+    XX = given(X, And(X**2 <= 1, X >= 0))
+    assert XX.pspace.domain.set == Interval(0, 1)
+    assert XX.pspace.domain.as_boolean() == \
+        And(0 <= X.symbol, X.symbol**2 <= 1, -oo < X.symbol, X.symbol < oo)
+
+    with raises(TypeError):
+        XX = given(X, X + 3)
+
+
+def test_random_symbols():
+    X, Y = Normal('X', 0, 1), Normal('Y', 0, 1)
+
+    assert set(random_symbols(2*X + 1)) == {X}
+    assert set(random_symbols(2*X + Y)) == {X, Y}
+    assert set(random_symbols(2*X + Y.symbol)) == {X}
+    assert set(random_symbols(2)) == set()
+
+
+def test_characteristic_function():
+    #  Imports I from sympy
+    from sympy.core.numbers import I
+    X = Normal('X',0,1)
+    Y = DiscreteUniform('Y', [1,2,7])
+    Z = Poisson('Z', 2)
+    t = symbols('_t')
+    P = Lambda(t, exp(-t**2/2))
+    Q = Lambda(t, exp(7*t*I)/3 + exp(2*t*I)/3 + exp(t*I)/3)
+    R = Lambda(t, exp(2 * exp(t*I) - 2))
+
+
+    assert characteristic_function(X).dummy_eq(P)
+    assert characteristic_function(Y).dummy_eq(Q)
+    assert characteristic_function(Z).dummy_eq(R)
+
+
+def test_moment_generating_function():
+
+    X = Normal('X',0,1)
+    Y = DiscreteUniform('Y', [1,2,7])
+    Z = Poisson('Z', 2)
+    t = symbols('_t')
+    P = Lambda(t, exp(t**2/2))
+    Q = Lambda(t, (exp(7*t)/3 + exp(2*t)/3 + exp(t)/3))
+    R = Lambda(t, exp(2 * exp(t) - 2))
+
+
+    assert moment_generating_function(X).dummy_eq(P)
+    assert moment_generating_function(Y).dummy_eq(Q)
+    assert moment_generating_function(Z).dummy_eq(R)
+
+def test_sample_iter():
+
+    X = Normal('X',0,1)
+    Y = DiscreteUniform('Y', [1, 2, 7])
+    Z = Poisson('Z', 2)
+
+    scipy = import_module('scipy')
+    if not scipy:
+        skip('Scipy is not installed. Abort tests')
+    expr = X**2 + 3
+    iterator = sample_iter(expr)
+
+    expr2 = Y**2 + 5*Y + 4
+    iterator2 = sample_iter(expr2)
+
+    expr3 = Z**3 + 4
+    iterator3 = sample_iter(expr3)
+
+    def is_iterator(obj):
+        if (
+            hasattr(obj, '__iter__') and
+            (hasattr(obj, 'next') or
+            hasattr(obj, '__next__')) and
+            callable(obj.__iter__) and
+            obj.__iter__() is obj
+           ):
+            return True
+        else:
+            return False
+    assert is_iterator(iterator)
+    assert is_iterator(iterator2)
+    assert is_iterator(iterator3)
+
+def test_pspace():
+    X, Y = Normal('X', 0, 1), Normal('Y', 0, 1)
+    x = Symbol('x')
+
+    raises(ValueError, lambda: pspace(5 + 3))
+    raises(ValueError, lambda: pspace(x < 1))
+    assert pspace(X) == X.pspace
+    assert pspace(2*X + 1) == X.pspace
+    assert pspace(2*X + Y) == IndependentProductPSpace(Y.pspace, X.pspace)
+
+def test_rs_swap():
+    X = Normal('x', 0, 1)
+    Y = Exponential('y', 1)
+
+    XX = Normal('x', 0, 2)
+    YY = Normal('y', 0, 3)
+
+    expr = 2*X + Y
+    assert expr.subs(rs_swap((X, Y), (YY, XX))) == 2*XX + YY
+
+
+def test_RandomSymbol():
+
+    X = Normal('x', 0, 1)
+    Y = Normal('x', 0, 2)
+    assert X.symbol == Y.symbol
+    assert X != Y
+
+    assert X.name == X.symbol.name
+
+    X = Normal('lambda', 0, 1) # make sure we can use protected terms
+    X = Normal('Lambda', 0, 1) # make sure we can use SymPy terms
+
+
+def test_RandomSymbol_diff():
+    X = Normal('x', 0, 1)
+    assert (2*X).diff(X)
+
+
+def test_random_symbol_no_pspace():
+    x = RandomSymbol(Symbol('x'))
+    assert x.pspace == PSpace()
+
+def test_overlap():
+    X = Normal('x', 0, 1)
+    Y = Normal('x', 0, 2)
+
+    raises(ValueError, lambda: P(X > Y))
+
+
+def test_IndependentProductPSpace():
+    X = Normal('X', 0, 1)
+    Y = Normal('Y', 0, 1)
+    px = X.pspace
+    py = Y.pspace
+    assert pspace(X + Y) == IndependentProductPSpace(px, py)
+    assert pspace(X + Y) == IndependentProductPSpace(py, px)
+
+
+def test_E():
+    assert E(5) == 5
+
+
+def test_H():
+    X = Normal('X', 0, 1)
+    D = Die('D', sides = 4)
+    G = Geometric('G', 0.5)
+    assert H(X, X > 0) == -log(2)/2 + S.Half + log(pi)/2
+    assert H(D, D > 2) == log(2)
+    assert comp(H(G).evalf().round(2), 1.39)
+
+
+def test_Sample():
+    X = Die('X', 6)
+    Y = Normal('Y', 0, 1)
+    z = Symbol('z', integer=True)
+
+    scipy = import_module('scipy')
+    if not scipy:
+        skip('Scipy is not installed. Abort tests')
+    assert sample(X) in [1, 2, 3, 4, 5, 6]
+    assert isinstance(sample(X + Y), float)
+
+    assert P(X + Y > 0, Y < 0, numsamples=10).is_number
+    assert E(X + Y, numsamples=10).is_number
+    assert E(X**2 + Y, numsamples=10).is_number
+    assert E((X + Y)**2, numsamples=10).is_number
+    assert variance(X + Y, numsamples=10).is_number
+
+    raises(TypeError, lambda: P(Y > z, numsamples=5))
+
+    assert P(sin(Y) <= 1, numsamples=10) == 1.0
+    assert P(sin(Y) <= 1, cos(Y) < 1, numsamples=10) == 1.0
+
+    assert all(i in range(1, 7) for i in density(X, numsamples=10))
+    assert all(i in range(4, 7) for i in density(X, X>3, numsamples=10))
+
+    numpy = import_module('numpy')
+    if not numpy:
+        skip('Numpy is not installed. Abort tests')
+    #Test Issue #21563: Output of sample must be a float or array
+    assert isinstance(sample(X), (numpy.int32, numpy.int64))
+    assert isinstance(sample(Y), numpy.float64)
+    assert isinstance(sample(X, size=2), numpy.ndarray)
+
+    with warns_deprecated_sympy():
+        sample(X, numsamples=2)
+
+@XFAIL
+def test_samplingE():
+    scipy = import_module('scipy')
+    if not scipy:
+        skip('Scipy is not installed. Abort tests')
+    Y = Normal('Y', 0, 1)
+    z = Symbol('z', integer=True)
+    assert E(Sum(1/z**Y, (z, 1, oo)), Y > 2, numsamples=3).is_number
+
+
+def test_given():
+    X = Normal('X', 0, 1)
+    Y = Normal('Y', 0, 1)
+    A = given(X, True)
+    B = given(X, Y > 2)
+
+    assert X == A == B
+
+
+def test_factorial_moment():
+    X = Poisson('X', 2)
+    Y = Binomial('Y', 2, S.Half)
+    Z = Hypergeometric('Z', 4, 2, 2)
+    assert factorial_moment(X, 2) == 4
+    assert factorial_moment(Y, 2) == S.Half
+    assert factorial_moment(Z, 2) == Rational(1, 3)
+
+    x, y, z, l = symbols('x y z l')
+    Y = Binomial('Y', 2, y)
+    Z = Hypergeometric('Z', 10, 2, 3)
+    assert factorial_moment(Y, l) == y**2*FallingFactorial(
+        2, l) + 2*y*(1 - y)*FallingFactorial(1, l) + (1 - y)**2*\
+            FallingFactorial(0, l)
+    assert factorial_moment(Z, l) == 7*FallingFactorial(0, l)/\
+        15 + 7*FallingFactorial(1, l)/15 + FallingFactorial(2, l)/15
+
+
+def test_dependence():
+    X, Y = Die('X'), Die('Y')
+    assert independent(X, 2*Y)
+    assert not dependent(X, 2*Y)
+
+    X, Y = Normal('X', 0, 1), Normal('Y', 0, 1)
+    assert independent(X, Y)
+    assert dependent(X, 2*X)
+
+    # Create a dependency
+    XX, YY = given(Tuple(X, Y), Eq(X + Y, 3))
+    assert dependent(XX, YY)
+
+def test_dependent_finite():
+    X, Y = Die('X'), Die('Y')
+    # Dependence testing requires symbolic conditions which currently break
+    # finite random variables
+    assert dependent(X, Y + X)
+
+    XX, YY = given(Tuple(X, Y), X + Y > 5)  # Create a dependency
+    assert dependent(XX, YY)
+
+
+def test_normality():
+    X, Y = Normal('X', 0, 1), Normal('Y', 0, 1)
+    x = Symbol('x', real=True)
+    z = Symbol('z', real=True)
+    dens = density(X - Y, Eq(X + Y, z))
+
+    assert integrate(dens(x), (x, -oo, oo)) == 1
+
+
+def test_Density():
+    X = Die('X', 6)
+    d = Density(X)
+    assert d.doit() == density(X)
+
+def test_NamedArgsMixin():
+    class Foo(Basic, NamedArgsMixin):
+        _argnames = 'foo', 'bar'
+
+    a = Foo(S(1), S(2))
+
+    assert a.foo == 1
+    assert a.bar == 2
+
+    raises(AttributeError, lambda: a.baz)
+
+    class Bar(Basic, NamedArgsMixin):
+        pass
+
+    raises(AttributeError, lambda: Bar(S(1), S(2)).foo)
+
+def test_density_constant():
+    assert density(3)(2) == 0
+    assert density(3)(3) == DiracDelta(0)
+
+def test_cmoment_constant():
+    assert variance(3) == 0
+    assert cmoment(3, 3) == 0
+    assert cmoment(3, 4) == 0
+    x = Symbol('x')
+    assert variance(x) == 0
+    assert cmoment(x, 15) == 0
+    assert cmoment(x, 0) == 1
+
+def test_moment_constant():
+    assert moment(3, 0) == 1
+    assert moment(3, 1) == 3
+    assert moment(3, 2) == 9
+    x = Symbol('x')
+    assert moment(x, 2) == x**2
+
+def test_median_constant():
+    assert median(3) == 3
+    x = Symbol('x')
+    assert median(x) == x
+
+def test_real():
+    x = Normal('x', 0, 1)
+    assert x.is_real
+
+
+def test_issue_10052():
+    X = Exponential('X', 3)
+    assert P(X < oo) == 1
+    assert P(X > oo) == 0
+    assert P(X < 2, X > oo) == 0
+    assert P(X < oo, X > oo) == 0
+    assert P(X < oo, X > 2) == 1
+    assert P(X < 3, X == 2) == 0
+    raises(ValueError, lambda: P(1))
+    raises(ValueError, lambda: P(X < 1, 2))
+
+def test_issue_11934():
+    density = {0: .5, 1: .5}
+    X = FiniteRV('X', density)
+    assert E(X) == 0.5
+    assert P( X>= 2) == 0
+
+def test_issue_8129():
+    X = Exponential('X', 4)
+    assert P(X >= X) == 1
+    assert P(X > X) == 0
+    assert P(X > X+1) == 0
+
+def test_issue_12237():
+    X = Normal('X', 0, 1)
+    Y = Normal('Y', 0, 1)
+    U = P(X > 0, X)
+    V = P(Y < 0, X)
+    W = P(X + Y > 0, X)
+    assert W == P(X + Y > 0, X)
+    assert U == BernoulliDistribution(S.Half, S.Zero, S.One)
+    assert V == S.Half
+
+def test_is_random():
+    X = Normal('X', 0, 1)
+    Y = Normal('Y', 0, 1)
+    a, b = symbols('a, b')
+    G = GaussianUnitaryEnsemble('U', 2)
+    B = BernoulliProcess('B', 0.9)
+    assert not is_random(a)
+    assert not is_random(a + b)
+    assert not is_random(a * b)
+    assert not is_random(Matrix([a**2, b**2]))
+    assert is_random(X)
+    assert is_random(X**2 + Y)
+    assert is_random(Y + b**2)
+    assert is_random(Y > 5)
+    assert is_random(B[3] < 1)
+    assert is_random(G)
+    assert is_random(X * Y * B[1])
+    assert is_random(Matrix([[X, B[2]], [G, Y]]))
+    assert is_random(Eq(X, 4))
+
+def test_issue_12283():
+    x = symbols('x')
+    X = RandomSymbol(x)
+    Y = RandomSymbol('Y')
+    Z = RandomMatrixSymbol('Z', 2, 1)
+    W = RandomMatrixSymbol('W', 2, 1)
+    RI = RandomIndexedSymbol(Indexed('RI', 3))
+    assert pspace(Z) == PSpace()
+    assert pspace(RI) == PSpace()
+    assert pspace(X) == PSpace()
+    assert E(X) == Expectation(X)
+    assert P(Y > 3) == Probability(Y > 3)
+    assert variance(X) == Variance(X)
+    assert variance(RI) == Variance(RI)
+    assert covariance(X, Y) == Covariance(X, Y)
+    assert covariance(W, Z) == Covariance(W, Z)
+
+def test_issue_6810():
+    X = Die('X', 6)
+    Y = Normal('Y', 0, 1)
+    assert P(Eq(X, 2)) == S(1)/6
+    assert P(Eq(Y, 0)) == 0
+    assert P(Or(X > 2, X < 3)) == 1
+    assert P(And(X > 3, X > 2)) == S(1)/2
+
+def test_issue_20286():
+    n, p = symbols('n p')
+    B = Binomial('B', n, p)
+    k = Dummy('k', integer = True)
+    eq = Sum(Piecewise((-p**k*(1 - p)**(-k + n)*log(p**k*(1 - p)**(-k + n)*binomial(n, k))*binomial(n, k), (k >= 0) & (k <= n)), (nan, True)), (k, 0, n))
+    assert eq.dummy_eq(H(B))

shared/package-files/06/069f0d6d4cdf0f03e40bf33b01cac2fc3413cce89a528caef3f9c75f4a22ea76/python_ivalue.h

@@ -0,0 +1,97 @@
+#pragma once
+#include <ATen/core/ivalue.h>
+#include <pybind11/pybind11.h>
+#include <torch/csrc/jit/python/pybind_utils.h>
+#include <torch/csrc/python_headers.h>
+#include <torch/csrc/utils/pybind.h>
+
+namespace py = pybind11;
+
+namespace c10::ivalue {
+
+// concrete ivalue Holder that hold a py::object
+struct C10_EXPORT ConcretePyObjectHolder final : PyObjectHolder {
+ public:
+  static c10::intrusive_ptr<PyObjectHolder> create(py::object py_obj) {
+    return c10::make_intrusive<ConcretePyObjectHolder>(std::move(py_obj));
+  }
+
+  static c10::intrusive_ptr<PyObjectHolder> create(const py::handle& handle) {
+    py::gil_scoped_acquire ag;
+    return c10::make_intrusive<ConcretePyObjectHolder>(
+        handle.cast<py::object>());
+  }
+
+  PyObject* getPyObject() override {
+    return py_obj_.ptr();
+  }
+
+  InferredType tryToInferType() override {
+    pybind11::gil_scoped_acquire ag;
+    return torch::jit::tryToInferType(py_obj_);
+  }
+
+  IValue toIValue(const TypePtr& type, c10::optional<int32_t> N = c10::nullopt)
+      override {
+    pybind11::gil_scoped_acquire ag;
+    return torch::jit::toIValue(py_obj_, type, N);
+  }
+
+  std::string toStr() override {
+    pybind11::gil_scoped_acquire ag;
+    return py::str(py_obj_);
+  }
+
+  std::vector<at::Tensor> extractTensors() override {
+    // We could implement this entirely in C++ via pybind11 but it turns out to
+    // be substantially slower. Namely, the total time taken by markCompleted on
+    // a CUDAFuture is 21.5us with this implementation, but goes up to 58.7us
+    // when using C++. The reason is unclear.
+    try {
+      pybind11::gil_scoped_acquire ag;
+      static py::object& extractorFn = *new py::object(
+          py::module::import("torch._jit_internal").attr("_extract_tensors"));
+      return extractorFn(py_obj_).cast<std::vector<at::Tensor>>();
+    } catch (py::error_already_set& e) {
+      auto err = std::runtime_error(
+          c10::str("Cannot extract tensors from value: ", e.what()));
+      {
+        pybind11::gil_scoped_acquire ag;
+        e.restore();
+        PyErr_Clear();
+      }
+      throw err;
+    }
+  }
+
+  // Note [Destructing py::object]
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~
+  //
+  // (1) Why py_obj_ = py::none(); does not work. Because we also need to
+  // acquire GIL when destructing py::object of None that de-references None.
+  // https://docs.python.org/3/c-api/none.html#c.Py_RETURN_NONE
+  //
+  // https://stackoverflow.com/questions/15287590/why-should-py-increfpy-none-be-required-before-returning-py-none-in-c
+  //
+  // (2) Why we need to call dec_ref() explicitly. Because py::object of
+  // nullptr, on destruction, effectively does nothing because of it calls
+  // Py_XDECREF(NULL) underlying.
+  // https://docs.python.org/3/c-api/refcounting.html#c.Py_XDECREF
+  ~ConcretePyObjectHolder() override {
+    pybind11::gil_scoped_acquire ag;
+    py_obj_.dec_ref();
+    // explicitly setting PyObject* to nullptr to prevent py::object's dtor to
+    // decref on the PyObject again.
+    py_obj_.ptr() = nullptr;
+  }
+
+  // explicit construction to avoid errornous implicit conversion and
+  // copy-initialization
+  explicit ConcretePyObjectHolder(py::object py_obj)
+      : py_obj_(std::move(py_obj)) {}
+
+ private:
+  py::object py_obj_;
+};
+
+} // namespace c10::ivalue

shared/package-files/06/06bd03cb0ab219a5701da59b81b21664b9d0610ed2a5ad38678794f13ac7cfef/__init__.pyi

@@ -0,0 +1,309 @@
+import sys
+from array import array
+from typing import (
+    Any,
+    Callable,
+    ClassVar,
+    Generic,
+    Iterable,
+    Iterator,
+    List,
+    Mapping,
+    Optional,
+    Sequence,
+    Text,
+    Tuple,
+    Type,
+    TypeVar,
+    Union as _UnionT,
+    overload,
+)
+
+if sys.version_info >= (3, 9):
+    from types import GenericAlias
+
+_T = TypeVar("_T")
+_DLLT = TypeVar("_DLLT", bound=CDLL)
+_CT = TypeVar("_CT", bound=_CData)
+
+RTLD_GLOBAL: int = ...
+RTLD_LOCAL: int = ...
+DEFAULT_MODE: int = ...
+
+class CDLL(object):
+    _func_flags_: ClassVar[int] = ...
+    _func_restype_: ClassVar[_CData] = ...
+    _name: str = ...
+    _handle: int = ...
+    _FuncPtr: Type[_FuncPointer] = ...
+    def __init__(
+        self,
+        name: Optional[str],
+        mode: int = ...,
+        handle: Optional[int] = ...,
+        use_errno: bool = ...,
+        use_last_error: bool = ...,
+        winmode: Optional[int] = ...,
+    ) -> None: ...
+    def __getattr__(self, name: str) -> _NamedFuncPointer: ...
+    def __getitem__(self, name: str) -> _NamedFuncPointer: ...
+
+if sys.platform == "win32":
+    class OleDLL(CDLL): ...
+    class WinDLL(CDLL): ...
+
+class PyDLL(CDLL): ...
+
+class LibraryLoader(Generic[_DLLT]):
+    def __init__(self, dlltype: Type[_DLLT]) -> None: ...
+    def __getattr__(self, name: str) -> _DLLT: ...
+    def __getitem__(self, name: str) -> _DLLT: ...
+    def LoadLibrary(self, name: str) -> _DLLT: ...
+    if sys.version_info >= (3, 9):
+        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+
+cdll: LibraryLoader[CDLL] = ...
+if sys.platform == "win32":
+    windll: LibraryLoader[WinDLL] = ...
+    oledll: LibraryLoader[OleDLL] = ...
+pydll: LibraryLoader[PyDLL] = ...
+pythonapi: PyDLL = ...
+
+# Anything that implements the read-write buffer interface.
+# The buffer interface is defined purely on the C level, so we cannot define a normal Protocol
+# for it. Instead we have to list the most common stdlib buffer classes in a Union.
+_WritableBuffer = _UnionT[bytearray, memoryview, array, _CData]
+# Same as _WritableBuffer, but also includes read-only buffer types (like bytes).
+_ReadOnlyBuffer = _UnionT[_WritableBuffer, bytes]
+
+class _CDataMeta(type):
+    # By default mypy complains about the following two methods, because strictly speaking cls
+    # might not be a Type[_CT]. However this can never actually happen, because the only class that
+    # uses _CDataMeta as its metaclass is _CData. So it's safe to ignore the errors here.
+    def __mul__(cls: Type[_CT], other: int) -> Type[Array[_CT]]: ...  # type: ignore
+    def __rmul__(cls: Type[_CT], other: int) -> Type[Array[_CT]]: ...  # type: ignore
+
+class _CData(metaclass=_CDataMeta):
+    _b_base: int = ...
+    _b_needsfree_: bool = ...
+    _objects: Optional[Mapping[Any, int]] = ...
+    @classmethod
+    def from_buffer(cls: Type[_CT], source: _WritableBuffer, offset: int = ...) -> _CT: ...
+    @classmethod
+    def from_buffer_copy(cls: Type[_CT], source: _ReadOnlyBuffer, offset: int = ...) -> _CT: ...
+    @classmethod
+    def from_address(cls: Type[_CT], address: int) -> _CT: ...
+    @classmethod
+    def from_param(cls: Type[_CT], obj: Any) -> _UnionT[_CT, _CArgObject]: ...
+    @classmethod
+    def in_dll(cls: Type[_CT], library: CDLL, name: str) -> _CT: ...
+
+class _CanCastTo(_CData): ...
+class _PointerLike(_CanCastTo): ...
+
+_ECT = Callable[[Optional[Type[_CData]], _FuncPointer, Tuple[_CData, ...]], _CData]
+_PF = _UnionT[Tuple[int], Tuple[int, str], Tuple[int, str, Any]]
+
+class _FuncPointer(_PointerLike, _CData):
+    restype: _UnionT[Type[_CData], Callable[[int], None], None] = ...
+    argtypes: Sequence[Type[_CData]] = ...
+    errcheck: _ECT = ...
+    @overload
+    def __init__(self, address: int) -> None: ...
+    @overload
+    def __init__(self, callable: Callable[..., Any]) -> None: ...
+    @overload
+    def __init__(self, func_spec: Tuple[_UnionT[str, int], CDLL], paramflags: Tuple[_PF, ...] = ...) -> None: ...
+    @overload
+    def __init__(self, vtlb_index: int, name: str, paramflags: Tuple[_PF, ...] = ..., iid: pointer[c_int] = ...) -> None: ...
+    def __call__(self, *args: Any, **kwargs: Any) -> Any: ...
+
+class _NamedFuncPointer(_FuncPointer):
+    __name__: str
+
+class ArgumentError(Exception): ...
+
+def CFUNCTYPE(
+    restype: Optional[Type[_CData]], *argtypes: Type[_CData], use_errno: bool = ..., use_last_error: bool = ...
+) -> Type[_FuncPointer]: ...
+
+if sys.platform == "win32":
+    def WINFUNCTYPE(
+        restype: Optional[Type[_CData]], *argtypes: Type[_CData], use_errno: bool = ..., use_last_error: bool = ...
+    ) -> Type[_FuncPointer]: ...
+
+def PYFUNCTYPE(restype: Optional[Type[_CData]], *argtypes: Type[_CData]) -> Type[_FuncPointer]: ...
+
+class _CArgObject: ...
+
+# Any type that can be implicitly converted to c_void_p when passed as a C function argument.
+# (bytes is not included here, see below.)
+_CVoidPLike = _UnionT[_PointerLike, Array[Any], _CArgObject, int]
+# Same as above, but including types known to be read-only (i. e. bytes).
+# This distinction is not strictly necessary (ctypes doesn't differentiate between const
+# and non-const pointers), but it catches errors like memmove(b'foo', buf, 4)
+# when memmove(buf, b'foo', 4) was intended.
+_CVoidConstPLike = _UnionT[_CVoidPLike, bytes]
+
+def addressof(obj: _CData) -> int: ...
+def alignment(obj_or_type: _UnionT[_CData, Type[_CData]]) -> int: ...
+def byref(obj: _CData, offset: int = ...) -> _CArgObject: ...
+
+_CastT = TypeVar("_CastT", bound=_CanCastTo)
+
+def cast(obj: _UnionT[_CData, _CArgObject, int], type: Type[_CastT]) -> _CastT: ...
+def create_string_buffer(init: _UnionT[int, bytes], size: Optional[int] = ...) -> Array[c_char]: ...
+
+c_buffer = create_string_buffer
+
+def create_unicode_buffer(init: _UnionT[int, Text], size: Optional[int] = ...) -> Array[c_wchar]: ...
+
+if sys.platform == "win32":
+    def DllCanUnloadNow() -> int: ...
+    def DllGetClassObject(rclsid: Any, riid: Any, ppv: Any) -> int: ...  # TODO not documented
+    def FormatError(code: int) -> str: ...
+    def GetLastError() -> int: ...
+
+def get_errno() -> int: ...
+
+if sys.platform == "win32":
+    def get_last_error() -> int: ...
+
+def memmove(dst: _CVoidPLike, src: _CVoidConstPLike, count: int) -> None: ...
+def memset(dst: _CVoidPLike, c: int, count: int) -> None: ...
+def POINTER(type: Type[_CT]) -> Type[pointer[_CT]]: ...
+
+# The real ctypes.pointer is a function, not a class. The stub version of pointer behaves like
+# ctypes._Pointer in that it is the base class for all pointer types. Unlike the real _Pointer,
+# it can be instantiated directly (to mimic the behavior of the real pointer function).
+class pointer(Generic[_CT], _PointerLike, _CData):
+    _type_: ClassVar[Type[_CT]] = ...
+    contents: _CT = ...
+    def __init__(self, arg: _CT = ...) -> None: ...
+    @overload
+    def __getitem__(self, i: int) -> _CT: ...
+    @overload
+    def __getitem__(self, s: slice) -> List[_CT]: ...
+    @overload
+    def __setitem__(self, i: int, o: _CT) -> None: ...
+    @overload
+    def __setitem__(self, s: slice, o: Iterable[_CT]) -> None: ...
+
+def resize(obj: _CData, size: int) -> None: ...
+
+if sys.version_info < (3,):
+    def set_conversion_mode(encoding: str, errors: str) -> Tuple[str, str]: ...
+
+def set_errno(value: int) -> int: ...
+
+if sys.platform == "win32":
+    def set_last_error(value: int) -> int: ...
+
+def sizeof(obj_or_type: _UnionT[_CData, Type[_CData]]) -> int: ...
+def string_at(address: _CVoidConstPLike, size: int = ...) -> bytes: ...
+
+if sys.platform == "win32":
+    def WinError(code: Optional[int] = ..., descr: Optional[str] = ...) -> OSError: ...
+
+def wstring_at(address: _CVoidConstPLike, size: int = ...) -> str: ...
+
+class _SimpleCData(Generic[_T], _CData):
+    value: _T = ...
+    def __init__(self, value: _T = ...) -> None: ...
+
+class c_byte(_SimpleCData[int]): ...
+
+class c_char(_SimpleCData[bytes]):
+    def __init__(self, value: _UnionT[int, bytes] = ...) -> None: ...
+
+class c_char_p(_PointerLike, _SimpleCData[Optional[bytes]]):
+    def __init__(self, value: Optional[_UnionT[int, bytes]] = ...) -> None: ...
+
+class c_double(_SimpleCData[float]): ...
+class c_longdouble(_SimpleCData[float]): ...
+class c_float(_SimpleCData[float]): ...
+class c_int(_SimpleCData[int]): ...
+class c_int8(_SimpleCData[int]): ...
+class c_int16(_SimpleCData[int]): ...
+class c_int32(_SimpleCData[int]): ...
+class c_int64(_SimpleCData[int]): ...
+class c_long(_SimpleCData[int]): ...
+class c_longlong(_SimpleCData[int]): ...
+class c_short(_SimpleCData[int]): ...
+class c_size_t(_SimpleCData[int]): ...
+class c_ssize_t(_SimpleCData[int]): ...
+class c_ubyte(_SimpleCData[int]): ...
+class c_uint(_SimpleCData[int]): ...
+class c_uint8(_SimpleCData[int]): ...
+class c_uint16(_SimpleCData[int]): ...
+class c_uint32(_SimpleCData[int]): ...
+class c_uint64(_SimpleCData[int]): ...
+class c_ulong(_SimpleCData[int]): ...
+class c_ulonglong(_SimpleCData[int]): ...
+class c_ushort(_SimpleCData[int]): ...
+class c_void_p(_PointerLike, _SimpleCData[Optional[int]]): ...
+class c_wchar(_SimpleCData[Text]): ...
+
+class c_wchar_p(_PointerLike, _SimpleCData[Optional[Text]]):
+    def __init__(self, value: Optional[_UnionT[int, Text]] = ...) -> None: ...
+
+class c_bool(_SimpleCData[bool]):
+    def __init__(self, value: bool = ...) -> None: ...
+
+if sys.platform == "win32":
+    class HRESULT(_SimpleCData[int]): ...  # TODO undocumented
+
+class py_object(_CanCastTo, _SimpleCData[_T]): ...
+
+class _CField:
+    offset: int = ...
+    size: int = ...
+
+class _StructUnionMeta(_CDataMeta):
+    _fields_: Sequence[_UnionT[Tuple[str, Type[_CData]], Tuple[str, Type[_CData], int]]] = ...
+    _pack_: int = ...
+    _anonymous_: Sequence[str] = ...
+    def __getattr__(self, name: str) -> _CField: ...
+
+class _StructUnionBase(_CData, metaclass=_StructUnionMeta):
+    def __init__(self, *args: Any, **kw: Any) -> None: ...
+    def __getattr__(self, name: str) -> Any: ...
+    def __setattr__(self, name: str, value: Any) -> None: ...
+
+class Union(_StructUnionBase): ...
+class Structure(_StructUnionBase): ...
+class BigEndianStructure(Structure): ...
+class LittleEndianStructure(Structure): ...
+
+class Array(Generic[_CT], _CData):
+    _length_: ClassVar[int] = ...
+    _type_: ClassVar[Type[_CT]] = ...
+    raw: bytes = ...  # Note: only available if _CT == c_char
+    value: Any = ...  # Note: bytes if _CT == c_char, Text if _CT == c_wchar, unavailable otherwise
+    # TODO These methods cannot be annotated correctly at the moment.
+    # All of these "Any"s stand for the array's element type, but it's not possible to use _CT
+    # here, because of a special feature of ctypes.
+    # By default, when accessing an element of an Array[_CT], the returned object has type _CT.
+    # However, when _CT is a "simple type" like c_int, ctypes automatically "unboxes" the object
+    # and converts it to the corresponding Python primitive. For example, when accessing an element
+    # of an Array[c_int], a Python int object is returned, not a c_int.
+    # This behavior does *not* apply to subclasses of "simple types".
+    # If MyInt is a subclass of c_int, then accessing an element of an Array[MyInt] returns
+    # a MyInt, not an int.
+    # This special behavior is not easy to model in a stub, so for now all places where
+    # the array element type would belong are annotated with Any instead.
+    def __init__(self, *args: Any) -> None: ...
+    @overload
+    def __getitem__(self, i: int) -> Any: ...
+    @overload
+    def __getitem__(self, s: slice) -> List[Any]: ...
+    @overload
+    def __setitem__(self, i: int, o: Any) -> None: ...
+    @overload
+    def __setitem__(self, s: slice, o: Iterable[Any]) -> None: ...
+    def __iter__(self) -> Iterator[Any]: ...
+    # Can't inherit from Sized because the metaclass conflict between
+    # Sized and _CData prevents using _CDataMeta.
+    def __len__(self) -> int: ...
+    if sys.version_info >= (3, 9):
+        def __class_getitem__(cls, item: Any) -> GenericAlias: ...

shared/package-files/06/06d090ae1a5cf3f42e004c937acfa25d9bcd1830a4e0c7218eaf4e0ee7a40025/sparse_csc_tensor_ops.h

@@ -0,0 +1,39 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Operator.h
+
+#include <tuple>
+#include <vector>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+namespace _ops {
+
+
+struct TORCH_API sparse_csc_tensor_ccol_row_value_size {
+  using schema = at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::IntArrayRef, c10::optional<at::ScalarType>, c10::optional<at::Layout>, c10::optional<at::Device>, c10::optional<bool>);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::sparse_csc_tensor")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "ccol_row_value_size")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "sparse_csc_tensor.ccol_row_value_size(Tensor ccol_indices, Tensor row_indices, Tensor values, int[] size, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=False) -> Tensor")
+  static at::Tensor call(const at::Tensor & ccol_indices, const at::Tensor & row_indices, const at::Tensor & values, at::IntArrayRef size, c10::optional<at::ScalarType> dtype, c10::optional<at::Layout> layout, c10::optional<at::Device> device, c10::optional<bool> pin_memory);
+  static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & ccol_indices, const at::Tensor & row_indices, const at::Tensor & values, at::IntArrayRef size, c10::optional<at::ScalarType> dtype, c10::optional<at::Layout> layout, c10::optional<at::Device> device, c10::optional<bool> pin_memory);
+};
+
+struct TORCH_API sparse_csc_tensor_ccol_row_value {
+  using schema = at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, c10::optional<at::ScalarType>, c10::optional<at::Layout>, c10::optional<at::Device>, c10::optional<bool>);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::sparse_csc_tensor")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "ccol_row_value")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "sparse_csc_tensor.ccol_row_value(Tensor ccol_indices, Tensor row_indices, Tensor values, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=False) -> Tensor")
+  static at::Tensor call(const at::Tensor & ccol_indices, const at::Tensor & row_indices, const at::Tensor & values, c10::optional<at::ScalarType> dtype, c10::optional<at::Layout> layout, c10::optional<at::Device> device, c10::optional<bool> pin_memory);
+  static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & ccol_indices, const at::Tensor & row_indices, const at::Tensor & values, c10::optional<at::ScalarType> dtype, c10::optional<at::Layout> layout, c10::optional<at::Device> device, c10::optional<bool> pin_memory);
+};
+
+}} // namespace at::_ops

shared/package-files/06/06e5eecfab0237d4daed4956441ce3c7876d0e96dd748de38cabbcc4ea430f04/kl_div.h

@@ -0,0 +1,30 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Function.h
+
+#include <ATen/Context.h>
+#include <ATen/DeviceGuard.h>
+#include <ATen/TensorUtils.h>
+#include <ATen/TracerMode.h>
+#include <ATen/core/Generator.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+
+
+
+#include <ATen/ops/kl_div_ops.h>
+
+namespace at {
+
+
+// aten::kl_div(Tensor self, Tensor target, int reduction=Mean, *, bool log_target=False) -> Tensor
+inline at::Tensor kl_div(const at::Tensor & self, const at::Tensor & target, int64_t reduction=at::Reduction::Mean, bool log_target=false) {
+    return at::_ops::kl_div::call(self, target, reduction, log_target);
+}
+
+}

shared/package-files/1f/1f0c7a1de6f606f4d33037d660bdf24685eca8c77dc5dbb5fcb457cf69cccf0b/win32-headers.h

@@ -0,0 +1,60 @@
+#pragma once
+
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+#ifndef NOKERNEL
+#define NOKERNEL
+#endif
+#ifndef NOUSER
+#define NOUSER
+#endif
+#ifndef NOSERVICE
+#define NOSERVICE
+#endif
+#ifndef NOSOUND
+#define NOSOUND
+#endif
+#ifndef NOMCX
+#define NOMCX
+#endif
+#ifndef NOGDI
+#define NOGDI
+#endif
+#ifndef NOMSG
+#define NOMSG
+#endif
+#ifndef NOMB
+#define NOMB
+#endif
+#ifndef NOCLIPBOARD
+#define NOCLIPBOARD
+#endif
+
+// dbghelp seems to require windows.h.
+// clang-format off
+#include <windows.h>
+#include <dbghelp.h>
+// clang-format on
+
+#undef VOID
+#undef DELETE
+#undef IN
+#undef THIS
+#undef CONST
+#undef NAN
+#undef UNKNOWN
+#undef NONE
+#undef ANY
+#undef IGNORE
+#undef STRICT
+#undef GetObject
+#undef CreateSemaphore
+#undef Yield
+#undef RotateRight32
+#undef RotateLeft32
+#undef RotateRight64
+#undef RotateLeft64

shared/package-files/1f/1f0c9cca56cf020455cf89d9be3bf0a8dde642725ba8a03e35131a02f20ff821/_utility_functions.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from ._array_object import Array
+
+from typing import Optional, Tuple, Union
+
+import numpy as np
+
+
+def all(
+    x: Array,
+    /,
+    *,
+    axis: Optional[Union[int, Tuple[int, ...]]] = None,
+    keepdims: bool = False,
+) -> Array:
+    """
+    Array API compatible wrapper for :py:func:`np.all <numpy.all>`.
+
+    See its docstring for more information.
+    """
+    return Array._new(np.asarray(np.all(x._array, axis=axis, keepdims=keepdims)))
+
+
+def any(
+    x: Array,
+    /,
+    *,
+    axis: Optional[Union[int, Tuple[int, ...]]] = None,
+    keepdims: bool = False,
+) -> Array:
+    """
+    Array API compatible wrapper for :py:func:`np.any <numpy.any>`.
+
+    See its docstring for more information.
+    """
+    return Array._new(np.asarray(np.any(x._array, axis=axis, keepdims=keepdims)))

shared/package-files/1f/1f1b0f5dede0263bd81773a78e98af551f36361accb315b618c8ae70a5fe781e/id.msg

@@ -0,0 +1,47 @@
+# created by tools/loadICU.tcl -- do not edit
+namespace eval ::tcl::clock {
+    ::msgcat::mcset id DAYS_OF_WEEK_ABBREV [list \
+        "Min"\
+        "Sen"\
+        "Sel"\
+        "Rab"\
+        "Kam"\
+        "Jum"\
+        "Sab"]
+    ::msgcat::mcset id DAYS_OF_WEEK_FULL [list \
+        "Minggu"\
+        "Senin"\
+        "Selasa"\
+        "Rabu"\
+        "Kamis"\
+        "Jumat"\
+        "Sabtu"]
+    ::msgcat::mcset id MONTHS_ABBREV [list \
+        "Jan"\
+        "Peb"\
+        "Mar"\
+        "Apr"\
+        "Mei"\
+        "Jun"\
+        "Jul"\
+        "Agu"\
+        "Sep"\
+        "Okt"\
+        "Nov"\
+        "Des"\
+        ""]
+    ::msgcat::mcset id MONTHS_FULL [list \
+        "Januari"\
+        "Pebruari"\
+        "Maret"\
+        "April"\
+        "Mei"\
+        "Juni"\
+        "Juli"\
+        "Agustus"\
+        "September"\
+        "Oktober"\
+        "November"\
+        "Desember"\
+        ""]
+}

shared/package-files/1f/1f3a5a429231389a9f86b10784ac845d11b0cdcfeeefd22eab2fcabaded1562d/six.h

@@ -0,0 +1,52 @@
+#pragma once
+
+#include <pybind11/pybind11.h>
+#include <torch/csrc/utils/object_ptr.h>
+#include <torch/csrc/utils/pybind.h>
+#include <torch/csrc/utils/structseq.h>
+
+namespace six {
+
+// Usually instances of PyStructSequence is also an instance of tuple
+// but in some py2 environment it is not, so we have to manually check
+// the name of the type to determine if it is a namedtupled returned
+// by a pytorch operator.
+
+inline bool isStructSeq(pybind11::handle input) {
+  return pybind11::cast<std::string>(input.get_type().attr("__module__")) ==
+      "torch.return_types";
+}
+
+inline bool isStructSeq(PyObject* obj) {
+  return isStructSeq(pybind11::handle(obj));
+}
+
+inline bool isTuple(pybind11::handle input) {
+  if (PyTuple_Check(input.ptr())) {
+    return true;
+  }
+  return false;
+}
+
+inline bool isTuple(PyObject* obj) {
+  return isTuple(pybind11::handle(obj));
+}
+
+// maybeAsTuple: if the input is a structseq, then convert it to a tuple
+//
+// On Python 3, structseq is a subtype of tuple, so these APIs could be used
+// directly. But on Python 2, structseq is not a subtype of tuple, so we need to
+// manually create a new tuple object from structseq.
+inline THPObjectPtr maybeAsTuple(PyStructSequence* obj) {
+  Py_INCREF(obj);
+  return THPObjectPtr((PyObject*)obj);
+}
+
+inline THPObjectPtr maybeAsTuple(PyObject* obj) {
+  if (isStructSeq(obj))
+    return maybeAsTuple((PyStructSequence*)obj);
+  Py_INCREF(obj);
+  return THPObjectPtr(obj);
+}
+
+} // namespace six

shared/package-files/1f/1f3b4f48d844fbb98ef3162a664f704c9437659bb4e9b80a8ddb8f6fc373ca9c/bernoulli_cuda_dispatch.h

@@ -0,0 +1,26 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace cuda {
+
+TORCH_API at::Tensor & bernoulli_out(at::Tensor & out, const at::Tensor & self, c10::optional<at::Generator> generator=c10::nullopt);
+TORCH_API at::Tensor & bernoulli_outf(const at::Tensor & self, c10::optional<at::Generator> generator, at::Tensor & out);
+TORCH_API at::Tensor & bernoulli_(at::Tensor & self, const at::Tensor & p, c10::optional<at::Generator> generator=c10::nullopt);
+TORCH_API at::Tensor & bernoulli_(at::Tensor & self, double p=0.5, c10::optional<at::Generator> generator=c10::nullopt);
+
+} // namespace cuda
+} // namespace at

shared/package-files/1f/1f42bd13d30048a580a164a3b7aa8e67279ef71e4bb7368abc848422c8654da6/norm_except_dim.h

@@ -0,0 +1,30 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Function.h
+
+#include <ATen/Context.h>
+#include <ATen/DeviceGuard.h>
+#include <ATen/TensorUtils.h>
+#include <ATen/TracerMode.h>
+#include <ATen/core/Generator.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+
+
+
+#include <ATen/ops/norm_except_dim_ops.h>
+
+namespace at {
+
+
+// aten::norm_except_dim(Tensor v, int pow=2, int dim=0) -> Tensor
+inline at::Tensor norm_except_dim(const at::Tensor & v, int64_t pow=2, int64_t dim=0) {
+    return at::_ops::norm_except_dim::call(v, pow, dim);
+}
+
+}

shared/package-files/1f/1f4a0d664366c293fc8ba529cac9e40fbc9abded04dd853767c74a1a86d26ce0/test_sdm.py

@@ -0,0 +1,444 @@
+"""
+Tests for the basic functionality of the SDM class.
+"""
+
+from itertools import product
+
+from sympy.core.singleton import S
+from sympy.external.gmpy import HAS_GMPY
+from sympy.testing.pytest import raises
+
+from sympy.polys.domains import QQ, ZZ, EXRAW
+from sympy.polys.matrices.sdm import SDM
+from sympy.polys.matrices.ddm import DDM
+from sympy.polys.matrices.exceptions import (DMBadInputError, DMDomainError,
+                                             DMShapeError)
+
+
+def test_SDM():
+    A = SDM({0:{0:ZZ(1)}}, (2, 2), ZZ)
+    assert A.domain == ZZ
+    assert A.shape == (2, 2)
+    assert dict(A) == {0:{0:ZZ(1)}}
+
+    raises(DMBadInputError, lambda: SDM({5:{1:ZZ(0)}}, (2, 2), ZZ))
+    raises(DMBadInputError, lambda: SDM({0:{5:ZZ(0)}}, (2, 2), ZZ))
+
+
+def test_DDM_str():
+    sdm = SDM({0:{0:ZZ(1)}, 1:{1:ZZ(1)}}, (2, 2), ZZ)
+    assert str(sdm) == '{0: {0: 1}, 1: {1: 1}}'
+    if HAS_GMPY: # pragma: no cover
+        assert repr(sdm) == 'SDM({0: {0: mpz(1)}, 1: {1: mpz(1)}}, (2, 2), ZZ)'
+    else:        # pragma: no cover
+        assert repr(sdm) == 'SDM({0: {0: 1}, 1: {1: 1}}, (2, 2), ZZ)'
+
+
+def test_SDM_new():
+    A = SDM({0:{0:ZZ(1)}}, (2, 2), ZZ)
+    B = A.new({}, (2, 2), ZZ)
+    assert B == SDM({}, (2, 2), ZZ)
+
+
+def test_SDM_copy():
+    A = SDM({0:{0:ZZ(1)}}, (2, 2), ZZ)
+    B = A.copy()
+    assert A == B
+    A[0][0] = ZZ(2)
+    assert A != B
+
+
+def test_SDM_from_list():
+    A = SDM.from_list([[ZZ(0), ZZ(1)], [ZZ(1), ZZ(0)]], (2, 2), ZZ)
+    assert A == SDM({0:{1:ZZ(1)}, 1:{0:ZZ(1)}}, (2, 2), ZZ)
+
+    raises(DMBadInputError, lambda: SDM.from_list([[ZZ(0)], [ZZ(0), ZZ(1)]], (2, 2), ZZ))
+    raises(DMBadInputError, lambda: SDM.from_list([[ZZ(0), ZZ(1)]], (2, 2), ZZ))
+
+
+def test_SDM_to_list():
+    A = SDM({0:{1: ZZ(1)}}, (2, 2), ZZ)
+    assert A.to_list() == [[ZZ(0), ZZ(1)], [ZZ(0), ZZ(0)]]
+
+    A = SDM({}, (0, 2), ZZ)
+    assert A.to_list() == []
+
+    A = SDM({}, (2, 0), ZZ)
+    assert A.to_list() == [[], []]
+
+
+def test_SDM_to_list_flat():
+    A = SDM({0:{1: ZZ(1)}}, (2, 2), ZZ)
+    assert A.to_list_flat() == [ZZ(0), ZZ(1), ZZ(0), ZZ(0)]
+
+
+def test_SDM_to_dok():
+    A = SDM({0:{1: ZZ(1)}}, (2, 2), ZZ)
+    assert A.to_dok() == {(0, 1): ZZ(1)}
+
+
+def test_SDM_from_ddm():
+    A = DDM([[ZZ(1), ZZ(0)], [ZZ(1), ZZ(0)]], (2, 2), ZZ)
+    B = SDM.from_ddm(A)
+    assert B.domain == ZZ
+    assert B.shape == (2, 2)
+    assert dict(B) == {0:{0:ZZ(1)}, 1:{0:ZZ(1)}}
+
+
+def test_SDM_to_ddm():
+    A = SDM({0:{1: ZZ(1)}}, (2, 2), ZZ)
+    B = DDM([[ZZ(0), ZZ(1)], [ZZ(0), ZZ(0)]], (2, 2), ZZ)
+    assert A.to_ddm() == B
+
+
+def test_SDM_to_sdm():
+    A = SDM({0:{1: ZZ(1)}}, (2, 2), ZZ)
+    assert A.to_sdm() == A
+
+
+def test_SDM_getitem():
+    A = SDM({0:{1:ZZ(1)}}, (2, 2), ZZ)
+    assert A.getitem(0, 0) == ZZ.zero
+    assert A.getitem(0, 1) == ZZ.one
+    assert A.getitem(1, 0) == ZZ.zero
+    assert A.getitem(-2, -2) == ZZ.zero
+    assert A.getitem(-2, -1) == ZZ.one
+    assert A.getitem(-1, -2) == ZZ.zero
+    raises(IndexError, lambda: A.getitem(2, 0))
+    raises(IndexError, lambda: A.getitem(0, 2))
+
+
+def test_SDM_setitem():
+    A = SDM({0:{1:ZZ(1)}}, (2, 2), ZZ)
+    A.setitem(0, 0, ZZ(1))
+    assert A == SDM({0:{0:ZZ(1), 1:ZZ(1)}}, (2, 2), ZZ)
+    A.setitem(1, 0, ZZ(1))
+    assert A == SDM({0:{0:ZZ(1), 1:ZZ(1)}, 1:{0:ZZ(1)}}, (2, 2), ZZ)
+    A.setitem(1, 0, ZZ(0))
+    assert A == SDM({0:{0:ZZ(1), 1:ZZ(1)}}, (2, 2), ZZ)
+    # Repeat the above test so that this time the row is empty
+    A.setitem(1, 0, ZZ(0))
+    assert A == SDM({0:{0:ZZ(1), 1:ZZ(1)}}, (2, 2), ZZ)
+    A.setitem(0, 0, ZZ(0))
+    assert A == SDM({0:{1:ZZ(1)}}, (2, 2), ZZ)
+    # This time the row is there but column is empty
+    A.setitem(0, 0, ZZ(0))
+    assert A == SDM({0:{1:ZZ(1)}}, (2, 2), ZZ)
+    raises(IndexError, lambda: A.setitem(2, 0, ZZ(1)))
+    raises(IndexError, lambda: A.setitem(0, 2, ZZ(1)))
+
+
+def test_SDM_extract_slice():
+    A = SDM({0:{0:ZZ(1), 1:ZZ(2)}, 1:{0:ZZ(3), 1:ZZ(4)}}, (2, 2), ZZ)
+    B = A.extract_slice(slice(1, 2), slice(1, 2))
+    assert B == SDM({0:{0:ZZ(4)}}, (1, 1), ZZ)
+
+
+def test_SDM_extract():
+    A = SDM({0:{0:ZZ(1), 1:ZZ(2)}, 1:{0:ZZ(3), 1:ZZ(4)}}, (2, 2), ZZ)
+    B = A.extract([1], [1])
+    assert B == SDM({0:{0:ZZ(4)}}, (1, 1), ZZ)
+    B = A.extract([1, 0], [1, 0])
+    assert B == SDM({0:{0:ZZ(4), 1:ZZ(3)}, 1:{0:ZZ(2), 1:ZZ(1)}}, (2, 2), ZZ)
+    B = A.extract([1, 1], [1, 1])
+    assert B == SDM({0:{0:ZZ(4), 1:ZZ(4)}, 1:{0:ZZ(4), 1:ZZ(4)}}, (2, 2), ZZ)
+    B = A.extract([-1], [-1])
+    assert B == SDM({0:{0:ZZ(4)}}, (1, 1), ZZ)
+
+    A = SDM({}, (2, 2), ZZ)
+    B = A.extract([0, 1, 0], [0, 0])
+    assert B == SDM({}, (3, 2), ZZ)
+
+    A = SDM({0:{0:ZZ(1), 1:ZZ(2)}, 1:{0:ZZ(3), 1:ZZ(4)}}, (2, 2), ZZ)
+    assert A.extract([], []) == SDM.zeros((0, 0), ZZ)
+    assert A.extract([1], []) == SDM.zeros((1, 0), ZZ)
+    assert A.extract([], [1]) == SDM.zeros((0, 1), ZZ)
+
+    raises(IndexError, lambda: A.extract([2], [0]))
+    raises(IndexError, lambda: A.extract([0], [2]))
+    raises(IndexError, lambda: A.extract([-3], [0]))
+    raises(IndexError, lambda: A.extract([0], [-3]))
+
+
+def test_SDM_zeros():
+    A = SDM.zeros((2, 2), ZZ)
+    assert A.domain == ZZ
+    assert A.shape == (2, 2)
+    assert dict(A) == {}
+
+def test_SDM_ones():
+    A = SDM.ones((1, 2), QQ)
+    assert A.domain == QQ
+    assert A.shape == (1, 2)
+    assert dict(A) == {0:{0:QQ(1), 1:QQ(1)}}
+
+def test_SDM_eye():
+    A = SDM.eye((2, 2), ZZ)
+    assert A.domain == ZZ
+    assert A.shape == (2, 2)
+    assert dict(A) == {0:{0:ZZ(1)}, 1:{1:ZZ(1)}}
+
+
+def test_SDM_diag():
+    A = SDM.diag([ZZ(1), ZZ(2)], ZZ, (2, 3))
+    assert A == SDM({0:{0:ZZ(1)}, 1:{1:ZZ(2)}}, (2, 3), ZZ)
+
+
+def test_SDM_transpose():
+    A = SDM({0:{0:ZZ(1), 1:ZZ(2)}, 1:{0:ZZ(3), 1:ZZ(4)}}, (2, 2), ZZ)
+    B = SDM({0:{0:ZZ(1), 1:ZZ(3)}, 1:{0:ZZ(2), 1:ZZ(4)}}, (2, 2), ZZ)
+    assert A.transpose() == B
+
+    A = SDM({0:{1:ZZ(2)}}, (2, 2), ZZ)
+    B = SDM({1:{0:ZZ(2)}}, (2, 2), ZZ)
+    assert A.transpose() == B
+
+    A = SDM({0:{1:ZZ(2)}}, (1, 2), ZZ)
+    B = SDM({1:{0:ZZ(2)}}, (2, 1), ZZ)
+    assert A.transpose() == B
+
+
+def test_SDM_mul():
+    A = SDM({0:{0:ZZ(2)}}, (2, 2), ZZ)
+    B = SDM({0:{0:ZZ(4)}}, (2, 2), ZZ)
+    assert A*ZZ(2) == B
+    assert ZZ(2)*A == B
+
+    raises(TypeError, lambda: A*QQ(1, 2))
+    raises(TypeError, lambda: QQ(1, 2)*A)
+
+
+def test_SDM_mul_elementwise():
+    A = SDM({0:{0:ZZ(2), 1:ZZ(2)}}, (2, 2), ZZ)
+    B = SDM({0:{0:ZZ(4)}, 1:{0:ZZ(3)}}, (2, 2), ZZ)
+    C = SDM({0:{0:ZZ(8)}}, (2, 2), ZZ)
+    assert A.mul_elementwise(B) == C
+    assert B.mul_elementwise(A) == C
+
+    Aq = A.convert_to(QQ)
+    A1 = SDM({0:{0:ZZ(1)}}, (1, 1), ZZ)
+
+    raises(DMDomainError, lambda: Aq.mul_elementwise(B))
+    raises(DMShapeError, lambda: A1.mul_elementwise(B))
+
+
+def test_SDM_matmul():
+    A = SDM({0:{0:ZZ(2)}}, (2, 2), ZZ)
+    B = SDM({0:{0:ZZ(4)}}, (2, 2), ZZ)
+    assert A.matmul(A) == A*A == B
+
+    C = SDM({0:{0:ZZ(2)}}, (2, 2), QQ)
+    raises(DMDomainError, lambda: A.matmul(C))
+
+    A = SDM({0:{0:ZZ(1), 1:ZZ(2)}, 1:{0:ZZ(3), 1:ZZ(4)}}, (2, 2), ZZ)
+    B = SDM({0:{0:ZZ(7), 1:ZZ(10)}, 1:{0:ZZ(15), 1:ZZ(22)}}, (2, 2), ZZ)
+    assert A.matmul(A) == A*A == B
+
+    A22 = SDM({0:{0:ZZ(4)}}, (2, 2), ZZ)
+    A32 = SDM({0:{0:ZZ(2)}}, (3, 2), ZZ)
+    A23 = SDM({0:{0:ZZ(4)}}, (2, 3), ZZ)
+    A33 = SDM({0:{0:ZZ(8)}}, (3, 3), ZZ)
+    A22 = SDM({0:{0:ZZ(8)}}, (2, 2), ZZ)
+    assert A32.matmul(A23) == A33
+    assert A23.matmul(A32) == A22
+    # XXX: @ not supported by SDM...
+    #assert A32.matmul(A23) == A32 @ A23 == A33
+    #assert A23.matmul(A32) == A23 @ A32 == A22
+    #raises(DMShapeError, lambda: A23 @ A22)
+    raises(DMShapeError, lambda: A23.matmul(A22))
+
+    A = SDM({0: {0: ZZ(-1), 1: ZZ(1)}}, (1, 2), ZZ)
+    B = SDM({0: {0: ZZ(-1)}, 1: {0: ZZ(-1)}}, (2, 1), ZZ)
+    assert A.matmul(B) == A*B == SDM({}, (1, 1), ZZ)
+
+
+def test_matmul_exraw():
+
+    def dm(d):
+        result = {}
+        for i, row in d.items():
+            row = {j:val for j, val in row.items() if val}
+            if row:
+                result[i] = row
+        return SDM(result, (2, 2), EXRAW)
+
+    values = [S.NegativeInfinity, S.NegativeOne, S.Zero, S.One, S.Infinity]
+    for a, b, c, d in product(*[values]*4):
+        Ad = dm({0: {0:a, 1:b}, 1: {0:c, 1:d}})
+        Ad2 = dm({0: {0:a*a + b*c, 1:a*b + b*d}, 1:{0:c*a + d*c, 1: c*b + d*d}})
+        assert Ad * Ad == Ad2
+
+
+def test_SDM_add():
+    A = SDM({0:{1:ZZ(1)}, 1:{0:ZZ(2), 1:ZZ(3)}}, (2, 2), ZZ)
+    B = SDM({0:{0:ZZ(1)}, 1:{0:ZZ(-2), 1:ZZ(3)}}, (2, 2), ZZ)
+    C = SDM({0:{0:ZZ(1), 1:ZZ(1)}, 1:{1:ZZ(6)}}, (2, 2), ZZ)
+    assert A.add(B) == B.add(A) == A + B == B + A == C
+
+    A = SDM({0:{1:ZZ(1)}}, (2, 2), ZZ)
+    B = SDM({0:{0:ZZ(1)}, 1:{0:ZZ(-2), 1:ZZ(3)}}, (2, 2), ZZ)
+    C = SDM({0:{0:ZZ(1), 1:ZZ(1)}, 1:{0:ZZ(-2), 1:ZZ(3)}}, (2, 2), ZZ)
+    assert A.add(B) == B.add(A) == A + B == B + A == C
+
+    raises(TypeError, lambda: A + [])
+
+
+def test_SDM_sub():
+    A = SDM({0:{1:ZZ(1)}, 1:{0:ZZ(2), 1:ZZ(3)}}, (2, 2), ZZ)
+    B = SDM({0:{0:ZZ(1)}, 1:{0:ZZ(-2), 1:ZZ(3)}}, (2, 2), ZZ)
+    C = SDM({0:{0:ZZ(-1), 1:ZZ(1)}, 1:{0:ZZ(4)}}, (2, 2), ZZ)
+    assert A.sub(B) == A - B == C
+
+    raises(TypeError, lambda: A - [])
+
+
+def test_SDM_neg():
+    A = SDM({0:{1:ZZ(1)}, 1:{0:ZZ(2), 1:ZZ(3)}}, (2, 2), ZZ)
+    B = SDM({0:{1:ZZ(-1)}, 1:{0:ZZ(-2), 1:ZZ(-3)}}, (2, 2), ZZ)
+    assert A.neg() == -A == B
+
+
+def test_SDM_convert_to():
+    A = SDM({0:{1:ZZ(1)}, 1:{0:ZZ(2), 1:ZZ(3)}}, (2, 2), ZZ)
+    B = SDM({0:{1:QQ(1)}, 1:{0:QQ(2), 1:QQ(3)}}, (2, 2), QQ)
+    C = A.convert_to(QQ)
+    assert C == B
+    assert C.domain == QQ
+
+    D = A.convert_to(ZZ)
+    assert D == A
+    assert D.domain == ZZ
+
+
+def test_SDM_hstack():
+    A = SDM({0:{1:ZZ(1)}}, (2, 2), ZZ)
+    B = SDM({1:{1:ZZ(1)}}, (2, 2), ZZ)
+    AA = SDM({0:{1:ZZ(1), 3:ZZ(1)}}, (2, 4), ZZ)
+    AB = SDM({0:{1:ZZ(1)}, 1:{3:ZZ(1)}}, (2, 4), ZZ)
+    assert SDM.hstack(A) == A
+    assert SDM.hstack(A, A) == AA
+    assert SDM.hstack(A, B) == AB
+
+
+def test_SDM_vstack():
+    A = SDM({0:{1:ZZ(1)}}, (2, 2), ZZ)
+    B = SDM({1:{1:ZZ(1)}}, (2, 2), ZZ)
+    AA = SDM({0:{1:ZZ(1)}, 2:{1:ZZ(1)}}, (4, 2), ZZ)
+    AB = SDM({0:{1:ZZ(1)}, 3:{1:ZZ(1)}}, (4, 2), ZZ)
+    assert SDM.vstack(A) == A
+    assert SDM.vstack(A, A) == AA
+    assert SDM.vstack(A, B) == AB
+
+
+def test_SDM_applyfunc():
+    A = SDM({0:{1:ZZ(1)}}, (2, 2), ZZ)
+    B = SDM({0:{1:ZZ(2)}}, (2, 2), ZZ)
+    assert A.applyfunc(lambda x: 2*x, ZZ) == B
+
+
+def test_SDM_inv():
+    A = SDM({0:{0:QQ(1), 1:QQ(2)}, 1:{0:QQ(3), 1:QQ(4)}}, (2, 2), QQ)
+    B = SDM({0:{0:QQ(-2), 1:QQ(1)}, 1:{0:QQ(3, 2), 1:QQ(-1, 2)}}, (2, 2), QQ)
+    assert A.inv() == B
+
+
+def test_SDM_det():
+    A = SDM({0:{0:QQ(1), 1:QQ(2)}, 1:{0:QQ(3), 1:QQ(4)}}, (2, 2), QQ)
+    assert A.det() == QQ(-2)
+
+
+def test_SDM_lu():
+    A = SDM({0:{0:QQ(1), 1:QQ(2)}, 1:{0:QQ(3), 1:QQ(4)}}, (2, 2), QQ)
+    L = SDM({0:{0:QQ(1)}, 1:{0:QQ(3), 1:QQ(1)}}, (2, 2), QQ)
+    #U = SDM({0:{0:QQ(1), 1:QQ(2)}, 1:{0:QQ(3), 1:QQ(-2)}}, (2, 2), QQ)
+    #swaps = []
+    # This doesn't quite work. U has some nonzero elements in the lower part.
+    #assert A.lu() == (L, U, swaps)
+    assert A.lu()[0] == L
+
+
+def test_SDM_lu_solve():
+    A = SDM({0:{0:QQ(1), 1:QQ(2)}, 1:{0:QQ(3), 1:QQ(4)}}, (2, 2), QQ)
+    b = SDM({0:{0:QQ(1)}, 1:{0:QQ(2)}}, (2, 1), QQ)
+    x = SDM({1:{0:QQ(1, 2)}}, (2, 1), QQ)
+    assert A.matmul(x) == b
+    assert A.lu_solve(b) == x
+
+
+def test_SDM_charpoly():
+    A = SDM({0:{0:ZZ(1), 1:ZZ(2)}, 1:{0:ZZ(3), 1:ZZ(4)}}, (2, 2), ZZ)
+    assert A.charpoly() == [ZZ(1), ZZ(-5), ZZ(-2)]
+
+
+def test_SDM_nullspace():
+    A = SDM({0:{0:QQ(1), 1:QQ(1)}}, (2, 2), QQ)
+    assert A.nullspace()[0] == SDM({0:{0:QQ(-1), 1:QQ(1)}}, (1, 2), QQ)
+
+
+def test_SDM_rref():
+    eye2 = SDM({0:{0:QQ(1)}, 1:{1:QQ(1)}}, (2, 2), QQ)
+
+    A = SDM({0:{0:QQ(1), 1:QQ(2)}, 1:{0:QQ(3), 1:QQ(4)}}, (2, 2), QQ)
+    assert A.rref() == (eye2, [0, 1])
+
+    A = SDM({0:{0:QQ(1)}, 1:{0:QQ(3), 1:QQ(4)}}, (2, 2), QQ)
+    assert A.rref() == (eye2, [0, 1])
+
+    A = SDM({0:{1:QQ(2)}, 1:{0:QQ(3), 1:QQ(4)}}, (2, 2), QQ)
+    assert A.rref() == (eye2, [0, 1])
+
+    A = SDM({0:{0:QQ(1), 1:QQ(2), 2:QQ(3)},
+             1:{0:QQ(4), 1:QQ(5), 2:QQ(6)},
+             2:{0:QQ(7), 1:QQ(8), 2:QQ(9)} }, (3, 3), QQ)
+    Arref = SDM({0:{0:QQ(1), 2:QQ(-1)}, 1:{1:QQ(1), 2:QQ(2)}}, (3, 3), QQ)
+    assert A.rref() == (Arref, [0, 1])
+
+    A = SDM({0:{0:QQ(1), 1:QQ(2), 3:QQ(1)},
+             1:{0:QQ(1), 1:QQ(1), 2:QQ(9)}}, (2, 4), QQ)
+    Arref = SDM({0:{0:QQ(1), 2:QQ(18), 3:QQ(-1)},
+                 1:{1:QQ(1), 2:QQ(-9), 3:QQ(1)}}, (2, 4), QQ)
+    assert A.rref() == (Arref, [0, 1])
+
+    A = SDM({0:{0:QQ(1), 1:QQ(1), 2:QQ(1)},
+             1:{0:QQ(1), 1:QQ(2), 2:QQ(2)}}, (2, 3), QQ)
+    Arref = SDM(
+            {0: {0: QQ(1,1)}, 1: {1: QQ(1,1), 2: QQ(1,1)}},
+            (2, 3), QQ)
+    assert A.rref() == (Arref, [0, 1])
+
+
+def test_SDM_particular():
+    A = SDM({0:{0:QQ(1)}}, (2, 2), QQ)
+    Apart = SDM.zeros((1, 2), QQ)
+    assert A.particular() == Apart
+
+
+def test_SDM_is_zero_matrix():
+    A = SDM({0: {0: QQ(1)}}, (2, 2), QQ)
+    Azero = SDM.zeros((1, 2), QQ)
+    assert A.is_zero_matrix() is False
+    assert Azero.is_zero_matrix() is True
+
+
+def test_SDM_is_upper():
+    A = SDM({0: {0: QQ(1), 1: QQ(2), 2: QQ(3), 3: QQ(4)},
+                       1: {1: QQ(5), 2: QQ(6), 3: QQ(7)},
+                                 2: {2: QQ(8), 3: QQ(9)}}, (3, 4), QQ)
+    B = SDM({0: {0: QQ(1), 1: QQ(2), 2: QQ(3), 3: QQ(4)},
+                       1: {1: QQ(5), 2: QQ(6), 3: QQ(7)},
+                       2: {1: QQ(7), 2: QQ(8), 3: QQ(9)}}, (3, 4), QQ)
+    assert A.is_upper() is True
+    assert B.is_upper() is False
+
+
+def test_SDM_is_lower():
+    A = SDM({0: {0: QQ(1), 1: QQ(2), 2: QQ(3), 3: QQ(4)},
+                       1: {1: QQ(5), 2: QQ(6), 3: QQ(7)},
+                                 2: {2: QQ(8), 3: QQ(9)}}, (3, 4), QQ
+            ).transpose()
+    B = SDM({0: {0: QQ(1), 1: QQ(2), 2: QQ(3), 3: QQ(4)},
+                       1: {1: QQ(5), 2: QQ(6), 3: QQ(7)},
+                       2: {1: QQ(7), 2: QQ(8), 3: QQ(9)}}, (3, 4), QQ
+            ).transpose()
+    assert A.is_lower() is True
+    assert B.is_lower() is False

shared/package-files/1f/1f4e17b848b9d5800cfe065a7cf1e576cdfc9cf2c9fd527134095169d52612a6/_nested_get_lengths_ops.h

@@ -0,0 +1,28 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Operator.h
+
+#include <tuple>
+#include <vector>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+namespace _ops {
+
+
+struct TORCH_API _nested_get_lengths {
+  using schema = at::Tensor (const at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_nested_get_lengths")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_nested_get_lengths(Tensor self) -> Tensor")
+  static at::Tensor call(const at::Tensor & self);
+  static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self);
+};
+
+}} // namespace at::_ops

shared/package-files/1f/1f519e110eea3924b0828e79b0d51a896cd56f5bdb02a3abd378677d1f81fa8f/_vector_sentinel.pyx

@@ -0,0 +1,118 @@
+from cython.operator cimport dereference as deref
+from cpython.ref cimport Py_INCREF
+cimport numpy as cnp
+
+cnp.import_array()
+
+
+cdef StdVectorSentinel _create_sentinel(vector_typed * vect_ptr):
+    if vector_typed is vector[float64_t]:
+        return StdVectorSentinelFloat64.create_for(vect_ptr)
+    elif vector_typed is vector[int32_t]:
+        return StdVectorSentinelInt32.create_for(vect_ptr)
+    elif vector_typed is vector[int64_t]:
+        return StdVectorSentinelInt64.create_for(vect_ptr)
+    else:  # intp_t
+        return StdVectorSentinelIntP.create_for(vect_ptr)
+
+
+cdef class StdVectorSentinel:
+    """Wraps a reference to a vector which will be deallocated with this object.
+
+    When created, the StdVectorSentinel swaps the reference of its internal
+    vectors with the provided one (vect_ptr), thus making the StdVectorSentinel
+    manage the provided one's lifetime.
+    """
+    cdef void* get_data(self):
+        """Return pointer to data."""
+
+    cdef int get_typenum(self):
+        """Get typenum for PyArray_SimpleNewFromData."""
+
+
+cdef class StdVectorSentinelFloat64(StdVectorSentinel):
+    cdef vector[float64_t] vec
+
+    @staticmethod
+    cdef StdVectorSentinel create_for(vector[float64_t] * vect_ptr):
+        # This initializes the object directly without calling __init__
+        # See: https://cython.readthedocs.io/en/latest/src/userguide/extension_types.html#instantiation-from-existing-c-c-pointers # noqa
+        cdef StdVectorSentinelFloat64 sentinel = StdVectorSentinelFloat64.__new__(StdVectorSentinelFloat64)
+        sentinel.vec.swap(deref(vect_ptr))
+        return sentinel
+
+    cdef void* get_data(self):
+        return self.vec.data()
+
+    cdef int get_typenum(self):
+        return cnp.NPY_FLOAT64
+
+
+cdef class StdVectorSentinelIntP(StdVectorSentinel):
+    cdef vector[intp_t] vec
+
+    @staticmethod
+    cdef StdVectorSentinel create_for(vector[intp_t] * vect_ptr):
+        # This initializes the object directly without calling __init__
+        # See: https://cython.readthedocs.io/en/latest/src/userguide/extension_types.html#instantiation-from-existing-c-c-pointers # noqa
+        cdef StdVectorSentinelIntP sentinel = StdVectorSentinelIntP.__new__(StdVectorSentinelIntP)
+        sentinel.vec.swap(deref(vect_ptr))
+        return sentinel
+
+    cdef void* get_data(self):
+        return self.vec.data()
+
+    cdef int get_typenum(self):
+        return cnp.NPY_INTP
+
+
+cdef class StdVectorSentinelInt32(StdVectorSentinel):
+    cdef vector[int32_t] vec
+
+    @staticmethod
+    cdef StdVectorSentinel create_for(vector[int32_t] * vect_ptr):
+        # This initializes the object directly without calling __init__
+        # See: https://cython.readthedocs.io/en/latest/src/userguide/extension_types.html#instantiation-from-existing-c-c-pointers # noqa
+        cdef StdVectorSentinelInt32 sentinel = StdVectorSentinelInt32.__new__(StdVectorSentinelInt32)
+        sentinel.vec.swap(deref(vect_ptr))
+        return sentinel
+
+    cdef void* get_data(self):
+        return self.vec.data()
+
+    cdef int get_typenum(self):
+        return cnp.NPY_INT32
+
+
+cdef class StdVectorSentinelInt64(StdVectorSentinel):
+    cdef vector[int64_t] vec
+
+    @staticmethod
+    cdef StdVectorSentinel create_for(vector[int64_t] * vect_ptr):
+        # This initializes the object directly without calling __init__
+        # See: https://cython.readthedocs.io/en/latest/src/userguide/extension_types.html#instantiation-from-existing-c-c-pointers # noqa
+        cdef StdVectorSentinelInt64 sentinel = StdVectorSentinelInt64.__new__(StdVectorSentinelInt64)
+        sentinel.vec.swap(deref(vect_ptr))
+        return sentinel
+
+    cdef void* get_data(self):
+        return self.vec.data()
+
+    cdef int get_typenum(self):
+        return cnp.NPY_INT64
+
+
+cdef cnp.ndarray vector_to_nd_array(vector_typed * vect_ptr):
+    cdef:
+        cnp.npy_intp size = deref(vect_ptr).size()
+        StdVectorSentinel sentinel = _create_sentinel(vect_ptr)
+        cnp.ndarray arr = cnp.PyArray_SimpleNewFromData(
+            1, &size, sentinel.get_typenum(), sentinel.get_data())
+
+    # Makes the numpy array responsible of the life-cycle of its buffer.
+    # A reference to the StdVectorSentinel will be stolen by the call to
+    # `PyArray_SetBaseObject` below, so we increase its reference counter.
+    # See: https://docs.python.org/3/c-api/intro.html#reference-count-details
+    Py_INCREF(sentinel)
+    cnp.PyArray_SetBaseObject(arr, sentinel)
+    return arr

shared/package-files/1f/1f55bdde7a0e8213fab2d4962730fac65163b7476179f1f5b926595c4fcc4d53/rshift_ops.h

@@ -0,0 +1,83 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Operator.h
+
+#include <tuple>
+#include <vector>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+namespace _ops {
+
+
+struct TORCH_API __rshift___Scalar {
+  using schema = at::Tensor (const at::Tensor &, const at::Scalar &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::__rshift__")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Scalar")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "__rshift__.Scalar(Tensor self, Scalar other) -> Tensor")
+  static at::Tensor call(const at::Tensor & self, const at::Scalar & other);
+  static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Scalar & other);
+};
+
+struct TORCH_API __rshift___Tensor {
+  using schema = at::Tensor (const at::Tensor &, const at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::__rshift__")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Tensor")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "__rshift__.Tensor(Tensor self, Tensor other) -> Tensor")
+  static at::Tensor call(const at::Tensor & self, const at::Tensor & other);
+  static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Tensor & other);
+};
+
+struct TORCH_API __irshift___Scalar {
+  using schema = at::Tensor & (at::Tensor &, const at::Scalar &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::__irshift__")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Scalar")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "__irshift__.Scalar(Tensor(a!) self, Scalar other) -> Tensor(a!)")
+  static at::Tensor & call(at::Tensor & self, const at::Scalar & other);
+  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, at::Tensor & self, const at::Scalar & other);
+};
+
+struct TORCH_API __irshift___Tensor {
+  using schema = at::Tensor & (at::Tensor &, const at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::__irshift__")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Tensor")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "__irshift__.Tensor(Tensor(a!) self, Tensor other) -> Tensor(a!)")
+  static at::Tensor & call(at::Tensor & self, const at::Tensor & other);
+  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, at::Tensor & self, const at::Tensor & other);
+};
+
+struct TORCH_API __rshift___Scalar_out {
+  using schema = at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::__rshift__")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Scalar_out")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "__rshift__.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!)")
+  static at::Tensor & call(const at::Tensor & self, const at::Scalar & other, at::Tensor & out);
+  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Scalar & other, at::Tensor & out);
+};
+
+struct TORCH_API __rshift___Tensor_out {
+  using schema = at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::__rshift__")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Tensor_out")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "__rshift__.Tensor_out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)")
+  static at::Tensor & call(const at::Tensor & self, const at::Tensor & other, at::Tensor & out);
+  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Tensor & other, at::Tensor & out);
+};
+
+}} // namespace at::_ops

shared/package-files/1f/1f569ce27cb3145b482bc8bf51cef0b8e9fd1ae8f1e2e7a128061b1ddf93bb0e/scotland_births.html

@@ -0,0 +1,312 @@
+
+<HTML>
+<HEAD>
+<META NAME="GENERATOR" Content="Microsoft Visual InterDev 1.0">
+<META HTTP-EQUIV="Content-Type" content="text/html; charset=iso-8859-1">
+<TITLE>Cross-sectional dataset viewer v1.1</TITLE>
+</HEAD>
+<BODY bgcolor='#ffffff' leftmargin="5" topmargin="0" >
+<table RULES="columns" border="1" frame = "void" bgcolor='#000000' width="640" cellpadding="0" cellspacing="0">
+<tr >
+<td>
+	<a href= "mainmenu.asp"><img alt="Home" border="noborder" src= "images/home.gif" height="12" width="48" valign="center"></a>
+</td>
+<td>
+	<a href= "ss.asp"><img alt="StatSearch" border="noborder" src= "images/ssrch.gif" height="12" width="84" align= 'left' valign="center"></a>
+</td>
+<td>
+	<a href= "search.asp"><img alt="Text Search" border="noborder" src= "images/textsrch.gif" height="12" align= 'left' width="94" valign="center"></a>
+</td>
+<td>
+	<a href= "datasets2.asp"><img alt="StatStore" border="noborder" src= "images/sstore.gif" height="12" width="84" align= 'left' valign="center"></a>
+</td>
+<td>
+	<a href= "faq.asp"><img alt="FAQ" border="noborder" src= "images/faq.gif" height="12" width="84" align= 'left' valign="center"></a>
+</td>
+
+
+<td  width="210">
+	&nbsp;
+</td>
+</tr>
+</table>
+			
+			<table rules='none' border='0' bordercolordark="EEEEEE" bordercolorlight="#FFFFFF" border="0" width="640">
+			<tr>
+				<td valign='top' bgcolor='#ffffff' colspan= '2'><font face= "arial" color="#339900" size="5"><strong>Dataset Display - Cross-Sectional</strong></font></td>
+			</tr>
+			<tr>
+				<td colspan= '2'><hr></td>
+			</tr>
+			<tr>
+				<td width='200' valign='top' align='left' bgcolor='#ffffff'><b>Dataset Name:</b></td>
+				<td valign='top' align='left' bgcolor='#ffffff'>
+			RT331602				
+			</td>
+			</tr>
+			<tr>
+				<td valign='top' align='left' bgcolor='#ffffff'><b>Title:</b></td>
+				<td valign='top' align='left' bgcolor='#ffffff'>
+
+			Vital and social statistics: Scotland				
+			</td>
+			</tr>
+			
+			
+			
+		<tr>
+			<td valign='top' align='left' bgcolor='#ffffff'><b>Description:</b></td>
+			
+			<td valign='top' align='left' bgcolor='#ffffff'>Vital and social statistics: Scotland<br><br>This dataset has been compiled from data published in Regional Trends 33, 1998 edition published on 25 June 1998.<br><br></td>
+			</tr>
+			<tr>
+			<td valign='top' align='left' bgcolor='#ffffff'><b>Source:</b></td>
+			<td valign='top' align='left' bgcolor='#ffffff'>
+			Office for National Statistics; General Register Office for Scotland						
+			</td>
+			</tr>
+			<tr>
+			<td valign='top' align='left' bgcolor='#ffffff'><b>Time Frame:</b></td>
+			<td>
+			1996	
+			</td>
+			</tr>
+			
+			
+			<tr>
+			<td valign='top' align='left' bgcolor='#ffffff'><b>Geographic Coverage:</b></td>
+			<td>
+			United Kingdom	
+			
+			</td>
+			
+			</tr>
+			<td valign='top' align='left' bgcolor='#ffffff'><b>Universe:</b></td>
+			<td>
+			 UK live births
+			</td>
+			</tr>
+			<tr>
+			<td valign='top' align='left' bgcolor='#ffffff'><b>Measure:</b></td>
+			<td>
+			various
+			</td>
+			</tr>
+			
+			
+			
+			<tr>
+			<td valign='top' align='left' bgcolor='#ffffff'><b>Units:</b></td>
+			<td>
+			See table
+			</td>
+			</tr>
+			<tr>
+			<td valign='top' align='left' bgcolor='#ffffff'><b>Scalar:</b></td>
+			<td>
+			various
+			</td>
+			</tr>
+			<tr>
+			<td valign='top' align='left' bgcolor='#ffffff'><b>Formula:</b></td>
+			<td>
+			none
+			</td>
+			
+			</tr>
+			
+			</table>
+		
+			
+			
+			<hr align='left' width='640'>
+			
+			<table rules="box" border='0' width='640'>
+			<tr>
+			<td colspan="2" align="center" valign="center"bgcolor="#ffffff"><strong>Table Dimensions</strong></td>
+			</tr>
+			<tr><td colspan="2" width valign="top" bgcolor="#ffffff">Please select at least one item from each list and "Display Selection" or choose "Display All" </td></tr>
+			<tr><td colspan="2" width valign="top" bgcolor="#ffffff">To select list items either hold down 'Ctrl' key and click each item required, or click the first item and hold down the mouse button whilst scrolling down the list.</td></tr>
+
+			<tr>
+		
+
+				<td width valign="top" bgcolor="#ffffff">
+				<b>Region</b>
+
+			<SUP>4</SUP>	
+			</td>
+		
+
+				<td width valign="top" bgcolor="#ffffff">
+				<b>Measure</b>
+
+				
+			</td>
+		
+		</tr>
+		
+			
+			
+			<form TARGET="_self" ACTION="xsdataset.asp">
+			<tr>
+			
+				<td>
+					<select multiple size="6" name="list1">
+				
+						<option value="1" SELECTED>
+					United Kingdom
+						<option value="2" SELECTED>
+					Scotland
+						<option value="3" SELECTED>
+					Aberdeen City
+						<option value="4" SELECTED>
+					Aberdeenshire
+						<option value="5" SELECTED>
+					Angus
+						<option value="6" SELECTED>
+					Argyll and Bute
+						<option value="7" SELECTED>
+					Clackmannanshire
+						<option value="8" SELECTED>
+					Dumfries and Galloway
+						<option value="9" SELECTED>
+					Dundee City
+						<option value="10" SELECTED>
+					East Ayrshire
+						<option value="11" SELECTED>
+					East Dunbartonshire
+						<option value="12" SELECTED>
+					East Lothian
+						<option value="13" SELECTED>
+					East Renfrewshire
+						<option value="14" SELECTED>
+					Edinburgh, City of
+						<option value="15" SELECTED>
+					Eilean Siar (Western Isles)
+						<option value="16" SELECTED>
+					Falkirk
+						<option value="17" SELECTED>
+					Fife
+						<option value="18" SELECTED>
+					Glasgow City
+						<option value="19" SELECTED>
+					Highland
+						<option value="20" SELECTED>
+					Inverclyde
+						<option value="21" SELECTED>
+					Midlothian
+						<option value="22" SELECTED>
+					Moray
+						<option value="23" SELECTED>
+					North Ayrshire
+						<option value="24" SELECTED>
+					North Lanarkshire
+						<option value="25" SELECTED>
+					Orkney Islands
+						<option value="26" SELECTED>
+					Perth and Kinross
+						<option value="27" SELECTED>
+					Renfrewshire
+						<option value="28" SELECTED>
+					Scottish Borders, The
+						<option value="29" SELECTED>
+					Shetland Islands
+						<option value="30" SELECTED>
+					South Ayrshire
+						<option value="31" SELECTED>
+					South Lanarkshire
+						<option value="32" SELECTED>
+					Stirling
+						<option value="33" SELECTED>
+					West Dunbartonshire
+						<option value="34" SELECTED>
+					West Lothian
+				</select>
+				</td>
+			
+				<td>
+					<select multiple size="6" name="list2">
+				
+						<option value="1" SELECTED>
+					Live births per 1,000 population 1996
+						<option value="2" SELECTED>
+					Deaths per 1,000 population 1996
+						<option value="3" SELECTED>
+					Perinatal mortality rate, 3 year average, 1994-1996
+						<option value="4" SELECTED>
+					Infant mortality rate, 3 year average, 1994-1996
+						<option value="5" SELECTED>
+					Percentage of live births outside marriage 1996
+				</select>
+				</td>
+			
+			
+			</tr>
+			<tr>
+				<td><input type="submit" value="Display All" name="B2"></td>
+				<td><input type="submit" value="Display Selection" name="B1"></td>
+				<td>&nbsp;</td>
+
+			</tr>
+			
+			
+				<tr>
+				<tr><td colspan="2" width valign="top" bgcolor="#000000" align="center"><font color="#ffffff">To change your selection, click in the appropriate box</font></td></tr>
+				<tr>
+			
+
+			</form>
+			</table>
+			
+			
+			
+			<hr align='left' width='640'>
+			
+
+
+<table
+
+ border="1"
+
+ frame = "border"
+
+ rules="all"
+
+ cellpadding="0" width="640"	bgcolor="#FFFFFF"
+
+ bordercolordark= "#999999"
+
+ bordercolorlight= "#EEEEEE"
+
+ width="640"
+
+
+>
+
+<THEAD>
+<tr>
+        <th 
+					colspan="3"
+			>
+		
+		<font size="3"
+	
+ >
+		<strong>Table</strong></font>
+
+
+
+
+        </th>
+</tr>
+</THEAD>
+<TBODY><TR><TD></TD><TD ALIGN='center'>Live births per 1,000 population 1996<SUP>1</SUP></TD><TD ALIGN='center'>Deaths per 1,000 population 1996<SUP>1</SUP></TD><TD ALIGN='center'>Perinatal mortality rate, 3 year average, 1994-1996<SUP>2</SUP></TD><TD ALIGN='center'>Infant mortality rate, 3 year average, 1994-1996<SUP>3</SUP></TD><TD ALIGN='center'>Percentage of live births outside marriage 1996</TD><TR><TD ALIGN='left'>United Kingdom</TD><TD ALIGN='right'>12.5</TD><TD ALIGN='right'>10.9</TD><TD ALIGN='right'>8.8</TD><TD ALIGN='right'>6.1</TD><TD ALIGN='right'>36.0</TD><TR><TD ALIGN='left'>Scotland</TD><TD ALIGN='right'>11.6</TD><TD ALIGN='right'>11.8</TD><TD ALIGN='right'>9.3</TD><TD ALIGN='right'>6.2</TD><TD ALIGN='right'>36.0</TD><TR><TD ALIGN='left'>Aberdeen City</TD><TD ALIGN='right'>11.0</TD><TD ALIGN='right'>10.4</TD><TD ALIGN='right'>7.7</TD><TD ALIGN='right'>5.7</TD><TD ALIGN='right'>35.0</TD><TR><TD ALIGN='left'>Aberdeenshire</TD><TD ALIGN='right'>11.3</TD><TD ALIGN='right'>9.0</TD><TD ALIGN='right'>9.0</TD><TD ALIGN='right'>3.8</TD><TD ALIGN='right'>24.0</TD><TR><TD ALIGN='left'>Angus<SUP>3</SUP></TD><TD ALIGN='right'>11.0</TD><TD ALIGN='right'>13.2</TD><TD ALIGN='right'>5.6</TD><TD ALIGN='right'>3.2</TD><TD ALIGN='right'>33.0</TD><TR><TD ALIGN='left'>Argyll and Bute</TD><TD ALIGN='right'>10.5</TD><TD ALIGN='right'>13.8</TD><TD ALIGN='right'>8.6</TD><TD ALIGN='right'>7.0</TD><TD ALIGN='right'>33.0</TD><TR><TD ALIGN='left'>Clackmannanshire</TD><TD ALIGN='right'>12.3</TD><TD ALIGN='right'>11.3</TD><TD ALIGN='right'>10.4</TD><TD ALIGN='right'>6.3</TD><TD ALIGN='right'>40.0</TD><TR><TD ALIGN='left'>Dumfries and Galloway</TD><TD ALIGN='right'>10.9</TD><TD ALIGN='right'>12.8</TD><TD ALIGN='right'>8.8</TD><TD ALIGN='right'>7.8</TD><TD ALIGN='right'>34.0</TD><TR><TD ALIGN='left'>Dundee City</TD><TD ALIGN='right'>11.5</TD><TD ALIGN='right'>13.1</TD><TD ALIGN='right'>8.6</TD><TD ALIGN='right'>6.8</TD><TD ALIGN='right'>51.0</TD><TR><TD ALIGN='left'>East Ayrshire<SUP>3</SUP></TD><TD ALIGN='right'>11.4</TD><TD ALIGN='right'>11.6</TD><TD ALIGN='right'>12.3</TD><TD ALIGN='right'>6.5</TD><TD ALIGN='right'>40.0</TD><TR><TD ALIGN='left'>East Dunbartonshire</TD><TD ALIGN='right'>10.5</TD><TD ALIGN='right'>9.2</TD><TD ALIGN='right'>8.1</TD><TD ALIGN='right'>7.2</TD><TD ALIGN='right'>19.0</TD><TR><TD ALIGN='left'>East Lothian</TD><TD ALIGN='right'>12.3</TD><TD ALIGN='right'>12.6</TD><TD ALIGN='right'>7.6</TD><TD ALIGN='right'>5.2</TD><TD ALIGN='right'>29.0</TD><TR><TD ALIGN='left'>East Renfrewshire</TD><TD ALIGN='right'>11.5</TD><TD ALIGN='right'>9.5</TD><TD ALIGN='right'>7.4</TD><TD ALIGN='right'>6.2</TD><TD ALIGN='right'>19.0</TD><TR><TD ALIGN='left'>Edinburgh, City of</TD><TD ALIGN='right'>11.4</TD><TD ALIGN='right'>11.7</TD><TD ALIGN='right'>8.1</TD><TD ALIGN='right'>6.4</TD><TD ALIGN='right'>33.0</TD><TR><TD ALIGN='left'>Eilean Siar (Western Isles)<SUP>23</SUP></TD><TD ALIGN='right'>9.7</TD><TD ALIGN='right'>14.9</TD><TD ALIGN='right'>11.2</TD><TD ALIGN='right'>5.7</TD><TD ALIGN='right'>19.0</TD><TR><TD ALIGN='left'>Falkirk</TD><TD ALIGN='right'>11.7</TD><TD ALIGN='right'>11.7</TD><TD ALIGN='right'>7.9</TD><TD ALIGN='right'>4.8</TD><TD ALIGN='right'>34.0</TD><TR><TD ALIGN='left'>Fife</TD><TD ALIGN='right'>11.0</TD><TD ALIGN='right'>11.4</TD><TD ALIGN='right'>8.7</TD><TD ALIGN='right'>7.1</TD><TD ALIGN='right'>37.0</TD><TR><TD ALIGN='left'>Glasgow City</TD><TD ALIGN='right'>12.5</TD><TD ALIGN='right'>14.0</TD><TD ALIGN='right'>11.1</TD><TD ALIGN='right'>6.9</TD><TD ALIGN='right'>49.0</TD><TR><TD ALIGN='left'>Highland</TD><TD ALIGN='right'>11.4</TD><TD ALIGN='right'>11.4</TD><TD ALIGN='right'>8.3</TD><TD ALIGN='right'>6.5</TD><TD ALIGN='right'>34.0</TD><TR><TD ALIGN='left'>Inverclyde</TD><TD ALIGN='right'>11.7</TD><TD ALIGN='right'>14.5</TD><TD ALIGN='right'>11.5</TD><TD ALIGN='right'>8.0</TD><TD ALIGN='right'>45.0</TD><TR><TD ALIGN='left'>Midlothian</TD><TD ALIGN='right'>11.2</TD><TD ALIGN='right'>10.7</TD><TD ALIGN='right'>10.8</TD><TD ALIGN='right'>6.0</TD><TD ALIGN='right'>35.0</TD><TR><TD ALIGN='left'>Moray</TD><TD ALIGN='right'>12.4</TD><TD ALIGN='right'>11.0</TD><TD ALIGN='right'>9.8</TD><TD ALIGN='right'>7.4</TD><TD ALIGN='right'>26.0</TD><TR><TD ALIGN='left'>North Ayrshire<SUP>23</SUP></TD><TD ALIGN='right'>11.3</TD><TD ALIGN='right'>11.8</TD><TD ALIGN='right'>11.6</TD><TD ALIGN='right'>6.9</TD><TD ALIGN='right'>42.0</TD><TR><TD ALIGN='left'>North Lanarkshire</TD><TD ALIGN='right'>12.5</TD><TD ALIGN='right'>11.1</TD><TD ALIGN='right'>11.6</TD><TD ALIGN='right'>8.5</TD><TD ALIGN='right'>38.0</TD><TR><TD ALIGN='left'>Orkney Islands</TD><TD ALIGN='right'>10.9</TD><TD ALIGN='right'>11.6</TD><TD ALIGN='right'>7.5</TD><TD ALIGN='right'>1.4</TD><TD ALIGN='right'>30.0</TD><TR><TD ALIGN='left'>Perth and Kinross<SUP>3</SUP></TD><TD ALIGN='right'>10.5</TD><TD ALIGN='right'>12.6</TD><TD ALIGN='right'>9.8</TD><TD ALIGN='right'>5.9</TD><TD ALIGN='right'>29.0</TD><TR><TD ALIGN='left'>Renfrewshire<SUP>3</SUP></TD><TD ALIGN='right'>11.9</TD><TD ALIGN='right'>11.6</TD><TD ALIGN='right'>8.0</TD><TD ALIGN='right'>4.5</TD><TD ALIGN='right'>39.0</TD><TR><TD ALIGN='left'>Scottish Borders, The<SUP>3</SUP></TD><TD ALIGN='right'>10.7</TD><TD ALIGN='right'>12.8</TD><TD ALIGN='right'>8.0</TD><TD ALIGN='right'>4.9</TD><TD ALIGN='right'>28.0</TD><TR><TD ALIGN='left'>Shetland Islands<SUP>23</SUP></TD><TD ALIGN='right'>11.7</TD><TD ALIGN='right'>10.9</TD><TD ALIGN='right'>9.9</TD><TD ALIGN='right'>6.5</TD><TD ALIGN='right'>28.0</TD><TR><TD ALIGN='left'>South Ayrshire</TD><TD ALIGN='right'>10.1</TD><TD ALIGN='right'>12.7</TD><TD ALIGN='right'>6.2</TD><TD ALIGN='right'>4.3</TD><TD ALIGN='right'>33.0</TD><TR><TD ALIGN='left'>South Lanarkshire</TD><TD ALIGN='right'>11.5</TD><TD ALIGN='right'>11.3</TD><TD ALIGN='right'>9.2</TD><TD ALIGN='right'>5.1</TD><TD ALIGN='right'>33.0</TD><TR><TD ALIGN='left'>Stirling</TD><TD ALIGN='right'>11.1</TD><TD ALIGN='right'>11.8</TD><TD ALIGN='right'>7.7</TD><TD ALIGN='right'>4.9</TD><TD ALIGN='right'>33.0</TD><TR><TD ALIGN='left'>West Dunbartonshire</TD><TD ALIGN='right'>12.5</TD><TD ALIGN='right'>12.7</TD><TD ALIGN='right'>11.7</TD><TD ALIGN='right'>8.7</TD><TD ALIGN='right'>42.0</TD><TR><TD ALIGN='left'>West Lothian</TD><TD ALIGN='right'>13.1</TD><TD ALIGN='right'>9.5</TD><TD ALIGN='right'>8.7</TD><TD ALIGN='right'>4.6</TD><TD ALIGN='right'>33.0</TD></TABLE>
+			<HR align='left' width='640'>
+			
+					<table border='0' width='640'>
+					<tr><td colspan='2' valign='top' align='center' ><strong>Footnotes</strong></td></tr>
+				<tr><td valign='top' width='20'>1 -</td><td>Births are on the basis of year of occurrence in England and Wales and year of registration in Scotland and Northern Ireland. Deaths relate to year of registration.<BR></td></tr><tr><td valign='top' width='20'>2 -</td><td>Still births and deaths of infants under 1 week of age per 1,000 live and still births.  Figures for some Council areas  should be treated with caution as the perinatal mortality rate was based on fewer than 20 deaths.<BR></td></tr><tr><td valign='top' width='20'>3 -</td><td>Deaths of infants under 1 year of age per 1,000 live births.  Figures for some Council areas  should be treated with caution as the infant mortality rate was based on fewer than 20 deaths.<BR></td></tr><tr><td valign='top' width='20'>4 -</td><td>New Councils for Scotland<BR></td></tr>
+					</table>
+					<hr align='left' width='640'>
+			

shared/package-files/1f/1f59a95f609804c5eab38ac88282aaed1af4aa19acf7d2c3368da9c5d44e3447/bincount_compositeexplicitautograd_dispatch.h

@@ -0,0 +1,24 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace compositeexplicitautograd {
+
+TORCH_API at::Tensor & bincount_out(at::Tensor & out, const at::Tensor & self, const c10::optional<at::Tensor> & weights={}, int64_t minlength=0);
+TORCH_API at::Tensor & bincount_outf(const at::Tensor & self, const c10::optional<at::Tensor> & weights, int64_t minlength, at::Tensor & out);
+
+} // namespace compositeexplicitautograd
+} // namespace at

shared/package-files/1f/1f5a6512789fd760f107664a07c1ff9a40b95b15eb3c7a5e1516d32d2c594142/_random.pyx

@@ -0,0 +1,355 @@
+# Authors: The scikit-learn developers
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""
+Random utility function
+=======================
+This module complements missing features of ``numpy.random``.
+
+The module contains:
+    * Several algorithms to sample integers without replacement.
+    * Fast rand_r alternative based on xor shifts
+"""
+import numpy as np
+from . import check_random_state
+
+from ._typedefs cimport intp_t
+
+
+cdef uint32_t DEFAULT_SEED = 1
+
+
+# Compatibility type to always accept the default int type used by NumPy, both
+# before and after NumPy 2. On Windows, `long` does not always match `inp_t`.
+# See the comments in the `sample_without_replacement` Python function for more
+# details.
+ctypedef fused default_int:
+    intp_t
+    long
+
+
+cpdef _sample_without_replacement_check_input(default_int n_population,
+                                              default_int n_samples):
+    """ Check that input are consistent for sample_without_replacement"""
+    if n_population < 0:
+        raise ValueError('n_population should be greater than 0, got %s.'
+                         % n_population)
+
+    if n_samples > n_population:
+        raise ValueError('n_population should be greater or equal than '
+                         'n_samples, got n_samples > n_population (%s > %s)'
+                         % (n_samples, n_population))
+
+
+cpdef _sample_without_replacement_with_tracking_selection(
+        default_int n_population,
+        default_int n_samples,
+        random_state=None):
+    r"""Sample integers without replacement.
+
+    Select n_samples integers from the set [0, n_population) without
+    replacement.
+
+    Time complexity:
+        - Worst-case: unbounded
+        - Average-case:
+            O(O(np.random.randint) * \sum_{i=1}^n_samples 1 /
+                                              (1 - i / n_population)))
+            <= O(O(np.random.randint) *
+                   n_population * ln((n_population - 2)
+                                     /(n_population - 1 - n_samples)))
+            <= O(O(np.random.randint) *
+                 n_population * 1 / (1 - n_samples / n_population))
+
+    Space complexity of O(n_samples) in a python set.
+
+
+    Parameters
+    ----------
+    n_population : int
+        The size of the set to sample from.
+
+    n_samples : int
+        The number of integer to sample.
+
+    random_state : int, RandomState instance or None, default=None
+        If int, random_state is the seed used by the random number generator;
+        If RandomState instance, random_state is the random number generator;
+        If None, the random number generator is the RandomState instance used
+        by `np.random`.
+
+    Returns
+    -------
+    out : ndarray of shape (n_samples,)
+        The sampled subsets of integer.
+    """
+    _sample_without_replacement_check_input(n_population, n_samples)
+
+    cdef default_int i
+    cdef default_int j
+    cdef default_int[::1] out = np.empty((n_samples, ), dtype=int)
+
+    rng = check_random_state(random_state)
+    rng_randint = rng.randint
+
+    # The following line of code are heavily inspired from python core,
+    # more precisely of random.sample.
+    cdef set selected = set()
+
+    for i in range(n_samples):
+        j = rng_randint(n_population)
+        while j in selected:
+            j = rng_randint(n_population)
+        selected.add(j)
+        out[i] = j
+
+    return np.asarray(out)
+
+
+cpdef _sample_without_replacement_with_pool(default_int n_population,
+                                            default_int n_samples,
+                                            random_state=None):
+    """Sample integers without replacement.
+
+    Select n_samples integers from the set [0, n_population) without
+    replacement.
+
+    Time complexity: O(n_population +  O(np.random.randint) * n_samples)
+
+    Space complexity of O(n_population + n_samples).
+
+
+    Parameters
+    ----------
+    n_population : int
+        The size of the set to sample from.
+
+    n_samples : int
+        The number of integer to sample.
+
+    random_state : int, RandomState instance or None, default=None
+        If int, random_state is the seed used by the random number generator;
+        If RandomState instance, random_state is the random number generator;
+        If None, the random number generator is the RandomState instance used
+        by `np.random`.
+
+    Returns
+    -------
+    out : ndarray of shape (n_samples,)
+        The sampled subsets of integer.
+    """
+    _sample_without_replacement_check_input(n_population, n_samples)
+
+    cdef default_int i
+    cdef default_int j
+    cdef default_int[::1] out = np.empty((n_samples,), dtype=int)
+    cdef default_int[::1] pool = np.empty((n_population,), dtype=int)
+
+    rng = check_random_state(random_state)
+    rng_randint = rng.randint
+
+    # Initialize the pool
+    for i in range(n_population):
+        pool[i] = i
+
+    # The following line of code are heavily inspired from python core,
+    # more precisely of random.sample.
+    for i in range(n_samples):
+        j = rng_randint(n_population - i)  # invariant: non-selected at [0,n-i)
+        out[i] = pool[j]
+        pool[j] = pool[n_population - i - 1]  # move non-selected item into vacancy
+
+    return np.asarray(out)
+
+
+cpdef _sample_without_replacement_with_reservoir_sampling(
+    default_int n_population,
+    default_int n_samples,
+    random_state=None
+):
+    """Sample integers without replacement.
+
+    Select n_samples integers from the set [0, n_population) without
+    replacement.
+
+    Time complexity of
+        O((n_population - n_samples) * O(np.random.randint) + n_samples)
+    Space complexity of O(n_samples)
+
+
+    Parameters
+    ----------
+    n_population : int
+        The size of the set to sample from.
+
+    n_samples : int
+         The number of integer to sample.
+
+    random_state : int, RandomState instance or None, default=None
+        If int, random_state is the seed used by the random number generator;
+        If RandomState instance, random_state is the random number generator;
+        If None, the random number generator is the RandomState instance used
+        by `np.random`.
+
+    Returns
+    -------
+    out : ndarray of shape (n_samples,)
+        The sampled subsets of integer. The order of the items is not
+        necessarily random. Use a random permutation of the array if the order
+        of the items has to be randomized.
+    """
+    _sample_without_replacement_check_input(n_population, n_samples)
+
+    cdef default_int i
+    cdef default_int j
+    cdef default_int[::1] out = np.empty((n_samples, ), dtype=int)
+
+    rng = check_random_state(random_state)
+    rng_randint = rng.randint
+
+    # This cython implementation is based on the one of Robert Kern:
+    # http://mail.scipy.org/pipermail/numpy-discussion/2010-December/
+    # 054289.html
+    #
+    for i in range(n_samples):
+        out[i] = i
+
+    for i from n_samples <= i < n_population:
+        j = rng_randint(0, i + 1)
+        if j < n_samples:
+            out[j] = i
+
+    return np.asarray(out)
+
+
+cdef _sample_without_replacement(default_int n_population,
+                                 default_int n_samples,
+                                 method="auto",
+                                 random_state=None):
+    """Sample integers without replacement.
+
+    Private function for the implementation, see sample_without_replacement
+    documentation for more details.
+    """
+    _sample_without_replacement_check_input(n_population, n_samples)
+
+    all_methods = ("auto", "tracking_selection", "reservoir_sampling", "pool")
+
+    ratio = <double> n_samples / n_population if n_population != 0.0 else 1.0
+
+    # Check ratio and use permutation unless ratio < 0.01 or ratio > 0.99
+    if method == "auto" and ratio > 0.01 and ratio < 0.99:
+        rng = check_random_state(random_state)
+        return rng.permutation(n_population)[:n_samples]
+
+    if method == "auto" or method == "tracking_selection":
+        # TODO the pool based method can also be used.
+        #      however, it requires special benchmark to take into account
+        #      the memory requirement of the array vs the set.
+
+        # The value 0.2 has been determined through benchmarking.
+        if ratio < 0.2:
+            return _sample_without_replacement_with_tracking_selection(
+                n_population, n_samples, random_state)
+        else:
+            return _sample_without_replacement_with_reservoir_sampling(
+                n_population, n_samples, random_state)
+
+    elif method == "reservoir_sampling":
+        return _sample_without_replacement_with_reservoir_sampling(
+            n_population, n_samples, random_state)
+
+    elif method == "pool":
+        return _sample_without_replacement_with_pool(n_population, n_samples,
+                                                     random_state)
+    else:
+        raise ValueError('Expected a method name in %s, got %s. '
+                         % (all_methods, method))
+
+
+def sample_without_replacement(
+        object n_population, object n_samples, method="auto", random_state=None):
+    """Sample integers without replacement.
+
+    Select n_samples integers from the set [0, n_population) without
+    replacement.
+
+
+    Parameters
+    ----------
+    n_population : int
+        The size of the set to sample from.
+
+    n_samples : int
+        The number of integer to sample.
+
+    random_state : int, RandomState instance or None, default=None
+        If int, random_state is the seed used by the random number generator;
+        If RandomState instance, random_state is the random number generator;
+        If None, the random number generator is the RandomState instance used
+        by `np.random`.
+
+    method : {"auto", "tracking_selection", "reservoir_sampling", "pool"}, \
+            default='auto'
+        If method == "auto", the ratio of n_samples / n_population is used
+        to determine which algorithm to use:
+        If ratio is between 0 and 0.01, tracking selection is used.
+        If ratio is between 0.01 and 0.99, numpy.random.permutation is used.
+        If ratio is greater than 0.99, reservoir sampling is used.
+        The order of the selected integers is undefined. If a random order is
+        desired, the selected subset should be shuffled.
+
+        If method =="tracking_selection", a set based implementation is used
+        which is suitable for `n_samples` <<< `n_population`.
+
+        If method == "reservoir_sampling", a reservoir sampling algorithm is
+        used which is suitable for high memory constraint or when
+        O(`n_samples`) ~ O(`n_population`).
+        The order of the selected integers is undefined. If a random order is
+        desired, the selected subset should be shuffled.
+
+        If method == "pool", a pool based algorithm is particularly fast, even
+        faster than the tracking selection method. However, a vector containing
+        the entire population has to be initialized.
+        If n_samples ~ n_population, the reservoir sampling method is faster.
+
+    Returns
+    -------
+    out : ndarray of shape (n_samples,)
+        The sampled subsets of integer. The subset of selected integer might
+        not be randomized, see the method argument.
+
+    Examples
+    --------
+    >>> from sklearn.utils.random import sample_without_replacement
+    >>> sample_without_replacement(10, 5, random_state=42)
+    array([8, 1, 5, 0, 7])
+    """
+    cdef:
+        intp_t n_pop_intp, n_samples_intp
+        long n_pop_long, n_samples_long
+
+    # On most platforms `np.int_ is np.intp`.  However, before NumPy 2 the
+    # default integer `np.int_` was a long which is 32bit on 64bit windows
+    # while `intp` is 64bit on 64bit platforms and 32bit on 32bit ones.
+    if np.int_ is np.intp:
+        # Branch always taken on NumPy >=2 (or when not on 64bit windows).
+        # Cython has different rules for conversion of values to integers.
+        # For NumPy <1.26.2 AND Cython 3, this first branch requires `int()`
+        # called explicitly to allow e.g. floats.
+        n_pop_intp = int(n_population)
+        n_samples_intp = int(n_samples)
+        return _sample_without_replacement(
+                n_pop_intp, n_samples_intp, method, random_state)
+    else:
+        # Branch taken on 64bit windows with Numpy<2.0 where `long` is 32bit
+        n_pop_long = n_population
+        n_samples_long = n_samples
+        return _sample_without_replacement(
+                n_pop_long, n_samples_long, method, random_state)
+
+
+def _our_rand_r_py(seed):
+    """Python utils to test the our_rand_r function"""
+    cdef uint32_t my_seed = seed
+    return our_rand_r(&my_seed)

shared/package-files/1f/1f5b81f8d9bec88c2ba738c6a08bba4abc6dc4c6fbb70c3c7c303080eb214cc1/_convert_indices_from_coo_to_csr_native.h

@@ -0,0 +1,26 @@
+#pragma once
+
+// @generated by torchgen/gen.py from NativeFunction.h
+
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+#include <c10/core/QScheme.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <tuple>
+#include <vector>
+#include <ATen/ops/_convert_indices_from_coo_to_csr_meta.h>
+
+namespace at {
+namespace native {
+struct TORCH_API structured__convert_indices_from_coo_to_csr_structured_cpu : public at::meta::structured__convert_indices_from_coo_to_csr {
+void impl(const at::Tensor & self, int64_t size, bool out_int32, const at::Tensor & out);
+};
+struct TORCH_API structured__convert_indices_from_coo_to_csr_structured_cuda : public at::meta::structured__convert_indices_from_coo_to_csr {
+void impl(const at::Tensor & self, int64_t size, bool out_int32, const at::Tensor & out);
+};
+} // namespace native
+} // namespace at

shared/package-files/1f/1f666c36d96b5c0a28a42b6200b4cce5a74bde72a327d547e367b2daae2a6abc/nbinom_resids.csv

@@ -0,0 +1,20 @@
+-.5049508,-.6297218,-83.54991,-1.306285,-6.620286
+-.2341522,-.2554235,-216.8307,-.758866,-7.183702
+1.024237,.7987758,483.7363,2.503515,22.51353
+-.2850617,-.3177966,-70411.51,-2.379918,-141.7456
+.2099025,.1967877,2247.514,.9519455,21.77242
+-.4034835,-.4757415,-19563.36,-2.635026,-88.94614
+-.1644134,-.1744011,-17331.03,-1.162355,-53.42135
+-.4296077,-.5134667,-5300.37,-2.244962,-47.82603
+.323713,.2941846,4110.794,1.486844,36.55984
+.1503672,.1434294,7285.321,.8855429,33.1355
+.4212886,.373428,1373.157,1.521332,24.15702
+.4506587,.3965867,1701.469,1.661779,27.80326
+.2435375,.226174,3184.023,1.136562,27.90734
+1.051829,.8162054,6001.352,3.890797,79.71313
+-.5544503,-.712749,-2094.852,-2.454965,-34.21899
+-.6057506,-.8064111,-274.7382,-1.907744,-13.05105
+-.3412157,-.3902446,-631.138,-1.270229,-14.76001
+.2218985,.2073287,691.1358,.8168764,12.43929
+.2455925,.2266392,.1992506,.2579483,.2747237
+-.7589526,-1.153008,-256.739,-2.407166,-14.14742

shared/package-files/1f/1f6a89978659a99e1b23e13d3426eed6815fb68d04745c424ca4ee80c3c74478/matfuncs.py

@@ -0,0 +1,18 @@
+# This file is not meant for public use and will be removed in SciPy v2.0.0.
+# Use the `scipy.sparse.linalg` namespace for importing the functions
+# included below.
+
+from scipy._lib.deprecation import _sub_module_deprecation
+
+
+__all__ = ["expm", "inv", "spsolve", "LinearOperator"]  # noqa: F822
+
+
+def __dir__():
+    return __all__
+
+
+def __getattr__(name):
+    return _sub_module_deprecation(sub_package="sparse.linalg", module="matfuncs",
+                                   private_modules=["_matfuncs"], all=__all__,
+                                   attribute=name)

shared/package-files/1f/1f6b93fa6477edbf10cfa2880c369f2c16fd53712fcd5de308ecbca5f4237663/dense.py

@@ -0,0 +1,236 @@
+"""Floyd-Warshall algorithm for shortest paths.
+"""
+import networkx as nx
+
+__all__ = [
+    "floyd_warshall",
+    "floyd_warshall_predecessor_and_distance",
+    "reconstruct_path",
+    "floyd_warshall_numpy",
+]
+
+
+@nx._dispatch
+def floyd_warshall_numpy(G, nodelist=None, weight="weight"):
+    """Find all-pairs shortest path lengths using Floyd's algorithm.
+
+    This algorithm for finding shortest paths takes advantage of
+    matrix representations of a graph and works well for dense
+    graphs where all-pairs shortest path lengths are desired.
+    The results are returned as a NumPy array, distance[i, j],
+    where i and j are the indexes of two nodes in nodelist.
+    The entry distance[i, j] is the distance along a shortest
+    path from i to j. If no path exists the distance is Inf.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    nodelist : list, optional (default=G.nodes)
+       The rows and columns are ordered by the nodes in nodelist.
+       If nodelist is None then the ordering is produced by G.nodes.
+       Nodelist should include all nodes in G.
+
+    weight: string, optional (default='weight')
+       Edge data key corresponding to the edge weight.
+
+    Returns
+    -------
+    distance : 2D numpy.ndarray
+        A numpy array of shortest path distances between nodes.
+        If there is no path between two nodes the value is Inf.
+
+    Notes
+    -----
+    Floyd's algorithm is appropriate for finding shortest paths in
+    dense graphs or graphs with negative weights when Dijkstra's
+    algorithm fails. This algorithm can still fail if there are negative
+    cycles. It has running time $O(n^3)$ with running space of $O(n^2)$.
+
+    Raises
+    ------
+    NetworkXError
+        If nodelist is not a list of the nodes in G.
+    """
+    import numpy as np
+
+    if nodelist is not None:
+        if not (len(nodelist) == len(G) == len(set(nodelist))):
+            raise nx.NetworkXError(
+                "nodelist must contain every node in G with no repeats."
+                "If you wanted a subgraph of G use G.subgraph(nodelist)"
+            )
+
+    # To handle cases when an edge has weight=0, we must make sure that
+    # nonedges are not given the value 0 as well.
+    A = nx.to_numpy_array(
+        G, nodelist, multigraph_weight=min, weight=weight, nonedge=np.inf
+    )
+    n, m = A.shape
+    np.fill_diagonal(A, 0)  # diagonal elements should be zero
+    for i in range(n):
+        # The second term has the same shape as A due to broadcasting
+        A = np.minimum(A, A[i, :][np.newaxis, :] + A[:, i][:, np.newaxis])
+    return A
+
+
+@nx._dispatch
+def floyd_warshall_predecessor_and_distance(G, weight="weight"):
+    """Find all-pairs shortest path lengths using Floyd's algorithm.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    weight: string, optional (default= 'weight')
+       Edge data key corresponding to the edge weight.
+
+    Returns
+    -------
+    predecessor,distance : dictionaries
+       Dictionaries, keyed by source and target, of predecessors and distances
+       in the shortest path.
+
+    Examples
+    --------
+    >>> G = nx.DiGraph()
+    >>> G.add_weighted_edges_from(
+    ...     [
+    ...         ("s", "u", 10),
+    ...         ("s", "x", 5),
+    ...         ("u", "v", 1),
+    ...         ("u", "x", 2),
+    ...         ("v", "y", 1),
+    ...         ("x", "u", 3),
+    ...         ("x", "v", 5),
+    ...         ("x", "y", 2),
+    ...         ("y", "s", 7),
+    ...         ("y", "v", 6),
+    ...     ]
+    ... )
+    >>> predecessors, _ = nx.floyd_warshall_predecessor_and_distance(G)
+    >>> print(nx.reconstruct_path("s", "v", predecessors))
+    ['s', 'x', 'u', 'v']
+
+    Notes
+    -----
+    Floyd's algorithm is appropriate for finding shortest paths
+    in dense graphs or graphs with negative weights when Dijkstra's algorithm
+    fails.  This algorithm can still fail if there are negative cycles.
+    It has running time $O(n^3)$ with running space of $O(n^2)$.
+
+    See Also
+    --------
+    floyd_warshall
+    floyd_warshall_numpy
+    all_pairs_shortest_path
+    all_pairs_shortest_path_length
+    """
+    from collections import defaultdict
+
+    # dictionary-of-dictionaries representation for dist and pred
+    # use some defaultdict magick here
+    # for dist the default is the floating point inf value
+    dist = defaultdict(lambda: defaultdict(lambda: float("inf")))
+    for u in G:
+        dist[u][u] = 0
+    pred = defaultdict(dict)
+    # initialize path distance dictionary to be the adjacency matrix
+    # also set the distance to self to 0 (zero diagonal)
+    undirected = not G.is_directed()
+    for u, v, d in G.edges(data=True):
+        e_weight = d.get(weight, 1.0)
+        dist[u][v] = min(e_weight, dist[u][v])
+        pred[u][v] = u
+        if undirected:
+            dist[v][u] = min(e_weight, dist[v][u])
+            pred[v][u] = v
+    for w in G:
+        dist_w = dist[w]  # save recomputation
+        for u in G:
+            dist_u = dist[u]  # save recomputation
+            for v in G:
+                d = dist_u[w] + dist_w[v]
+                if dist_u[v] > d:
+                    dist_u[v] = d
+                    pred[u][v] = pred[w][v]
+    return dict(pred), dict(dist)
+
+
+def reconstruct_path(source, target, predecessors):
+    """Reconstruct a path from source to target using the predecessors
+    dict as returned by floyd_warshall_predecessor_and_distance
+
+    Parameters
+    ----------
+    source : node
+       Starting node for path
+
+    target : node
+       Ending node for path
+
+    predecessors: dictionary
+       Dictionary, keyed by source and target, of predecessors in the
+       shortest path, as returned by floyd_warshall_predecessor_and_distance
+
+    Returns
+    -------
+    path : list
+       A list of nodes containing the shortest path from source to target
+
+       If source and target are the same, an empty list is returned
+
+    Notes
+    -----
+    This function is meant to give more applicability to the
+    floyd_warshall_predecessor_and_distance function
+
+    See Also
+    --------
+    floyd_warshall_predecessor_and_distance
+    """
+    if source == target:
+        return []
+    prev = predecessors[source]
+    curr = prev[target]
+    path = [target, curr]
+    while curr != source:
+        curr = prev[curr]
+        path.append(curr)
+    return list(reversed(path))
+
+
+@nx._dispatch
+def floyd_warshall(G, weight="weight"):
+    """Find all-pairs shortest path lengths using Floyd's algorithm.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    weight: string, optional (default= 'weight')
+       Edge data key corresponding to the edge weight.
+
+
+    Returns
+    -------
+    distance : dict
+       A dictionary,  keyed by source and target, of shortest paths distances
+       between nodes.
+
+    Notes
+    -----
+    Floyd's algorithm is appropriate for finding shortest paths
+    in dense graphs or graphs with negative weights when Dijkstra's algorithm
+    fails.  This algorithm can still fail if there are negative cycles.
+    It has running time $O(n^3)$ with running space of $O(n^2)$.
+
+    See Also
+    --------
+    floyd_warshall_predecessor_and_distance
+    floyd_warshall_numpy
+    all_pairs_shortest_path
+    all_pairs_shortest_path_length
+    """
+    # could make this its own function to reduce memory costs
+    return floyd_warshall_predecessor_and_distance(G, weight=weight)[1]

shared/package-files/1f/1f6dfbca13ca6ec97e0a2bf847a12dfcb5f9b815012eb0ea4c3bc14f524c79fe/middleware.pyi

@@ -0,0 +1,7 @@
+from django.http.request import HttpRequest
+from django.http.response import HttpResponse
+from django.utils.deprecation import MiddlewareMixin
+
+class MessageMiddleware(MiddlewareMixin):
+    def process_request(self, request: HttpRequest) -> None: ...
+    def process_response(self, request: HttpRequest, response: HttpResponse) -> HttpResponse: ...

shared/package-files/1f/1f6e42785e06337150ab407abb7710a7515918088695b38e86016a9f84480059/_svm_cython_blas_helpers.h

@@ -0,0 +1,9 @@
+#ifndef _SVM_CYTHON_BLAS_HELPERS_H
+#define _SVM_CYTHON_BLAS_HELPERS_H
+
+typedef double (*dot_func)(int, const double*, int, const double*, int);
+typedef struct BlasFunctions{
+    dot_func dot;
+} BlasFunctions;
+
+#endif

shared/package-files/1f/1f771e18fa4065f1f6fa66eefae63b300ea3b1e93e1c45182c1bd878b4ce3c40/environment.yml

@@ -0,0 +1,3 @@
+name: to-save
+dependencies:
+  - python

shared/package-files/1f/1f7be1029f426e7fbb26e4c6a334be3301a83a511c7757c72a63f4a2ad19d946/_param_validation.py

@@ -0,0 +1,910 @@
+# Authors: The scikit-learn developers
+# SPDX-License-Identifier: BSD-3-Clause
+
+import functools
+import math
+import operator
+import re
+from abc import ABC, abstractmethod
+from collections.abc import Iterable
+from inspect import signature
+from numbers import Integral, Real
+
+import numpy as np
+from scipy.sparse import csr_matrix, issparse
+
+from .._config import config_context, get_config
+from .validation import _is_arraylike_not_scalar
+
+
+class InvalidParameterError(ValueError, TypeError):
+    """Custom exception to be raised when the parameter of a class/method/function
+    does not have a valid type or value.
+    """
+
+    # Inherits from ValueError and TypeError to keep backward compatibility.
+
+
+def validate_parameter_constraints(parameter_constraints, params, caller_name):
+    """Validate types and values of given parameters.
+
+    Parameters
+    ----------
+    parameter_constraints : dict or {"no_validation"}
+        If "no_validation", validation is skipped for this parameter.
+
+        If a dict, it must be a dictionary `param_name: list of constraints`.
+        A parameter is valid if it satisfies one of the constraints from the list.
+        Constraints can be:
+        - an Interval object, representing a continuous or discrete range of numbers
+        - the string "array-like"
+        - the string "sparse matrix"
+        - the string "random_state"
+        - callable
+        - None, meaning that None is a valid value for the parameter
+        - any type, meaning that any instance of this type is valid
+        - an Options object, representing a set of elements of a given type
+        - a StrOptions object, representing a set of strings
+        - the string "boolean"
+        - the string "verbose"
+        - the string "cv_object"
+        - the string "nan"
+        - a MissingValues object representing markers for missing values
+        - a HasMethods object, representing method(s) an object must have
+        - a Hidden object, representing a constraint not meant to be exposed to the user
+
+    params : dict
+        A dictionary `param_name: param_value`. The parameters to validate against the
+        constraints.
+
+    caller_name : str
+        The name of the estimator or function or method that called this function.
+    """
+    for param_name, param_val in params.items():
+        # We allow parameters to not have a constraint so that third party estimators
+        # can inherit from sklearn estimators without having to necessarily use the
+        # validation tools.
+        if param_name not in parameter_constraints:
+            continue
+
+        constraints = parameter_constraints[param_name]
+
+        if constraints == "no_validation":
+            continue
+
+        constraints = [make_constraint(constraint) for constraint in constraints]
+
+        for constraint in constraints:
+            if constraint.is_satisfied_by(param_val):
+                # this constraint is satisfied, no need to check further.
+                break
+        else:
+            # No constraint is satisfied, raise with an informative message.
+
+            # Ignore constraints that we don't want to expose in the error message,
+            # i.e. options that are for internal purpose or not officially supported.
+            constraints = [
+                constraint for constraint in constraints if not constraint.hidden
+            ]
+
+            if len(constraints) == 1:
+                constraints_str = f"{constraints[0]}"
+            else:
+                constraints_str = (
+                    f"{', '.join([str(c) for c in constraints[:-1]])} or"
+                    f" {constraints[-1]}"
+                )
+
+            raise InvalidParameterError(
+                f"The {param_name!r} parameter of {caller_name} must be"
+                f" {constraints_str}. Got {param_val!r} instead."
+            )
+
+
+def make_constraint(constraint):
+    """Convert the constraint into the appropriate Constraint object.
+
+    Parameters
+    ----------
+    constraint : object
+        The constraint to convert.
+
+    Returns
+    -------
+    constraint : instance of _Constraint
+        The converted constraint.
+    """
+    if isinstance(constraint, str) and constraint == "array-like":
+        return _ArrayLikes()
+    if isinstance(constraint, str) and constraint == "sparse matrix":
+        return _SparseMatrices()
+    if isinstance(constraint, str) and constraint == "random_state":
+        return _RandomStates()
+    if constraint is callable:
+        return _Callables()
+    if constraint is None:
+        return _NoneConstraint()
+    if isinstance(constraint, type):
+        return _InstancesOf(constraint)
+    if isinstance(
+        constraint, (Interval, StrOptions, Options, HasMethods, MissingValues)
+    ):
+        return constraint
+    if isinstance(constraint, str) and constraint == "boolean":
+        return _Booleans()
+    if isinstance(constraint, str) and constraint == "verbose":
+        return _VerboseHelper()
+    if isinstance(constraint, str) and constraint == "cv_object":
+        return _CVObjects()
+    if isinstance(constraint, Hidden):
+        constraint = make_constraint(constraint.constraint)
+        constraint.hidden = True
+        return constraint
+    if (isinstance(constraint, str) and constraint == "nan") or (
+        isinstance(constraint, float) and np.isnan(constraint)
+    ):
+        return _NanConstraint()
+    raise ValueError(f"Unknown constraint type: {constraint}")
+
+
+def validate_params(parameter_constraints, *, prefer_skip_nested_validation):
+    """Decorator to validate types and values of functions and methods.
+
+    Parameters
+    ----------
+    parameter_constraints : dict
+        A dictionary `param_name: list of constraints`. See the docstring of
+        `validate_parameter_constraints` for a description of the accepted constraints.
+
+        Note that the *args and **kwargs parameters are not validated and must not be
+        present in the parameter_constraints dictionary.
+
+    prefer_skip_nested_validation : bool
+        If True, the validation of parameters of inner estimators or functions
+        called by the decorated function will be skipped.
+
+        This is useful to avoid validating many times the parameters passed by the
+        user from the public facing API. It's also useful to avoid validating
+        parameters that we pass internally to inner functions that are guaranteed to
+        be valid by the test suite.
+
+        It should be set to True for most functions, except for those that receive
+        non-validated objects as parameters or that are just wrappers around classes
+        because they only perform a partial validation.
+
+    Returns
+    -------
+    decorated_function : function or method
+        The decorated function.
+    """
+
+    def decorator(func):
+        # The dict of parameter constraints is set as an attribute of the function
+        # to make it possible to dynamically introspect the constraints for
+        # automatic testing.
+        setattr(func, "_skl_parameter_constraints", parameter_constraints)
+
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            global_skip_validation = get_config()["skip_parameter_validation"]
+            if global_skip_validation:
+                return func(*args, **kwargs)
+
+            func_sig = signature(func)
+
+            # Map *args/**kwargs to the function signature
+            params = func_sig.bind(*args, **kwargs)
+            params.apply_defaults()
+
+            # ignore self/cls and positional/keyword markers
+            to_ignore = [
+                p.name
+                for p in func_sig.parameters.values()
+                if p.kind in (p.VAR_POSITIONAL, p.VAR_KEYWORD)
+            ]
+            to_ignore += ["self", "cls"]
+            params = {k: v for k, v in params.arguments.items() if k not in to_ignore}
+
+            validate_parameter_constraints(
+                parameter_constraints, params, caller_name=func.__qualname__
+            )
+
+            try:
+                with config_context(
+                    skip_parameter_validation=(
+                        prefer_skip_nested_validation or global_skip_validation
+                    )
+                ):
+                    return func(*args, **kwargs)
+            except InvalidParameterError as e:
+                # When the function is just a wrapper around an estimator, we allow
+                # the function to delegate validation to the estimator, but we replace
+                # the name of the estimator by the name of the function in the error
+                # message to avoid confusion.
+                msg = re.sub(
+                    r"parameter of \w+ must be",
+                    f"parameter of {func.__qualname__} must be",
+                    str(e),
+                )
+                raise InvalidParameterError(msg) from e
+
+        return wrapper
+
+    return decorator
+
+
+class RealNotInt(Real):
+    """A type that represents reals that are not instances of int.
+
+    Behaves like float, but also works with values extracted from numpy arrays.
+    isintance(1, RealNotInt) -> False
+    isinstance(1.0, RealNotInt) -> True
+    """
+
+
+RealNotInt.register(float)
+
+
+def _type_name(t):
+    """Convert type into human readable string."""
+    module = t.__module__
+    qualname = t.__qualname__
+    if module == "builtins":
+        return qualname
+    elif t == Real:
+        return "float"
+    elif t == Integral:
+        return "int"
+    return f"{module}.{qualname}"
+
+
+class _Constraint(ABC):
+    """Base class for the constraint objects."""
+
+    def __init__(self):
+        self.hidden = False
+
+    @abstractmethod
+    def is_satisfied_by(self, val):
+        """Whether or not a value satisfies the constraint.
+
+        Parameters
+        ----------
+        val : object
+            The value to check.
+
+        Returns
+        -------
+        is_satisfied : bool
+            Whether or not the constraint is satisfied by this value.
+        """
+
+    @abstractmethod
+    def __str__(self):
+        """A human readable representational string of the constraint."""
+
+
+class _InstancesOf(_Constraint):
+    """Constraint representing instances of a given type.
+
+    Parameters
+    ----------
+    type : type
+        The valid type.
+    """
+
+    def __init__(self, type):
+        super().__init__()
+        self.type = type
+
+    def is_satisfied_by(self, val):
+        return isinstance(val, self.type)
+
+    def __str__(self):
+        return f"an instance of {_type_name(self.type)!r}"
+
+
+class _NoneConstraint(_Constraint):
+    """Constraint representing the None singleton."""
+
+    def is_satisfied_by(self, val):
+        return val is None
+
+    def __str__(self):
+        return "None"
+
+
+class _NanConstraint(_Constraint):
+    """Constraint representing the indicator `np.nan`."""
+
+    def is_satisfied_by(self, val):
+        return (
+            not isinstance(val, Integral) and isinstance(val, Real) and math.isnan(val)
+        )
+
+    def __str__(self):
+        return "numpy.nan"
+
+
+class _PandasNAConstraint(_Constraint):
+    """Constraint representing the indicator `pd.NA`."""
+
+    def is_satisfied_by(self, val):
+        try:
+            import pandas as pd
+
+            return isinstance(val, type(pd.NA)) and pd.isna(val)
+        except ImportError:
+            return False
+
+    def __str__(self):
+        return "pandas.NA"
+
+
+class Options(_Constraint):
+    """Constraint representing a finite set of instances of a given type.
+
+    Parameters
+    ----------
+    type : type
+
+    options : set
+        The set of valid scalars.
+
+    deprecated : set or None, default=None
+        A subset of the `options` to mark as deprecated in the string
+        representation of the constraint.
+    """
+
+    def __init__(self, type, options, *, deprecated=None):
+        super().__init__()
+        self.type = type
+        self.options = options
+        self.deprecated = deprecated or set()
+
+        if self.deprecated - self.options:
+            raise ValueError("The deprecated options must be a subset of the options.")
+
+    def is_satisfied_by(self, val):
+        return isinstance(val, self.type) and val in self.options
+
+    def _mark_if_deprecated(self, option):
+        """Add a deprecated mark to an option if needed."""
+        option_str = f"{option!r}"
+        if option in self.deprecated:
+            option_str = f"{option_str} (deprecated)"
+        return option_str
+
+    def __str__(self):
+        options_str = (
+            f"{', '.join([self._mark_if_deprecated(o) for o in self.options])}"
+        )
+        return f"a {_type_name(self.type)} among {{{options_str}}}"
+
+
+class StrOptions(Options):
+    """Constraint representing a finite set of strings.
+
+    Parameters
+    ----------
+    options : set of str
+        The set of valid strings.
+
+    deprecated : set of str or None, default=None
+        A subset of the `options` to mark as deprecated in the string
+        representation of the constraint.
+    """
+
+    def __init__(self, options, *, deprecated=None):
+        super().__init__(type=str, options=options, deprecated=deprecated)
+
+
+class Interval(_Constraint):
+    """Constraint representing a typed interval.
+
+    Parameters
+    ----------
+    type : {numbers.Integral, numbers.Real, RealNotInt}
+        The set of numbers in which to set the interval.
+
+        If RealNotInt, only reals that don't have the integer type
+        are allowed. For example 1.0 is allowed but 1 is not.
+
+    left : float or int or None
+        The left bound of the interval. None means left bound is -∞.
+
+    right : float, int or None
+        The right bound of the interval. None means right bound is +∞.
+
+    closed : {"left", "right", "both", "neither"}
+        Whether the interval is open or closed. Possible choices are:
+
+        - `"left"`: the interval is closed on the left and open on the right.
+          It is equivalent to the interval `[ left, right )`.
+        - `"right"`: the interval is closed on the right and open on the left.
+          It is equivalent to the interval `( left, right ]`.
+        - `"both"`: the interval is closed.
+          It is equivalent to the interval `[ left, right ]`.
+        - `"neither"`: the interval is open.
+          It is equivalent to the interval `( left, right )`.
+
+    Notes
+    -----
+    Setting a bound to `None` and setting the interval closed is valid. For instance,
+    strictly speaking, `Interval(Real, 0, None, closed="both")` corresponds to
+    `[0, +∞) U {+∞}`.
+    """
+
+    def __init__(self, type, left, right, *, closed):
+        super().__init__()
+        self.type = type
+        self.left = left
+        self.right = right
+        self.closed = closed
+
+        self._check_params()
+
+    def _check_params(self):
+        if self.type not in (Integral, Real, RealNotInt):
+            raise ValueError(
+                "type must be either numbers.Integral, numbers.Real or RealNotInt."
+                f" Got {self.type} instead."
+            )
+
+        if self.closed not in ("left", "right", "both", "neither"):
+            raise ValueError(
+                "closed must be either 'left', 'right', 'both' or 'neither'. "
+                f"Got {self.closed} instead."
+            )
+
+        if self.type is Integral:
+            suffix = "for an interval over the integers."
+            if self.left is not None and not isinstance(self.left, Integral):
+                raise TypeError(f"Expecting left to be an int {suffix}")
+            if self.right is not None and not isinstance(self.right, Integral):
+                raise TypeError(f"Expecting right to be an int {suffix}")
+            if self.left is None and self.closed in ("left", "both"):
+                raise ValueError(
+                    f"left can't be None when closed == {self.closed} {suffix}"
+                )
+            if self.right is None and self.closed in ("right", "both"):
+                raise ValueError(
+                    f"right can't be None when closed == {self.closed} {suffix}"
+                )
+        else:
+            if self.left is not None and not isinstance(self.left, Real):
+                raise TypeError("Expecting left to be a real number.")
+            if self.right is not None and not isinstance(self.right, Real):
+                raise TypeError("Expecting right to be a real number.")
+
+        if self.right is not None and self.left is not None and self.right <= self.left:
+            raise ValueError(
+                f"right can't be less than left. Got left={self.left} and "
+                f"right={self.right}"
+            )
+
+    def __contains__(self, val):
+        if not isinstance(val, Integral) and np.isnan(val):
+            return False
+
+        left_cmp = operator.lt if self.closed in ("left", "both") else operator.le
+        right_cmp = operator.gt if self.closed in ("right", "both") else operator.ge
+
+        left = -np.inf if self.left is None else self.left
+        right = np.inf if self.right is None else self.right
+
+        if left_cmp(val, left):
+            return False
+        if right_cmp(val, right):
+            return False
+        return True
+
+    def is_satisfied_by(self, val):
+        if not isinstance(val, self.type):
+            return False
+
+        return val in self
+
+    def __str__(self):
+        type_str = "an int" if self.type is Integral else "a float"
+        left_bracket = "[" if self.closed in ("left", "both") else "("
+        left_bound = "-inf" if self.left is None else self.left
+        right_bound = "inf" if self.right is None else self.right
+        right_bracket = "]" if self.closed in ("right", "both") else ")"
+
+        # better repr if the bounds were given as integers
+        if not self.type == Integral and isinstance(self.left, Real):
+            left_bound = float(left_bound)
+        if not self.type == Integral and isinstance(self.right, Real):
+            right_bound = float(right_bound)
+
+        return (
+            f"{type_str} in the range "
+            f"{left_bracket}{left_bound}, {right_bound}{right_bracket}"
+        )
+
+
+class _ArrayLikes(_Constraint):
+    """Constraint representing array-likes"""
+
+    def is_satisfied_by(self, val):
+        return _is_arraylike_not_scalar(val)
+
+    def __str__(self):
+        return "an array-like"
+
+
+class _SparseMatrices(_Constraint):
+    """Constraint representing sparse matrices."""
+
+    def is_satisfied_by(self, val):
+        return issparse(val)
+
+    def __str__(self):
+        return "a sparse matrix"
+
+
+class _Callables(_Constraint):
+    """Constraint representing callables."""
+
+    def is_satisfied_by(self, val):
+        return callable(val)
+
+    def __str__(self):
+        return "a callable"
+
+
+class _RandomStates(_Constraint):
+    """Constraint representing random states.
+
+    Convenience class for
+    [Interval(Integral, 0, 2**32 - 1, closed="both"), np.random.RandomState, None]
+    """
+
+    def __init__(self):
+        super().__init__()
+        self._constraints = [
+            Interval(Integral, 0, 2**32 - 1, closed="both"),
+            _InstancesOf(np.random.RandomState),
+            _NoneConstraint(),
+        ]
+
+    def is_satisfied_by(self, val):
+        return any(c.is_satisfied_by(val) for c in self._constraints)
+
+    def __str__(self):
+        return (
+            f"{', '.join([str(c) for c in self._constraints[:-1]])} or"
+            f" {self._constraints[-1]}"
+        )
+
+
+class _Booleans(_Constraint):
+    """Constraint representing boolean likes.
+
+    Convenience class for
+    [bool, np.bool_]
+    """
+
+    def __init__(self):
+        super().__init__()
+        self._constraints = [
+            _InstancesOf(bool),
+            _InstancesOf(np.bool_),
+        ]
+
+    def is_satisfied_by(self, val):
+        return any(c.is_satisfied_by(val) for c in self._constraints)
+
+    def __str__(self):
+        return (
+            f"{', '.join([str(c) for c in self._constraints[:-1]])} or"
+            f" {self._constraints[-1]}"
+        )
+
+
+class _VerboseHelper(_Constraint):
+    """Helper constraint for the verbose parameter.
+
+    Convenience class for
+    [Interval(Integral, 0, None, closed="left"), bool, numpy.bool_]
+    """
+
+    def __init__(self):
+        super().__init__()
+        self._constraints = [
+            Interval(Integral, 0, None, closed="left"),
+            _InstancesOf(bool),
+            _InstancesOf(np.bool_),
+        ]
+
+    def is_satisfied_by(self, val):
+        return any(c.is_satisfied_by(val) for c in self._constraints)
+
+    def __str__(self):
+        return (
+            f"{', '.join([str(c) for c in self._constraints[:-1]])} or"
+            f" {self._constraints[-1]}"
+        )
+
+
+class MissingValues(_Constraint):
+    """Helper constraint for the `missing_values` parameters.
+
+    Convenience for
+    [
+        Integral,
+        Interval(Real, None, None, closed="both"),
+        str,   # when numeric_only is False
+        None,  # when numeric_only is False
+        _NanConstraint(),
+        _PandasNAConstraint(),
+    ]
+
+    Parameters
+    ----------
+    numeric_only : bool, default=False
+        Whether to consider only numeric missing value markers.
+
+    """
+
+    def __init__(self, numeric_only=False):
+        super().__init__()
+
+        self.numeric_only = numeric_only
+
+        self._constraints = [
+            _InstancesOf(Integral),
+            # we use an interval of Real to ignore np.nan that has its own constraint
+            Interval(Real, None, None, closed="both"),
+            _NanConstraint(),
+            _PandasNAConstraint(),
+        ]
+        if not self.numeric_only:
+            self._constraints.extend([_InstancesOf(str), _NoneConstraint()])
+
+    def is_satisfied_by(self, val):
+        return any(c.is_satisfied_by(val) for c in self._constraints)
+
+    def __str__(self):
+        return (
+            f"{', '.join([str(c) for c in self._constraints[:-1]])} or"
+            f" {self._constraints[-1]}"
+        )
+
+
+class HasMethods(_Constraint):
+    """Constraint representing objects that expose specific methods.
+
+    It is useful for parameters following a protocol and where we don't want to impose
+    an affiliation to a specific module or class.
+
+    Parameters
+    ----------
+    methods : str or list of str
+        The method(s) that the object is expected to expose.
+    """
+
+    @validate_params(
+        {"methods": [str, list]},
+        prefer_skip_nested_validation=True,
+    )
+    def __init__(self, methods):
+        super().__init__()
+        if isinstance(methods, str):
+            methods = [methods]
+        self.methods = methods
+
+    def is_satisfied_by(self, val):
+        return all(callable(getattr(val, method, None)) for method in self.methods)
+
+    def __str__(self):
+        if len(self.methods) == 1:
+            methods = f"{self.methods[0]!r}"
+        else:
+            methods = (
+                f"{', '.join([repr(m) for m in self.methods[:-1]])} and"
+                f" {self.methods[-1]!r}"
+            )
+        return f"an object implementing {methods}"
+
+
+class _IterablesNotString(_Constraint):
+    """Constraint representing iterables that are not strings."""
+
+    def is_satisfied_by(self, val):
+        return isinstance(val, Iterable) and not isinstance(val, str)
+
+    def __str__(self):
+        return "an iterable"
+
+
+class _CVObjects(_Constraint):
+    """Constraint representing cv objects.
+
+    Convenient class for
+    [
+        Interval(Integral, 2, None, closed="left"),
+        HasMethods(["split", "get_n_splits"]),
+        _IterablesNotString(),
+        None,
+    ]
+    """
+
+    def __init__(self):
+        super().__init__()
+        self._constraints = [
+            Interval(Integral, 2, None, closed="left"),
+            HasMethods(["split", "get_n_splits"]),
+            _IterablesNotString(),
+            _NoneConstraint(),
+        ]
+
+    def is_satisfied_by(self, val):
+        return any(c.is_satisfied_by(val) for c in self._constraints)
+
+    def __str__(self):
+        return (
+            f"{', '.join([str(c) for c in self._constraints[:-1]])} or"
+            f" {self._constraints[-1]}"
+        )
+
+
+class Hidden:
+    """Class encapsulating a constraint not meant to be exposed to the user.
+
+    Parameters
+    ----------
+    constraint : str or _Constraint instance
+        The constraint to be used internally.
+    """
+
+    def __init__(self, constraint):
+        self.constraint = constraint
+
+
+def generate_invalid_param_val(constraint):
+    """Return a value that does not satisfy the constraint.
+
+    Raises a NotImplementedError if there exists no invalid value for this constraint.
+
+    This is only useful for testing purpose.
+
+    Parameters
+    ----------
+    constraint : _Constraint instance
+        The constraint to generate a value for.
+
+    Returns
+    -------
+    val : object
+        A value that does not satisfy the constraint.
+    """
+    if isinstance(constraint, StrOptions):
+        return f"not {' or '.join(constraint.options)}"
+
+    if isinstance(constraint, MissingValues):
+        return np.array([1, 2, 3])
+
+    if isinstance(constraint, _VerboseHelper):
+        return -1
+
+    if isinstance(constraint, HasMethods):
+        return type("HasNotMethods", (), {})()
+
+    if isinstance(constraint, _IterablesNotString):
+        return "a string"
+
+    if isinstance(constraint, _CVObjects):
+        return "not a cv object"
+
+    if isinstance(constraint, Interval) and constraint.type is Integral:
+        if constraint.left is not None:
+            return constraint.left - 1
+        if constraint.right is not None:
+            return constraint.right + 1
+
+        # There's no integer outside (-inf, +inf)
+        raise NotImplementedError
+
+    if isinstance(constraint, Interval) and constraint.type in (Real, RealNotInt):
+        if constraint.left is not None:
+            return constraint.left - 1e-6
+        if constraint.right is not None:
+            return constraint.right + 1e-6
+
+        # bounds are -inf, +inf
+        if constraint.closed in ("right", "neither"):
+            return -np.inf
+        if constraint.closed in ("left", "neither"):
+            return np.inf
+
+        # interval is [-inf, +inf]
+        return np.nan
+
+    raise NotImplementedError
+
+
+def generate_valid_param(constraint):
+    """Return a value that does satisfy a constraint.
+
+    This is only useful for testing purpose.
+
+    Parameters
+    ----------
+    constraint : Constraint instance
+        The constraint to generate a value for.
+
+    Returns
+    -------
+    val : object
+        A value that does satisfy the constraint.
+    """
+    if isinstance(constraint, _ArrayLikes):
+        return np.array([1, 2, 3])
+
+    if isinstance(constraint, _SparseMatrices):
+        return csr_matrix([[0, 1], [1, 0]])
+
+    if isinstance(constraint, _RandomStates):
+        return np.random.RandomState(42)
+
+    if isinstance(constraint, _Callables):
+        return lambda x: x
+
+    if isinstance(constraint, _NoneConstraint):
+        return None
+
+    if isinstance(constraint, _InstancesOf):
+        if constraint.type is np.ndarray:
+            # special case for ndarray since it can't be instantiated without arguments
+            return np.array([1, 2, 3])
+
+        if constraint.type in (Integral, Real):
+            # special case for Integral and Real since they are abstract classes
+            return 1
+
+        return constraint.type()
+
+    if isinstance(constraint, _Booleans):
+        return True
+
+    if isinstance(constraint, _VerboseHelper):
+        return 1
+
+    if isinstance(constraint, MissingValues) and constraint.numeric_only:
+        return np.nan
+
+    if isinstance(constraint, MissingValues) and not constraint.numeric_only:
+        return "missing"
+
+    if isinstance(constraint, HasMethods):
+        return type(
+            "ValidHasMethods", (), {m: lambda self: None for m in constraint.methods}
+        )()
+
+    if isinstance(constraint, _IterablesNotString):
+        return [1, 2, 3]
+
+    if isinstance(constraint, _CVObjects):
+        return 5
+
+    if isinstance(constraint, Options):  # includes StrOptions
+        for option in constraint.options:
+            return option
+
+    if isinstance(constraint, Interval):
+        interval = constraint
+        if interval.left is None and interval.right is None:
+            return 0
+        elif interval.left is None:
+            return interval.right - 1
+        elif interval.right is None:
+            return interval.left + 1
+        else:
+            if interval.type is Real:
+                return (interval.left + interval.right) / 2
+            else:
+                return interval.left + 1
+
+    raise ValueError(f"Unknown constraint type: {constraint}")

shared/package-files/1f/1f7c72d37dca932cd875eb3c732d17c01de6273fd30f8b38f85e236ed94cd2e3/pprint.py

@@ -0,0 +1,670 @@
+#  Author:      Fred L. Drake, Jr.
+#               fdrake@acm.org
+#
+#  This is a simple little module I wrote to make life easier.  I didn't
+#  see anything quite like it in the library, though I may have overlooked
+#  something.  I wrote this when I was trying to read some heavily nested
+#  tuples with fairly non-descriptive content.  This is modeled very much
+#  after Lisp/Scheme - style pretty-printing of lists.  If you find it
+#  useful, thank small children who sleep at night.
+
+"""Support to pretty-print lists, tuples, & dictionaries recursively.
+
+Very simple, but useful, especially in debugging data structures.
+
+Classes
+-------
+
+PrettyPrinter()
+    Handle pretty-printing operations onto a stream using a configured
+    set of formatting parameters.
+
+Functions
+---------
+
+pformat()
+    Format a Python object into a pretty-printed representation.
+
+pprint()
+    Pretty-print a Python object to a stream [default is sys.stdout].
+
+saferepr()
+    Generate a 'standard' repr()-like value, but protect against recursive
+    data structures.
+
+"""
+
+import collections as _collections
+import dataclasses as _dataclasses
+import re
+import sys as _sys
+import types as _types
+from io import StringIO as _StringIO
+
+__all__ = ["pprint","pformat","isreadable","isrecursive","saferepr",
+           "PrettyPrinter", "pp"]
+
+
+def pprint(object, stream=None, indent=1, width=80, depth=None, *,
+           compact=False, sort_dicts=True, underscore_numbers=False):
+    """Pretty-print a Python object to a stream [default is sys.stdout]."""
+    printer = PrettyPrinter(
+        stream=stream, indent=indent, width=width, depth=depth,
+        compact=compact, sort_dicts=sort_dicts,
+        underscore_numbers=underscore_numbers)
+    printer.pprint(object)
+
+def pformat(object, indent=1, width=80, depth=None, *,
+            compact=False, sort_dicts=True, underscore_numbers=False):
+    """Format a Python object into a pretty-printed representation."""
+    return PrettyPrinter(indent=indent, width=width, depth=depth,
+                         compact=compact, sort_dicts=sort_dicts,
+                         underscore_numbers=underscore_numbers).pformat(object)
+
+def pp(object, *args, sort_dicts=False, **kwargs):
+    """Pretty-print a Python object"""
+    pprint(object, *args, sort_dicts=sort_dicts, **kwargs)
+
+def saferepr(object):
+    """Version of repr() which can handle recursive data structures."""
+    return PrettyPrinter()._safe_repr(object, {}, None, 0)[0]
+
+def isreadable(object):
+    """Determine if saferepr(object) is readable by eval()."""
+    return PrettyPrinter()._safe_repr(object, {}, None, 0)[1]
+
+def isrecursive(object):
+    """Determine if object requires a recursive representation."""
+    return PrettyPrinter()._safe_repr(object, {}, None, 0)[2]
+
+class _safe_key:
+    """Helper function for key functions when sorting unorderable objects.
+
+    The wrapped-object will fallback to a Py2.x style comparison for
+    unorderable types (sorting first comparing the type name and then by
+    the obj ids).  Does not work recursively, so dict.items() must have
+    _safe_key applied to both the key and the value.
+
+    """
+
+    __slots__ = ['obj']
+
+    def __init__(self, obj):
+        self.obj = obj
+
+    def __lt__(self, other):
+        try:
+            return self.obj < other.obj
+        except TypeError:
+            return ((str(type(self.obj)), id(self.obj)) < \
+                    (str(type(other.obj)), id(other.obj)))
+
+def _safe_tuple(t):
+    "Helper function for comparing 2-tuples"
+    return _safe_key(t[0]), _safe_key(t[1])
+
+class PrettyPrinter:
+    def __init__(self, indent=1, width=80, depth=None, stream=None, *,
+                 compact=False, sort_dicts=True, underscore_numbers=False):
+        """Handle pretty printing operations onto a stream using a set of
+        configured parameters.
+
+        indent
+            Number of spaces to indent for each level of nesting.
+
+        width
+            Attempted maximum number of columns in the output.
+
+        depth
+            The maximum depth to print out nested structures.
+
+        stream
+            The desired output stream.  If omitted (or false), the standard
+            output stream available at construction will be used.
+
+        compact
+            If true, several items will be combined in one line.
+
+        sort_dicts
+            If true, dict keys are sorted.
+
+        """
+        indent = int(indent)
+        width = int(width)
+        if indent < 0:
+            raise ValueError('indent must be >= 0')
+        if depth is not None and depth <= 0:
+            raise ValueError('depth must be > 0')
+        if not width:
+            raise ValueError('width must be != 0')
+        self._depth = depth
+        self._indent_per_level = indent
+        self._width = width
+        if stream is not None:
+            self._stream = stream
+        else:
+            self._stream = _sys.stdout
+        self._compact = bool(compact)
+        self._sort_dicts = sort_dicts
+        self._underscore_numbers = underscore_numbers
+
+    def pprint(self, object):
+        self._format(object, self._stream, 0, 0, {}, 0)
+        self._stream.write("\n")
+
+    def pformat(self, object):
+        sio = _StringIO()
+        self._format(object, sio, 0, 0, {}, 0)
+        return sio.getvalue()
+
+    def isrecursive(self, object):
+        return self.format(object, {}, 0, 0)[2]
+
+    def isreadable(self, object):
+        s, readable, recursive = self.format(object, {}, 0, 0)
+        return readable and not recursive
+
+    def _format(self, object, stream, indent, allowance, context, level):
+        objid = id(object)
+        if objid in context:
+            stream.write(_recursion(object))
+            self._recursive = True
+            self._readable = False
+            return
+        rep = self._repr(object, context, level)
+        max_width = self._width - indent - allowance
+        if len(rep) > max_width:
+            p = self._dispatch.get(type(object).__repr__, None)
+            if p is not None:
+                context[objid] = 1
+                p(self, object, stream, indent, allowance, context, level + 1)
+                del context[objid]
+                return
+            elif (_dataclasses.is_dataclass(object) and
+                  not isinstance(object, type) and
+                  object.__dataclass_params__.repr and
+                  # Check dataclass has generated repr method.
+                  hasattr(object.__repr__, "__wrapped__") and
+                  "__create_fn__" in object.__repr__.__wrapped__.__qualname__):
+                context[objid] = 1
+                self._pprint_dataclass(object, stream, indent, allowance, context, level + 1)
+                del context[objid]
+                return
+        stream.write(rep)
+
+    def _pprint_dataclass(self, object, stream, indent, allowance, context, level):
+        cls_name = object.__class__.__name__
+        indent += len(cls_name) + 1
+        items = [(f.name, getattr(object, f.name)) for f in _dataclasses.fields(object) if f.repr]
+        stream.write(cls_name + '(')
+        self._format_namespace_items(items, stream, indent, allowance, context, level)
+        stream.write(')')
+
+    _dispatch = {}
+
+    def _pprint_dict(self, object, stream, indent, allowance, context, level):
+        write = stream.write
+        write('{')
+        if self._indent_per_level > 1:
+            write((self._indent_per_level - 1) * ' ')
+        length = len(object)
+        if length:
+            if self._sort_dicts:
+                items = sorted(object.items(), key=_safe_tuple)
+            else:
+                items = object.items()
+            self._format_dict_items(items, stream, indent, allowance + 1,
+                                    context, level)
+        write('}')
+
+    _dispatch[dict.__repr__] = _pprint_dict
+
+    def _pprint_ordered_dict(self, object, stream, indent, allowance, context, level):
+        if not len(object):
+            stream.write(repr(object))
+            return
+        cls = object.__class__
+        stream.write(cls.__name__ + '(')
+        self._format(list(object.items()), stream,
+                     indent + len(cls.__name__) + 1, allowance + 1,
+                     context, level)
+        stream.write(')')
+
+    _dispatch[_collections.OrderedDict.__repr__] = _pprint_ordered_dict
+
+    def _pprint_list(self, object, stream, indent, allowance, context, level):
+        stream.write('[')
+        self._format_items(object, stream, indent, allowance + 1,
+                           context, level)
+        stream.write(']')
+
+    _dispatch[list.__repr__] = _pprint_list
+
+    def _pprint_tuple(self, object, stream, indent, allowance, context, level):
+        stream.write('(')
+        endchar = ',)' if len(object) == 1 else ')'
+        self._format_items(object, stream, indent, allowance + len(endchar),
+                           context, level)
+        stream.write(endchar)
+
+    _dispatch[tuple.__repr__] = _pprint_tuple
+
+    def _pprint_set(self, object, stream, indent, allowance, context, level):
+        if not len(object):
+            stream.write(repr(object))
+            return
+        typ = object.__class__
+        if typ is set:
+            stream.write('{')
+            endchar = '}'
+        else:
+            stream.write(typ.__name__ + '({')
+            endchar = '})'
+            indent += len(typ.__name__) + 1
+        object = sorted(object, key=_safe_key)
+        self._format_items(object, stream, indent, allowance + len(endchar),
+                           context, level)
+        stream.write(endchar)
+
+    _dispatch[set.__repr__] = _pprint_set
+    _dispatch[frozenset.__repr__] = _pprint_set
+
+    def _pprint_str(self, object, stream, indent, allowance, context, level):
+        write = stream.write
+        if not len(object):
+            write(repr(object))
+            return
+        chunks = []
+        lines = object.splitlines(True)
+        if level == 1:
+            indent += 1
+            allowance += 1
+        max_width1 = max_width = self._width - indent
+        for i, line in enumerate(lines):
+            rep = repr(line)
+            if i == len(lines) - 1:
+                max_width1 -= allowance
+            if len(rep) <= max_width1:
+                chunks.append(rep)
+            else:
+                # A list of alternating (non-space, space) strings
+                parts = re.findall(r'\S*\s*', line)
+                assert parts
+                assert not parts[-1]
+                parts.pop()  # drop empty last part
+                max_width2 = max_width
+                current = ''
+                for j, part in enumerate(parts):
+                    candidate = current + part
+                    if j == len(parts) - 1 and i == len(lines) - 1:
+                        max_width2 -= allowance
+                    if len(repr(candidate)) > max_width2:
+                        if current:
+                            chunks.append(repr(current))
+                        current = part
+                    else:
+                        current = candidate
+                if current:
+                    chunks.append(repr(current))
+        if len(chunks) == 1:
+            write(rep)
+            return
+        if level == 1:
+            write('(')
+        for i, rep in enumerate(chunks):
+            if i > 0:
+                write('\n' + ' '*indent)
+            write(rep)
+        if level == 1:
+            write(')')
+
+    _dispatch[str.__repr__] = _pprint_str
+
+    def _pprint_bytes(self, object, stream, indent, allowance, context, level):
+        write = stream.write
+        if len(object) <= 4:
+            write(repr(object))
+            return
+        parens = level == 1
+        if parens:
+            indent += 1
+            allowance += 1
+            write('(')
+        delim = ''
+        for rep in _wrap_bytes_repr(object, self._width - indent, allowance):
+            write(delim)
+            write(rep)
+            if not delim:
+                delim = '\n' + ' '*indent
+        if parens:
+            write(')')
+
+    _dispatch[bytes.__repr__] = _pprint_bytes
+
+    def _pprint_bytearray(self, object, stream, indent, allowance, context, level):
+        write = stream.write
+        write('bytearray(')
+        self._pprint_bytes(bytes(object), stream, indent + 10,
+                           allowance + 1, context, level + 1)
+        write(')')
+
+    _dispatch[bytearray.__repr__] = _pprint_bytearray
+
+    def _pprint_mappingproxy(self, object, stream, indent, allowance, context, level):
+        stream.write('mappingproxy(')
+        self._format(object.copy(), stream, indent + 13, allowance + 1,
+                     context, level)
+        stream.write(')')
+
+    _dispatch[_types.MappingProxyType.__repr__] = _pprint_mappingproxy
+
+    def _pprint_simplenamespace(self, object, stream, indent, allowance, context, level):
+        if type(object) is _types.SimpleNamespace:
+            # The SimpleNamespace repr is "namespace" instead of the class
+            # name, so we do the same here. For subclasses; use the class name.
+            cls_name = 'namespace'
+        else:
+            cls_name = object.__class__.__name__
+        indent += len(cls_name) + 1
+        items = object.__dict__.items()
+        stream.write(cls_name + '(')
+        self._format_namespace_items(items, stream, indent, allowance, context, level)
+        stream.write(')')
+
+    _dispatch[_types.SimpleNamespace.__repr__] = _pprint_simplenamespace
+
+    def _format_dict_items(self, items, stream, indent, allowance, context,
+                           level):
+        write = stream.write
+        indent += self._indent_per_level
+        delimnl = ',\n' + ' ' * indent
+        last_index = len(items) - 1
+        for i, (key, ent) in enumerate(items):
+            last = i == last_index
+            rep = self._repr(key, context, level)
+            write(rep)
+            write(': ')
+            self._format(ent, stream, indent + len(rep) + 2,
+                         allowance if last else 1,
+                         context, level)
+            if not last:
+                write(delimnl)
+
+    def _format_namespace_items(self, items, stream, indent, allowance, context, level):
+        write = stream.write
+        delimnl = ',\n' + ' ' * indent
+        last_index = len(items) - 1
+        for i, (key, ent) in enumerate(items):
+            last = i == last_index
+            write(key)
+            write('=')
+            if id(ent) in context:
+                # Special-case representation of recursion to match standard
+                # recursive dataclass repr.
+                write("...")
+            else:
+                self._format(ent, stream, indent + len(key) + 1,
+                             allowance if last else 1,
+                             context, level)
+            if not last:
+                write(delimnl)
+
+    def _format_items(self, items, stream, indent, allowance, context, level):
+        write = stream.write
+        indent += self._indent_per_level
+        if self._indent_per_level > 1:
+            write((self._indent_per_level - 1) * ' ')
+        delimnl = ',\n' + ' ' * indent
+        delim = ''
+        width = max_width = self._width - indent + 1
+        it = iter(items)
+        try:
+            next_ent = next(it)
+        except StopIteration:
+            return
+        last = False
+        while not last:
+            ent = next_ent
+            try:
+                next_ent = next(it)
+            except StopIteration:
+                last = True
+                max_width -= allowance
+                width -= allowance
+            if self._compact:
+                rep = self._repr(ent, context, level)
+                w = len(rep) + 2
+                if width < w:
+                    width = max_width
+                    if delim:
+                        delim = delimnl
+                if width >= w:
+                    width -= w
+                    write(delim)
+                    delim = ', '
+                    write(rep)
+                    continue
+            write(delim)
+            delim = delimnl
+            self._format(ent, stream, indent,
+                         allowance if last else 1,
+                         context, level)
+
+    def _repr(self, object, context, level):
+        repr, readable, recursive = self.format(object, context.copy(),
+                                                self._depth, level)
+        if not readable:
+            self._readable = False
+        if recursive:
+            self._recursive = True
+        return repr
+
+    def format(self, object, context, maxlevels, level):
+        """Format object for a specific context, returning a string
+        and flags indicating whether the representation is 'readable'
+        and whether the object represents a recursive construct.
+        """
+        return self._safe_repr(object, context, maxlevels, level)
+
+    def _pprint_default_dict(self, object, stream, indent, allowance, context, level):
+        if not len(object):
+            stream.write(repr(object))
+            return
+        rdf = self._repr(object.default_factory, context, level)
+        cls = object.__class__
+        indent += len(cls.__name__) + 1
+        stream.write('%s(%s,\n%s' % (cls.__name__, rdf, ' ' * indent))
+        self._pprint_dict(object, stream, indent, allowance + 1, context, level)
+        stream.write(')')
+
+    _dispatch[_collections.defaultdict.__repr__] = _pprint_default_dict
+
+    def _pprint_counter(self, object, stream, indent, allowance, context, level):
+        if not len(object):
+            stream.write(repr(object))
+            return
+        cls = object.__class__
+        stream.write(cls.__name__ + '({')
+        if self._indent_per_level > 1:
+            stream.write((self._indent_per_level - 1) * ' ')
+        items = object.most_common()
+        self._format_dict_items(items, stream,
+                                indent + len(cls.__name__) + 1, allowance + 2,
+                                context, level)
+        stream.write('})')
+
+    _dispatch[_collections.Counter.__repr__] = _pprint_counter
+
+    def _pprint_chain_map(self, object, stream, indent, allowance, context, level):
+        if not len(object.maps):
+            stream.write(repr(object))
+            return
+        cls = object.__class__
+        stream.write(cls.__name__ + '(')
+        indent += len(cls.__name__) + 1
+        for i, m in enumerate(object.maps):
+            if i == len(object.maps) - 1:
+                self._format(m, stream, indent, allowance + 1, context, level)
+                stream.write(')')
+            else:
+                self._format(m, stream, indent, 1, context, level)
+                stream.write(',\n' + ' ' * indent)
+
+    _dispatch[_collections.ChainMap.__repr__] = _pprint_chain_map
+
+    def _pprint_deque(self, object, stream, indent, allowance, context, level):
+        if not len(object):
+            stream.write(repr(object))
+            return
+        cls = object.__class__
+        stream.write(cls.__name__ + '(')
+        indent += len(cls.__name__) + 1
+        stream.write('[')
+        if object.maxlen is None:
+            self._format_items(object, stream, indent, allowance + 2,
+                               context, level)
+            stream.write('])')
+        else:
+            self._format_items(object, stream, indent, 2,
+                               context, level)
+            rml = self._repr(object.maxlen, context, level)
+            stream.write('],\n%smaxlen=%s)' % (' ' * indent, rml))
+
+    _dispatch[_collections.deque.__repr__] = _pprint_deque
+
+    def _pprint_user_dict(self, object, stream, indent, allowance, context, level):
+        self._format(object.data, stream, indent, allowance, context, level - 1)
+
+    _dispatch[_collections.UserDict.__repr__] = _pprint_user_dict
+
+    def _pprint_user_list(self, object, stream, indent, allowance, context, level):
+        self._format(object.data, stream, indent, allowance, context, level - 1)
+
+    _dispatch[_collections.UserList.__repr__] = _pprint_user_list
+
+    def _pprint_user_string(self, object, stream, indent, allowance, context, level):
+        self._format(object.data, stream, indent, allowance, context, level - 1)
+
+    _dispatch[_collections.UserString.__repr__] = _pprint_user_string
+
+    def _safe_repr(self, object, context, maxlevels, level):
+        # Return triple (repr_string, isreadable, isrecursive).
+        typ = type(object)
+        if typ in _builtin_scalars:
+            return repr(object), True, False
+
+        r = getattr(typ, "__repr__", None)
+
+        if issubclass(typ, int) and r is int.__repr__:
+            if self._underscore_numbers:
+                return f"{object:_d}", True, False
+            else:
+                return repr(object), True, False
+
+        if issubclass(typ, dict) and r is dict.__repr__:
+            if not object:
+                return "{}", True, False
+            objid = id(object)
+            if maxlevels and level >= maxlevels:
+                return "{...}", False, objid in context
+            if objid in context:
+                return _recursion(object), False, True
+            context[objid] = 1
+            readable = True
+            recursive = False
+            components = []
+            append = components.append
+            level += 1
+            if self._sort_dicts:
+                items = sorted(object.items(), key=_safe_tuple)
+            else:
+                items = object.items()
+            for k, v in items:
+                krepr, kreadable, krecur = self.format(
+                    k, context, maxlevels, level)
+                vrepr, vreadable, vrecur = self.format(
+                    v, context, maxlevels, level)
+                append("%s: %s" % (krepr, vrepr))
+                readable = readable and kreadable and vreadable
+                if krecur or vrecur:
+                    recursive = True
+            del context[objid]
+            return "{%s}" % ", ".join(components), readable, recursive
+
+        if (issubclass(typ, list) and r is list.__repr__) or \
+           (issubclass(typ, tuple) and r is tuple.__repr__):
+            if issubclass(typ, list):
+                if not object:
+                    return "[]", True, False
+                format = "[%s]"
+            elif len(object) == 1:
+                format = "(%s,)"
+            else:
+                if not object:
+                    return "()", True, False
+                format = "(%s)"
+            objid = id(object)
+            if maxlevels and level >= maxlevels:
+                return format % "...", False, objid in context
+            if objid in context:
+                return _recursion(object), False, True
+            context[objid] = 1
+            readable = True
+            recursive = False
+            components = []
+            append = components.append
+            level += 1
+            for o in object:
+                orepr, oreadable, orecur = self.format(
+                    o, context, maxlevels, level)
+                append(orepr)
+                if not oreadable:
+                    readable = False
+                if orecur:
+                    recursive = True
+            del context[objid]
+            return format % ", ".join(components), readable, recursive
+
+        rep = repr(object)
+        return rep, (rep and not rep.startswith('<')), False
+
+_builtin_scalars = frozenset({str, bytes, bytearray, float, complex,
+                              bool, type(None)})
+
+def _recursion(object):
+    return ("<Recursion on %s with id=%s>"
+            % (type(object).__name__, id(object)))
+
+
+def _perfcheck(object=None):
+    import time
+    if object is None:
+        object = [("string", (1, 2), [3, 4], {5: 6, 7: 8})] * 100000
+    p = PrettyPrinter()
+    t1 = time.perf_counter()
+    p._safe_repr(object, {}, None, 0, True)
+    t2 = time.perf_counter()
+    p.pformat(object)
+    t3 = time.perf_counter()
+    print("_safe_repr:", t2 - t1)
+    print("pformat:", t3 - t2)
+
+def _wrap_bytes_repr(object, width, allowance):
+    current = b''
+    last = len(object) // 4 * 4
+    for i in range(0, len(object), 4):
+        part = object[i: i+4]
+        candidate = current + part
+        if i == last:
+            width -= allowance
+        if len(repr(candidate)) > width:
+            if current:
+                yield repr(current)
+            current = part
+        else:
+            current = candidate
+    if current:
+        yield repr(current)
+
+if __name__ == "__main__":
+    _perfcheck()

shared/package-files/1f/1f81141da40215c6463fb7f03ac38bd2f5cfd7dfb760881371a194e32c08c489/mps_convolution_backward_ops.h

@@ -0,0 +1,39 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Operator.h
+
+#include <tuple>
+#include <vector>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+namespace _ops {
+
+
+struct TORCH_API mps_convolution_backward {
+  using schema = ::std::tuple<at::Tensor,at::Tensor,at::Tensor> (const at::Tensor &, const at::Tensor &, const at::Tensor &, c10::SymIntArrayRef, c10::SymIntArrayRef, c10::SymIntArrayRef, c10::SymInt, ::std::array<bool,3>);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::mps_convolution_backward")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "mps_convolution_backward(Tensor self, Tensor grad_output, Tensor weight, SymInt[] padding, SymInt[] stride, SymInt[] dilation, SymInt groups, bool[3] output_mask) -> (Tensor, Tensor, Tensor)")
+  static ::std::tuple<at::Tensor,at::Tensor,at::Tensor> call(const at::Tensor & self, const at::Tensor & grad_output, const at::Tensor & weight, c10::SymIntArrayRef padding, c10::SymIntArrayRef stride, c10::SymIntArrayRef dilation, c10::SymInt groups, ::std::array<bool,3> output_mask);
+  static ::std::tuple<at::Tensor,at::Tensor,at::Tensor> redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Tensor & grad_output, const at::Tensor & weight, c10::SymIntArrayRef padding, c10::SymIntArrayRef stride, c10::SymIntArrayRef dilation, c10::SymInt groups, ::std::array<bool,3> output_mask);
+};
+
+struct TORCH_API mps_convolution_backward_out {
+  using schema = ::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> (const at::Tensor &, const at::Tensor &, const at::Tensor &, c10::SymIntArrayRef, c10::SymIntArrayRef, c10::SymIntArrayRef, c10::SymInt, ::std::array<bool,3>, at::Tensor &, at::Tensor &, at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::mps_convolution_backward")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "mps_convolution_backward.out(Tensor self, Tensor grad_output, Tensor weight, SymInt[] padding, SymInt[] stride, SymInt[] dilation, SymInt groups, bool[3] output_mask, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2) -> (Tensor(a!), Tensor(b!), Tensor(c!))")
+  static ::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> call(const at::Tensor & self, const at::Tensor & grad_output, const at::Tensor & weight, c10::SymIntArrayRef padding, c10::SymIntArrayRef stride, c10::SymIntArrayRef dilation, c10::SymInt groups, ::std::array<bool,3> output_mask, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2);
+  static ::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Tensor & grad_output, const at::Tensor & weight, c10::SymIntArrayRef padding, c10::SymIntArrayRef stride, c10::SymIntArrayRef dilation, c10::SymInt groups, ::std::array<bool,3> output_mask, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2);
+};
+
+}} // namespace at::_ops

shared/package-files/1f/1f8219810623ae657a2136fb89ec77178ab0052143c8f6ddadbd1ee195db90c6/_dsp.py

@@ -0,0 +1,433 @@
+import warnings
+from typing import List, Optional, Union
+
+import torch
+
+from torchaudio.functional import fftconvolve
+
+
+def oscillator_bank(
+    frequencies: torch.Tensor,
+    amplitudes: torch.Tensor,
+    sample_rate: float,
+    reduction: str = "sum",
+    dtype: Optional[torch.dtype] = torch.float64,
+) -> torch.Tensor:
+    """Synthesize waveform from the given instantaneous frequencies and amplitudes.
+
+    .. devices:: CPU CUDA
+
+    .. properties:: Autograd TorchScript
+
+    Note:
+        The phase information of the output waveform is found by taking the cumulative sum
+        of the given instantaneous frequencies (``frequencies``).
+        This incurs roundoff error when the data type does not have enough precision.
+        Using ``torch.float64`` can work around this.
+
+        The following figure shows the difference between ``torch.float32`` and
+        ``torch.float64`` when generating a sin wave of constant frequency and amplitude
+        with sample rate 8000 [Hz].
+        Notice that ``torch.float32`` version shows artifacts that are not seen in
+        ``torch.float64`` version.
+
+        .. image:: https://download.pytorch.org/torchaudio/doc-assets/oscillator_precision.png
+
+    Args:
+        frequencies (Tensor): Sample-wise oscillator frequencies (Hz). Shape `(..., time, N)`.
+        amplitudes (Tensor): Sample-wise oscillator amplitude. Shape: `(..., time, N)`.
+        sample_rate (float): Sample rate
+        reduction (str): Reduction to perform.
+            Valid values are ``"sum"``, ``"mean"`` or ``"none"``. Default: ``"sum"``
+        dtype (torch.dtype or None, optional): The data type on which cumulative sum operation is performed.
+            Default: ``torch.float64``. Pass ``None`` to disable the casting.
+
+    Returns:
+        Tensor:
+            The resulting waveform.
+
+            If ``reduction`` is ``"none"``, then the shape is
+            `(..., time, N)`, otherwise the shape is `(..., time)`.
+    """
+    if frequencies.shape != amplitudes.shape:
+        raise ValueError(
+            "The shapes of `frequencies` and `amplitudes` must match. "
+            f"Found: {frequencies.shape} and {amplitudes.shape} respectively."
+        )
+    reductions = ["sum", "mean", "none"]
+    if reduction not in reductions:
+        raise ValueError(f"The value of reduction must be either {reductions}. Found: {reduction}")
+
+    invalid = torch.abs(frequencies) >= sample_rate / 2
+    if torch.any(invalid):
+        warnings.warn(
+            "Some frequencies are above nyquist frequency. "
+            "Setting the corresponding amplitude to zero. "
+            "This might cause numerically unstable gradient."
+        )
+        amplitudes = torch.where(invalid, 0.0, amplitudes)
+
+    pi2 = 2.0 * torch.pi
+    freqs = frequencies * pi2 / sample_rate % pi2
+    phases = torch.cumsum(freqs, dim=-2, dtype=dtype)
+    if dtype is not None and freqs.dtype != dtype:
+        phases = phases.to(freqs.dtype)
+
+    waveform = amplitudes * torch.sin(phases)
+    if reduction == "sum":
+        return waveform.sum(-1)
+    if reduction == "mean":
+        return waveform.mean(-1)
+    return waveform
+
+
+def adsr_envelope(
+    num_frames: int,
+    *,
+    attack: float = 0.0,
+    hold: float = 0.0,
+    decay: float = 0.0,
+    sustain: float = 1.0,
+    release: float = 0.0,
+    n_decay: int = 2,
+    dtype: Optional[torch.dtype] = None,
+    device: Optional[torch.device] = None,
+):
+    """Generate ADSR Envelope
+
+    .. devices:: CPU CUDA
+
+    Args:
+        num_frames (int): The number of output frames.
+        attack (float, optional):
+            The relative *time* it takes to reach the maximum level from
+            the start. (Default: ``0.0``)
+        hold (float, optional):
+            The relative *time* the maximum level is held before
+            it starts to decay. (Default: ``0.0``)
+        decay (float, optional):
+            The relative *time* it takes to sustain from
+            the maximum level. (Default: ``0.0``)
+        sustain (float, optional): The relative *level* at which
+            the sound should sustain. (Default: ``1.0``)
+
+            .. Note::
+               The duration of sustain is derived as `1.0 - (The sum of attack, hold, decay and release)`.
+
+        release (float, optional): The relative *time* it takes for the sound level to
+            reach zero after the sustain. (Default: ``0.0``)
+        n_decay (int, optional): The degree of polynomial decay. Default: ``2``.
+        dtype (torch.dtype, optional): the desired data type of returned tensor.
+            Default: if ``None``, uses a global default
+            (see :py:func:`torch.set_default_tensor_type`).
+        device (torch.device, optional): the desired device of returned tensor.
+            Default: if ``None``, uses the current device for the default tensor type
+            (see :py:func:`torch.set_default_tensor_type`).
+            device will be the CPU for CPU tensor types and the current CUDA
+            device for CUDA tensor types.
+
+    Returns:
+        Tensor: ADSR Envelope. Shape: `(num_frames, )`
+
+    Example
+        .. image:: https://download.pytorch.org/torchaudio/doc-assets/adsr_examples.png
+
+    """
+    if not 0 <= attack <= 1:
+        raise ValueError(f"The value of `attack` must be within [0, 1]. Found: {attack}")
+    if not 0 <= decay <= 1:
+        raise ValueError(f"The value of `decay` must be within [0, 1]. Found: {decay}")
+    if not 0 <= sustain <= 1:
+        raise ValueError(f"The value of `sustain` must be within [0, 1]. Found: {sustain}")
+    if not 0 <= hold <= 1:
+        raise ValueError(f"The value of `hold` must be within [0, 1]. Found: {hold}")
+    if not 0 <= release <= 1:
+        raise ValueError(f"The value of `release` must be within [0, 1]. Found: {release}")
+    if attack + decay + release + hold > 1:
+        raise ValueError("The sum of `attack`, `hold`, `decay` and `release` must not exceed 1.")
+
+    nframes = num_frames - 1
+    num_a = int(nframes * attack)
+    num_h = int(nframes * hold)
+    num_d = int(nframes * decay)
+    num_r = int(nframes * release)
+
+    # Initialize with sustain
+    out = torch.full((num_frames,), float(sustain), device=device, dtype=dtype)
+
+    # attack
+    if num_a > 0:
+        torch.linspace(0.0, 1.0, num_a + 1, out=out[: num_a + 1])
+
+    # hold
+    if num_h > 0:
+        out[num_a : num_a + num_h + 1] = 1.0
+
+    # decay
+    if num_d > 0:
+        # Compute: sustain + (1.0 - sustain) * (linspace[1, 0] ** n_decay)
+        i = num_a + num_h
+        decay = out[i : i + num_d + 1]
+        torch.linspace(1.0, 0.0, num_d + 1, out=decay)
+        decay **= n_decay
+        decay *= 1.0 - sustain
+        decay += sustain
+
+    # sustain is handled by initialization
+
+    # release
+    if num_r > 0:
+        torch.linspace(sustain, 0, num_r + 1, out=out[-num_r - 1 :])
+
+    return out
+
+
+def extend_pitch(
+    base: torch.Tensor,
+    pattern: Union[int, List[float], torch.Tensor],
+):
+    """Extend the given time series values with multipliers of them.
+
+    .. devices:: CPU CUDA
+
+    .. properties:: Autograd TorchScript
+
+    Given a series of fundamental frequencies (pitch), this function appends
+    its harmonic overtones or inharmonic partials.
+
+    Args:
+        base (torch.Tensor):
+            Base time series, like fundamental frequencies (Hz). Shape: `(..., time, 1)`.
+        pattern (int, list of floats or torch.Tensor):
+            If ``int``, the number of pitch series after the operation.
+            `pattern - 1` tones are added, so that the resulting Tensor contains
+            up to `pattern`-th overtones of the given series.
+
+            If list of float or ``torch.Tensor``, it must be one dimensional,
+            representing the custom multiplier of the fundamental frequency.
+
+    Returns:
+        Tensor: Oscillator frequencies (Hz). Shape: `(..., time, num_tones)`.
+
+    Example
+        >>> # fundamental frequency
+        >>> f0 = torch.linspace(1, 5, 5).unsqueeze(-1)
+        >>> f0
+        tensor([[1.],
+                [2.],
+                [3.],
+                [4.],
+                [5.]])
+        >>> # Add harmonic overtones, up to 3rd.
+        >>> f = extend_pitch(f0, 3)
+        >>> f.shape
+        torch.Size([5, 3])
+        >>> f
+        tensor([[ 1.,  2.,  3.],
+                [ 2.,  4.,  6.],
+                [ 3.,  6.,  9.],
+                [ 4.,  8., 12.],
+                [ 5., 10., 15.]])
+        >>> # Add custom (inharmonic) partials.
+        >>> f = extend_pitch(f0, torch.tensor([1, 2.1, 3.3, 4.5]))
+        >>> f.shape
+        torch.Size([5, 4])
+        >>> f
+        tensor([[ 1.0000,  2.1000,  3.3000,  4.5000],
+                [ 2.0000,  4.2000,  6.6000,  9.0000],
+                [ 3.0000,  6.3000,  9.9000, 13.5000],
+                [ 4.0000,  8.4000, 13.2000, 18.0000],
+                [ 5.0000, 10.5000, 16.5000, 22.5000]])
+    """
+    if isinstance(pattern, torch.Tensor):
+        mult = pattern
+    elif isinstance(pattern, int):
+        mult = torch.linspace(1.0, float(pattern), pattern, device=base.device, dtype=base.dtype)
+    else:
+        mult = torch.tensor(pattern, dtype=base.dtype, device=base.device)
+    h_freq = base @ mult.unsqueeze(0)
+    return h_freq
+
+
+def sinc_impulse_response(cutoff: torch.Tensor, window_size: int = 513, high_pass: bool = False):
+    """Create windowed-sinc impulse response for given cutoff frequencies.
+
+    .. devices:: CPU CUDA
+
+    .. properties:: Autograd TorchScript
+
+    Args:
+        cutoff (Tensor): Cutoff frequencies for low-pass sinc filter.
+
+        window_size (int, optional): Size of the Hamming window to apply. Must be odd.
+        (Default: 513)
+
+        high_pass (bool, optional):
+            If ``True``, convert the resulting filter to high-pass.
+            Otherwise low-pass filter is returned. Default: ``False``.
+
+    Returns:
+        Tensor: A series of impulse responses. Shape: `(..., window_size)`.
+    """
+    if window_size % 2 == 0:
+        raise ValueError(f"`window_size` must be odd. Given: {window_size}")
+
+    half = window_size // 2
+    device, dtype = cutoff.device, cutoff.dtype
+    idx = torch.linspace(-half, half, window_size, device=device, dtype=dtype)
+
+    filt = torch.special.sinc(cutoff.unsqueeze(-1) * idx.unsqueeze(0))
+    filt = filt * torch.hamming_window(window_size, device=device, dtype=dtype, periodic=False).unsqueeze(0)
+    filt = filt / filt.sum(dim=-1, keepdim=True).abs()
+
+    # High pass IR is obtained by subtracting low_pass IR from delta function.
+    # https://courses.engr.illinois.edu/ece401/fa2020/slides/lec10.pdf
+    if high_pass:
+        filt = -filt
+        filt[..., half] = 1.0 + filt[..., half]
+    return filt
+
+
+def frequency_impulse_response(magnitudes):
+    """Create filter from desired frequency response
+
+    Args:
+        magnitudes: The desired frequency responses. Shape: `(..., num_fft_bins)`
+
+    Returns:
+        Tensor: Impulse response. Shape `(..., 2 * (num_fft_bins - 1))`
+    """
+    if magnitudes.min() < 0.0:
+        # Negative magnitude does not make sense but allowing so that autograd works
+        # around 0.
+        # Should we raise error?
+        warnings.warn("The input frequency response should not contain negative values.")
+    ir = torch.fft.fftshift(torch.fft.irfft(magnitudes), dim=-1)
+    device, dtype = magnitudes.device, magnitudes.dtype
+    window = torch.hann_window(ir.size(-1), periodic=False, device=device, dtype=dtype).expand_as(ir)
+    return ir * window
+
+
+def _overlap_and_add(waveform, stride):
+    num_frames, frame_size = waveform.shape[-2:]
+    numel = (num_frames - 1) * stride + frame_size
+    buffer = torch.zeros(waveform.shape[:-2] + (numel,), device=waveform.device, dtype=waveform.dtype)
+    for i in range(num_frames):
+        start = i * stride
+        end = start + frame_size
+        buffer[..., start:end] += waveform[..., i, :]
+    return buffer
+
+
+def filter_waveform(waveform: torch.Tensor, kernels: torch.Tensor, delay_compensation: int = -1):
+    """Applies filters along time axis of the given waveform.
+
+    This function applies the given filters along time axis in the following manner:
+
+    1. Split the given waveform into chunks. The number of chunks is equal to the number of given filters.
+    2. Filter each chunk with corresponding filter.
+    3. Place the filtered chunks at the original indices while adding up the overlapping parts.
+    4. Crop the resulting waveform so that delay introduced by the filter is removed and its length
+       matches that of the input waveform.
+
+    The following figure illustrates this.
+
+        .. image:: https://download.pytorch.org/torchaudio/doc-assets/filter_waveform.png
+
+    .. note::
+
+       If the number of filters is one, then the operation becomes stationary.
+       i.e. the same filtering is applied across the time axis.
+
+    Args:
+        waveform (Tensor): Shape `(..., time)`.
+        kernels (Tensor): Impulse responses.
+            Valid inputs are 2D tensor with shape `(num_filters, filter_length)` or
+            `(N+1)`-D tensor with shape `(..., num_filters, filter_length)`, where `N` is
+            the dimension of waveform.
+
+            In case of 2D input, the same set of filters is used across channels and batches.
+            Otherwise, different sets of filters are applied. In this case, the shape of
+            the first `N-1` dimensions of filters must match (or be broadcastable to) that of waveform.
+
+        delay_compensation (int): Control how the waveform is cropped after full convolution.
+            If the value is zero or positive, it is interpreted as the length of crop at the
+            beginning of the waveform. The value cannot be larger than the size of filter kernel.
+            Otherwise the initial crop is ``filter_size // 2``.
+            When cropping happens, the waveform is also cropped from the end so that the
+            length of the resulting waveform matches the input waveform.
+
+    Returns:
+        Tensor: `(..., time)`.
+    """
+    if kernels.ndim not in [2, waveform.ndim + 1]:
+        raise ValueError(
+            "`kernels` must be 2 or N+1 dimension where "
+            f"N is the dimension of waveform. Found: {kernels.ndim} (N={waveform.ndim})"
+        )
+
+    num_filters, filter_size = kernels.shape[-2:]
+    num_frames = waveform.size(-1)
+
+    if delay_compensation > filter_size:
+        raise ValueError(
+            "When `delay_compenstation` is provided, it cannot be larger than the size of filters."
+            f"Found: delay_compensation={delay_compensation}, filter_size={filter_size}"
+        )
+
+    # Transform waveform's time axis into (num_filters x chunk_length) with optional padding
+    chunk_length = num_frames // num_filters
+    if num_frames % num_filters > 0:
+        chunk_length += 1
+        num_pad = chunk_length * num_filters - num_frames
+        waveform = torch.nn.functional.pad(waveform, [0, num_pad], "constant", 0)
+    chunked = waveform.unfold(-1, chunk_length, chunk_length)
+    assert chunked.numel() >= waveform.numel()
+
+    # Broadcast kernels
+    if waveform.ndim + 1 > kernels.ndim:
+        expand_shape = waveform.shape[:-1] + kernels.shape
+        kernels = kernels.expand(expand_shape)
+
+    convolved = fftconvolve(chunked, kernels)
+    restored = _overlap_and_add(convolved, chunk_length)
+
+    # Trim in a way that the number of samples are same as input,
+    # and the filter delay is compensated
+    if delay_compensation >= 0:
+        start = delay_compensation
+    else:
+        start = filter_size // 2
+    num_crops = restored.size(-1) - num_frames
+    end = num_crops - start
+    result = restored[..., start:-end]
+    return result
+
+
+def exp_sigmoid(
+    input: torch.Tensor, exponent: float = 10.0, max_value: float = 2.0, threshold: float = 1e-7
+) -> torch.Tensor:
+    """Exponential Sigmoid pointwise nonlinearity.
+    Implements the equation:
+    ``max_value`` * sigmoid(``input``) ** (log(``exponent``)) + ``threshold``
+
+    The output has a range of [``threshold``, ``max_value``].
+    ``exponent`` controls the slope of the output.
+
+    .. devices:: CPU CUDA
+
+    Args:
+        input (Tensor): Input Tensor
+        exponent (float, optional): Exponent. Controls the slope of the output
+        max_value (float, optional): Maximum value of the output
+        threshold (float, optional): Minimum value of the output
+
+    Returns:
+        Tensor: Exponential Sigmoid output. Shape: same as input
+
+    """
+
+    return max_value * torch.pow(
+        torch.nn.functional.sigmoid(input),
+        torch.log(torch.tensor(exponent, device=input.device, dtype=input.dtype)),
+    ) + torch.tensor(threshold, device=input.device, dtype=input.dtype)

shared/package-files/1f/1f85f237c2e6c383416779bf50496d1caed3e590037377dba24d8ac0e2804e6f/mergesort.py

@@ -0,0 +1,126 @@
+"""
+The same algorithm as translated from numpy.
+See numpy/core/src/npysort/mergesort.c.src.
+The high-level numba code is adding a little overhead comparing to
+the pure-C implementation in numpy.
+"""
+import numpy as np
+from collections import namedtuple
+
+# Array size smaller than this will be sorted by insertion sort
+SMALL_MERGESORT = 20
+
+
+MergesortImplementation = namedtuple('MergesortImplementation', [
+    'run_mergesort',
+])
+
+
+def make_mergesort_impl(wrap, lt=None, is_argsort=False):
+    kwargs_lite = dict(no_cpython_wrapper=True, _nrt=False)
+
+    # The less than
+    if lt is None:
+        @wrap(**kwargs_lite)
+        def lt(a, b):
+            return a < b
+    else:
+        lt = wrap(**kwargs_lite)(lt)
+
+    if is_argsort:
+        @wrap(**kwargs_lite)
+        def lessthan(a, b, vals):
+            return lt(vals[a], vals[b])
+    else:
+        @wrap(**kwargs_lite)
+        def lessthan(a, b, vals):
+            return lt(a, b)
+
+    @wrap(**kwargs_lite)
+    def argmergesort_inner(arr, vals, ws):
+        """The actual mergesort function
+
+        Parameters
+        ----------
+        arr : array [read+write]
+            The values being sorted inplace.  For argsort, this is the
+            indices.
+        vals : array [readonly]
+            ``None`` for normal sort.  In argsort, this is the actual array values.
+        ws : array [write]
+            The workspace.  Must be of size ``arr.size // 2``
+        """
+        if arr.size > SMALL_MERGESORT:
+            # Merge sort
+            mid = arr.size // 2
+
+            argmergesort_inner(arr[:mid], vals, ws)
+            argmergesort_inner(arr[mid:], vals, ws)
+
+            # Copy left half into workspace so we don't overwrite it
+            for i in range(mid):
+                ws[i] = arr[i]
+
+            # Merge
+            left = ws[:mid]
+            right = arr[mid:]
+            out = arr
+
+            i = j = k = 0
+            while i < left.size and j < right.size:
+                if not lessthan(right[j], left[i], vals):
+                    out[k] = left[i]
+                    i += 1
+                else:
+                    out[k] = right[j]
+                    j += 1
+                k += 1
+
+            # Leftovers
+            while i < left.size:
+                out[k] = left[i]
+                i += 1
+                k += 1
+
+            while j < right.size:
+                out[k] = right[j]
+                j += 1
+                k += 1
+        else:
+            # Insertion sort
+            i = 1
+            while i < arr.size:
+                j = i
+                while j > 0 and lessthan(arr[j], arr[j - 1], vals):
+                    arr[j - 1], arr[j] = arr[j], arr[j - 1]
+                    j -= 1
+                i += 1
+
+    # The top-level entry points
+
+    @wrap(no_cpython_wrapper=True)
+    def mergesort(arr):
+        "Inplace"
+        ws = np.empty(arr.size // 2, dtype=arr.dtype)
+        argmergesort_inner(arr, None, ws)
+        return arr
+
+
+    @wrap(no_cpython_wrapper=True)
+    def argmergesort(arr):
+        "Out-of-place"
+        idxs = np.arange(arr.size)
+        ws = np.empty(arr.size // 2, dtype=idxs.dtype)
+        argmergesort_inner(idxs, arr, ws)
+        return idxs
+
+    return MergesortImplementation(
+        run_mergesort=(argmergesort if is_argsort else mergesort)
+        )
+
+
+def make_jit_mergesort(*args, **kwargs):
+    from numba import njit
+    # NOTE: wrap with njit to allow recursion
+    #       because @register_jitable => @overload doesn't support recursion
+    return make_mergesort_impl(njit, *args, **kwargs)

shared/package-files/1f/1f8619123a353e3e1824e9a27597baaf3b37bf872dd0b130c2d9cb8b1d060858/select_copy_compositeexplicitautogradnonfunctional_dispatch.h

@@ -0,0 +1,24 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace compositeexplicitautogradnonfunctional {
+
+TORCH_API at::Tensor select_copy(const at::Tensor & self, int64_t dim, int64_t index);
+TORCH_API at::Tensor select_copy_symint(const at::Tensor & self, int64_t dim, c10::SymInt index);
+
+} // namespace compositeexplicitautogradnonfunctional
+} // namespace at

shared/package-files/1f/1f8ae7ffab8be339418828bb6a492cec0af74998929c06e12ced655f51383398/special_erfinv_native.h

@@ -0,0 +1,22 @@
+#pragma once
+
+// @generated by torchgen/gen.py from NativeFunction.h
+
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+#include <c10/core/QScheme.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <tuple>
+#include <vector>
+
+
+namespace at {
+namespace native {
+TORCH_API at::Tensor special_erfinv(const at::Tensor & self);
+TORCH_API at::Tensor & special_erfinv_out(const at::Tensor & self, at::Tensor & out);
+} // namespace native
+} // namespace at

shared/package-files/1f/1f8c830a711f10c154138388320d452589fd72f8f909b411bf5cdea244dee906/template.pyi

@@ -0,0 +1,14 @@
+from typing import Any
+
+dot_re: Any
+
+def blankout(src: str, char: str) -> str: ...
+
+context_re: Any
+inline_re: Any
+block_re: Any
+endblock_re: Any
+plural_re: Any
+constant_re: Any
+
+def templatize(src: str, origin: str = ...) -> str: ...

shared/package-files/1f/1f924aedebc4c68ebe2b52c946ca31e1f5940451e0f18fee2077c47b4f645a66/tensor_split_compositeimplicitautograd_dispatch.h

@@ -0,0 +1,27 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace compositeimplicitautograd {
+
+TORCH_API ::std::vector<at::Tensor> tensor_split(const at::Tensor & self, int64_t sections, int64_t dim=0);
+TORCH_API ::std::vector<at::Tensor> tensor_split_symint(const at::Tensor & self, c10::SymInt sections, int64_t dim=0);
+TORCH_API ::std::vector<at::Tensor> tensor_split(const at::Tensor & self, at::IntArrayRef indices, int64_t dim=0);
+TORCH_API ::std::vector<at::Tensor> tensor_split_symint(const at::Tensor & self, c10::SymIntArrayRef indices, int64_t dim=0);
+TORCH_API ::std::vector<at::Tensor> tensor_split(const at::Tensor & self, const at::Tensor & tensor_indices_or_sections, int64_t dim=0);
+
+} // namespace compositeimplicitautograd
+} // namespace at

shared/package-files/1f/1f9398544b699e11b1ead37a04f2481b645857f1d901659a0c17580e3598fa91/DeviceArray.h

@@ -0,0 +1,28 @@
+#include <c10/core/Allocator.h>
+#include <c10/util/Exception.h>
+#include <cstddef>
+#include <cstdint>
+#include <type_traits>
+
+namespace c10 {
+
+template <typename T>
+class DeviceArray {
+ public:
+  DeviceArray(c10::Allocator& allocator, size_t size)
+      : data_ptr_(allocator.allocate(size * sizeof(T))) {
+    static_assert(std::is_trivial<T>::value, "T must be a trivial type");
+    TORCH_INTERNAL_ASSERT(
+        0 == (reinterpret_cast<intptr_t>(data_ptr_.get()) % alignof(T)),
+        "c10::DeviceArray: Allocated memory is not aligned for this data type");
+  }
+
+  T* get() {
+    return static_cast<T*>(data_ptr_.get());
+  }
+
+ private:
+  c10::DataPtr data_ptr_;
+};
+
+} // namespace c10

shared/package-files/1f/1f9aec5b2fb484ec217fb62d337825bba40eae08e6c85fbaaeebdb53e9b58859/replication_pad2d_native.h

@@ -0,0 +1,26 @@
+#pragma once
+
+// @generated by torchgen/gen.py from NativeFunction.h
+
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+#include <c10/core/QScheme.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <tuple>
+#include <vector>
+#include <ATen/ops/replication_pad2d_meta.h>
+
+namespace at {
+namespace native {
+struct TORCH_API structured_replication_pad2d_out_cpu : public at::meta::structured_replication_pad2d {
+void impl(const at::Tensor & self, at::ArrayRef<int64_t> padding, const at::Tensor & out);
+};
+struct TORCH_API structured_replication_pad2d_out_cuda : public at::meta::structured_replication_pad2d {
+void impl(const at::Tensor & self, at::ArrayRef<int64_t> padding, const at::Tensor & out);
+};
+} // namespace native
+} // namespace at