diff --git a/.gitignore b/.gitignore
index 20f245e3dca3b11f428faab14eb7a8181616aaf4..39e9879694e66e9d3dfce07986a8b30c9e6efe47 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,6 +4,6 @@
.~lock.*#
R/Companies/
Formulas_Reference/2013*.xls*
-LifeInsuranceContracts.Rproj
+LifeInsureR.Rproj
Vergleichsrechnung_Excel
inst/doc
diff --git a/DESCRIPTION b/DESCRIPTION
index bbd7461fcb997c0ffcac5069e11083fa38761c55..839a67b48986f4f27384b6d1ad8847696bd6d69c 100644
--- a/DESCRIPTION
+++ b/DESCRIPTION
@@ -1,7 +1,7 @@
-Package: LifeInsuranceContracts
+Package: LifeInsureR
Type: Package
-Version: 0.0.5
-Date: 2023-10-18
+Version: 1.0.0
+Date: 2023-10-20
Title: Framework for Traditional Life Insurance Contracts
Description: R6 classes to model traditional life insurance
contracts like annuities, whole life insurances or endowments. Such life
@@ -45,7 +45,7 @@ Collate:
'InsuranceContract.R'
'addDataTableWorksheet.R'
'contractGrid.R'
- 'create_LIC_project.R'
+ 'create_LIR_project.R'
'exportInsuranceContract_xlsx.R'
'showVmGlgExamples.R'
'exportInsuranceContractExample.R'
@@ -57,5 +57,5 @@ Suggests:
fs
VignetteBuilder: knitr
Roxygen: list(markdown = TRUE)
-URL: https://gitlab.open-tools.net/R/r-life-insurance-contracts
-BugReports: https://gitlab.open-tools.net/R/r-life-insurance-contracts/-/issues
+URL: https://gitlab.open-tools.net/R/LifeInsureR
+BugReports: https://gitlab.open-tools.net/R/LifeInsureR/-/issues
diff --git a/Examples/Beispiel_Vortrag.R b/Examples/Beispiel_Vortrag.R
index 7031d533675417a7446435ce94ed222845606b29..c877743e9ccae3e3eb3ad56fa63def250a6a1b28 100644
--- a/Examples/Beispiel_Vortrag.R
+++ b/Examples/Beispiel_Vortrag.R
@@ -3,7 +3,7 @@
library(magrittr)
library(MortalityTables)
library(lubridate)
-library(LifeInsuranceContracts)
+library(LifeInsureR)
mortalityTables.load("Austria_Census")
mort.AT.census.2011.male
diff --git a/Examples/Example_Endowment_Dynamics_CODE.R b/Examples/Example_Endowment_Dynamics_CODE.R
index 7ccb9ae3e82329e6772e388d2982ff88635c6502..e6805b0379f54a750bee9c6bec3c757ecffc33f4 100644
--- a/Examples/Example_Endowment_Dynamics_CODE.R
+++ b/Examples/Example_Endowment_Dynamics_CODE.R
@@ -1,6 +1,6 @@
library(magrittr)
library(MortalityTables)
-library(LifeInsuranceContracts)
+library(LifeInsureR)
mortalityTables.load("Austria_Census")
# Costs: 4% acquisition, where 2.5% are zillmered, 5\% of each premium as beta costs,
diff --git a/R/InsuranceParameters.R b/R/InsuranceParameters.R
index 337ff57040dc4383bc4370cf4aa17dc3ecf761a0..b663454b94f261bfe712aa0597cc1540350a340b 100644
--- a/R/InsuranceParameters.R
+++ b/R/InsuranceParameters.R
@@ -32,14 +32,14 @@ NULL
#'
#' @export
setCost = function(costs, type, basis = "SumInsured", frequency = "PolicyPeriod", value) {
- costs[type, basis, frequency] = value
- costs
+ costs[type, basis, frequency] = value
+ costs
}
#' Initialize or modify a data structure for the definition of [InsuranceTarif] costs
#'
-#' Initialize a cost matrix with dimensions: {CostType, Basis, Period}, where:
+#' Initialize a cost matrix with dimensions: \{CostType, Basis, Period\}, where:
#' \describe{
#' \item{CostType:}{alpha, Zillmer, beta, gamma, gamma_nopremiums, unitcosts}
#' \item{Basis:}{SumInsured, SumPremiums, GrossPremium, NetPremium, Benefits, Constant}
@@ -100,7 +100,7 @@ setCost = function(costs, type, basis = "SumInsured", frequency = "PolicyPeriod"
initializeCosts = function(costs, alpha, Zillmer, alpha.commission, beta, gamma, gamma.paidUp, gamma.premiumfree, gamma.contract, gamma.afterdeath, gamma.fullcontract, unitcosts, unitcosts.PolicyPeriod) {
if (missing(costs)) {
dimnm = list(
- type = c("alpha", "Zillmer", "beta", "gamma", "gamma_nopremiums", "unitcosts"),
+ type = c("alpha", "Zillmer", "beta", "gamma", "gamma_nopremiums", "unitcosts"),
basis = c("SumInsured", "SumPremiums", "GrossPremium", "NetPremium", "Benefits", "Constant", "Reserve"),
frequency = c("once", "PremiumPeriod", "PremiumFree", "PolicyPeriod", "AfterDeath", "FullContract", "CommissionPeriod")
);
@@ -118,37 +118,37 @@ initializeCosts = function(costs, alpha, Zillmer, alpha.commission, beta, gamma,
costs = setCost(costs, "Zillmer", "SumPremiums", "CommissionPeriod", alpha.commission)
}
if (!missing(Zillmer)) {
- costs = setCost(costs, "Zillmer","SumPremiums", "once", Zillmer)
+ costs = setCost(costs, "Zillmer","SumPremiums", "once", Zillmer)
}
if (!missing(beta)) {
- costs = setCost(costs, "beta", "GrossPremium", "PremiumPeriod", beta)
+ costs = setCost(costs, "beta", "GrossPremium", "PremiumPeriod", beta)
}
if (!missing(gamma)) {
- costs = setCost(costs, "gamma", "SumInsured", "PremiumPeriod", gamma)
+ costs = setCost(costs, "gamma", "SumInsured", "PremiumPeriod", gamma)
}
if (!missing(gamma.premiumfree)) {
- costs = setCost(costs, "gamma", "SumInsured", "PremiumFree", gamma.premiumfree)
+ costs = setCost(costs, "gamma", "SumInsured", "PremiumFree", gamma.premiumfree)
}
if (!missing(gamma.paidUp)) {
- costs = setCost(costs, "gamma_nopremiums", "SumInsured", "PolicyPeriod", gamma.paidUp)
+ costs = setCost(costs, "gamma_nopremiums", "SumInsured", "PolicyPeriod", gamma.paidUp)
}
if (!missing(gamma.contract)) {
- costs = setCost(costs, "gamma", "SumInsured", "PolicyPeriod", gamma.contract)
- # costs = setCost(costs, "gamma_nopremiums", "SumInsured", "PolicyPeriod", gamma.contract)
+ costs = setCost(costs, "gamma", "SumInsured", "PolicyPeriod", gamma.contract)
+ # costs = setCost(costs, "gamma_nopremiums", "SumInsured", "PolicyPeriod", gamma.contract)
}
if (!missing(gamma.afterdeath)) {
- costs = setCost(costs, "gamma", "SumInsured", "AfterDeath", gamma.afterdeath)
- costs = setCost(costs, "gamma_nopremiums", "SumInsured", "AfterDeath", gamma.afterdeath)
+ costs = setCost(costs, "gamma", "SumInsured", "AfterDeath", gamma.afterdeath)
+ costs = setCost(costs, "gamma_nopremiums", "SumInsured", "AfterDeath", gamma.afterdeath)
}
if (!missing(gamma.fullcontract)) {
- costs = setCost(costs, "gamma", "SumInsured", "FullContract", gamma.fullcontract)
- costs = setCost(costs, "gamma_nopremiums", "SumInsured", "FullContract", gamma.fullcontract)
+ costs = setCost(costs, "gamma", "SumInsured", "FullContract", gamma.fullcontract)
+ costs = setCost(costs, "gamma_nopremiums", "SumInsured", "FullContract", gamma.fullcontract)
}
if (!missing(unitcosts)) {
- costs = setCost(costs, "unitcosts", "Constant", "PremiumPeriod", unitcosts)
+ costs = setCost(costs, "unitcosts", "Constant", "PremiumPeriod", unitcosts)
}
if (!missing(unitcosts.PolicyPeriod)) {
- costs = setCost(costs, "unitcosts", "Constant", "PolicyPeriod", unitcosts.PolicyPeriod)
+ costs = setCost(costs, "unitcosts", "Constant", "PolicyPeriod", unitcosts.PolicyPeriod)
}
costs
}
@@ -165,13 +165,13 @@ initializeCosts = function(costs, alpha, Zillmer, alpha.commission, beta, gamma,
#'
#' @export
costs.baseAlpha = function(alpha) {
- function(params, values, costs) {
- costs = setCost(costs, "alpha", "SumPremiums", "once", alpha)
- if (costs["Zillmer", "SumPremiums", "once"] != 0) {
- costs = setCost(costs, "Zillmer", "SumPremiums", "once", alpha)
+ function(params, values, costs) {
+ costs = setCost(costs, "alpha", "SumPremiums", "once", alpha)
+ if (costs["Zillmer", "SumPremiums", "once"] != 0) {
+ costs = setCost(costs, "Zillmer", "SumPremiums", "once", alpha)
+ }
+ costs
}
- costs
- }
}
#' Helper function to modify alpha costs of an insurance contract individually
@@ -187,10 +187,10 @@ costs.baseAlpha = function(alpha) {
#'
#' @export
costs.scaleAlpha = function(scale) {
- function(costs, ...) {
- costs[c("alpha", "Zillmer"),,] = costs[c("alpha", "Zillmer"),,] * scale
- costs
- }
+ function(costs, ...) {
+ costs[c("alpha", "Zillmer"),,] = costs[c("alpha", "Zillmer"),,] * scale
+ costs
+ }
}
@@ -201,9 +201,9 @@ costs.scaleAlpha = function(scale) {
#' @param costs The cost structure to be displayed in a concise table style.
#' @export
costsDisplayTable = function(costs) {
- costtable = as.data.frame.table(setInsuranceValuesLabels(costs) )
- colnames(costtable) = c("Kostenart", "Basis", "Periode", "Kostensatz");
- costtable[costtable[,"Kostensatz"] != 0.0000,]
+ costtable = as.data.frame.table(setInsuranceValuesLabels(costs) )
+ colnames(costtable) = c("Kostenart", "Basis", "Periode", "Kostensatz");
+ costtable[costtable[,"Kostensatz"] != 0.0000,]
}
diff --git a/R/InsuranceTarif.R b/R/InsuranceTarif.R
index aa5de30957e4a36e57cf3c4fd38c3aa86b3da33e..51d6195cbc6cfd9d37c6588003228ffc9a569b9b 100644
--- a/R/InsuranceTarif.R
+++ b/R/InsuranceTarif.R
@@ -1478,7 +1478,7 @@ InsuranceTarif = R6Class(
#'
#' @details Not to be called directly, but implicitly by the [InsuranceContract] object.
#' @param ... Additional parameters for the profit participation calculation, passed
- #' through to the profit participation scheme's \href{../../LifeInsuranceContracts/html/ProfitParticipation.html#method-getProfitParticipation}{\code{ProfitParticipation$getProfitParticipation()}}
+ #' through to the profit participation scheme's \href{../../LifeInsureR/html/ProfitParticipation.html#method-getProfitParticipation}{\code{ProfitParticipation$getProfitParticipation()}}
calculateProfitParticipation = function(params, ...) {
if (getOption('LIC.debug.calculateProfitParticipation', FALSE)) {
browser();
diff --git a/R/ProfitParticipation.R b/R/ProfitParticipation.R
index 1bf0964668009a59f0244ef293270d9180864cc6..17dec78077fbbd4da77f07e49093f616836129ad 100644
--- a/R/ProfitParticipation.R
+++ b/R/ProfitParticipation.R
@@ -15,8 +15,8 @@ NULL
#'
#' @export
filterProfitRates = function(rates, classes) {
- rates %>%
- dplyr::filter(.data$profitClass %in% classes)
+ rates %>%
+ dplyr::filter(.data$profitClass %in% classes)
}
@@ -43,336 +43,336 @@ filterProfitRates = function(rates, classes) {
#'
#' @export
ProfitParticipation = R6Class(
- "ProfitParticipation",
- public = list(
- #' @field name The human-readable name of the profit plan.
- name = "Name des Gewinnplans",
- #' @field Parameters Parameter template for profit-participation-specific
- #' parameters, i.e. the \code{ProfitParticipation} element of the
- #' [InsuranceContract.ParameterStructure] data structure.
- #'
- #' All elements defined in the profit scheme can be overriden per contract
- #' in the call to \code{[InsuranceContract]$new} or even in the explicit
- #' call to \ifelse{html}{\href{../../LifeInsuranceContracts/html/InsuranceContract.html#method-profitScenario}{\code{InsuranceContract$profitScenario()}}}{\code{InsuranceContract$profitScenario()()}}
- #' or \ifelse{html}{\href{../../LifeInsuranceContracts/html/InsuranceContract.html#method-addProfitScenario}{\code{InsuranceContract$addProfitScenario()}}}{\code{InsuranceContract$addProfitScenario()()}}.
- #'
- #'
- Parameters = InsuranceContract.ParameterStructure$ProfitParticipation,
-
- ########################################################################m#
- # Function blocks (modular) to determine bases, rates and calculation ##m#
- ########################################################################m#
- #' @field Functions list of functions defined to calculate the individual
- #' components. For each of the profit components
- #' \itemize{
- #' \item interest profit
- #' \item risk profit
- #' \item expense profit
- #' \item sum profit
- #' \item terminal bonus
- #' \item terminal bonus fund
- #' }
- #' a rate, a profit base and a calculation function can be defined, by assigning one of the pre-defined
- #' [ProfitParticipationFunctions] or proving your own function with signature
- #' \code{function(rates, params, values, ...)}. Additionally, for each of the
- #' benefit types (survival, death, surrender, premium waiver) a function can
- #' be provided to calculate the benefit stemming from profit participation.
- Functions = list(
-
- #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- # Calculation bases for the various types of profit
- # Can / shall be overridden in child classes that use other bases!
- #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- getInterestProfitBase = PP.base.meanContractualReserve,
- getRiskProfitBase = PP.base.ZillmerRiskPremium,
- getExpenseProfitBase = PP.base.sumInsured,
- getSumProfitBase = PP.base.sumInsured,
- getTerminalBonusBase = PP.base.sumInsured,
- getTerminalBonusFundBase = PP.base.totalProfitAssignment,
-
- #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- # Profit rates for the various types of profit
- # Can / shall be overridden in child classes that use other schemes!
- #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- getInterestProfitRate = PP.rate.interestProfit,
- getRiskProfitRate = PP.rate.riskProfit,
- getExpenseProfitRate = PP.rate.expenseProfit,
- getSumProfitRate = PP.rate.sumProfit,
- getTerminalBonusRate = PP.rate.terminalBonus,
- getTerminalBonusFundRate= PP.rate.terminalBonusFund,
-
-
- getInterestOnProfits = PP.rate.totalInterest,
-
-
-
- calculateInterestProfit = PP.calculate.RateOnBase,
- calculateRiskProfit = PP.calculate.RateOnBase,
- calculateExpenseProfit = PP.calculate.RateOnBase,
- calculateSumProfit = PP.calculate.RateOnBase,
-
- calculateTerminalBonus = PP.calculate.RateOnBase,
- getTerminalBonusReserve = function(profits, rates, terminalBonus, terminalBonusAccount, params, values) {
- n = length(terminalBonusAccount)
- terminalBonusAccount * 1/(1.07) ^ ((n - 1):0)
+ "ProfitParticipation",
+ public = list(
+ #' @field name The human-readable name of the profit plan.
+ name = "Name des Gewinnplans",
+ #' @field Parameters Parameter template for profit-participation-specific
+ #' parameters, i.e. the \code{ProfitParticipation} element of the
+ #' [InsuranceContract.ParameterStructure] data structure.
+ #'
+ #' All elements defined in the profit scheme can be overriden per contract
+ #' in the call to \code{[InsuranceContract]$new} or even in the explicit
+ #' call to \ifelse{html}{\href{../../LifeInsureR/html/InsuranceContract.html#method-profitScenario}{\code{InsuranceContract$profitScenario()}}}{\code{InsuranceContract$profitScenario()()}}
+ #' or \ifelse{html}{\href{../../LifeInsureR/html/InsuranceContract.html#method-addProfitScenario}{\code{InsuranceContract$addProfitScenario()}}}{\code{InsuranceContract$addProfitScenario()()}}.
+ #'
+ #'
+ Parameters = InsuranceContract.ParameterStructure$ProfitParticipation,
+
+ ########################################################################m#
+ # Function blocks (modular) to determine bases, rates and calculation ##m#
+ ########################################################################m#
+ #' @field Functions list of functions defined to calculate the individual
+ #' components. For each of the profit components
+ #' \itemize{
+ #' \item interest profit
+ #' \item risk profit
+ #' \item expense profit
+ #' \item sum profit
+ #' \item terminal bonus
+ #' \item terminal bonus fund
+ #' }
+ #' a rate, a profit base and a calculation function can be defined, by assigning one of the pre-defined
+ #' [ProfitParticipationFunctions] or proving your own function with signature
+ #' \code{function(rates, params, values, ...)}. Additionally, for each of the
+ #' benefit types (survival, death, surrender, premium waiver) a function can
+ #' be provided to calculate the benefit stemming from profit participation.
+ Functions = list(
+
+ #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ # Calculation bases for the various types of profit
+ # Can / shall be overridden in child classes that use other bases!
+ #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ getInterestProfitBase = PP.base.meanContractualReserve,
+ getRiskProfitBase = PP.base.ZillmerRiskPremium,
+ getExpenseProfitBase = PP.base.sumInsured,
+ getSumProfitBase = PP.base.sumInsured,
+ getTerminalBonusBase = PP.base.sumInsured,
+ getTerminalBonusFundBase = PP.base.totalProfitAssignment,
+
+ #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ # Profit rates for the various types of profit
+ # Can / shall be overridden in child classes that use other schemes!
+ #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ getInterestProfitRate = PP.rate.interestProfit,
+ getRiskProfitRate = PP.rate.riskProfit,
+ getExpenseProfitRate = PP.rate.expenseProfit,
+ getSumProfitRate = PP.rate.sumProfit,
+ getTerminalBonusRate = PP.rate.terminalBonus,
+ getTerminalBonusFundRate= PP.rate.terminalBonusFund,
+
+
+ getInterestOnProfits = PP.rate.totalInterest,
+
+
+
+ calculateInterestProfit = PP.calculate.RateOnBase,
+ calculateRiskProfit = PP.calculate.RateOnBase,
+ calculateExpenseProfit = PP.calculate.RateOnBase,
+ calculateSumProfit = PP.calculate.RateOnBase,
+
+ calculateTerminalBonus = PP.calculate.RateOnBase,
+ getTerminalBonusReserve = function(profits, rates, terminalBonus, terminalBonusAccount, params, values) {
+ n = length(terminalBonusAccount)
+ terminalBonusAccount * 1/(1.07) ^ ((n - 1):0)
+ },
+ calculateTerminalBonusFund = PP.calculate.RateOnBase,
+
+ #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ # Calculations of the assigned profit amounts, based on the bases and
+ # rates defined with the functions above.
+ # Can / shall be overridden in child classes that use other bases!
+ #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+ calculateSurvivalBenefit = PP.benefit.ProfitPlusTerminalBonusReserve,
+ calculateDeathBenefitAccrued = PP.benefit.ProfitPlusGuaranteedInterest,
+ calculateDeathBenefitTerminal = PP.benefit.TerminalBonus5YearsProRata,
+ calculateSurrenderBenefitAccrued = PP.benefit.ProfitPlusHalfGuaranteedInterest,
+ calculateSurrenderBenefitTerminal = PP.benefit.TerminalBonus5YearsProRata,
+ calculatePremiumWaiverBenefitAccrued = PP.benefit.Profit,
+ calculatePremiumWaiverBenefitTerminal = PP.benefit.TerminalBonus5YearsProRata,
+
+
+ dummy = 0
+ ),
+
+
+ #' @description Create a new profit participation scheme
+ #' @details This function is called when a new profit participation scheme
+ #' is created with a call to \code{ProfitParticipation$new(...)}. Possible
+ #' parameters to the \code{new}-Call are all parameters from the `ProfitParticipation` sublist of the
+ #' [InsuranceContract.ParameterStructure] parameter
+ #' structure (which are understood as template values that can be overridden
+ #' per contract or even per profit participation scenario) and the components
+ #' of the `Functions` field defining the functions to calculate the individual
+ #' components of the profit participation (rates, calculation bases, calculation, benefits)
+ #'
+ #' @param name The name of the profit scheme (typicall the name of the profit plan and its version)
+ #' @param ... profit participation parameters to be stored in the
+ #' `Parameters field or calculation functions to be stored in the `Functions`
+ #' field
+ initialize = function(name = NULL, ...) {
+ if (!missing(name)) self$name = name;
+ self$setParameters(...);
+ self$setFunctions(...);
+ self$setFallbackParameters();
},
- calculateTerminalBonusFund = PP.calculate.RateOnBase,
-
- #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- # Calculations of the assigned profit amounts, based on the bases and
- # rates defined with the functions above.
- # Can / shall be overridden in child classes that use other bases!
- #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-
- calculateSurvivalBenefit = PP.benefit.ProfitPlusTerminalBonusReserve,
- calculateDeathBenefitAccrued = PP.benefit.ProfitPlusGuaranteedInterest,
- calculateDeathBenefitTerminal = PP.benefit.TerminalBonus5YearsProRata,
- calculateSurrenderBenefitAccrued = PP.benefit.ProfitPlusHalfGuaranteedInterest,
- calculateSurrenderBenefitTerminal = PP.benefit.TerminalBonus5YearsProRata,
- calculatePremiumWaiverBenefitAccrued = PP.benefit.Profit,
- calculatePremiumWaiverBenefitTerminal = PP.benefit.TerminalBonus5YearsProRata,
-
-
- dummy = 0
- ),
-
-
- #' @description Create a new profit participation scheme
- #' @details This function is called when a new profit participation scheme
- #' is created with a call to \code{ProfitParticipation$new(...)}. Possible
- #' parameters to the \code{new}-Call are all parameters from the `ProfitParticipation` sublist of the
- #' [InsuranceContract.ParameterStructure] parameter
- #' structure (which are understood as template values that can be overridden
- #' per contract or even per profit participation scenario) and the components
- #' of the `Functions` field defining the functions to calculate the individual
- #' components of the profit participation (rates, calculation bases, calculation, benefits)
- #'
- #' @param name The name of the profit scheme (typicall the name of the profit plan and its version)
- #' @param ... profit participation parameters to be stored in the
- #' `Parameters field or calculation functions to be stored in the `Functions`
- #' field
- initialize = function(name = NULL, ...) {
- if (!missing(name)) self$name = name;
- self$setParameters(...);
- self$setFunctions(...);
- self$setFallbackParameters();
- },
- #' @description Store all passed parameters in the `Parameters` field
- #' @param ... any of the named fields defined in the `ProfitParticipation` sublist of the
- #' [InsuranceContract.ParameterStructure]. All other arguments will be ignored
- setParameters = function(...) {
- self$Parameters = fillFields(self$Parameters, list(...));
- },
+ #' @description Store all passed parameters in the `Parameters` field
+ #' @param ... any of the named fields defined in the `ProfitParticipation` sublist of the
+ #' [InsuranceContract.ParameterStructure]. All other arguments will be ignored
+ setParameters = function(...) {
+ self$Parameters = fillFields(self$Parameters, list(...));
+ },
- #' @description Store all passed functions in the `Functions` field
- #' @param ... any of the functions defined in the `Functions` field. All other
- #' arguments will be ignored
- setFunctions = function(...) {
- self$Functions = fillFields(self$Functions, list(...));
- },
+ #' @description Store all passed functions in the `Functions` field
+ #' @param ... any of the functions defined in the `Functions` field. All other
+ #' arguments will be ignored
+ setFunctions = function(...) {
+ self$Functions = fillFields(self$Functions, list(...));
+ },
- #' @description Fill all missing parameters with the default fall-back values
- setFallbackParameters = function() {
- self$Parameters = fallbackFields(self$Parameters, list(profitParticipationScheme = self));
- self$Parameters = fallbackFields(self$Parameters, InsuranceContract.ParameterDefaults$ProfitParticipation);
- },
+ #' @description Fill all missing parameters with the default fall-back values
+ setFallbackParameters = function() {
+ self$Parameters = fallbackFields(self$Parameters, list(profitParticipationScheme = self));
+ self$Parameters = fallbackFields(self$Parameters, InsuranceContract.ParameterDefaults$ProfitParticipation);
+ },
- #' @description create a copy of a profit scheme with certain parameters changed
- #' @details This method \code{createModification} returns a copy of the profit scheme
- #' with all given arguments changed in the schmes's `Parameters`
- #' parameter list.
- #'
- #' As ProfitParticipation is a R6 class with reference logic, simply assigning
- #' the object to a new variable does not create a copy, but references the
- #' original profit scheme object. To create an actual copy, one needs to call this
- #' method, which first clones the whole object and then adjusts all parameters
- #' to the values passed to this method.
- #'
- #' @param name The new name for the cloned [ProfitParticipation] object
- #' @param ... Parameters for the [InsuranceContract.ParameterStructure],
- #' defining the characteristics of the tariff.
- createModification = function(name = NULL, ...) {
- cloned = self$clone();
- if (!missing(name)) cloned$name = name;
- cloned$Parameters = fillFields(cloned$Parameters, list(...));
- cloned$Functions = fillFields(cloned$Functions, list(...));
- cloned
- },
+ #' @description create a copy of a profit scheme with certain parameters changed
+ #' @details This method \code{createModification} returns a copy of the profit scheme
+ #' with all given arguments changed in the schmes's `Parameters`
+ #' parameter list.
+ #'
+ #' As ProfitParticipation is a R6 class with reference logic, simply assigning
+ #' the object to a new variable does not create a copy, but references the
+ #' original profit scheme object. To create an actual copy, one needs to call this
+ #' method, which first clones the whole object and then adjusts all parameters
+ #' to the values passed to this method.
+ #'
+ #' @param name The new name for the cloned [ProfitParticipation] object
+ #' @param ... Parameters for the [InsuranceContract.ParameterStructure],
+ #' defining the characteristics of the tariff.
+ createModification = function(name = NULL, ...) {
+ cloned = self$clone();
+ if (!missing(name)) cloned$name = name;
+ cloned$Parameters = fillFields(cloned$Parameters, list(...));
+ cloned$Functions = fillFields(cloned$Functions, list(...));
+ cloned
+ },
- ##########################################################################m#
- # Advance Profit Participation ####
- ##########################################################################m#
-
- #' @description Calculate and return the advance profit participation (to be
- #' applied on the actuarial gross premium)
- #'
- #' @details The [InsuranceContract]'s param structure [InsuranceContract.ParameterStructure]
- #' contains the field \code{params$ProfitParticipation$advanceProfitParticipation},
- #' which can either be numeric rate for advance profit participation, or
- #' a function with signature \code{function(params, values, ...)} that
- #' returns the advance profit participation rate when called with the
- #' contract's parameters and the values calculated so far (cash flows and premiums)
- #' @return Return either one numerical value (constant for the whole premium payment period)
- #' of a vector of numerical values for the whole contract period
- #'
- #' @param ... optional parameters, to be passed to the advanceProfitParticipation
- #' field of the parameter structure (if that is a function)
- getAdvanceProfitParticipation = function(params, values, ...) {
- valueOrFunction(params$ProfitParticipation$advanceProfitParticipation, params, values, ...)
- },
+ ##########################################################################m#
+ # Advance Profit Participation ####
+ ##########################################################################m#
+
+ #' @description Calculate and return the advance profit participation (to be
+ #' applied on the actuarial gross premium)
+ #'
+ #' @details The [InsuranceContract]'s param structure [InsuranceContract.ParameterStructure]
+ #' contains the field \code{params$ProfitParticipation$advanceProfitParticipation},
+ #' which can either be numeric rate for advance profit participation, or
+ #' a function with signature \code{function(params, values, ...)} that
+ #' returns the advance profit participation rate when called with the
+ #' contract's parameters and the values calculated so far (cash flows and premiums)
+ #' @return Return either one numerical value (constant for the whole premium payment period)
+ #' of a vector of numerical values for the whole contract period
+ #'
+ #' @param ... optional parameters, to be passed to the advanceProfitParticipation
+ #' field of the parameter structure (if that is a function)
+ getAdvanceProfitParticipation = function(params, values, ...) {
+ valueOrFunction(params$ProfitParticipation$advanceProfitParticipation, params, values, ...)
+ },
- #' @description Calculate and return the advance profit participation (to be
- #' applied after unit costs are added to the gross premium)
- #'
- #' @details The [InsuranceContract]'s param structure [InsuranceContract.ParameterStructure]
- #' contains the field \code{params$ProfitParticipation$advanceProfitParticipationInclUnitCost},
- #' which can either be numeric rate for advance profit participation, or
- #' a function with signature \code{function(params, values, ...)} that
- #' returns the advance profit participation rate when called with the
- #' contract's parameters and the values calculated so far (cash flows and premiums)
- #' @return Return either one numerical value (constant for the whole premium payment period)
- #' of a vector of numerical values for the whole contract period
- #'
- #' @param ... optional parameters, to be passed to the advanceProfitParticipationInclUnitCost
- #' field of the parameter structure (if that is a function)
- getAdvanceProfitParticipationAfterUnitCosts = function(params, values, ...) {
- valueOrFunction(params$ProfitParticipation$advanceProfitParticipationInclUnitCost, params, values, ...)
- },
+ #' @description Calculate and return the advance profit participation (to be
+ #' applied after unit costs are added to the gross premium)
+ #'
+ #' @details The [InsuranceContract]'s param structure [InsuranceContract.ParameterStructure]
+ #' contains the field \code{params$ProfitParticipation$advanceProfitParticipationInclUnitCost},
+ #' which can either be numeric rate for advance profit participation, or
+ #' a function with signature \code{function(params, values, ...)} that
+ #' returns the advance profit participation rate when called with the
+ #' contract's parameters and the values calculated so far (cash flows and premiums)
+ #' @return Return either one numerical value (constant for the whole premium payment period)
+ #' of a vector of numerical values for the whole contract period
+ #'
+ #' @param ... optional parameters, to be passed to the advanceProfitParticipationInclUnitCost
+ #' field of the parameter structure (if that is a function)
+ getAdvanceProfitParticipationAfterUnitCosts = function(params, values, ...) {
+ valueOrFunction(params$ProfitParticipation$advanceProfitParticipationInclUnitCost, params, values, ...)
+ },
- ##########################################################################m#
- # Traditional Profit participation: ####
- # - Interest profit ##m#
- # - Risk profit ##m#
- # - Expense profit ##m#
- # - Sum profit ##m#
- # - Terminal bonus ##m#
- ##########################################################################m#
-
-
- #' @description Set up the data.frame containing the profit participation rates
- #' @param ... additional parameters passed to the profit calculation functions
- #' stored in the `Functions` field.
- setupRates = function(params, values, ...) {
- # 1) Profit scheme or contract provides general company-wide profit rates for some years:
- # profitRates
- # 2) Contract can override individual rates (either for calendar years or contract years):
- # guaranteedInterest, interestProfitRate, totalInterest, mortalityProfitRate,
- # expenseProfitRate, sumProfitRate, terminalBonusRate, terminalBonusFundRate
- # 3) Explicit function arguments (either for calendar years or contract years).
- # 4) Any missing values will be taken from the last given year
- startYear = year(params$ContractData$contractClosing);
- policyPeriod = params$ContractData$policyPeriod;
- years = startYear:(startYear + policyPeriod);
-
- columns = c(
- "year",
- "guaranteedInterest", "interestProfitRate", "totalInterest", "interestProfitRate2", "totalInterest2",
- "mortalityProfitRate", "expenseProfitRate", "expenseProfitRate_premiumfree",
- "sumProfitRate",
- "terminalBonusRate", "terminalBonusFundRate")
- rates = data.frame(matrix(ncol = length(columns), nrow = length(years), dimnames = list(years = years, rates = columns)))
- rates$year = years;
-
- # 1) profitRates are general company-wide tables with all default rates
- # => use them as default, unless overridden
- defrates = params$ProfitParticipation$profitRates
- if (!is.null(defrates)) {
- profclass = params$ProfitParticipation$profitClass
- defrates = dplyr::filter(defrates, profitClass == profclass)
- rownames(defrates) = defrates$year
-
- defcols = intersect(columns, colnames(defrates))
-
- rates[rownames(defrates), defcols] = defrates[, defcols]
- }
+ ##########################################################################m#
+ # Traditional Profit participation: ####
+ # - Interest profit ##m#
+ # - Risk profit ##m#
+ # - Expense profit ##m#
+ # - Sum profit ##m#
+ # - Terminal bonus ##m#
+ ##########################################################################m#
+
+
+ #' @description Set up the data.frame containing the profit participation rates
+ #' @param ... additional parameters passed to the profit calculation functions
+ #' stored in the `Functions` field.
+ setupRates = function(params, values, ...) {
+ # 1) Profit scheme or contract provides general company-wide profit rates for some years:
+ # profitRates
+ # 2) Contract can override individual rates (either for calendar years or contract years):
+ # guaranteedInterest, interestProfitRate, totalInterest, mortalityProfitRate,
+ # expenseProfitRate, sumProfitRate, terminalBonusRate, terminalBonusFundRate
+ # 3) Explicit function arguments (either for calendar years or contract years).
+ # 4) Any missing values will be taken from the last given year
+ startYear = year(params$ContractData$contractClosing);
+ policyPeriod = params$ContractData$policyPeriod;
+ years = startYear:(startYear + policyPeriod);
+
+ columns = c(
+ "year",
+ "guaranteedInterest", "interestProfitRate", "totalInterest", "interestProfitRate2", "totalInterest2",
+ "mortalityProfitRate", "expenseProfitRate", "expenseProfitRate_premiumfree",
+ "sumProfitRate",
+ "terminalBonusRate", "terminalBonusFundRate")
+ rates = data.frame(matrix(ncol = length(columns), nrow = length(years), dimnames = list(years = years, rates = columns)))
+ rates$year = years;
+
+ # 1) profitRates are general company-wide tables with all default rates
+ # => use them as default, unless overridden
+ defrates = params$ProfitParticipation$profitRates
+ if (!is.null(defrates)) {
+ profclass = params$ProfitParticipation$profitClass
+ defrates = dplyr::filter(defrates, profitClass == profclass)
+ rownames(defrates) = defrates$year
+
+ defcols = intersect(columns, colnames(defrates))
+
+ rates[rownames(defrates), defcols] = defrates[, defcols]
+ }
- # 2) Add the explicit overrides per profit rate (from the contract)
- for (col in columns) {
- if (!is.null(params$ProfitParticipation[[col]])) {
- rt = valueOrFunction(params$ProfitParticipation[[col]], params = params, values = values);
- if (is.null(names(rt))) {
- # numeric value or vector => assume values from the contract start year
- # and fill ALL policy years with the given rates (last entry repeated)
- rates[as.character(years), col] = padLast(rt, length(years));
- } else {
- # values with years assigned => use them only for the given year(s), don't override any other year
- rates[names(rt), col] = rt;
- rates[names(rt), "year"] = names(rt);
+ # 2) Add the explicit overrides per profit rate (from the contract)
+ for (col in columns) {
+ if (!is.null(params$ProfitParticipation[[col]])) {
+ rt = valueOrFunction(params$ProfitParticipation[[col]], params = params, values = values);
+ if (is.null(names(rt))) {
+ # numeric value or vector => assume values from the contract start year
+ # and fill ALL policy years with the given rates (last entry repeated)
+ rates[as.character(years), col] = padLast(rt, length(years));
+ } else {
+ # values with years assigned => use them only for the given year(s), don't override any other year
+ rates[names(rt), col] = rt;
+ rates[names(rt), "year"] = names(rt);
+ }
}
}
- }
- # 3) Use explicit function param overrides per profit rate (from this function call)
- argcols = match.call(expand.dots = FALSE)$`...`;
- matching.cols = intersect(columns, names(argcols))
- for (col in matching.cols) {
- rt = eval(argcols[[col]]);
- if (!is.null(rt)) {
- rt = valueOrFunction(rt, params = params, values = values);
- if (is.null(names(rt))) {
- # numeric value or vector => assume values from the contract start year
- # and fill ALL policy years with the given rates (last entry repeated)
- rates[as.character(years), col] = padLast(rt, length(years));
- } else {
- # values with years assigned => use them only for the given year(s), don't override any other year
- rates[names(rt), col] = rt;
- rates[names(rt), "year"] = names(rt);
+ # 3) Use explicit function param overrides per profit rate (from this function call)
+ argcols = match.call(expand.dots = FALSE)$`...`;
+ matching.cols = intersect(columns, names(argcols))
+ for (col in matching.cols) {
+ rt = eval(argcols[[col]]);
+ if (!is.null(rt)) {
+ rt = valueOrFunction(rt, params = params, values = values);
+ if (is.null(names(rt))) {
+ # numeric value or vector => assume values from the contract start year
+ # and fill ALL policy years with the given rates (last entry repeated)
+ rates[as.character(years), col] = padLast(rt, length(years));
+ } else {
+ # values with years assigned => use them only for the given year(s), don't override any other year
+ rates[names(rt), col] = rt;
+ rates[names(rt), "year"] = names(rt);
+ }
}
}
- }
- rownames(rates) = rates[, "year"]
+ rownames(rates) = rates[, "year"]
- # 4) Fill all NAs with the last known value
- # First, make sure that all entries are in the correct order (sorted by year)
- rates
- newrates = rates %>% dplyr::arrange(year) %>% dplyr::mutate_all(fillNAgaps)
- rownames(newrates) = newrates$year
+ # 4) Fill all NAs with the last known value
+ # First, make sure that all entries are in the correct order (sorted by year)
+ rates
+ newrates = rates %>% dplyr::arrange(year) %>% dplyr::mutate_all(fillNAgaps)
+ rownames(newrates) = newrates$year
- # 5) Replace all NA values with 0, so we don't run into any problems later on
- newrates[is.na(newrates)] <- 0
+ # 5) Replace all NA values with 0, so we don't run into any problems later on
+ newrates[is.na(newrates)] <- 0
- # TODO: Fix guaranteedInterest + interestProfitRate = totalInterest, where one of them might be missing!
+ # TODO: Fix guaranteedInterest + interestProfitRate = totalInterest, where one of them might be missing!
- # Return only the policy years...
- self$adjustRates(newrates[as.character(years),], params = params, values = values)
- },
+ # Return only the policy years...
+ self$adjustRates(newrates[as.character(years),], params = params, values = values)
+ },
- #' @description Adjust the data.frame of profit participation rates after their setup
- #' @details This function provides an easy way to modify the whole set of
- #' profit rates after their initial setup. Possible applications are waiting
- #' periods, which can be implemented once for all rates rather than inside
- #' each individual calculation period.
- #' @param rates data.frame of profit paticipation rates
- adjustRates = function(rates, params, values) {
- rates[1,] = 0;
- rates
- },
+ #' @description Adjust the data.frame of profit participation rates after their setup
+ #' @details This function provides an easy way to modify the whole set of
+ #' profit rates after their initial setup. Possible applications are waiting
+ #' periods, which can be implemented once for all rates rather than inside
+ #' each individual calculation period.
+ #' @param rates data.frame of profit paticipation rates
+ adjustRates = function(rates, params, values) {
+ rates[1,] = 0;
+ rates
+ },
- #' @description Calculation the full time series of profit participation for
- #' the given contract values
- #'
- #' @param calculateFrom The time from which to start calculating the profit
- #' participation. When a contract is changed at some time t (possibly even
- #' changing the profit scheme), all future profit participation needs to be
- #' re-calculated from that time on, without changing past profit participation.
- #' All values before \code{calculateFrom} will not be calculated.
- #' @param profitScenario profit participation values from a previous calculation
- #' (NULL if profit calculation is to be calculated from the contract inception).
- #' Values before \code{calculateFrom} will be used from this data.frame.
- #' @param ... additional parameters to be passed to \href{../../LifeInsuranceContracts/html/ProfitParticipation.html#method-setupRates}{\code{ProfitParticipation$setupRates()}}
- getProfitParticipation = function(calculateFrom = 0, profitScenario = NULL, params, values, ...) {
- waiting = valueOrFunction(params$ProfitParticipation$waitingPeriod, params = params, values = values);
- if (is.numeric(waiting) && waiting > 0) {
- waitingFactor = c(rep(0, waiting + 1), rep(1, params$ContractData$policyPeriod - waiting));
+ #' @description Calculation the full time series of profit participation for
+ #' the given contract values
+ #'
+ #' @param calculateFrom The time from which to start calculating the profit
+ #' participation. When a contract is changed at some time t (possibly even
+ #' changing the profit scheme), all future profit participation needs to be
+ #' re-calculated from that time on, without changing past profit participation.
+ #' All values before \code{calculateFrom} will not be calculated.
+ #' @param profitScenario profit participation values from a previous calculation
+ #' (NULL if profit calculation is to be calculated from the contract inception).
+ #' Values before \code{calculateFrom} will be used from this data.frame.
+ #' @param ... additional parameters to be passed to \href{../../LifeInsureR/html/ProfitParticipation.html#method-setupRates}{\code{ProfitParticipation$setupRates()}}
+ getProfitParticipation = function(calculateFrom = 0, profitScenario = NULL, params, values, ...) {
+ waiting = valueOrFunction(params$ProfitParticipation$waitingPeriod, params = params, values = values);
+ if (is.numeric(waiting) && waiting > 0) {
+ waitingFactor = c(rep(0, waiting + 1), rep(1, params$ContractData$policyPeriod - waiting));
} else {
waitingFactor = 1;
}
diff --git a/R/contractGrid.R b/R/contractGrid.R
index 407e9f7d6ab97b137f99c934d513330c9179a7af..fc74c8d6a6fbad1312be6b384eaf7d1df3f23f72 100644
--- a/R/contractGrid.R
+++ b/R/contractGrid.R
@@ -23,7 +23,7 @@
#' The \code{axes} list describing the parameters changing along the axes of the
#' resulting grid is internally expanded with [expand.grid()]. The resulting flat
#' list of parameter (together with the fixed parameters passed as \code{...})
-#' is then passed to the \ifelse{html}{\href{../../LifeInsuranceContracts/html/InsuranceContract.html#method-new}{\code{InsuranceContract$new()}}}{\code{InsuranceContract$new()()}} call to create the corresponding
+#' is then passed to the \ifelse{html}{\href{../../LifeInsureR/html/InsuranceContract.html#method-new}{\code{InsuranceContract$new()}}}{\code{InsuranceContract$new()()}} call to create the corresponding
#' contract object.
#'
#' To create the human-readable row-/columnnames of the resulting array,
@@ -36,7 +36,7 @@
#' @param axes List of paramters spanning the dimensions of the grid.
#' @param YOB optional year of bith. If missing, the \code{observationYear} and the contract's age
#' @param observationYear The observation year, for which the grid shall be calculated. If given, the YOB is calculated from it, otherwise the contract's YOB is used
-#' @param ... In \code{contractGrid}: Additional parameters to be passed to \ifelse{html}{\href{../../LifeInsuranceContracts/html/InsuranceContract.html#method-new}{\code{InsuranceContract$new()}}}{\code{InsuranceContract$new()()}}; In \code{contractGridPremium}: Additional parameters to be passed to \code{contractGrid}.
+#' @param ... In \code{contractGrid}: Additional parameters to be passed to \ifelse{html}{\href{../../LifeInsureR/html/InsuranceContract.html#method-new}{\code{InsuranceContract$new()}}}{\code{InsuranceContract$new()()}}; In \code{contractGridPremium}: Additional parameters to be passed to \code{contractGrid}.
#
# Params of the contractGridPreimium function:
#' @param contractGrid (optional) existing contract grid from which to derive
diff --git a/R/create_LIC_project.R b/R/create_LIR_project.R
similarity index 94%
rename from R/create_LIC_project.R
rename to R/create_LIR_project.R
index b90ccf296c547fafc8f322a024d55792d26eac70..16388b877628581d3e6a3ed696b7b6ed831a5311 100644
--- a/R/create_LIC_project.R
+++ b/R/create_LIR_project.R
@@ -4,7 +4,7 @@
# https://blog.devgenius.io/make-your-own-rstudio-project-template-1f77c4888e79
# and heavily modified
-create_LIC_project <- function(path, ...) {
+create_LIR_project <- function(path, ...) {
dots <- list(...)
CompanyName = dots$Company
@@ -21,10 +21,10 @@ create_LIC_project <- function(path, ...) {
LIC.src <- function (..., lib.loc = NULL, mustWork = FALSE){
system.file("rstudio", "templates", "project", ...,
- package = "LifeInsuranceContracts",
+ package = "LifeInsureR",
lib.loc = lib.loc, mustWork = mustWork)
}
- from <- LIC.src("LifeInsuranceContracts")
+ from <- LIC.src("LifeInsureR")
fs::dir_copy(path = from, new_path = path, overwrite = TRUE)
diff --git a/R/exportInsuranceContractExample.R b/R/exportInsuranceContractExample.R
index b4b3b00824a4e5ba2e07c54cb7baca31c67e93d5..a9cc5ed8b1115c126f4f04bbf6daa58aee983a9f 100644
--- a/R/exportInsuranceContractExample.R
+++ b/R/exportInsuranceContractExample.R
@@ -10,10 +10,10 @@ NULL
#' required by the Austrian regulation).
#'
#' Three output files are generated:
-#' - {DATE}_{TARIFF}_Example.xlsx: Full history/timeseries
-#' - {DATE}_{TARIFF}_Example_PremiumWaiver_t10.xlsx: Full history/timeseries
+#' - \{DATE\}_\{TARIFF\}_Example.xlsx: Full history/timeseries
+#' - \{DATE\}_\{TARIFF\}_Example_PremiumWaiver_t10.xlsx: Full history/timeseries
#' after a premium waiver at the given time \code{prf}
-#' - {DATE}_{TARIFF}_Examples_VmGlg.txt: Example calculation required for the
+#' - \{DATE\}_\{TARIFF\}_Examples_VmGlg.txt: Example calculation required for the
#' Austrian regulation (LV-VMGLV)
#'
#' @param contract The \code{\link{InsuranceContract}} object to be exported
diff --git a/README.md b/README.md
index b96611f2849df091967b4b44c1d36bbabf6668b4..dba4b1fd9b0fe5b93afe233610cb84ed20a134ac 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-# The *LifeInsuranceContracts* Package For Traditional Life Insurance with Guarantee and Profit Participation
+# The *LifeInsureR* Package For Traditional Life Insurance with Guarantee and Profit Participation
R package implementing general life insurance contracts
This package R6 classes to model traditional life insurance
diff --git a/inst/Beispiele/Example_Endowment.R b/inst/Beispiele/Example_Endowment.R
index 0791875aaeea9280ab080b041b3a14404ce064c5..f959d5fe14e8c98ae4fc6b31b82b61e7e373dab0 100644
--- a/inst/Beispiele/Example_Endowment.R
+++ b/inst/Beispiele/Example_Endowment.R
@@ -1,4 +1,4 @@
-library(LifeInsuranceContracts)
+library(LifeInsureR)
library(MortalityTables)
library(lubridate)
mortalityTables.load("Austria_Census")
diff --git a/inst/Beispiele/Example_WholeLife_L71-U.R b/inst/Beispiele/Example_WholeLife_L71-U.R
index 40101f35b3bdae55a6c2cd6245e108bf04fe2ecc..86797905182cea6e2e36b9001c436a883e7dd987 100644
--- a/inst/Beispiele/Example_WholeLife_L71-U.R
+++ b/inst/Beispiele/Example_WholeLife_L71-U.R
@@ -1,6 +1,6 @@
library(magrittr)
library(MortalityTables)
-library(LifeInsuranceContracts)
+library(LifeInsureR)
mortalityTables.load("Austria_Census")
Tarif.L71U = InsuranceTarif$new(
diff --git a/inst/Beispiele/examples.R b/inst/Beispiele/examples.R
new file mode 100644
index 0000000000000000000000000000000000000000..eac5db02e152150cc0bfcfa2118ea609f587f8ee
--- /dev/null
+++ b/inst/Beispiele/examples.R
@@ -0,0 +1,141 @@
+library(MortalityTables)
+library(LifeInsureR)
+mortalityTables.load("Austria_Census")
+mortalityTables.load("Austria_Annuities_AVOe2005R")
+# Costs: 4% acquisition, where 2.5% are zillmered, 5\% of each premium as beta costs,
+# 1%o acquisition costs of the sum insured over the whole contract period
+example.Costs = initializeCosts(
+ alpha = 0.04, Zillmer = 0.025,
+ beta = 0.05,
+ gamma.contract = 0.001, gamma.paidUp = 0.001
+)
+example.Surrender = function(surrenderReserve, params, values) {
+ n = params$ContractData$policyPeriod
+ # Surrender Penalty is 10% at the beginning and decreases linearly to 0%
+ surrenderReserve * (0.9 + 0.1 * (0:n)/n)
+}
+
+
+Tarif.Endowment = InsuranceTarif$new(
+ name = "Example Tariff - Endowment",
+ type = "endowment",
+ tarif = "EN1",
+ desc = "An endowment with regular premiums",
+
+ mortalityTable = mort.AT.census.2011.unisex,
+ i = 0.005,
+ costs = example.Costs,
+ unitcosts = 10,
+ tax = 0.04, # 4% insurance tax
+ surrenderValueCalculation = example.Surrender
+)
+
+Tarif.Life = InsuranceTarif$new(
+ name = "Example Tariff - Whole/Term Life",
+ type = "wholelife",
+ tarif = "Life1",
+ desc = "A whole or term life insurance with regular premiums",
+
+ mortalityTable = mort.AT.census.2011.unisex,
+ i = 0.005,
+ costs = example.Costs,
+ unitcosts = 10,
+ tax = 0.04, # 4% insurance tax
+ surrenderValueCalculation = example.Surrender
+)
+
+Tarif.ImmAnnuity = InsuranceTarif$new(
+ name = "Example Tariff - Immediate Annuity",
+ type = "annuity",
+ tarif = "Ann1",
+ desc = "An annuity with single-premium",
+ premiumPeriod = 1,
+
+ mortalityTable = AVOe2005R.unisex,
+ i = 0.005,
+ costs = example.Costs,
+ tax = 0.04 # 4% insurance tax
+)
+
+
+# Premium periods and deferral periods can also be given as a function of other
+# contract parameters (like the age at contract inception, etc.)
+Tarif.DefAnnuity = InsuranceTarif$new(
+ name = "Example Tariff - Deferred Annuity",
+ type = "annuity",
+ tarif = "Life1",
+ desc = "A deferred annuity (life-long payments start at age 65) with reg. premiums",
+
+ contractPeriod = function(params, values) { 120 - params$ContractData$age},
+ deferralPeriod = function(params, values) { 65 - params$ContractData$age},
+ premiumPeriod = function(params, values) { 65 - params$ContractData$age},
+
+ mortalityTable = AVOe2005R.unisex,
+ i = 0.005,
+ costs = example.Costs,
+ tax = 0.04, # 4% insurance tax
+ surrenderValueCalculation = example.Surrender
+)
+
+# An example dread-disease tariff, morbidity is assumed linearly increasing with age
+ddTable = mortalityTable.period(name = "Linear dread-disease table",
+ ages = 0:100, deathProbs = 0:100/500)
+Tarif.DreadDisease = InsuranceTarif$new(
+ name = "Example Tariff - Dread-Disease",
+ type = "dread-disease",
+ tarif = "DD1",
+ desc = "A dread disease insurance with a lump-sum payment upon diagnosis",
+
+ sumInsured = 50000,
+ mortalityTable = mort.AT.census.2011.unisex,
+ invalidityTable = ddTable,
+ i = 0.005,
+ costs = example.Costs,
+ unitcosts = 10,
+ tax = 0.04, # 4% insurance tax
+ surrenderValueCalculation = example.Surrender
+)
+
+
+Tarif.PureEnd = InsuranceTarif$new(
+ name = "Example Tariff - Pure Endowment",
+ type = "pureendowment",
+ tarif = "PE1-RP",
+ desc = "A pure endowment with regular premiums (standard tariff)",
+
+ mortalityTable = mort.AT.census.2011.unisex,
+ i = 0.005,
+ # Costs: 4% acquisition, where 2.5% are zillmered, 5\% of each premium as beta costs,
+ # 1%o administration costs of the sum insured over the whole contract period
+ costs = initializeCosts(alpha = 0.04, Zillmer = 0.025, beta = 0.05, gamma.contract = 0.001, gamma.paidUp = 0.001),
+ unitcosts = 10,
+
+ # Yearly premiums get no surcharge, monthly premiums add +4%
+ premiumFrequencyLoading = list("1" = 0, "2" = 0, "4" = 0, "12" = 0.04),
+ premiumRefund = 1, # Full gross premium refund upon death
+ tax = 0.04, # 4% insurance tas
+
+ surrenderValueCalculation = function(surrenderReserve, params, values) {
+ n = params$ContractData$policyPeriod
+ # Surrender Penalty is 10% at the beginning and decreases linearly to 0%
+ surrenderReserve * (0.9 + 0.1 * (0:n)/n)
+ }
+)
+
+
+contract.PureEnd = InsuranceContract$new(
+ Tarif.PureEnd,
+ age = 50, policyPeriod = 20,
+ premiumFrequency = 2,
+ sumInsured = 100000,
+ initialCapital = 50000,
+ contractClosing = as.Date("2020-10-01"),
+ balanceSheetDate = as.Date("2020-09-30")
+)
+
+contract.PureEnd$Values$cashFlows
+contract.PureEnd$Values$premiums
+contract.PureEnd$Values$reservesBalanceSheet
+
+exportInsuranceContract.xlsx(contract.PureEnd, "test.xlsx")
+openxlsx::openXL("text.xlsx")
diff --git a/inst/rstudio/templates/project/LifeInsuranceContracts/tests/testthat.R b/inst/rstudio/templates/project/LifeInsuranceContracts/tests/testthat.R
deleted file mode 100644
index e0b550c9a2eefca1d3d9c0fb0261a46943339c86..0000000000000000000000000000000000000000
--- a/inst/rstudio/templates/project/LifeInsuranceContracts/tests/testthat.R
+++ /dev/null
@@ -1,4 +0,0 @@
-library(testthat)
-library(LifeInsuranceContractsXXXCOMPANYXXX)
-
-test_check("LifeInsuranceContractsXXXCOMPANYXXX")
diff --git a/inst/rstudio/templates/project/LifeInsuranceContracts.dcf b/inst/rstudio/templates/project/LifeInsureR.dcf
similarity index 54%
rename from inst/rstudio/templates/project/LifeInsuranceContracts.dcf
rename to inst/rstudio/templates/project/LifeInsureR.dcf
index ce4aeb5dccbb2eaaa4c5f4e94a5d013ecef73085..e18a1c5c1b6be505496db6a5cd73646ad3f026a2 100644
--- a/inst/rstudio/templates/project/LifeInsuranceContracts.dcf
+++ b/inst/rstudio/templates/project/LifeInsureR.dcf
@@ -1,8 +1,8 @@
-Binding: create_LIC_project
-Title: LifeInsuranceContracts Implementation
-Subtitle: Company-specific product definitions using the LifeInsuranceContracts package
+Binding: create_LIR_project
+Title: LifeInsureR Implementation
+Subtitle: Company-specific product definitions using the LifeInsureR package
OpenFiles: RechnungGesamtbestand.R
-Caption: Company-specific LifeInsuranceContracts product implementation
+Caption: Company-specific LifeInsureR product implementation
Parameter: Company
Widget: TextInput
diff --git a/inst/rstudio/templates/project/LifeInsuranceContracts/.Rbuildignore b/inst/rstudio/templates/project/LifeInsureR/.Rbuildignore
similarity index 100%
rename from inst/rstudio/templates/project/LifeInsuranceContracts/.Rbuildignore
rename to inst/rstudio/templates/project/LifeInsureR/.Rbuildignore
diff --git a/inst/rstudio/templates/project/LifeInsuranceContracts/.gitignore b/inst/rstudio/templates/project/LifeInsureR/.gitignore
similarity index 100%
rename from inst/rstudio/templates/project/LifeInsuranceContracts/.gitignore
rename to inst/rstudio/templates/project/LifeInsureR/.gitignore
diff --git a/inst/rstudio/templates/project/LifeInsuranceContracts/DESCRIPTION b/inst/rstudio/templates/project/LifeInsureR/DESCRIPTION
similarity index 82%
rename from inst/rstudio/templates/project/LifeInsuranceContracts/DESCRIPTION
rename to inst/rstudio/templates/project/LifeInsureR/DESCRIPTION
index 1b35ed472b0ec1b52c36aa6f712571cbf707bcde..cb8d978c86a8b09f6780c3b27dda45a2babbe5a5 100644
--- a/inst/rstudio/templates/project/LifeInsuranceContracts/DESCRIPTION
+++ b/inst/rstudio/templates/project/LifeInsureR/DESCRIPTION
@@ -1,6 +1,6 @@
-Package: LifeInsuranceContractsXXXCOMPANYXXX
+Package: LifeInsureRXXXCOMPANYXXX
Type: Package
-Title: LifeInsuranceContract Implementation for XXXCOMPANYXXX
+Title: LifeInsureR Implementation for XXXCOMPANYXXX
Version: 0.1
Date: 2023-12-31
Description: Implementation of XXXCOMPANYXXX life insurance products.
@@ -10,7 +10,7 @@ Authors@R: c(person("Firstname", "Lastname", role = c("aut", "cre"),
Author: Firstname Lastname [aut, cre]
Maintainer: Firstname Lastname <email@example.com>
Depends: R (>= 3.1.0),
- LifeInsuranceContracts,
+ LifeInsureR,
MortalityTables,
here
Encoding: UTF-8
diff --git a/inst/rstudio/templates/project/LifeInsuranceContracts/NAMESPACE b/inst/rstudio/templates/project/LifeInsureR/NAMESPACE
similarity index 100%
rename from inst/rstudio/templates/project/LifeInsuranceContracts/NAMESPACE
rename to inst/rstudio/templates/project/LifeInsureR/NAMESPACE
diff --git a/inst/rstudio/templates/project/LifeInsuranceContracts/R/XXXCOMPANYXXX_General.R b/inst/rstudio/templates/project/LifeInsureR/R/XXXCOMPANYXXX_General.R
similarity index 93%
rename from inst/rstudio/templates/project/LifeInsuranceContracts/R/XXXCOMPANYXXX_General.R
rename to inst/rstudio/templates/project/LifeInsureR/R/XXXCOMPANYXXX_General.R
index c571c783c40dadf7afed9c18b317319cdacb4320..9e0bb13c006b1b895980ecee6c95da5d6d571ecd 100644
--- a/inst/rstudio/templates/project/LifeInsuranceContracts/R/XXXCOMPANYXXX_General.R
+++ b/inst/rstudio/templates/project/LifeInsureR/R/XXXCOMPANYXXX_General.R
@@ -36,25 +36,25 @@ XXXCOMPANYXXX.register = function(Tarif, Produkt, GV = NULL, AVB = NULL) {
# new products/tariffs cannot be added via XXXCOMPANYXXX.register.
# => Figure out a way to store all registered tariffs in a list
# that is not locked / that can be unlocked!
- if ("package:LifeInsuranceContractsXXXCOMPANYXXX" %in% search()) {
- pkgenv = as.environment("package:LifeInsuranceContractsXXXCOMPANYXXX")
+ if ("package:LifeInsureRXXXCOMPANYXXX" %in% search()) {
+ pkgenv = as.environment("package:LifeInsureRXXXCOMPANYXXX")
locked = bindingIsLocked("XXXCOMPANYXXX.Tariffs", pkgenv)
# if (locked) {
- # unlockBinding("XXXCOMPANYXXX.Tariffs", pkgenv)
- # locked = bindingIsLocked("XXXCOMPANYXXX.Tariffs", pkgenv)
+ # unlockBinding("XXXCOMPANYXXX.Tariffs", pkgenv)
+ # locked = bindingIsLocked("XXXCOMPANYXXX.Tariffs", pkgenv)
# }
- # nsenv = as.environment("namespace:LifeInsuranceContractsXXXCOMPANYXXX")
+ # nsenv = as.environment("namespace:LifeInsureRXXXCOMPANYXXX")
# locked = bindingIsLocked("XXXCOMPANYXXX.Tariffs", pkgenv)
# if (locked) {
# unlockBinding("XXXCOMPANYXXX.Tariffs", pkgenv)
# locked = bindingIsLocked("XXXCOMPANYXXX.Tariffs", pkgenv)
# }
}
- # assign("XXXCOMPANYXXX.Tariffs", 123, -1, as.environment("package:LifeInsuranceContractsXXXCOMPANYXXX"))
+ # assign("XXXCOMPANYXXX.Tariffs", 123, -1, as.environment("package:LifeInsureRXXXCOMPANYXXX"))
# if (locked) {
# warning("")
# }
- # unlockBinding("XXXCOMPANYXXX.Tariffs", as.environment("package:LifeInsuranceContractsXXXCOMPANYXXX"))
+ # unlockBinding("XXXCOMPANYXXX.Tariffs", as.environment("package:LifeInsureRXXXCOMPANYXXX"))
# unlockBinding(XXXCOMPANYXXX.Tariffs, pryr::where("XXXCOMPANYXXX.Tariffs"))
if (!locked && !is.null(GV) && !is.null(AVB)) {
XXXCOMPANYXXX.Tariffs[[paste0(Produkt, "/GV", GV, "/AVB", AVB)]] <<- Tarif
diff --git a/inst/rstudio/templates/project/LifeInsuranceContracts/R/XXXCOMPANYXXX_Gewinnplan1.R b/inst/rstudio/templates/project/LifeInsureR/R/XXXCOMPANYXXX_Gewinnplan1.R
similarity index 100%
rename from inst/rstudio/templates/project/LifeInsuranceContracts/R/XXXCOMPANYXXX_Gewinnplan1.R
rename to inst/rstudio/templates/project/LifeInsureR/R/XXXCOMPANYXXX_Gewinnplan1.R
diff --git a/inst/rstudio/templates/project/LifeInsuranceContracts/R/XXXCOMPANYXXX_Tarif1.R b/inst/rstudio/templates/project/LifeInsureR/R/XXXCOMPANYXXX_Tarif1.R
similarity index 100%
rename from inst/rstudio/templates/project/LifeInsuranceContracts/R/XXXCOMPANYXXX_Tarif1.R
rename to inst/rstudio/templates/project/LifeInsureR/R/XXXCOMPANYXXX_Tarif1.R
diff --git a/inst/rstudio/templates/project/LifeInsuranceContracts/R/XXXCOMPANYXXX_Tarif2.R b/inst/rstudio/templates/project/LifeInsureR/R/XXXCOMPANYXXX_Tarif2.R
similarity index 100%
rename from inst/rstudio/templates/project/LifeInsuranceContracts/R/XXXCOMPANYXXX_Tarif2.R
rename to inst/rstudio/templates/project/LifeInsureR/R/XXXCOMPANYXXX_Tarif2.R
diff --git a/inst/rstudio/templates/project/LifeInsuranceContracts/XXXCOMPANYXXXRechnungGesamtbestand.R b/inst/rstudio/templates/project/LifeInsureR/XXXCOMPANYXXXRechnungGesamtbestand.R
similarity index 98%
rename from inst/rstudio/templates/project/LifeInsuranceContracts/XXXCOMPANYXXXRechnungGesamtbestand.R
rename to inst/rstudio/templates/project/LifeInsureR/XXXCOMPANYXXXRechnungGesamtbestand.R
index 25b7095d3ce86c7b25cdd4bbf6b96df6871cc021..b609e33c969e150e3a7a813f5ee080d9d0b82521 100644
--- a/inst/rstudio/templates/project/LifeInsuranceContracts/XXXCOMPANYXXXRechnungGesamtbestand.R
+++ b/inst/rstudio/templates/project/LifeInsureR/XXXCOMPANYXXXRechnungGesamtbestand.R
@@ -1,12 +1,12 @@
-# This file was created from a template provided by the LifeInsuranceContracts
+# This file was created from a template provided by the LifeInsureR
# package. It's purpose is to read in a set of contract data and calculate the
# corresponding reserves (e.g. to validate the official numbers in the financial
# statements).
#
# Steps:
# 1. Implement the corresponding products in the files in the R/ subdirectory.
-# Use the LifeInsuranceContracts documentation available at
-# https://cran.r-project.org/web/packages/LifeInsuranceContracts/vignettes/using-the-lifeinsurancecontracts-package.html
+# Use the LifeInsureR documentation available at
+# https://cran.r-project.org/web/packages/LifeInsureR/vignettes/using-the-lifeinsurer-package.html
# 2. Install the package (using the "Install" button in RStudio's "Build" pane)
# 3. Set up the mapping of the columns of the contract data source to the package's arguments.
# The columns of the input data can be directly mapped to named arguments in LifeInsuranceContract$new(..) calls.
@@ -60,7 +60,7 @@
# c. Grouping happens by column SliceID. This allows multiple portfolio
# data rows to be combined to one contract with several slices / sum
# increases, which are calculated as one contract (see section "10.3
-# Dynamic Increases" of the LifeInsuranceContracts vignette). If each
+# Dynamic Increases" of the LifeInsureR vignette). If each
# slice / dynamic increase is supposed to be calculated individually
# and independent from the main contract / other increases, then the
# column mapped to the SliceID column needs to have a different value
@@ -136,7 +136,7 @@ library(purrrlyr)
library(openxlsx)
library(tictoc)
library(tidyverse)
-library(LifeInsuranceContractsXXXCOMPANYXXX)
+library(LifeInsureRXXXCOMPANYXXX)
mortalityTables.load("Austria_*")
diff --git a/inst/rstudio/templates/project/LifeInsureR/tests/testthat.R b/inst/rstudio/templates/project/LifeInsureR/tests/testthat.R
new file mode 100644
index 0000000000000000000000000000000000000000..fb6592bec988b8f85a3cc58be62a5c716f87ef2a
--- /dev/null
+++ b/inst/rstudio/templates/project/LifeInsureR/tests/testthat.R
@@ -0,0 +1,4 @@
+library(testthat)
+library(LifeInsureRXXXCOMPANYXXX)
+
+test_check("LifeInsureRXXXCOMPANYXXX")
diff --git a/inst/rstudio/templates/project/LifeInsuranceContracts/tests/testthat/.gitignore b/inst/rstudio/templates/project/LifeInsureR/tests/testthat/.gitignore
similarity index 100%
rename from inst/rstudio/templates/project/LifeInsuranceContracts/tests/testthat/.gitignore
rename to inst/rstudio/templates/project/LifeInsureR/tests/testthat/.gitignore
diff --git a/inst/rstudio/templates/project/LifeInsuranceContracts/tests/testthat/test-Tarif1.R b/inst/rstudio/templates/project/LifeInsureR/tests/testthat/test-Tarif1.R
similarity index 95%
rename from inst/rstudio/templates/project/LifeInsuranceContracts/tests/testthat/test-Tarif1.R
rename to inst/rstudio/templates/project/LifeInsureR/tests/testthat/test-Tarif1.R
index dc411b5150efa46a7f29c0ff639b6e59cc4afadd..36ace78fcaeaa1ccce8bc58a7b8cac1607cdf2bd 100644
--- a/inst/rstudio/templates/project/LifeInsuranceContracts/tests/testthat/test-Tarif1.R
+++ b/inst/rstudio/templates/project/LifeInsureR/tests/testthat/test-Tarif1.R
@@ -1,4 +1,4 @@
-# LifeInsuranceContracts::vmGlgExample.generateTest(
+# LifeInsureR::vmGlgExample.generateTest(
# XXXCOMPANYXXX.Tarif1,
# age=35, policyPeriod=30, sumInsured=100000,
# contractClosing = as.Date("2000-07-01"))
diff --git a/inst/rstudio/templates/project/LifeInsuranceContracts/tests/testthat/test-Tarif2.R b/inst/rstudio/templates/project/LifeInsureR/tests/testthat/test-Tarif2.R
similarity index 95%
rename from inst/rstudio/templates/project/LifeInsuranceContracts/tests/testthat/test-Tarif2.R
rename to inst/rstudio/templates/project/LifeInsureR/tests/testthat/test-Tarif2.R
index d3e6585c8724461544579d713a9d2d1b202f059a..ff727ba54c4445e8ff6ada48d963babe6a0087d8 100644
--- a/inst/rstudio/templates/project/LifeInsuranceContracts/tests/testthat/test-Tarif2.R
+++ b/inst/rstudio/templates/project/LifeInsureR/tests/testthat/test-Tarif2.R
@@ -1,4 +1,4 @@
-# LifeInsuranceContracts::vmGlgExample.generateTest(
+# LifeInsureR::vmGlgExample.generateTest(
# XXXCOMPANYXXX.Tarif2,
# age=35, policyPeriod = 85, sumInsured=100000,
# contractClosing = as.Date("2000-07-01"),
diff --git a/man/InsuranceTarif.Rd b/man/InsuranceTarif.Rd
index e6dd304e3b942eb5df3b5db1ae243431232f2d50..224ae9971f5d519ab83153a71b1ac4b502227d1d 100644
--- a/man/InsuranceTarif.Rd
+++ b/man/InsuranceTarif.Rd
@@ -998,7 +998,7 @@ parameters and the already calculated reserves of the contract.
scheme and the contract)}
\item{\code{...}}{Additional parameters for the profit participation calculation, passed
-through to the profit participation scheme's \href{../../LifeInsuranceContracts/html/ProfitParticipation.html#method-getProfitParticipation}{\code{ProfitParticipation$getProfitParticipation()}}}
+through to the profit participation scheme's \href{../../LifeInsureR/html/ProfitParticipation.html#method-getProfitParticipation}{\code{ProfitParticipation$getProfitParticipation()}}}
}
\if{html}{\out{</div>}}
}
diff --git a/man/ProfitParticipation.Rd b/man/ProfitParticipation.Rd
index 40edd9bd5951d7d6910138b8e1f7c34eb8d993f0..2315d54b9f31298f03e5b41d3fe41b2e816cd3e1 100644
--- a/man/ProfitParticipation.Rd
+++ b/man/ProfitParticipation.Rd
@@ -71,8 +71,8 @@ parameters, i.e. the \code{ProfitParticipation} element of the
All elements defined in the profit scheme can be overriden per contract
in the call to \code{[InsuranceContract]$new} or even in the explicit
-call to \ifelse{html}{\href{../../LifeInsuranceContracts/html/InsuranceContract.html#method-profitScenario}{\code{InsuranceContract$profitScenario()}}}{\code{InsuranceContract$profitScenario()()}}
-or \ifelse{html}{\href{../../LifeInsuranceContracts/html/InsuranceContract.html#method-addProfitScenario}{\code{InsuranceContract$addProfitScenario()}}}{\code{InsuranceContract$addProfitScenario()()}}.}
+call to \ifelse{html}{\href{../../LifeInsureR/html/InsuranceContract.html#method-profitScenario}{\code{InsuranceContract$profitScenario()}}}{\code{InsuranceContract$profitScenario()()}}
+or \ifelse{html}{\href{../../LifeInsureR/html/InsuranceContract.html#method-addProfitScenario}{\code{InsuranceContract$addProfitScenario()}}}{\code{InsuranceContract$addProfitScenario()()}}.}
\item{\code{Functions}}{list of functions defined to calculate the individual
components. For each of the profit components
@@ -346,7 +346,7 @@ scheme and the contract)}
\item{\code{values}}{Contract values calculated so far (guaranteed component of the
insurance contract, including cash flows, premiums, reserves etc.).}
-\item{\code{...}}{additional parameters to be passed to \href{../../LifeInsuranceContracts/html/ProfitParticipation.html#method-setupRates}{\code{ProfitParticipation$setupRates()}}}
+\item{\code{...}}{additional parameters to be passed to \href{../../LifeInsureR/html/ProfitParticipation.html#method-setupRates}{\code{ProfitParticipation$setupRates()}}}
}
\if{html}{\out{</div>}}
}
diff --git a/man/contractGrid.Rd b/man/contractGrid.Rd
index 43967b72d651028e581dcb3d38c787439645a1a6..64fb64afff5ac7e5971c7c41cf4fd458b82dc9c0 100644
--- a/man/contractGrid.Rd
+++ b/man/contractGrid.Rd
@@ -28,7 +28,7 @@ contractGridPremium(
\item{observationYear}{The observation year, for which the grid shall be calculated. If given, the YOB is calculated from it, otherwise the contract's YOB is used}
-\item{...}{In \code{contractGrid}: Additional parameters to be passed to \ifelse{html}{\href{../../LifeInsuranceContracts/html/InsuranceContract.html#method-new}{\code{InsuranceContract$new()}}}{\code{InsuranceContract$new()()}}; In \code{contractGridPremium}: Additional parameters to be passed to \code{contractGrid}.}
+\item{...}{In \code{contractGrid}: Additional parameters to be passed to \ifelse{html}{\href{../../LifeInsureR/html/InsuranceContract.html#method-new}{\code{InsuranceContract$new()}}}{\code{InsuranceContract$new()()}}; In \code{contractGridPremium}: Additional parameters to be passed to \code{contractGrid}.}
\item{contractGrid}{(optional) existing contract grid from which to derive
premiums. If not given, \link{contractGrid} is called with all parameters, so
@@ -66,7 +66,7 @@ function \code{contractGridPremium}.
The \code{axes} list describing the parameters changing along the axes of the
resulting grid is internally expanded with \code{\link[=expand.grid]{expand.grid()}}. The resulting flat
list of parameter (together with the fixed parameters passed as \code{...})
-is then passed to the \ifelse{html}{\href{../../LifeInsuranceContracts/html/InsuranceContract.html#method-new}{\code{InsuranceContract$new()}}}{\code{InsuranceContract$new()()}} call to create the corresponding
+is then passed to the \ifelse{html}{\href{../../LifeInsureR/html/InsuranceContract.html#method-new}{\code{InsuranceContract$new()}}}{\code{InsuranceContract$new()()}} call to create the corresponding
contract object.
To create the human-readable row-/columnnames of the resulting array,
diff --git a/man/exportInsuranceContractExample.Rd b/man/exportInsuranceContractExample.Rd
index f8a59beabfbcd605529f357aed2b228b90d605a8..fad74ad39918ffd9d95daf7acab5c148091cdd08 100644
--- a/man/exportInsuranceContractExample.Rd
+++ b/man/exportInsuranceContractExample.Rd
@@ -40,10 +40,10 @@ required by the Austrian regulation).
\details{
Three output files are generated:
\itemize{
-\item {DATE}_{TARIFF}_Example.xlsx: Full history/timeseries
-\item {DATE}_{TARIFF}_Example_PremiumWaiver_t10.xlsx: Full history/timeseries
+\item \{DATE\}_\{TARIFF\}_Example.xlsx: Full history/timeseries
+\item \{DATE\}_\{TARIFF\}_Example_PremiumWaiver_t10.xlsx: Full history/timeseries
after a premium waiver at the given time \code{prf}
-\item {DATE}_{TARIFF}_Examples_VmGlg.txt: Example calculation required for the
+\item \{DATE\}_\{TARIFF\}_Examples_VmGlg.txt: Example calculation required for the
Austrian regulation (LV-VMGLV)
}
}
diff --git a/man/initializeCosts.Rd b/man/initializeCosts.Rd
index 372e32576ed7eae2f06c93ae3f44c60c0738b870..4d7772acc7abfe9eeb9337bf4e6811171bcf8344 100644
--- a/man/initializeCosts.Rd
+++ b/man/initializeCosts.Rd
@@ -55,7 +55,7 @@ even if the insured has already dies (for term-fix insurances)}
\item{unitcosts.PolicyPeriod}{Unit costs (absolute monetary amount, during full contract period)}
}
\description{
-Initialize a cost matrix with dimensions: {CostType, Basis, Period}, where:
+Initialize a cost matrix with dimensions: \{CostType, Basis, Period\}, where:
\describe{
\item{CostType:}{alpha, Zillmer, beta, gamma, gamma_nopremiums, unitcosts}
\item{Basis:}{SumInsured, SumPremiums, GrossPremium, NetPremium, Benefits, Constant}
diff --git a/tests/testthat.R b/tests/testthat.R
index ec93ddba512575a0df2746f0163477cddbc05496..47f916bee108ede215f4350a03538f25a08cba16 100644
--- a/tests/testthat.R
+++ b/tests/testthat.R
@@ -1,7 +1,7 @@
library(testthat)
-library(LifeInsuranceContracts)
+library(LifeInsureR)
library(MortalityTables)
mortalityTables.load("Austria_Census")
mortalityTables.load("Austria_Annuities_AVOe2005R")
-test_check("LifeInsuranceContracts")
+test_check("LifeInsureR")
diff --git a/vignettes/creating-company-specific-implementations-as-package.Rmd b/vignettes/creating-company-specific-implementations-as-package.Rmd
index e7982e81adbf94f880b1be058468dec15639c391..3f6acb582fe1f608545b3ed6acd827df8c4f34e5 100644
--- a/vignettes/creating-company-specific-implementations-as-package.Rmd
+++ b/vignettes/creating-company-specific-implementations-as-package.Rmd
@@ -1,5 +1,5 @@
---
-title: "Creating Company-Specific LifeInsuranceContracts Implementations (using an RStudio Package Template)"
+title: "Creating Company-Specific LifeInsureR Implementations (using an RStudio Package Template)"
author:
- name: Reinhold Kainhofer
affiliation: Open Tools
@@ -13,7 +13,7 @@ output:
fig_height: 5
number_sections: true
vignette: >
- %\VignetteIndexEntry{Creating Company-Specific LifeInsuranceContracts Implementations (using an RStudio Package Template)}
+ %\VignetteIndexEntry{Creating Company-Specific LifeInsureR Implementations (using an RStudio Package Template)}
%\VignetteEncoding{UTF-8}
%\VignetteEngine{knitr::rmarkdown}
editor_options:
@@ -25,7 +25,7 @@ editor_options:
knitr::opts_chunk$set(collapse = TRUE, comment = "#>")
library(knitr)
library(kableExtra)
-library(LifeInsuranceContracts)
+library(LifeInsureR)
library(dplyr)
library(tibble)
library(lubridate)
@@ -34,10 +34,10 @@ options(scipen=5)
library(pander)
```
-The LifeInsuranceContracts package provides a full-featured framework to
-model classical life insurance contracts (non-unit linked). This is
-typically sufficient to implement simple example calculations or
-validate a single contract or tariff by a single individual.
+The LifeInsureR package provides a full-featured framework to model
+classical life insurance contracts (non-unit linked). This is typically
+sufficient to implement simple example calculations or validate a single
+contract or tariff by a single individual.
However, when working for a company (either from inside the company or
as an external consultant), one typically wants the implementation to be
@@ -47,16 +47,16 @@ encapsulating the company-specific tariff implementations in an R
package that provides and exports the individual products of the
company.
-The LifeInsuranceContracts package even provides an RStudio project
-template to create a new skeleton of a company-specific implementation
-to use as the foundation of such an implementation.
+The LifeInsureR package even provides an RStudio project template to
+create a new skeleton of a company-specific implementation to use as the
+foundation of such an implementation.
# Creating an RStudio project from the template
-The `LifeInsuranceContracts` package provides an RStudio project
-template that sets up a package for a company-specific tariff
-implementation. After installing the package, simply create a new
-RStudio project from the template:
+The `LifeInsureR` package provides an RStudio project template that sets
+up a package for a company-specific tariff implementation. After
+installing the package, simply create a new RStudio project from the
+template:
{width="61%"}
@@ -64,8 +64,8 @@ Project\..."](images/01_RStudio_ProjectTemplate_new.png){width="61%"}
{width="61%"}
-{width="61%"}](images/03_RStudio_ProjectTemplate_selectTemplate.png){width="61%"}
The resulting RStudio project will have the following file structure:
@@ -86,7 +86,7 @@ template](images/05_RStudio_ProjectTemplate_fileStructure.png)
penalty functions, etc. and is typically sourced from each tariff's
implementation file.
-- The files in the `tests/testthat/` directory are unit tests for the
+- The files in the `tests/testthat/` directory are unit tests for the
testthat package. Typically, you will use the example prescribed (by
the regulator) in the official tariff definitions as test cases, so
that the implementation will always correspond to the official
@@ -106,9 +106,8 @@ to validate the official numbers in the financial statements).
## Steps to implement batch-testing a whole (sub-)portfolio
1. Implement the corresponding products in the files in the `R/`
- subdirectory. Use the LifeInsuranceContracts documentation available
- at
- <https://cran.r-project.org/web/packages/LifeInsuranceContracts/vignettes/using-the-lifeinsurancecontracts-package.html>
+ subdirectory. Use the LifeInsureR documentation available at
+ <https://cran.r-project.org/web/packages/LifeInsureR/vignettes/using-the-lifeinsurer-package.html>
2. Install the package (using the "Install" button in RStudio's "Build"
pane)
@@ -153,7 +152,7 @@ openxlsx::write.xlsx(results, outfile("Prods-1-2"),
openXL(outfile("Prods-1-2"))
```
-## General Overview of the batch-calculation procedure
+## General Overview of the batch-calculation procedure
1. The contract data are read in from the filenames provided in the
`files` list and stored in the data.frame called `bestandinfos.all`.
@@ -191,14 +190,14 @@ openXL(outfile("Prods-1-2"))
3. Grouping happens by column `SliceID`. This allows multiple
portfolio data rows to be combined to one contract with several
slices / sum increases, which are calculated as one contract
- (see section "10.3 Dynamic Increases" of the
- LifeInsuranceContracts vignette). If each slice / dynamic
- increase is supposed to be calculated individually and
- independent from the main contract / other increases, then the
- column mapped to the `SliceID` column needs to have a different
- value for each portfolio data row. If `SliceID` uses contract
- numbers, all dynamics, etc. belonging to the same contract
- number will be combined and calculated using `$addDynamics`
+ (see section "10.3 Dynamic Increases" of the LifeInsureR
+ vignette). If each slice / dynamic increase is supposed to be
+ calculated individually and independent from the main contract /
+ other increases, then the column mapped to the `SliceID` column
+ needs to have a different value for each portfolio data row. If
+ `SliceID` uses contract numbers, all dynamics, etc. belonging to
+ the same contract number will be combined and calculated using
+ `$addDynamics`
4. Each contract (entries with distinct `SliceID` value) is
calculated in a loop using the `by_slice` function, which calls
diff --git a/vignettes/using-the-lifeinsurancecontracts-package.Rmd b/vignettes/using-the-lifeinsurancecontracts-package.Rmd
index cdaed0e1ded7fadc601b1b31b5b22848a88c615b..c95b254b9370129f12167d27e9ccd0c9c527381a 100644
--- a/vignettes/using-the-lifeinsurancecontracts-package.Rmd
+++ b/vignettes/using-the-lifeinsurancecontracts-package.Rmd
@@ -1,5 +1,5 @@
---
-title: "Using the LifeInsuranceContracts Package"
+title: "Using the LifeInsureR Package"
author:
- name: Reinhold Kainhofer
affiliation: Open Tools
@@ -14,7 +14,7 @@ output:
fig_height: 5
number_sections: true
vignette: >
- %\VignetteIndexEntry{Using the LifeInsuranceContracts Package}
+ %\VignetteIndexEntry{Using the LifeInsureR Package}
%\VignetteEngine{knitr::rmarkdown}
%\VignetteEncoding{UTF-8}
---
@@ -24,7 +24,7 @@ vignette: >
knitr::opts_chunk$set(collapse = TRUE, comment = "#>")
library(knitr)
library(kableExtra)
-library(LifeInsuranceContracts)
+library(LifeInsureR)
library(dplyr)
library(tibble)
library(lubridate)
@@ -48,7 +48,7 @@ kableTable = function(grd, ...) {
```
-The LifeInsuranceContracts package provides a full-featured framework to model classical life insurance contracts (non-unit linked). Mathematically, a general life insurance contracts can be defined using death and survival (and disability) benefit vectors to define the cash flows and calculate all premiums and reserves recursively. This powerful approach is taken by the LifeInsuranceContracts package to provide the most flexible contract modelling framework in R.
+The LifeInsureR package provides a full-featured framework to model classical life insurance contracts (non-unit linked). Mathematically, a general life insurance contracts can be defined using death and survival (and disability) benefit vectors to define the cash flows and calculate all premiums and reserves recursively. This powerful approach is taken by the LifeInsureR package to provide the most flexible contract modelling framework in R.
# General Overview of the Concepts
@@ -133,7 +133,7 @@ Surrender Value:
```{r SimpleExampleRiskTarif, warning=F, results="hide", message = F}
library(magrittr)
library(MortalityTables)
-library(LifeInsuranceContracts)
+library(LifeInsureR)
mortalityTables.load("Austria_Census")
Tarif.L71U = InsuranceTarif$new(
@@ -205,7 +205,7 @@ In our term life example, the insurance contract's unit cash flows are 1 for dea
benefits (both when premiums are paid and when the contract is paid-up) and for
premiums in advance. All other cash flows (guaranteed, survival or disease cash
flows) are zero. Similarly, the cost structure described above and implemented
-by the `LifeInsuranceContracts::initializeCosts()` function defines all cost cash
+by the `LifeInsureR::initializeCosts()` function defines all cost cash
flows, which are the starting point for all further calculations (only relevant
columns of the data.frame are shown):
@@ -1256,7 +1256,7 @@ for (d in dimnames(grd)[[4]]) {
# Exporting contract data to Excel
-The LifeInsuranceContracts package also provides a function to export a given
+The LifeInsureR package also provides a function to export a given
contract to a spreadsheet in Excel format:
* `exportInsuranceContract.xlsx(contract, filename)`
@@ -1971,7 +1971,7 @@ parameters take the corresponding functions (signature: `function(profits, rates
While the details of a profit participation scheme are very specific and no two
profit schemes are exactly alike, the basic functionality to extract rates and
bases and the calculation functions are usually not so different. For this
-reason, the `LifeInsuranceContracts` package provides several little helper functions
+reason, the `LifeInsureR` package provides several little helper functions
that provide the most common functionality for the definition of rates, bases and
the profit calculation. See `?ProfitParticipationFunctions` for the full list.