rangekeeper 0.1.0__py3-none-any.whl

rangekeeper/dynamics/market.py

@@ -0,0 +1,328 @@
+from __future__ import annotations
+import os
+
+from typing import Generator
+import copy
+
+import numpy as np
+import pandas as pd
+from numba import jit
+import multiprocess
+
+import rangekeeper as rk
+
+
+class Market:
+    def __init__(
+            self,
+            sequence: pd.PeriodIndex,
+            trend: rk.dynamics.trend.Trend,
+            volatility: rk.dynamics.volatility.Volatility,
+            cyclicality: rk.dynamics.cyclicality.Cyclicality,
+            noise: rk.dynamics.noise.Noise,
+            black_swan: rk.dynamics.black_swan.BlackSwan):
+        """
+
+        """
+        self.sequence = sequence
+        self._sequence = rk.periodicity.offset_periodindex(
+            index=self.sequence,
+            offset_end=-1)
+
+        self.trend = trend
+        self.volatility = volatility
+        self.cyclicality = cyclicality
+
+        self.space_market = rk.flux.Flow(
+            movements=(
+                        self.cyclicality.space_waveform.movements * self.volatility.movements),
+            name='Space Market')
+
+        self.asset_market = rk.flux.Flow(
+            movements=self.trend.cap_rate - self.cyclicality.asset_waveform.movements,
+            name='Asset Market')
+        """
+        Negative of actual cap rate cycle. 
+        This makes this cycle directly reflect the asset pricing, as prices 
+        are an inverse function of the cap rate. By taking the negative of the 
+        actual cap rate, we therefore make it easier to envision the effect 
+        on prices.
+
+        We're subtracting the cap rate cycle from the long-term mean cap rate, 
+        rather than adding it, because we're entering the cap rate cycle 
+        negative to the actual cap rate cycle, so that the cycle is up when 
+        prices are up and down when prices are down. Recall that the actual 
+        cap rate is inversely related to prices 
+        (high cap rates ==> low prices & vice versa). 
+
+        It's easier to think about cycles positively.
+        """
+
+        self.asset_true_value = rk.flux.Flow(
+            movements=self.space_market.movements / self.asset_market.movements,
+            name='Asset True Value')
+        """
+        This applies the capital market cycle to the rent history to obtain 
+        the history of "true values," that is, the asset values (PVs) that 
+        would prevail if there were no "noise" (transaction or observation
+        "error"), and at this point also ignoring "black swan" events.
+        """
+
+        self.space_market_price_factors = rk.flux.Flow(
+            movements=self.space_market.movements / self.trend.initial_value,
+            name='Space Market Price Factors')
+        """
+        This is the "true value" pricing factor for just the space market, 
+        not reflecting the asset market cycle (cap rate). We have actually 
+        already computed this, and we're here just making it into a ratio
+        of the initial rent. This series of Pricing factors will apply to 
+        operating cash flows.
+        """
+
+        self.noise = noise
+        self.noisy_value = rk.flux.Flow(
+            movements=(1 + self.noise.generate().movements) * self.asset_true_value.movements,
+            name='Noisy Value')
+
+        self.black_swan = black_swan
+        self.historical_value = rk.flux.Flow(
+            movements=self.noisy_value.movements * (1 + self.black_swan.impact * self.black_swan.generate().movements),
+            name='Historical Value')
+
+        implied_cap_rate_data = (self.space_market.movements[1:].reset_index(drop=True) /
+                                 self.historical_value.movements[:-1].reset_index(drop=True))
+        # implied_cap_rate_data = pd.concat([implied_cap_rate_data, pd.Series(np.nan)], axis=0, join='outer')
+        self.implied_rev_cap_rate = rk.flux.Flow(
+            movements=pd.Series(
+                data=implied_cap_rate_data.values,
+                index=rk.periodicity.to_datestamps(period_index=self._sequence)),
+            name='Implied Cap Rate')
+        """
+        These are the forward-looking cap rates implied for each year of the 
+        scenario. These will govern the reversion (resale) cash flows in the 
+        DCF model of PV.
+        """
+
+        returns_data = (self.historical_value.movements[1:].reset_index(drop=True) /
+                        self.historical_value.movements[:-1].reset_index(drop=True)) - 1
+        # returns_data = pd.concat([returns_data, pd.Series(np.nan)], axis=0, join='outer')
+        self.returns = rk.flux.Flow(
+            movements=pd.Series(
+                data=returns_data.values,
+                index=rk.periodicity.to_datestamps(period_index=self._sequence)),
+            name='Returns')
+
+        """
+        This is the implied capital returns series for the scenario. It reflects
+        the overall pricing dynamics and uncertainty in the property value over 
+        time.        
+        """
+
+    @classmethod
+    def _from_args(
+            cls,
+            args: tuple) -> Market:
+        sequence, trend, volatility, cyclicality, noise, black_swan = args
+        return cls(
+            sequence=sequence,
+            trend=trend,
+            volatility=volatility,
+            cyclicality=cyclicality,
+            noise=noise,
+            black_swan=black_swan)
+
+    @classmethod
+    def from_likelihoods(
+            cls,
+            sequence: pd.PeriodIndex,
+            trends: [rk.dynamics.trend.Trend],
+            volatilities: [rk.dynamics.volatility.Volatility],
+            cyclicalities: [rk.dynamics.cyclicality.Cyclicality],
+            noise: rk.dynamics.noise.Noise,
+            black_swan: rk.dynamics.black_swan.BlackSwan) -> [Market]:
+
+        pool = multiprocess.Pool(os.cpu_count())
+
+        args = [(sequence, trend, volatility, cyclicality, noise, black_swan)
+            for (trend, volatility, cyclicality)
+            in zip(trends, volatilities, cyclicalities)]
+
+        return pool.map(cls._from_args, args)
+
+    # def __init__(
+    #         self,
+    #         sequence: pd.PeriodIndex,
+    #         market_params: dict,
+    #         volatility_params: dict,
+    #         cyclicality_params: dict):
+    #     """
+    #
+    #     """
+    #     self.span = rk.periodicity.to_span(period_index=sequence)
+    #     self._sequence = rk.periodicity.offset_periodindex(
+    #         index=sequence,
+    #         offset_end=-1)
+    #
+    #     self.trend = market_params['trend']
+    #     self.initial_rent = market_params['initial_rent']
+    #     self.market_trend = rk.flux.Flow.from_projection(
+    #         name='Market Trend',
+    #         value=self.initial_rent,
+    #         proj=rk.projection.Extrapolation(
+    #             form=self.trend,
+    #             sequence=sequence))
+    #
+    #     self.market_volatility = rk.dynamics.volatility.Volatility(
+    #         trend=self.trend,
+    #         initial_rent=self.initial_rent,
+    #         volatility_per_period=volatility_params['volatility_per_period'],
+    #         mean_reversion_param=volatility_params['mean_reversion_param'],
+    #         autoregression_param=volatility_params['autoregression_param'],
+    #         sequence=sequence)
+    #
+    #     self.market_cyclicality = rk.dynamics.cyclicality.Cyclicality(
+    #         space_cycle_period=cyclicality_params['space_cycle_period'],
+    #         space_cycle_phase=cyclicality_params['space_cycle_phase'],
+    #         space_cycle_amplitude=cyclicality_params['space_cycle_amplitude'],
+    #         space_cycle_asymmetric_parameter=cyclicality_params['space_cycle_asymmetric_parameter'],
+    #         asset_cycle_period=cyclicality_params['asset_cycle_period'],
+    #         asset_cycle_phase=cyclicality_params['asset_cycle_phase'],
+    #         asset_cycle_amplitude=cyclicality_params['asset_cycle_amplitude'],
+    #         asset_cycle_asymmetric_parameter=cyclicality_params['asset_cycle_asymmetric_parameter'],
+    #         sequence=sequence)
+    #
+    #     self.space_market = rk.flux.Flow(
+    #         movements=(
+    #                     self.market_cyclicality.space_waveform.movements * self.market_volatility.cumulative_volatility.movements),
+    #         name='Space Market')
+    #
+    #     self.asset_market = rk.flux.Flow(
+    #         movements=market_params['cap_rate'] - self.market_cyclicality.asset_waveform.movements,
+    #         name='Asset Market')
+    #     """
+    #     Negative of actual cap rate cycle.
+    #     This makes this cycle directly reflect the asset pricing, as prices
+    #     are an inverse function of the cap rate. By taking the negative of the
+    #     actual cap rate, we therefore make it easier to envision the effect
+    #     on prices.
+    #
+    #     We're subtracting the cap rate cycle from the long-term mean cap rate,
+    #     rather than adding it, because we're entering the cap rate cycle
+    #     negative to the actual cap rate cycle, so that the cycle is up when
+    #     prices are up and down when prices are down. Recall that the actual
+    #     cap rate is inversely related to prices
+    #     (high cap rates ==> low prices & vice versa).
+    #
+    #     It's easier to think about cycles positively.
+    #     """
+    #
+    #     self.asset_true_value = rk.flux.Flow(
+    #         movements=self.space_market.movements / self.asset_market.movements,
+    #         name='Asset True Value')
+    #     """
+    #     This applies the capital market cycle to the rent history to obtain
+    #     the history of "true values," that is, the asset values (PVs) that
+    #     would prevail if there were no "noise" (transaction or observation
+    #     "error"), and at this point also ignoring "black swan" events.
+    #     """
+    #
+    #     self.space_market_price_factors = rk.flux.Flow(
+    #         movements=self.space_market.movements / self.initial_rent,
+    #         name='Space Market Price Factors')
+    #     """
+    #     This is the "true value" pricing factor for just the space market,
+    #     not reflecting the asset market cycle (cap rate). We have actually
+    #     already computed this, and we're here just making it into a ratio
+    #     of the initial rent. This series of Pricing factors will apply to
+    #     operating cash flows.
+    #     """
+    #
+    #     self.noise_values = [rk.distribution.Symmetric(
+    #         distribution_type=rk.distribution.Type.PERT,
+    #         mean=0.,
+    #         residual=market_params['noise_residual']
+    #         ).distribution().sample() for _ in range(sequence.size)]
+    #     self.noise = rk.flux.Flow(
+    #         movements=pd.Series(
+    #             data=self.noise_values,
+    #             index=rk.periodicity.to_datestamps(period_index=sequence)),
+    #         name='Noise')
+    #     """
+    #     This is a symmetric PERT distribution. Note that a random realization
+    #     of noise is generated each period, but it is applied to the value
+    #     LEVELs (not to the returns or increments), hence, noise does not
+    #     accumulate over time in the levels (unlike volatility). In actuality
+    #     noise would be "realized" only when/if the asset is sold, or its value
+    #     is formally estimated. But of course, in principle, an asset sale
+    #     (or formal value estimation) could take place at any time.
+    #     """
+    #
+    #     self.noisy_value = rk.flux.Flow(
+    #         movements=(1 + self.noise.movements) * self.asset_true_value.movements,
+    #         name='Noisy Value')
+    #     """
+    #     In this column the noise we generated in the previous column is
+    #     applied to the noise-free value history in the "TrueValue" column,
+    #     to generate the actually-observable value each year (excluding any
+    #     "black swan" impact).
+    #     """
+    #
+    #     black_swan_effect_data = pd.Series(
+    #         data=self.calculate_black_swan_effects(
+    #             likelihood=market_params['black_swan_likelihood'],
+    #             dissipation_rate=market_params['black_swan_dissipation_rate'],
+    #             events=market_params['black_swan_prob_dist'].sample(sequence.size)),
+    #         index=rk.periodicity.to_datestamps(period_index=sequence))
+    #     self.black_swan_effect = rk.flux.Flow(
+    #         movements=black_swan_effect_data,
+    #         name='Black Swan Effect')
+    #     """
+    #     This random variable will determine whether a "black swan" event
+    #     occurs in any given year. We ensure that no more than one black
+    #     swan will occur in the 24-yr history, as black swans are by definition
+    #     rare events.
+    #
+    #     This column causes the effect of the Black Swan event to dissipate
+    #     over time, geometrically, at the same mean reversion rate as is
+    #     applied in general to the rents (entered in co.F).
+    #     """
+    #
+    #     self.historical_value = rk.flux.Flow(
+    #         movements=self.noisy_value.movements * (
+    #                 1 + market_params['black_swan_impact'] * self.black_swan_effect.movements),
+    #         name='Historical Value')
+    #     """
+    #     This is another source or type of uncertainty in real estate pricing.
+    #     This column will apply the given "black swan" result, but then reduces
+    #     the subsequent impact of the event gradually as mean-reversion
+    #     takes effect.
+    #     """
+    #
+    #     implied_cap_rate_data = (self.space_market.movements[1:].reset_index(drop=True) /
+    #                              self.historical_value.movements[:-1].reset_index(drop=True))
+    #     # implied_cap_rate_data = pd.concat([implied_cap_rate_data, pd.Series(np.nan)], axis=0, join='outer')
+    #     self.implied_rev_cap_rate = rk.flux.Flow(
+    #         movements=pd.Series(
+    #             data=implied_cap_rate_data.values,
+    #             index=rk.periodicity.to_datestamps(period_index=self._sequence)),
+    #         name='Implied Cap Rate')
+    #     """
+    #     These are the forward-looking cap rates implied for each year of the
+    #     scenario. These will govern the reversion (resale) cash flows in the
+    #     DCF model of PV.
+    #     """
+    #
+    #     returns_data = (self.historical_value.movements[1:].reset_index(drop=True) /
+    #                     self.historical_value.movements[:-1].reset_index(drop=True)) - 1
+    #     # returns_data = pd.concat([returns_data, pd.Series(np.nan)], axis=0, join='outer')
+    #     self.returns = rk.flux.Flow(
+    #         movements=pd.Series(
+    #             data=returns_data.values,
+    #             index=rk.periodicity.to_datestamps(period_index=self._sequence)),
+    #         name='Returns')
+    #
+    #     """
+    #     This is the implied capital returns series for the scenario. It reflects
+    #     the overall pricing dynamics and uncertainty in the property value over
+    #     time.
+    #     """

rangekeeper/dynamics/noise.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+import pandas as pd
+
+import rangekeeper as rk
+
+
+class Noise:
+    def __init__(
+            self,
+            sequence: pd.PeriodIndex,
+            noise_dist: rk.distribution.Form):
+        """
+        Note that a random realization of noise is generated each period, but it is applied to the value
+        LEVELs (not to the returns or increments), hence, noise does not
+        accumulate over time in the levels (unlike volatility). In actuality
+        noise would be "realized" only when/if the asset is sold, or its value
+        is formally estimated. But of course, in principle, an asset sale
+        (or formal value estimation) could take place at any time.
+
+        In this column the noise we generated in the previous column is
+        applied to the noise-free value history in the "TrueValue" column,
+        to generate the actually-observable value each year (excluding any
+        "black swan" impact).
+        """
+        self.sequence = sequence
+        self.noise_dist = noise_dist
+
+    def generate(self) -> rk.flux.Flow:
+        return rk.flux.Flow(
+            movements=pd.Series(
+                data=self.noise_dist.sample(size=self.sequence.size),
+                index=rk.periodicity.to_datestamps(period_index=self.sequence)),
+            name='Noise')

rangekeeper/dynamics/trend.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+import os
+
+from typing import Optional, Generator
+
+import pandas as pd
+import multiprocess
+
+import rangekeeper as rk
+
+
+class Trend(rk.flux.Flow):
+    growth_rate: float
+    cap_rate: float
+    initial_value: float
+    initial_price_factor: float
+
+    def __init__(
+            self,
+            sequence: pd.PeriodIndex,
+            growth_rate: float,
+            cap_rate: float,
+            initial_value: Optional[float] = None,
+            initial_price_factor: float = 1.):
+        self.sequence = sequence
+        self.cap_rate = cap_rate
+        self.growth_rate = growth_rate
+        self.initial_value = initial_price_factor * self.cap_rate if initial_value is None else initial_value
+        self.initial_price_factor = initial_price_factor
+
+        self.proj = rk.projection.Extrapolation(
+            form=rk.extrapolation.Compounding(rate=self.growth_rate),
+            sequence=self.sequence)
+
+        super().__init__(
+            name='Market Trend',
+            movements=self.proj.terms() * self.initial_value)
+
+    @classmethod
+    def _from_args(
+            cls,
+            args: tuple) -> Trend:
+        sequence, cap_rate, growth_rate, initial_value, initial_price_factor = args
+        return cls(
+            sequence=sequence,
+            cap_rate=cap_rate,
+            growth_rate=growth_rate,
+            initial_value=initial_value,
+            initial_price_factor=initial_price_factor)
+    @classmethod
+    def from_likelihoods(
+            cls,
+            sequence: pd.PeriodIndex,
+            cap_rate: float,
+            growth_rate_dist: rk.distribution,
+            initial_value_dist: rk.distribution,
+            initial_price_factor: float = 1.,
+            iterations: int = 1) -> [Trend]:
+        growth_rates = growth_rate_dist.sample(size=iterations)
+        initial_values = initial_value_dist.sample(size=iterations)
+
+        pool = multiprocess.Pool(os.cpu_count())
+
+        args = [
+            (sequence,
+             cap_rate,
+             growth_rate,
+             initial_value,
+             initial_price_factor)
+            for (growth_rate, initial_value)
+            in zip(growth_rates, initial_values)
+            ]
+
+        results = pool.map(cls._from_args, args)
+        if iterations == 1:
+            return results[0]
+        else:
+            return results
+

rangekeeper/dynamics/volatility.py

@@ -0,0 +1,140 @@
+from __future__ import annotations
+import os
+
+from typing import Generator
+import pandas as pd
+import scipy as sp
+from numba import jit
+import numba
+import multiprocess
+
+import rangekeeper as rk
+
+
+class Volatility(rk.flux.Flow):
+    def __init__(
+            self,
+            trend: rk.dynamics.trend.Trend,
+            volatility_per_period: float,
+            autoregression_param: float,
+            mean_reversion_param: float,
+            sequence: pd.PeriodIndex):
+        """
+        This is a normal (Gaussian) distribution.
+        Note that volatility is realized (new random increment is generated) in EACH period,
+        so that this "risk" outcome accumulates in the history of rent levels.
+        But this is just the volatility in the innovations; if there is autoregression then that will also affect the annual volatility.
+        Cycles will also affect the average volatility observed empirically across the scenario.
+        volatility_per_period = .08
+        """
+
+        volatilities = pd.Series(
+            data=[sp.special.ndtri(rk.distribution.Uniform(lower=0, range=1).sample()[0]) * volatility_per_period
+                  for x in range(sequence.size)],
+            # the ndtri() function replicates excel's NORMSINV().
+            # See https://stackoverflow.com/questions/20626994/how-to-calculate-the-inverse-of-the-normal-cumulative-distribution-function-in-p/20627638
+            index=rk.periodicity.to_datestamps(period_index=sequence))
+
+        self.volatility = rk.flux.Flow(
+            movements=volatilities,
+            name='Volatility')
+
+        volatility = numba.typed.List()
+        [volatility.append(x) for x in self.volatility.movements.to_list()]
+
+        autoregression_return_data = self.calculate_autoregression(
+            parameter=autoregression_param,
+            volatility=volatility)
+        self.autoregressive_returns = rk.flux.Flow(
+            movements=pd.Series(
+                data=autoregression_return_data,
+                index=self.volatility.movements.index),
+            name='Autoregressive Returns')
+
+        trend_values = numba.typed.List()
+        [trend_values.append(x) for x in trend.movements.to_list()]
+
+        ar_returns = numba.typed.List()
+        [ar_returns.append(x) for x in self.autoregressive_returns.movements.to_list()]
+
+        cumulative_volatility_data = self.calculate_volatility_accumulation(
+            trend_rate=trend.growth_rate,
+            trend_values=trend_values,
+            mr_parameter=mean_reversion_param,
+            ar_returns=ar_returns)
+
+        movements = pd.Series(
+                data=cumulative_volatility_data,
+                index=rk.periodicity.to_datestamps(period_index=sequence))
+
+        super().__init__(
+            name='Cumulative Volatility',
+            movements=movements)
+
+    @classmethod
+    def _from_args(
+            cls,
+            args: tuple) -> Volatility:
+        trend, volatility_per_period, autoregression_param, mean_reversion_param, sequence = args
+        return cls(
+            trend=trend,
+            volatility_per_period=volatility_per_period,
+            autoregression_param=autoregression_param,
+            mean_reversion_param=mean_reversion_param,
+            sequence=sequence)
+
+    @classmethod
+    def from_trends(
+            cls,
+            trends: [rk.dynamics.trend.Trend],
+            volatility_per_period: float,
+            autoregression_param: float,
+            mean_reversion_param: float,
+            sequence: pd.PeriodIndex) -> [Volatility]:
+
+        pool = multiprocess.Pool(os.cpu_count())
+
+        args = [
+            (trend,
+             volatility_per_period,
+             autoregression_param,
+             mean_reversion_param,
+             sequence)
+            for trend in trends]
+
+        return pool.map(cls._from_args, args)
+
+    @staticmethod
+    @jit(nopython=True)
+    def calculate_autoregression(
+            parameter: float,
+            volatility: numba.typed.List):
+        ar_returns = numba.typed.List()
+        for i in range(len(volatility)):
+            if i == 0:
+                ar_returns.append(volatility[0])
+            else:
+                ar_returns.append(volatility[i] + (parameter * ar_returns[i - 1]))
+        return ar_returns
+
+    @staticmethod
+    @jit(nopython=True)
+    def calculate_volatility_accumulation(
+            trend_rate: float,
+            trend_values: numba.typed.List,
+            mr_parameter: float,
+            ar_returns: numba.typed.List):
+        """
+        Cumulative Volatility:
+        Accumulate the volatility generated in the previous column, also reflecting the mean reversion tendency.
+        """
+        accumulated_volatility = numba.typed.List()
+        for i in range(len(trend_values)):
+            if i == 0:
+                accumulated_volatility.append(trend_values[0])
+            else:
+                accumulated_volatility.append(
+                    (accumulated_volatility[i - 1] * (1 + trend_rate + ar_returns[i])) +
+                    (mr_parameter * (trend_values[i - 1] - accumulated_volatility[i - 1]))
+                    )
+        return accumulated_volatility

rangekeeper/extrapolation.py

@@ -0,0 +1,100 @@
+from typing import Optional
+
+import enum
+import numpy as np
+import pandas as pd
+import scipy.stats as ss
+from abc import abstractmethod
+
+
+class Type(enum.Enum):
+    STRAIGHT_LINE = 'Straight Line'  # A constant-change (linearly growing (or decaying)) projection form, originating from an initial value.
+    COMPOUNDING = 'Compounding'  # An exponentially growing (compounding) or decaying projection at a specified rate per period.
+    RECURRING = 'Recurring'  # A projection form that repeats a specified sequence of values.
+    DYNAMIC = 'Dynamic'  # A projection form generated by a stochastic process.
+
+
+class Form:
+    type: Type
+    """
+    A specified methodology, logic, or algorithm for extrapolating a value to a sequence.
+    """
+
+    @abstractmethod
+    def terms(
+            self,
+            sequence: pd.RangeIndex) -> [float]:
+        """
+        Returns the set of terms that define the projection's form at each value in the sequence.
+        """
+        pass
+
+
+class StraightLine(Form):
+    slope: float
+    """
+    A constant-change (linearly growing (or decaying)) projection form, originating from an initial value.
+    To calculate the factor, the projection is modelled as a linear function of (slope * period) + 1
+    """
+
+    def __init__(
+            self,
+            slope: float):
+        self.type = Type.STRAIGHT_LINE
+        self.slope = slope
+
+    def terms(
+            self,
+            sequence: pd.RangeIndex) -> [float]:
+        """
+        Returns the additive terms to the projection at each value in the sequence.
+        """
+        return [(self.slope * index) for index in sequence]
+
+
+class Recurring(StraightLine):
+    def __init__(self):
+        super().__init__(slope=0)
+        self.type = Type.RECURRING
+
+
+class Compounding(Form):
+    rate: float
+    """
+    An exponentially growing (compounding) or decaying projection at a specified rate per period.
+    To calculate the factor, the projection is modelled as an exponential function of (1 + rate) ** period
+    """
+
+    def __init__(
+            self,
+            rate: float):
+        self.type = Type.COMPOUNDING
+        self.rate = rate
+
+    def terms(
+            self,
+            sequence: pd.RangeIndex) -> [float]:
+        """
+        Returns the multiplicative factors of the projection's form at each value in the sequence.
+        """
+        return [np.power((1 + self.rate), index) for index in sequence]
+
+
+class Dynamic(Form):
+    series: pd.Series
+
+    def __init__(
+            self,
+            series: pd.Series):
+        self.type = Type.DYNAMIC
+        self.series = series
+
+    def terms(
+            self,
+            sequence: pd.RangeIndex) -> [float]:
+        """
+        Returns the multiplicative factors of the projection's form at each value in the sequence.
+        """
+        if self.series.index.size != sequence.size:
+            raise ValueError("Error: series and sequence must match in size")
+        return list(self.series.values)