Metadata-Version: 2.1
Name: modelo_risco
Version: 0.0.3
Summary: Desenvolvimento do Modelo de Risco Atuarial individual e coletivo.
Home-page: https://github.com/filipeclduarte/modelo_risco/tree/master/
Author: Filipe C. L. Duarte
Author-email: filipe_pb_duarte@hotmail.com
License: Apache Software License 2.0
Description: # Modelo de Risco Atuarial
        > Modelo de Risco Individual.
        
        
        ## Install
        
        `pip install modelo_risco`
        
        ## Testando a classe ModeloRiscoInd
        
        ### Apenas 1 risco
        
        Vamos inicializar um objeto com apenas um risco.
        
        informações:
        
        * n = 100
        * q_i = 0.1
        * Distribuição B
        
        | P(Bi= B) | Bi |
        | --- | --- |
        | 0.4 | 122 |
        | 0.35 | 452 |
        | 0.2 | 210 |
        | 0.05 | 1000 |
        
        ```python
        # criando os dados para qtd_riscos = 1
        n = 100
        qi = 0.1
        
        B = {
            'PBi': [0.4, 0.35, 0.2, 0.05],
            'Bi': [122, 452, 210, 1000],
        }
        ```
        
        ### Criando o objeto ModeloRiscoInd com os parâemtros gerados:
        
        ```python
        # criando o modelo
        mod = ModeloRiscoInd(n, qi, B)
        
        # mostrando o modelo
        print(mod)
        ```
        
            Modelo de Risco Individual:
            n = 100
            E[I] = 0.1
            V[I] = 0.09000000000000001
            E[B] = 299.0
            V[B] = 46879.0
        
        
        #### Esperança do Sinistro
        
        ```python
        # calculando esperança do modelo
        print(mod.esperanca())
        ```
        
            2990.0
        
        
        #### Variância do Sinistro
        
        ```python
        # calculando variancia do modelo
        print(mod.variancia())
        ```
        
            1273399.0
        
        
        #### Desvio padrão do Sinistro
        
        ```python
        # calculando desvio pad
        print(mod.desv_pad())
        ```
        
            1128.4498216580123
        
        
        #### Coeficiente de variação
        
        # coeficiente de variacao
        print(mod.coef_var())
        
        #### Prêmio puro pelo princípio do valor esperado com carregamento de segurança
        
        ```python
        # premio puro
        print(mod.premio_puro(0.1))
        ```
        
            3289.0
        
        
        #### Prêmio comercial com carregamento de segurança e comercial
        
        ```python
        # premio comercial
        print(mod.premio_comercial(0.1, 0.3))
        ```
        
            4698.57
        
        
        #### Prêmio pela aproximação normal com probabilidade alfa de o Sinistro superar o Prêmio total
        
        ```python
        # premio aprox_normal
        alfa = 0.05
        print(mod.premio_aprox_normal(alfa))
        ```
        
            4846.134781986923
        
        
        #### Carregamento de segurança com probabilidade alfa de o Sinistro superar o prêmio total
        
        ```python
        # carreg seg aprox normal
        alfa = 0.025
        print(mod.carreg_seg(alfa))
        ```
        
            0.7397060230134953
        
        
        ### Mais de um risco
        
        #### Necessário utilizar NumPy arrays.
        
        * n = [200, 150, 50]
        * q_i = [0.12, 0.1, 0.05]
        * Distribuição B
        
        Risco n. 1
        
        | Bi | P(Bi = B) |
        | --- | --- |
        | 100 | 0.6 |
        | 340 | 0.3 |
        | 390 | 0.1 |
        
        Risco n. 2
        
        | B_i | P(B_i = B) |
        | --- | --- |
        | 500 | 0.8 |
        | 800 | 0.15 |
        | 950 | 0.05 |
        
        Risco n. 3
        
        | B_i | P(B_i = B) |
        | --- | --- |
        | 1000 | 0.8 |
        | 1500 | 0.1 |
        | 2500 | 0.1 |
        
        ```python
        import numpy as np
        
        ### Qtd_riscos = 2
        n = np.array([200, 150, 50])
        
        qi = np.array([0.12, 0.1, 0.05])
        
        PBi = np.array([[0.6, 0.3, 0.1], [0.8, 0.15, 0.05], [0.8, 0.1, 0.1]])
        Bi = np.array([[100, 340, 390], [500, 800, 950], [1000, 1500, 2500]])
        
        B = {
            'PBi': PBi,
            'Bi': Bi
        }
        
        mod = ModeloRiscoInd(n, qi, B, qtd_riscos = 3)
        
        print(mod)
        ```
        
            Modelo de Risco Individual:
            n = [200 150  50]
            E[I] = [0.12 0.1  0.05]
            V[I] = [0.1056 0.09   0.0475]
            E[B] = [ 201.   567.5 1200. ]
            V[B] = [ 15489.    19068.75 210000.  ]
        
        
        ```python
        ## checando
        es = (200 * 0.12 * 201) + (150 * 0.1 * 567.5) + (50 * 0.05 * 1200)
        print(es)
        eb1 = np.dot([0.6, 0.3, 0.1], [100, 340, 390])
        print(eb1)
        vb1 = np.dot(np.array([0.6, 0.3, 0.1]),np.array([100, 340, 390])**2) - eb1**2
        print(vb1)
        ```
        
            16336.5
            201.0
            15489.0
        
        
        ```python
        # esperança
        print(mod.esperanca())
        ```
        
            16336.5
        
        
        ```python
        # variancia
        print(mod.variancia())
        ```
        
            9803795.745000001
        
        
        ```python
        # desvio padrão
        print(mod.desv_pad())
        ```
        
            3131.1013629392455
        
        
        ```python
        # coef variacao
        print(mod.coef_var())
        ```
        
            0.1916629243068739
        
        
        ```python
        # premio puro
        print(mod.premio_puro(0.1))
        ```
        
            17970.15
        
        
        ```python
        # premio comercial
        print(mod.premio_comercial(0.1, 0.3))
        ```
        
            25671.64
        
        
        ```python
        # premio aprox normal
        print(mod.premio_aprox_normal(0.025))
        ```
        
            22473.3459033052
        
        
        ```python
        # carreg seg
        print(mod.carreg_seg(0.025))
        ```
        
            0.37565242881309935
        
        
        > Modelo de Risco Coletivo
        
        ### Testando a classe ModeloRiscoCol
        
        Necessário importar NumPy
        
        informações:
        
        * Distribuição N
        
        | P(N = n) | N |
        | ---  | --- |
        | 0.4  | 0 |
        | 0.35 | 1 |
        | 0.2  | 2 |
        | 0.05 | 3 |
        
        
        * Distribuição X
        
        | P(X = x) | X |
        | ---  | --- |
        | 0.3  | 1 |
        | 0.5  | 2 |
        | 0.15 | 3 |
        | 0.05 | 4 |
        
        
        
        ```python
        import numpy as np
        
        N = [0,1,2,3]
        PN = [0.4, 0.35, 0.2, 0.05]
        
        X = [1, 2, 3, 4]
        PX = [0.3, 0.5, 0.15, 0.05]
        
        modelo = ModeloRiscoCol(N, PN, X, PX)
        ```
        
        #### Inicialização do modelo
        
        ```python
        print(modelo)
        ```
        
            Modelo de Risco Coletivo:
            E[N] = 0.9
            V[N] = 0.79
            E[X] = 1.95
            V[X] = 0.6474999999999995
        
        
        #### Esperança do Sinistro
        
        ```python
        # esperança
        modelo.esperanca()
        ```
        
        
        
        
            1.755
        
        
        
        #### Variância do Sinistro
        
        ```python
        # variancia
        modelo.variancia()
        ```
        
        
        
        
            3.5867249999999995
        
        
        
        #### Desvio padrão do Sinistro
        
        ```python
        # desvio padrao
        modelo.desv_pad()
        ```
        
        
        
        
            1.8938650955123493
        
        
        
        #### Coeficiente de variação do Sinistro
        
        ```python
        # coeficiente de variação
        modelo.coef_var()
        ```
        
        
        
        
            1.0791254105483472
        
        
        
        #### Prêmio Puro pelo princípio do valor esperado com carregamento de segurança
        
        ```python
        # premio puro
        carreg_seg = 0.1
        modelo.premio_puro(carreg_seg)
        ```
        
        
        
        
            1.93
        
        
        
        #### Prêmio Comercial com carregamento de segurança e carregamento comercial
        
        ```python
        # premio comercial
        carreg_comercial = 0.3
        modelo.premio_comercial(carreg_seg, carreg_comercial)
        ```
        
        
        
        
            2.76
        
        
        
        #### Prêmio pela aproximação normal com probabilidade alfa de o Sinistro coletivo superar o Prêmio total
        
        ```python
        # premio aprox normal
        alfa = 0.025
        modelo.premio_aprox_normal(alfa)
        ```
        
        
        
        
            5.466907378781714
        
        
        
        #### Carregamento de segurança pela aproximação normal com probabilidade alfa de o Sinistro coletivo superar o Prêmio total
        
        ```python
        # carreg seg a partir da aprox normal
        modelo.carreg_seg(alfa)
        ```
        
        
        
        
            2.1150469394767604
        
        
        
Keywords: risco_atuarial
Platform: UNKNOWN
Classifier: Development Status :: 3 - Alpha
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: Apache Software License
Classifier: Natural Language :: English
Classifier: Programming Language :: Python :: 3.6
Classifier: Programming Language :: Python :: 3.7
Classifier: Programming Language :: Python :: 3.8
Requires-Python: >=3.6
Description-Content-Type: text/markdown
