Skip to content
New: Star-import, signal unraveling, Python 3.12 support, and more

#
rprob module

Module with RPROB.

## RPROB class

    RPROB(
        wrapper,
        input_list,
        input_mapper,
        in_output_list,
        output_list,
        param_list,
        mapper_list,
        short_name,
        level_names
    )

Random entry signal generator based on probabilities.

Generates `entries` based on rand_by_prob_place_nb().

Hint

All parameters can be either a single value (per frame) or a NumPy array (per row, column, or element). To generate multiple combinations, pass them as lists.

Usage

Generate three columns with different entry probabilities:

    >>> from vectorbtpro import *

    >>> rprob = vbt.RPROB.run(input_shape=(5,), prob=[0., 0.5, 1.], seed=42)

    >>> rprob.entries
    rprob_prob    0.0    0.5   1.0
    0           False   True  True
    1           False   True  True
    2           False  False  True
    3           False  False  True
    4           False  False  True

Probability can also be set per row, column, or element:

    >>> rprob = vbt.RPROB.run(input_shape=(5,), prob=np.array([0., 0., 1., 1., 1.]), seed=42)

    >>> rprob.entries
    0    False
    1    False
    2     True
    3     True
    4     True
    Name: array_0, dtype: bool

Superclasses

- Analyzable
- AttrResolverMixin
- Cacheable
- Chainable
- Comparable
- Configured
- ExtPandasIndexer
- HasSettings
- IndexingBase
- IndicatorBase
- PandasIndexer
- Pickleable
- PlotsBuilderMixin
- Prettified
- StatsBuilderMixin
- Wrapping
- `vectorbtpro.signals.generators.rprob.ParamIndexer`

Inherited members

- AttrResolverMixin.deep_getattr()
- AttrResolverMixin.post_resolve_attr()
- AttrResolverMixin.pre_resolve_attr()
- AttrResolverMixin.resolve_attr()
- AttrResolverMixin.resolve_shortcut_attr()
- Cacheable.get_ca_setup()
- Chainable.pipe()
- Configured.copy()
- Configured.equals()
- Configured.get_writeable_attrs()
- Configured.prettify()
- Configured.replace()
- Configured.resolve_merge_kwargs()
- Configured.update_config()
- HasSettings.get_path_setting()
- HasSettings.get_path_settings()
- HasSettings.get_setting()
- HasSettings.get_settings()
- HasSettings.has_path_setting()
- HasSettings.has_path_settings()
- HasSettings.has_setting()
- HasSettings.has_settings()
- HasSettings.reset_settings()
- HasSettings.resolve_setting()
- HasSettings.resolve_settings_paths()
- HasSettings.set_settings()
- IndexingBase.indexing_setter_func()
- IndicatorBase.cls_dir
- IndicatorBase.column_only_select
- IndicatorBase.column_stack()
- IndicatorBase.config
- IndicatorBase.dropna()
- IndicatorBase.group_select
- IndicatorBase.iloc
- IndicatorBase.in_output_names
- IndicatorBase.indexing_func()
- IndicatorBase.indexing_kwargs
- IndicatorBase.input_names
- IndicatorBase.lazy_output_names
- IndicatorBase.level_names
- IndicatorBase.loc
- IndicatorBase.output_flags
- IndicatorBase.output_names
- IndicatorBase.param_names
- IndicatorBase.plots_defaults
- IndicatorBase.range_only_select
- IndicatorBase.rec_state
- IndicatorBase.row_stack()
- IndicatorBase.run_pipeline()
- IndicatorBase.self_aliases
- IndicatorBase.short_name
- IndicatorBase.stats_defaults
- IndicatorBase.to_dict()
- IndicatorBase.to_frame()
- IndicatorBase.unpack()
- IndicatorBase.wrapper
- IndicatorBase.xloc
- PandasIndexer.xs()
- Pickleable.decode_config()
- Pickleable.decode_config_node()
- Pickleable.dumps()
- Pickleable.encode_config()
- Pickleable.encode_config_node()
- Pickleable.file_exists()
- Pickleable.getsize()
- Pickleable.load()
- Pickleable.loads()
- Pickleable.modify_state()
- Pickleable.resolve_file_path()
- Pickleable.save()
- PlotsBuilderMixin.build_subplots_doc()
- PlotsBuilderMixin.override_subplots_doc()
- PlotsBuilderMixin.plots()
- StatsBuilderMixin.build_metrics_doc()
- StatsBuilderMixin.override_metrics_doc()
- StatsBuilderMixin.stats()
- Wrapping.regroup()
- Wrapping.resample()
- Wrapping.resolve_column_stack_kwargs()
- Wrapping.resolve_row_stack_kwargs()
- Wrapping.resolve_self()
- Wrapping.resolve_stack_kwargs()
- Wrapping.select_col()
- Wrapping.select_col_from_obj()
- Wrapping.split()

Subclasses

- `vectorbtpro.signals.generators.rprob._RPROB`

### apply_func method

    RPROB.apply_func(
        i,
        target_shape,
        prob,
        entry_args,
        only_once,
        wait
    )

### custom_func method

    SignalFactory.with_place_func.<locals>.custom_func(
        input_list,
        in_output_list,
        param_list,
        *args,
        input_shape=None,
        place_args=None,
        entry_place_args=None,
        exit_place_args=None,
        entry_args=None,
        exit_args=None,
        cache_args=None,
        entry_kwargs=None,
        exit_kwargs=None,
        cache_kwargs=None,
        return_cache=False,
        use_cache=None,
        execute_kwargs=None,
        **_kwargs
    )

### entries property

Output array.

### entries_and method

    RPROB.entries_and(
        other,
        level_name=None,
        allow_multiple=True,
        **kwargs
    )

Return `entries AND other`.

See combine_objs().

### entries_or method

    RPROB.entries_or(
        other,
        level_name=None,
        allow_multiple=True,
        **kwargs
    )

Return `entries OR other`.

See combine_objs().

### entries_stats method

    RPROB.entries_stats(
        *args,
        **kwargs
    )

Stats of `entries` as signals.

### entries_xor method

    RPROB.entries_xor(
        other,
        level_name=None,
        allow_multiple=True,
        **kwargs
    )

Return `entries XOR other`.

See combine_objs().

### entry_place_func_nb method

    RPROB.entry_place_func_nb(
        c,
        prob,
        pick_first=False
    )

`place_func_nb` to randomly place signals with probability `prob`.

`prob` uses flexible indexing.

### exit_place_func_nb class variable

### plot method

    SignalFactory.__init__.<locals>.plot(
        _self,
        column=None,
        entry_y=None,
        exit_y=None,
        entry_types=None,
        exit_types=None,
        entry_trace_kwargs=None,
        exit_trace_kwargs=None,
        fig=None,
        **kwargs
    )

Plot RPROB.entries and `RPROB.exits`.

Args

`entry_y` :`array_like`
  Y-axis values to plot entry markers on.
`exit_y` :`array_like`
  Y-axis values to plot exit markers on.
`entry_types` :`array_like`
  Entry types in string format.
`exit_types` :`array_like`
  Exit types in string format.
`entry_trace_kwargs` :`dict`
  Keyword arguments passed to SignalsAccessor.plot_as_entries() for RPROB.entries.
`exit_trace_kwargs` :`dict`
  Keyword arguments passed to SignalsAccessor.plot_as_exits() for `RPROB.exits`.
`fig` :`Figure` or `FigureWidget`
  Figure to add traces to.
`**kwargs`
  Keyword arguments passed to SignalsAccessor.plot_as_markers().

### prob_list property

List of `prob` values.

### run class method

    RPROB.run(
        input_shape,
        prob,
        short_name='rprob',
        hide_params=None,
        hide_default=True,
        input_index=None,
        input_columns=None,
        **kwargs
    )

Run RPROB indicator.

- Parameters: `prob`
- Outputs: `entries`

Pass a list of parameter names as `hide_params` to hide their column levels, or True to hide all. Set `hide_default` to False to show the column levels of the parameters with a default value.

Other keyword arguments are passed to IndicatorBase.run_pipeline().

### run_combs class method

    RPROB.run_combs(
        input_shape,
        prob,
        r=2,
        param_product=False,
        comb_func=itertools.combinations,
        run_unique=True,
        short_names=None,
        hide_params=None,
        hide_default=True,
        input_index=None,
        input_columns=None,
        **kwargs
    )

Create a combination of multiple RPROB indicators using function `comb_func`.

- Parameters: `prob`
- Outputs: `entries`

`comb_func` must accept an iterable of parameter tuples and `r`. Also accepts all combinatoric iterators from itertools such as `itertools.combinations`. Pass `r` to specify how many indicators to run. Pass `short_names` to specify the short name for each indicator. Set `run_unique` to True to first compute raw outputs for all parameters, and then use them to build each indicator (faster).

Other keyword arguments are passed to RPROB.run().

Note

This method should only be used when multiple indicators are needed. To test multiple parameters, pass them as lists to RPROB.run().

#### Cookie consent

We use cookies to recognize your repeated visits and preferences, as well as to measure the effectiveness of our documentation and whether users find what they're searching for. With your consent, you're helping us to make our documentation better.

- Google Analytics
- GitHub

Manage settings