Struct DownCaptureRatio 

pub struct DownCaptureRatio { /* private fields */ }

Calculates the down capture ratio of portfolio returns relative to a benchmark.

The down capture ratio measures how the portfolio performed, on average, during the periods when the benchmark return was negative. It is the ratio of the portfolio’s geometric annualized return to the benchmark’s geometric annualized return, both computed over the down-market subset only:

DownCapture = annualized_return(portfolio | benchmark < 0) / annualized_return(benchmark | benchmark < 0)

where each side’s annualized return is the geometric (CAGR-style) value (prod(1 + x_i))^(period / m) - 1 and m is the number of down-market periods (the size of the filtered subset, not the full aligned length). The period defaults to 252 trading days. A value below 1.0 means the portfolio lost less than the benchmark in down markets (smaller drawdowns), which is desirable.

This is the empyrical.down_capture convention (geometric annualized-return ratio over the benchmark < 0 subset). Note that this differs from the Morningstar definition, which uses a ratio of cumulative (non-annualized) returns; the two coincide only when both subsets contain the same number of periods.

References

• empyrical down_capture / capture / annual_return (https://github.com/quantopian/empyrical).
• CFA Institute Investment Foundations, 3rd Edition

Implementations

impl DownCaptureRatio

pub fn new(period: Option<usize>) -> Self

Creates a new DownCaptureRatio instance.

Trait Implementations

impl Clone for DownCaptureRatio

fn clone(&self) -> DownCaptureRatio

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for DownCaptureRatio

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl DerefToPyAny for DownCaptureRatio

impl Display for DownCaptureRatio

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a, 'py> FromPyObject<'a, 'py> for DownCaptureRatio

where Self: Clone,

type Error = PyClassGuardError<'a, 'py>

The type returned in the event of a conversion error.

fn extract( obj: Borrowed<'a, 'py, PyAny>, ) -> Result<Self, <Self as FromPyObject<'a, 'py>>::Error>

Extracts Self from the bound smart pointer obj.

impl<'py> IntoPyObject<'py> for DownCaptureRatio

type Target = DownCaptureRatio

The Python output type

type Output = Bound<'py, <DownCaptureRatio as IntoPyObject<'py>>::Target>

The smart pointer type to use.

type Error = PyErr

The type returned in the event of a conversion error.

fn into_pyobject( self, py: Python<'py>, ) -> Result<<Self as IntoPyObject<'_>>::Output, <Self as IntoPyObject<'_>>::Error>

Performs the conversion.

impl PortfolioStatistic for DownCaptureRatio

type Item = f64

fn name(&self) -> String

Returns the name of this statistic for display and identification purposes.

fn calculate_from_returns(&self, _returns: &Returns) -> Option<Self::Item>

Calculates the statistic from time-indexed returns data.

fn calculate_from_realized_pnls( &self, _realized_pnls: &[f64], ) -> Option<Self::Item>

Calculates the statistic from realized profit and loss values.

fn calculate_from_positions( &self, _positions: &[Position], ) -> Option<Self::Item>

Calculates the statistic from position data.

fn calculate_from_returns_with_benchmark( &self, returns: &Returns, benchmark: &Returns, ) -> Option<Self::Item>

Calculates the statistic from time-indexed strategy returns relative to a benchmark.

fn calculate_from_orders( &self, orders: Vec<Box<dyn Order>>, ) -> Option<Self::Item>

Calculates the statistic from order data.

fn align_returns(&self, a: &Returns, b: &Returns) -> (Vec<f64>, Vec<f64>)

Aligns two returns series onto a common daily grid.

fn check_valid_returns(&self, returns: &Returns) -> bool

Validates that returns data is not empty.

fn downsample_to_daily_bins(&self, returns: &Returns) -> Returns

Downsamples high-frequency returns to daily bins by geometric compounding.

fn calculate_std(&self, returns: &Returns) -> f64

Calculates the standard deviation of returns with Bessel’s correction.

impl PyClass for DownCaptureRatio

const NAME: &str = "DownCaptureRatio"

Name of the class.

type Frozen = False

Whether the pyclass is frozen.

impl PyClassImpl for DownCaptureRatio

const MODULE: Option<&str>

Module which the class will be associated with.

const IS_BASETYPE: bool = false

#[pyclass(subclass)]

const IS_SUBCLASS: bool = false

#[pyclass(extends=…)]

const IS_MAPPING: bool = false

#[pyclass(mapping)]

const IS_SEQUENCE: bool = false

#[pyclass(sequence)]

const IS_IMMUTABLE_TYPE: bool = false

#[pyclass(immutable_type)]

const RAW_DOC: &'static CStr = /// Calculates the down capture ratio of portfolio returns relative to a benchmark. /// /// The down capture ratio measures how the portfolio performed, on average, during the /// periods when the benchmark return was negative. It is the ratio of the portfolio's /// geometric annualized return to the benchmark's geometric annualized return, both /// computed over the down-market subset only: /// /// `DownCapture = annualized_return(portfolio | benchmark < 0) / annualized_return(benchmark | benchmark < 0)` /// /// where each side's annualized return is the geometric (CAGR-style) value /// `(prod(1 + x_i))^(period / m) - 1` and `m` is the number of down-market periods (the /// size of the filtered subset, not the full aligned length). The period defaults to /// 252 trading days. A value below 1.0 means the portfolio lost less than the benchmark /// in down markets (smaller drawdowns), which is desirable. /// /// This is the `empyrical.down_capture` convention (geometric annualized-return ratio /// over the `benchmark < 0` subset). Note that this differs from the Morningstar /// definition, which uses a ratio of *cumulative* (non-annualized) returns; the two /// coincide only when both subsets contain the same number of periods. /// /// # References /// /// - empyrical `down_capture` / `capture` / `annual_return` /// (<https://github.com/quantopian/empyrical>). /// - CFA Institute Investment Foundations, 3rd Edition

Docstring for the class provided on the struct or enum.

const DOC: &'static CStr

Fully rendered class doc, including the text_signature if a constructor is defined.

type Layout = <<DownCaptureRatio as PyClassImpl>::BaseNativeType as PyClassBaseType>::Layout<DownCaptureRatio>

Description of how this class is laid out in memory

type BaseType = PyAny

Base class

type ThreadChecker = NoopThreadChecker

This handles following two situations:

type Inventory = Pyo3MethodsInventoryForDownCaptureRatio

type PyClassMutability = <<PyAny as PyClassBaseType>::PyClassMutability as PyClassMutability>::MutableChild

Immutable or mutable

type Dict = PyClassDummySlot

Specify this class has #[pyclass(dict)] or not.

type WeakRef = PyClassDummySlot

Specify this class has #[pyclass(weakref)] or not.

type BaseNativeType = PyAny

The closest native ancestor. This is PyAny by default, and when you declare #[pyclass(extends=PyDict)], it’s PyDict.

fn items_iter() -> PyClassItemsIter

fn lazy_type_object() -> &'static LazyTypeObject<Self>

fn dict_offset() -> Option<PyObjectOffset>

Used to provide the dictoffset slot (equivalent to tp_dictoffset)

fn weaklist_offset() -> Option<PyObjectOffset>

Used to provide the weaklistoffset slot (equivalent to tp_weaklistoffset

impl PyClassNewTextSignature for DownCaptureRatio

const TEXT_SIGNATURE: &'static str = "(period=None)"

impl PyStubType for DownCaptureRatio

fn type_output() -> TypeInfo

The type to be used in the output signature, i.e. return type of the Python function or methods.

fn type_input() -> TypeInfo

The type to be used in the input signature, i.e. the arguments of the Python function or methods.

impl PyTypeInfo for DownCaptureRatio

const NAME: &str = <Self as ::pyo3::PyClass>::NAME

👎Deprecated since 0.28.0:

prefer using ::type_object(py).name() to get the correct runtime value

Class name.

const MODULE: Option<&str> = <Self as ::pyo3::impl_::pyclass::PyClassImpl>::MODULE

👎Deprecated since 0.28.0:

prefer using ::type_object(py).module() to get the correct runtime value

Module name, if any.

fn type_object_raw(py: Python<'_>) -> *mut PyTypeObject

Returns the PyTypeObject instance for this type.

fn type_object(py: Python<'_>) -> Bound<'_, PyType>

Returns the safe abstraction over the type object.

fn is_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type or a subclass of this type.

fn is_exact_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type.