# rippy
ReInsurance Pricing in PYthon!
## Getting Started
Install rippy from pypi:
```pip install rippy```
## Introduction
Rippy is a simple, fast and lightweight simulation-based reinsurance modeling package. It has two main components:
1. Frequency-Severity, otherwise known as compound distribution simulation
Rippy contains the ```FrequencySeverityModel``` class to set up and simulate from compound distributions with a variety of frequency and severity distributions
```python
from rippy import FrequencySeverityModel, Distributions
claims = FrequencySeverityModel(Distributions.Poisson(5),Distributions.Pareto(0.5,100000)).generate()
```
2. Reinsurance contract calculation
Rippy can then calculate the recoveries of a number of types of reinsurance contract for the simulated claims.
```python
from rippy import XoL
xol_layer = XoL(name="Layer 1", limit=1000000, excess=100000, premium=1000)
xol_layer.apply(claims)
xol_layer.print_summary()
```
Rippy is based on the scientific python stack of numpy and scipy for fast performance. It can optionally run on a GPU for extremely fast performance. It is designed for interoperability with numpy and ndarrays, so for example the simulated claims can be operated on with
numpy ufuncs:
```python
import numpy as np
capped_claims = np.minimum(claims,2000000)
```
Under the hood/bonnet, rippy represents the simulations of the Frequency-Severity model in sparse storage, keeping two lists of simulation indices and values:
|sim_index | values|
|-----|-----|
| 0 | 13231.12
| 0 | 432.7 |
| 2 | 78935.12 |
| 3 | 3213.9 |
| 3 | 43843.1 |
| ...| ...|
Frequency-Severity simulations can be aggregated (summed within a sim_index), which results in a standard ```np.ndarray```
```python
aggregate_claims = claims.aggregate()
```
```python
np.array([13663.82,0,78935,12,47957.0,....])
```
### Configuring the simulation settings
The global number of simulations can be changed from the ```config``` class (the default is 100,000 simulations)
```python
from rippy import config
config.n_sims = 1000000
```
The global random seed can also be configured from the ```config``` class
```python
config.set_random_seed(123456)
```
Rippy uses the ```default_rng``` class of the ```numpy.random``` module. This can also be configured using the ```config.rng``` property.
### Using a GPU
GPU support requires a CUDA compatible GPU. Internally rippy uses the cupy library. Install the dependencies by running
```
pip install rippy[gpu]
```
To enable GPU mode, set the RIPPY_USE_GPU environment variable to 1.
```linux
export RIPPY_USE_GPU=1
```
on Linux or
```
set RIPPY_USE_GPU=1
```
on Windows. Set it to anythin else to revert to using a CPU
## Project Status
Rippy is currently a proof of concept. There are a limited number of supported distributions and reinsurance contracts. We are working on:
* Adding more distributions and loss generation types
* Adding support for Catastrophe loss generation and reinsurance contracts
* Adding support for more reinsurance contract types (Surplus, Stop Loss etc)
* Grouping reinsurance contracts into programs and structures
* Stratified sampling and Quasi-Monte Carlo methods
* Reporting dashboards
## Issues
Please log issues in github
## Contributing
You are welcome to contribute pull requests
Raw data
{
"_id": null,
"home_page": null,
"name": "rippy",
"maintainer": null,
"docs_url": null,
"requires_python": ">=3.10",
"maintainer_email": null,
"keywords": "reinsurance, actuarial, insurance",
"author": "James Norman",
"author_email": "James Norman <james.norman@proteusllp.com>",
"download_url": "https://files.pythonhosted.org/packages/28/f5/f74254360da671ab13a950cefc14d90c833ab1bef2421359d9d42aecdb19/rippy-0.0.8.tar.gz",
"platform": null,
"description": "# rippy\nReInsurance Pricing in PYthon!\n\n## Getting Started\n\nInstall rippy from pypi:\n\n```pip install rippy```\n\n## Introduction\n\nRippy is a simple, fast and lightweight simulation-based reinsurance modeling package. It has two main components:\n\n1. Frequency-Severity, otherwise known as compound distribution simulation\n\n Rippy contains the ```FrequencySeverityModel``` class to set up and simulate from compound distributions with a variety of frequency and severity distributions\n\n ```python\n from rippy import FrequencySeverityModel, Distributions\n claims = FrequencySeverityModel(Distributions.Poisson(5),Distributions.Pareto(0.5,100000)).generate()\n ```\n\n2. Reinsurance contract calculation\n \n Rippy can then calculate the recoveries of a number of types of reinsurance contract for the simulated claims.\n\n ```python\n from rippy import XoL\n xol_layer = XoL(name=\"Layer 1\", limit=1000000, excess=100000, premium=1000)\n xol_layer.apply(claims)\n xol_layer.print_summary()\n ```\n\n\nRippy is based on the scientific python stack of numpy and scipy for fast performance. It can optionally run on a GPU for extremely fast performance. It is designed for interoperability with numpy and ndarrays, so for example the simulated claims can be operated on with\nnumpy ufuncs:\n\n```python\nimport numpy as np\ncapped_claims = np.minimum(claims,2000000)\n```\n\nUnder the hood/bonnet, rippy represents the simulations of the Frequency-Severity model in sparse storage, keeping two lists of simulation indices and values: \n\n|sim_index | values|\n|-----|-----|\n| 0 | 13231.12\n| 0 | 432.7 |\n| 2 | 78935.12 |\n| 3 | 3213.9 |\n| 3 | 43843.1 |\n| ...| ...|\n\nFrequency-Severity simulations can be aggregated (summed within a sim_index), which results in a standard ```np.ndarray```\n\n```python\naggregate_claims = claims.aggregate()\n\n```\n\n```python\nnp.array([13663.82,0,78935,12,47957.0,....])\n```\n\n### Configuring the simulation settings\n\nThe global number of simulations can be changed from the ```config``` class (the default is 100,000 simulations)\n\n```python\nfrom rippy import config\nconfig.n_sims = 1000000\n```\n\nThe global random seed can also be configured from the ```config``` class\n\n```python\nconfig.set_random_seed(123456)\n```\n\nRippy uses the ```default_rng``` class of the ```numpy.random``` module. This can also be configured using the ```config.rng``` property.\n\n### Using a GPU\n\nGPU support requires a CUDA compatible GPU. Internally rippy uses the cupy library. Install the dependencies by running\n\n```\npip install rippy[gpu]\n```\n\nTo enable GPU mode, set the RIPPY_USE_GPU environment variable to 1.\n```linux\nexport RIPPY_USE_GPU=1\n```\non Linux or\n```\nset RIPPY_USE_GPU=1\n```\non Windows. Set it to anythin else to revert to using a CPU\n\n\n## Project Status\n\nRippy is currently a proof of concept. There are a limited number of supported distributions and reinsurance contracts. We are working on:\n\n* Adding more distributions and loss generation types\n* Adding support for Catastrophe loss generation and reinsurance contracts\n* Adding support for more reinsurance contract types (Surplus, Stop Loss etc)\n* Grouping reinsurance contracts into programs and structures\n* Stratified sampling and Quasi-Monte Carlo methods\n* Reporting dashboards\n\n## Issues\n\nPlease log issues in github\n\n## Contributing\n\nYou are welcome to contribute pull requests\n\n",
"bugtrack_url": null,
"license": "MIT License",
"summary": "Reinsurance Pricing in Python!",
"version": "0.0.8",
"project_urls": {
"Homepage": "https://github.com/ProteusLLP/rippy",
"Issues": "https://github.com/ProteusLLP/rippy/issues"
},
"split_keywords": [
"reinsurance",
" actuarial",
" insurance"
],
"urls": [
{
"comment_text": "",
"digests": {
"blake2b_256": "be4d5e701446410f62d1d7ad787b19813ad833df1c82a6dfafc483ea074e9edb",
"md5": "3c026634b412efc85581a165b9af84b5",
"sha256": "df39ce21dcba97b4ef9190bc209439b0c67198e793c8b0e1bf7f51f0a36b2141"
},
"downloads": -1,
"filename": "rippy-0.0.8-py3-none-any.whl",
"has_sig": false,
"md5_digest": "3c026634b412efc85581a165b9af84b5",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.10",
"size": 14093,
"upload_time": "2024-10-21T17:26:54",
"upload_time_iso_8601": "2024-10-21T17:26:54.645137Z",
"url": "https://files.pythonhosted.org/packages/be/4d/5e701446410f62d1d7ad787b19813ad833df1c82a6dfafc483ea074e9edb/rippy-0.0.8-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "28f5f74254360da671ab13a950cefc14d90c833ab1bef2421359d9d42aecdb19",
"md5": "4f7511cdfa148f656c7e7c3e1fd38e40",
"sha256": "8fd0d650e52e1843ffff64f0957c97eba55a5ddb86c28e71f60eb86c3a4a7354"
},
"downloads": -1,
"filename": "rippy-0.0.8.tar.gz",
"has_sig": false,
"md5_digest": "4f7511cdfa148f656c7e7c3e1fd38e40",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.10",
"size": 17338,
"upload_time": "2024-10-21T17:26:55",
"upload_time_iso_8601": "2024-10-21T17:26:55.998374Z",
"url": "https://files.pythonhosted.org/packages/28/f5/f74254360da671ab13a950cefc14d90c833ab1bef2421359d9d42aecdb19/rippy-0.0.8.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2024-10-21 17:26:55",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "ProteusLLP",
"github_project": "rippy",
"travis_ci": false,
"coveralls": false,
"github_actions": true,
"requirements": [
{
"name": "numpy",
"specs": [
[
"==",
"1.26.4"
]
]
},
{
"name": "scipy",
"specs": [
[
"==",
"1.12.0"
]
]
}
],
"lcname": "rippy"
}
JSON
