lifelines 0.27.8__tar.gz → 0.29.0__tar.gz

{lifelines-0.27.8/lifelines.egg-info → lifelines-0.29.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lifelines
-Version: 0.27.8
+Version: 0.29.0
 Summary: Survival analysis in Python, including Kaplan Meier, Nelson Aalen and regression
 Home-page: https://github.com/CamDavidsonPilon/lifelines
 Author: Cameron Davidson-Pilon
@@ -9,15 +9,20 @@ License: MIT
 Classifier: Development Status :: 4 - Beta
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Topic :: Scientific/Engineering
-Requires-Python: >=3.7
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: numpy<2.0,>=1.14.0
+Requires-Dist: scipy>=1.7.0
+Requires-Dist: pandas>=2.1
+Requires-Dist: matplotlib>=3.0
+Requires-Dist: autograd>=1.5
+Requires-Dist: autograd-gamma>=0.3
+Requires-Dist: formulaic>=0.2.2
 
 ![](http://i.imgur.com/EOowdSD.png)
 
@@ -45,8 +50,8 @@ If you are new to survival analysis, wondering why it is useful, or are interest
 
 ## Contact
  - Start a conversation in our [Discussions room](https://github.com/CamDavidsonPilon/lifelines/discussions).
- - Some users have posted common questions at [stats.stackexchange.com](https://stats.stackexchange.com/search?tab=votes&q=%22lifelines%22%20is%3aquestion)
- - creating an issue in the [Github repository](https://github.com/camdavidsonpilon/lifelines).
+ - Some users have posted common questions at [stats.stackexchange.com](https://stats.stackexchange.com/search?tab=votes&q=%22lifelines%22%20is%3aquestion).
+ - Creating an issue in the [Github repository](https://github.com/camdavidsonpilon/lifelines).
 
 ## Development
 

{lifelines-0.27.8 → lifelines-0.29.0}/README.md

@@ -24,8 +24,8 @@ If you are new to survival analysis, wondering why it is useful, or are interest
 
 ## Contact
  - Start a conversation in our [Discussions room](https://github.com/CamDavidsonPilon/lifelines/discussions).
- - Some users have posted common questions at [stats.stackexchange.com](https://stats.stackexchange.com/search?tab=votes&q=%22lifelines%22%20is%3aquestion)
- - creating an issue in the [Github repository](https://github.com/camdavidsonpilon/lifelines).
+ - Some users have posted common questions at [stats.stackexchange.com](https://stats.stackexchange.com/search?tab=votes&q=%22lifelines%22%20is%3aquestion).
+ - Creating an issue in the [Github repository](https://github.com/camdavidsonpilon/lifelines).
 
 ## Development
 

{lifelines-0.27.8 → lifelines-0.29.0}/lifelines/datasets/__init__.py

@@ -54,7 +54,7 @@ def load_multicenter_aids_cohort_study(**kwargs):
     """
     Originally in [1]::
 
-        Siz: (78, 4)
+        Size: (78, 4)
 
         AIDSY: date of AIDS diagnosis
         W: years from AIDS diagnosis to study entry

{lifelines-0.27.8 → lifelines-0.29.0}/lifelines/exceptions.py

@@ -5,6 +5,10 @@ class StatError(Exception):
     pass
 
 
+class ProportionalHazardAssumptionError(Exception):
+    pass
+
+
 class ConvergenceError(ValueError):
     # inherits from ValueError for backwards compatibility reasons
     def __init__(self, msg, original_exception=""):

{lifelines-0.27.8 → lifelines-0.29.0}/lifelines/fitters/__init__.py

@@ -18,7 +18,7 @@ from autograd.misc import flatten
 import autograd.numpy as anp
 
 from scipy.optimize import minimize, root_scalar
-from scipy.integrate import trapz
+from scipy.integrate import trapezoid
 from scipy import stats
 
 import pandas as pd
@@ -550,7 +550,7 @@ class ParametricUnivariateFitter(UnivariateFitter):
             minimizing_results, previous_results, minimizing_ll = None, None, np.inf
             for method, option in zip(
                 ["Nelder-Mead", self._scipy_fit_method],
-                [{"maxiter": 100}, {**{"disp": show_progress}, **self._scipy_fit_options, **fit_options}],
+                [{"maxiter": 400}, {**{"disp": show_progress}, **self._scipy_fit_options, **fit_options}],
             ):
 
                 initial_value = self._initial_values if previous_results is None else utils._to_1d_array(previous_results.x)
@@ -573,7 +573,7 @@ class ParametricUnivariateFitter(UnivariateFitter):
 
             # convergence successful.
             # I still need to check for ~np.isnan(minimizing_results.x).any() since minimize will happily
-            # return nans even when criteria is satisified.
+            # return nans even when criteria is satisfied.
             if minimizing_results and minimizing_results.success and ~np.isnan(minimizing_results.x).any():
                 sol = utils._to_1d_array(minimizing_results.x)
                 # pylint: disable=no-value-for-parameter
@@ -876,7 +876,7 @@ class ParametricUnivariateFitter(UnivariateFitter):
           length n, the end of the period the subject experienced the event in. If the value is equal to the corresponding value in lower_bound, then
           the individual's event was observed (not censored).
         event_observed: numpy array or pd.Series, optional
-          length n, if left optional, infer from ``lower_bound`` and ``upper_cound`` (if lower_bound==upper_bound then event observed, if lower_bound < upper_bound, then event censored)
+          length n, if left optional, infer from ``lower_bound`` and ``upper_bound`` (if lower_bound==upper_bound then event observed, if lower_bound < upper_bound, then event censored)
         timeline: list, optional
             return the estimate at the values in timeline (positively increasing)
         label: string, optional
@@ -1409,7 +1409,7 @@ class ParametricRegressionFitter(RegressionFitter):
     def _survival_function(self, params, T, Xs):
         return anp.clip(anp.exp(-self._cumulative_hazard(params, T, Xs)), 1e-12, 1 - 1e-12)
 
-    def _log_likelihood_right_censoring(self, params, Ts, E, W, entries, Xs) -> float:
+    def _log_likelihood_right_censoring(self, params, Ts: tuple, E, W, entries, Xs) -> float:
 
         T = Ts[0]
         non_zero_entries = entries > 0
@@ -1925,7 +1925,7 @@ class ParametricRegressionFitter(RegressionFitter):
     def _fit_model(
         self, likelihood, Ts, Xs, E, weights, entries, fit_options, show_progress=False, user_supplied_initial_point=None
     ):
-        inital_points_as_arrays, unflatten_array_to_dict = self._prepare_initial_points(
+        initial_points_as_arrays, unflatten_array_to_dict = self._prepare_initial_points(
             user_supplied_initial_point, Ts, E, entries, weights, Xs
         )
 
@@ -1939,7 +1939,7 @@ class ParametricRegressionFitter(RegressionFitter):
 
         minimum_ll = np.inf
         minimum_results = None
-        for _initial_point in inital_points_as_arrays:
+        for _initial_point in initial_points_as_arrays:
 
             if _initial_point.shape[0] != Xs.columns.size:
                 raise ValueError("initial_point is not the correct shape.")
@@ -2507,7 +2507,7 @@ class ParametricRegressionFitter(RegressionFitter):
         warnings.warn("""Approximating the expected value using trapezoid rule.\n""", exceptions.ApproximationWarning)
         subjects = utils._get_index(X)
         v = self.predict_survival_function(X, conditional_after=conditional_after)[subjects]
-        return pd.Series(trapz(v.values.T, v.index), index=subjects).squeeze()
+        return pd.Series(trapezoid(v.values.T, v.index), index=subjects).squeeze()
 
     @property
     def median_survival_time_(self):
@@ -3365,6 +3365,8 @@ class ParametericAFTRegressionFitter(ParametricRegressionFitter):
             also display the baseline survival, defined as the survival at the mean of the original dataset.
         times: iterable
             pass in a times to plot
+        y: str
+            one of "survival_function", "hazard", "cumulative_hazard". Default "survival_function"
         kwargs:
             pass in additional plotting commands
 

{lifelines-0.27.8 → lifelines-0.29.0}/lifelines/fitters/aalen_additive_fitter.py

@@ -6,7 +6,7 @@ import time
 import numpy as np
 import pandas as pd
 from numpy.linalg import LinAlgError
-from scipy.integrate import trapz
+from scipy.integrate import trapezoid
 
 from lifelines.fitters import RegressionFitter
 from lifelines.utils.printer import Printer
@@ -396,7 +396,7 @@ It's important to know that the naive variance estimates of the coefficients are
         """
         index = _get_index(X)
         t = self._index
-        return pd.Series(trapz(self.predict_survival_function(X)[index].values.T, t), index=index)
+        return pd.Series(trapezoid(self.predict_survival_function(X)[index].values.T, t), index=index)
 
     def _compute_confidence_intervals(self):
         ci = 100 * (1 - self.alpha)

{lifelines-0.27.8 → lifelines-0.29.0}/lifelines/fitters/breslow_fleming_harrington_fitter.py

@@ -72,7 +72,14 @@ class BreslowFlemingHarringtonFitter(NonParametricUnivariateFitter):
         alpha = coalesce(alpha, self.alpha)
 
         naf = NelsonAalenFitter(alpha=alpha)
-        naf.fit(durations, event_observed=event_observed, timeline=timeline, label=self._label, entry=entry, ci_labels=ci_labels)
+        naf.fit(
+            durations,
+            event_observed=event_observed,
+            timeline=timeline,
+            label=self._label,
+            entry=entry,
+            ci_labels=ci_labels,
+        )
         self.durations, self.event_observed, self.timeline, self.entry, self.event_table, self.weights = (
             naf.durations,
             naf.event_observed,
@@ -87,6 +94,7 @@ class BreslowFlemingHarringtonFitter(NonParametricUnivariateFitter):
         self.confidence_interval_ = np.exp(-naf.confidence_interval_)
         self.confidence_interval_survival_function_ = self.confidence_interval_
         self.confidence_interval_cumulative_density = 1 - self.confidence_interval_
+        self.confidence_interval_cumulative_density[:] = np.fliplr(self.confidence_interval_cumulative_density.values)
 
         # estimation methods
         self._estimation_method = "survival_function_"

{lifelines-0.27.8 → lifelines-0.29.0}/lifelines/fitters/cox_time_varying_fitter.py

@@ -801,7 +801,7 @@ See https://stats.stackexchange.com/questions/11109/how-to-deal-with-perfect-sep
             hazards = self.predict_partial_hazard(tv_data).values
 
         unique_death_times = np.unique(stop[events.values])
-        baseline_hazard_ = pd.DataFrame(np.zeros_like(unique_death_times), index=unique_death_times, columns=["baseline hazard"])
+        baseline_hazard_ = pd.DataFrame(np.zeros_like(unique_death_times).astype(float), index=unique_death_times, columns=["baseline hazard"])
 
         for t in unique_death_times:
             ix = (start.values < t) & (t <= stop.values)

{lifelines-0.27.8 → lifelines-0.29.0}/lifelines/fitters/coxph_fitter.py

@@ -9,7 +9,7 @@ import time
 from numpy import dot, einsum, log, exp, zeros, arange, multiply, ndarray
 import numpy as np
 from scipy.linalg import solve as spsolve, LinAlgError, norm, inv
-from scipy.integrate import trapz
+from scipy.integrate import trapezoid
 from scipy import stats
 from pandas import DataFrame, Series, Index
 import pandas as pd
@@ -80,7 +80,7 @@ class CoxPHFitter(RegressionFitter, ProportionalHazardMixin):
         When ``baseline_estimation_method="spline"``, this allows customizing the points in the time axis for the baseline hazard curve.
         To use evenly-spaced points in time, the ``n_baseline_knots`` parameter can be employed instead.
 
-      breakpoints: int
+      breakpoints: list, optional
         Used when ``baseline_estimation_method="piecewise"``. Set the positions of the baseline hazard breakpoints.
 
     Examples
@@ -2514,7 +2514,7 @@ See https://stats.stackexchange.com/q/11109/11867 for more.\n",
         """
         subjects = utils._get_index(X)
         v = self.predict_survival_function(X, conditional_after=conditional_after)[subjects]
-        return pd.Series(trapz(v.values.T, v.index), index=subjects)
+        return pd.Series(trapezoid(v.values.T, v.index), index=subjects)
 
     def _compute_baseline_hazard(self, partial_hazards: DataFrame, name: Any) -> pd.DataFrame:
         # https://stats.stackexchange.com/questions/46532/cox-baseline-hazard
@@ -3223,7 +3223,7 @@ class ParametricPiecewiseBaselinePHFitter(ParametricCoxModelFitter, Proportional
 
             for stratum, stratified_X in df.groupby(self.strata):
                 log_lambdas_ = anp.array(
-                    [0] + [self.params_[self._strata_labeler(stratum, i)][0] for i in range(2, self.n_breakpoints + 2)]
+                    [0] + [self.params_.loc[self._strata_labeler(stratum, i)].iloc[0] for i in range(2, self.n_breakpoints + 2)]
                 )
                 lambdas_ = np.exp(log_lambdas_)
 
@@ -3237,7 +3237,9 @@ class ParametricPiecewiseBaselinePHFitter(ParametricCoxModelFitter, Proportional
             return cumulative_hazard
 
         else:
-            log_lambdas_ = np.array([0] + [self.params_[param][0] for param in self._fitted_parameter_names if param != "beta_"])
+            log_lambdas_ = np.array(
+                [0] + [self.params_.loc[param].iloc[0] for param in self._fitted_parameter_names if param != "beta_"]
+            )
             lambdas_ = np.exp(log_lambdas_)
 
             Xs = self.regressors.transform_df(df)

{lifelines-0.27.8 → lifelines-0.29.0}/lifelines/fitters/generalized_gamma_fitter.py

@@ -105,6 +105,7 @@ class GeneralizedGammaFitter(KnownModelParametricUnivariateFitter):
     """
 
     _scipy_fit_method = "SLSQP"
+    _scipy_fit_options = {"maxiter": 10_000, "maxfev": 10_000}
     _fitted_parameter_names = ["mu_", "ln_sigma_", "lambda_"]
     _bounds = [(None, None), (None, None), (None, None)]
     _compare_to_values = np.array([0.0, 0.0, 1.0])
@@ -117,14 +118,14 @@ class GeneralizedGammaFitter(KnownModelParametricUnivariateFitter):
         elif CensoringType.is_interval_censoring(self):
             # this fails if Ts[1] == Ts[0], so we add a some fudge factors.
             log_data = log(Ts[1] - Ts[0] + 0.1)
-        return np.array([log_data.mean(), log(log_data.std() + 0.01), 0.1])
+        return np.array([log_data.mean() * 1.5, log(log_data.std() + 0.1), 1.0])
 
     def _cumulative_hazard(self, params, times):
         mu_, ln_sigma_, lambda_ = params
 
         sigma_ = safe_exp(ln_sigma_)
         Z = (log(times) - mu_) / sigma_
-        ilambda_2 = 1 / lambda_ ** 2
+        ilambda_2 = 1 / lambda_**2
         clipped_exp = np.clip(safe_exp(lambda_ * Z) * ilambda_2, 1e-300, 1e20)
 
         if lambda_ > 0:
@@ -137,7 +138,7 @@ class GeneralizedGammaFitter(KnownModelParametricUnivariateFitter):
 
     def _log_hazard(self, params, times):
         mu_, ln_sigma_, lambda_ = params
-        ilambda_2 = 1 / lambda_ ** 2
+        ilambda_2 = 1 / lambda_**2
         Z = (log(times) - mu_) / safe_exp(ln_sigma_)
         clipped_exp = np.clip(safe_exp(lambda_ * Z) * ilambda_2, 1e-300, 1e20)
         if lambda_ > 0:
@@ -171,5 +172,5 @@ class GeneralizedGammaFitter(KnownModelParametricUnivariateFitter):
         sigma_ = exp(self.ln_sigma_)
 
         if lambda_ > 0:
-            return exp(sigma_ * log(gammainccinv(1 / lambda_ ** 2, p) * lambda_ ** 2) / lambda_) * exp(self.mu_)
-        return exp(sigma_ * log(gammaincinv(1 / lambda_ ** 2, p) * lambda_ ** 2) / lambda_) * exp(self.mu_)
+            return exp(sigma_ * log(gammainccinv(1 / lambda_**2, p) * lambda_**2) / lambda_) * exp(self.mu_)
+        return exp(sigma_ * log(gammaincinv(1 / lambda_**2, p) * lambda_**2) / lambda_) * exp(self.mu_)

{lifelines-0.27.8 → lifelines-0.29.0}/lifelines/fitters/kaplan_meier_fitter.py

@@ -351,9 +351,14 @@ class KaplanMeierFitter(NonParametricUnivariateFitter):
         primary_estimate_name = "survival_function_"
         secondary_estimate_name = "cumulative_density_"
 
-        (self.durations, self.event_observed, self.timeline, self.entry, self.event_table, self.weights) = _preprocess_inputs(
-            durations, event_observed, timeline, entry, weights
-        )
+        (
+            self.durations,
+            self.event_observed,
+            self.timeline,
+            self.entry,
+            self.event_table,
+            self.weights,
+        ) = _preprocess_inputs(durations, event_observed, timeline, entry, weights)
 
         alpha = alpha if alpha else self.alpha
         log_estimate, cumulative_sq_ = _additive_estimate(
@@ -386,6 +391,7 @@ class KaplanMeierFitter(NonParametricUnivariateFitter):
 
         self.confidence_interval_survival_function_ = self.confidence_interval_
         self.confidence_interval_cumulative_density_ = 1 - self.confidence_interval_
+        self.confidence_interval_cumulative_density_[:] = np.fliplr(self.confidence_interval_cumulative_density_.values)
         self._median = median_survival_times(self.survival_function_)
         self._cumulative_sq_ = cumulative_sq_
 

{lifelines-0.27.8 → lifelines-0.29.0}/lifelines/fitters/mixins.py

@@ -4,6 +4,7 @@ from textwrap import dedent, fill
 from autograd import numpy as anp
 import numpy as np
 from pandas import DataFrame, Series
+from lifelines.exceptions import ProportionalHazardAssumptionError
 from lifelines.statistics import proportional_hazard_test, TimeTransformers
 from lifelines.utils import format_p_value
 from lifelines.utils.lowess import lowess
@@ -28,6 +29,7 @@ class ProportionalHazardMixin:
         p_value_threshold: float = 0.01,
         plot_n_bootstraps: int = 15,
         columns: Optional[List[str]] = None,
+        raise_on_fail: bool = False,
     ) -> None:
         """
         Use this function to test the proportional hazards assumption. See usage example at
@@ -51,6 +53,8 @@ class ProportionalHazardMixin:
             the function significantly.
         columns: list, optional
             specify a subset of columns to test.
+        raise_on_fail: bool, optional
+            throw a ``ProportionalHazardAssumptionError`` if the test fails. Default: False.
 
         Returns
         --------
@@ -106,8 +110,8 @@ class ProportionalHazardMixin:
         axes = []
 
         for variable in self.params_.index.intersection(columns or self.params_.index):
-            minumum_observed_p_value = test_results.summary.loc[variable, "p"].min()
-            
+            minimum_observed_p_value = test_results.summary.loc[variable, "p"].min()
+
             # plot is done (regardless of test result) whenever `show_plots = True`
             if show_plots:
                 axes.append([])
@@ -150,7 +154,7 @@ class ProportionalHazardMixin:
                 plt.tight_layout()
                 plt.subplots_adjust(top=0.90)
 
-            if np.round(minumum_observed_p_value, 2) > p_value_threshold:
+            if np.round(minimum_observed_p_value, 2) > p_value_threshold:
                 continue
 
             counter += 1
@@ -178,7 +182,7 @@ class ProportionalHazardMixin:
             print()
             print(
                 "%d. Variable '%s' failed the non-proportional test: p-value is %s."
-                % (counter, variable, format_p_value(4)(minumum_observed_p_value)),
+                % (counter, variable, format_p_value(4)(minimum_observed_p_value)),
                 end="\n\n",
             )
 
@@ -224,9 +228,8 @@ class ProportionalHazardMixin:
                         ),
                         end="\n\n",
                     )
-#################
+        #################
 
-            
         if advice and counter > 0:
             print(
                 dedent(
@@ -243,6 +246,8 @@ class ProportionalHazardMixin:
 
         if counter == 0:
             print("Proportional hazard assumption looks okay.")
+        elif raise_on_fail:
+            raise ProportionalHazardAssumptionError()
         return axes
 
     @property

{lifelines-0.27.8 → lifelines-0.29.0}/lifelines/fitters/nelson_aalen_fitter.py

@@ -183,7 +183,7 @@ class NelsonAalenFitter(UnivariateFitter):
         )
 
     def _variance_f_discrete(self, population, deaths):
-        return (population - deaths) * deaths / population ** 3
+        return (1 - deaths / population) * (deaths / population) * (1.0 / population)
 
     def _additive_f_smooth(self, population, deaths):
         cum_ = np.cumsum(1.0 / np.arange(1, np.max(population) + 1))
@@ -200,7 +200,7 @@ class NelsonAalenFitter(UnivariateFitter):
         Parameters
         -----------
         bandwidth: float
-            the bandwith used in the Epanechnikov kernel.
+            the bandwidth used in the Epanechnikov kernel.
 
         Returns
         -------
@@ -239,7 +239,7 @@ class NelsonAalenFitter(UnivariateFitter):
         C = var_hazard_.values != 0.0  # only consider the points with jumps
         std_hazard_ = np.sqrt(
             1.0
-            / (bandwidth ** 2)
+            / (bandwidth**2)
             * np.dot(epanechnikov_kernel(timeline[:, None], timeline[C][None, :], bandwidth) ** 2, var_hazard_.values[C])
         )
         values = {

{lifelines-0.27.8 → lifelines-0.29.0}/lifelines/fitters/npmle.py

@@ -291,7 +291,7 @@ def reconstruct_survival_function(
 
     # First backfill at events between known observations
     # Second fill all events _outside_ known obs with running_sum
-    return full_dataframe.combine_first(df).bfill().fillna(running_sum).clip(lower=0.0)
+    return full_dataframe.combine_first(df).astype(float).bfill().fillna(running_sum).clip(lower=0.0)
 
 
 def npmle_compute_confidence_intervals(left, right, mle_, alpha=0.05, samples=1000):

{lifelines-0.27.8 → lifelines-0.29.0}/lifelines/fitters/piecewise_exponential_regression_fitter.py

@@ -66,7 +66,7 @@ class PiecewiseExponentialRegressionFitter(ParametricRegressionFitter):
         coef_penalty = 0
         if self.penalizer > 0:
             for i in range(params_stacked.shape[1]):
-                if not self._cols_to_not_penalize[i]:
+                if not self._cols_to_not_penalize.iloc[i]:
                     coef_penalty = coef_penalty + (params_stacked[:, i]).var()
 
         return neg_ll + self.penalizer * coef_penalty

{lifelines-0.27.8 → lifelines-0.29.0}/lifelines/generate_datasets.py

@@ -5,7 +5,7 @@ import pandas as pd
 
 from scipy import stats
 from scipy.optimize import newton
-from scipy.integrate import cumtrapz
+from scipy.integrate import cumulative_trapezoid
 
 random = np.random
 
@@ -172,7 +172,7 @@ def constant_coefficients(d, timelines, constant=True, independent=0):
     timelines: the observational times
     constant: True for constant coefficients
     independent: the number of coffients to set to 0 (covariate is ind of survival), or
-      a list of covariates to make indepent.
+      a list of covariates to make independent.
 
     returns a matrix (t,d+1) of coefficients
     """
@@ -187,7 +187,7 @@ def time_varying_coefficients(d, timelines, constant=False, independent=0, randg
     timelines: the observational times
     constant: True for constant coefficients
     independent: the number of coffients to set to 0 (covariate is ind of survival), or
-      a list of covariates to make indepent.
+      a list of covariates to make independent.
     randgen: how scalar coefficients (betas) are sampled.
 
     returns a matrix (t,d+1) of coefficients
@@ -221,7 +221,7 @@ def generate_hazard_rates(n, d, timelines, constant=False, independent=0, n_bina
       n: the number of instances
       d: the number of covariates
       lifelines: the observational times
-      constant: make the coeffients constant (not time dependent)
+      constant: make the coefficients constant (not time dependent)
       n_binary: the number of binary covariates
       model: from ["aalen", "cox"]
 
@@ -253,7 +253,7 @@ def generate_random_lifetimes(hazard_rates, timelines, size=1, censor=None):
       timelines: (t,) the observation times
       size: the number to return, per hardard rate
       censor: If True, adds uniform censoring between timelines.max() and  0
-              If a postive number, censors all events above that value.
+              If a positive number, censors all events above that value.
               If (n,) np.array >=0 , censor elementwise.
 
 
@@ -308,7 +308,7 @@ def cumulative_integral(fx, x):
     fx: (n,d) numpy array, what you want to integral of
     x: (n,) numpy array, location to integrate over.
     """
-    return cumtrapz(fx.T, x, initial=0).T
+    return cumulative_trapezoid(fx.T, x, initial=0).T
 
 
 def construct_survival_curves(hazard_rates, timelines):