diff --git a/R/InsuranceContract.R b/R/InsuranceContract.R
index 67f7ee6dda465f27e11d5e122eec18dd0a09ed05..7ca48ea9a8b78b403b463184be023223c293b4b0 100644
--- a/R/InsuranceContract.R
+++ b/R/InsuranceContract.R
@@ -70,7 +70,7 @@ InsuranceContract = R6Class(
}
private$consolidateContractData(tarif = tarif, ...);
- self$calculateContract(calculate = calculate, start = self$Parameters$ContractData$blockStart);
+ self$calculateContract(calculate = calculate);
invisible(self)
},
@@ -93,13 +93,14 @@ InsuranceContract = R6Class(
invisible(self)
},
- addBlock = function(blockID = NULL, block = NULL, t = 0, comment = comment, ...) {
+ addBlock = function(id = NULL, block = NULL, t = block$Values$int$blockStart, comment = comment, ...) {
if (missing(block) || is.null(block) || !is(block, "InsuranceContract")) {
# Create a block with the same tariff and parameters as the main contract, but allow overriding params with the ... arguments
- block = InsuranceContract$new(...)
+ block = InsuranceContract$new(id = id, ...)
}
+ # declare as child of 'self', store the time offset to the parent contract
block$parent = self
- block$Values$int$startsAt = t
+ block$Parameters$ContractData$blockStart = t
if (length(self$blocks) == 0) {
main = self$clone()
@@ -108,12 +109,12 @@ InsuranceContract = R6Class(
self$Parameters$ContractData$id = "Gesamt"
}
- if (missing(blockID) || is.null(blockID)) {
- blockID = paste0("block", length(self$blocks) + 1)
+ if (missing(id) || is.null(id)) {
+ id = paste0("block", length(self$blocks) + 1)
}
- self$blocks[[blockID]] = block
+ self$blocks[[id]] = block
# recalculate the whole contract by consolidating values from each block
- self$consolidateBlocks(start = t)
+ self$consolidateBlocks(valuesFrom = t)
self$addHistorySnapshot(time = t, comment = comment,
type = "Dynamics", params = self$Parameters, values = self$Values);
@@ -150,49 +151,50 @@ InsuranceContract = R6Class(
}
params$t = t
- params$blockID = id
params$id = id
params$comment = sprintf("Dynamic increase at time %d to sum %d", t, NewSumInsured)
do.call(self$addBlock, params)
},
- calculateContract = function(calculate = "all", start = 0, preservePastPV = TRUE, recalculatePremiums = TRUE, recalculatePremiumSum = TRUE, history_comment = NULL, history_type = "Contract") {
+ calculateContract = function(calculate = "all", valuesFrom = 0, premiumCalculationTime = 0, preservePastPV = TRUE, recalculatePremiums = TRUE, recalculatePremiumSum = TRUE, history_comment = NULL, history_type = "Contract") {
if (!is.null(self$blocks)) {
- .args = as.list(match.call()[-1])
for (b in self$blocks) {
+ .args = as.list(match.call()[-1])
+ # correctly shift the valuesFrom by each block's blockStart parameter
+ .args$valuesFrom = max(0, .args$valuesFrom - b$Parameters$ContractData$blockStart)
do.call(b$calculateContract, .args)
}
}
- self$Values$int = private$determineInternalValues(start = start)
+ self$Values$int = private$determineInternalValues()
self$Values$transitionProbabilities = mergeValues(
starting = self$Values$transitionProbabilities,
- ending = private$determineTransitionProbabilities(start = start),
- t = start)
+ ending = private$determineTransitionProbabilities(),
+ t = valuesFrom)
if (calculate == "probabilities") return(invisible(self));
self$Values$cashFlowsBasic = mergeValues(
starting = self$Values$cashFlowsBasic,
- ending = private$determineCashFlowsBasic(start = start),
- t = start);
+ ending = private$determineCashFlowsBasic(),
+ t = valuesFrom);
self$Values$cashFlows = mergeValues(
starting = self$Values$cashFlows,
- ending = private$determineCashFlows(start = start),
- t = start);
+ ending = private$determineCashFlows(),
+ t = valuesFrom);
if (recalculatePremiumSum) {
# Premium waiver: Premium sum is not affected by premium waivers, i.e. everything depending on the premium sum uses the original premium sum!
- self$Values$unitPremiumSum = private$determinePremiumSum(start = start);
+ self$Values$unitPremiumSum = private$determinePremiumSum();
}
self$Values$cashFlowsCosts = mergeValues3D(
starting = self$Values$cashFlowsCosts,
- ending = private$determineCashFlowsCosts(start = start),
- t = start);
+ ending = private$determineCashFlowsCosts(),
+ t = valuesFrom);
if (calculate == "cashflows") return(invisible(self));
# Shall we re-calculate PV or preserve the old ones???
- pv = private$calculatePresentValues(start = start)
- pvCost = private$calculatePresentValuesCosts(start = start)
+ pv = private$calculatePresentValues()
+ pvCost = private$calculatePresentValuesCosts()
oldPV = self$Values$presentValues
if (preservePastPV) {
# Preserve past present values, i.e. the PV represents the PV
@@ -206,8 +208,8 @@ InsuranceContract = R6Class(
if (!is.null(self$Values$presentValues)) {
self$Values$presentValues = self$Values$presentValues[,1:NCOL(pv)]
}
- self$Values$presentValues = mergeValues(starting = self$Values$presentValues, ending = pv, t = start)
- self$Values$presentValuesCosts = mergeValues3D(starting = self$Values$presentValuesCosts, ending = pvCost, t = start)
+ self$Values$presentValues = mergeValues(starting = self$Values$presentValues, ending = pv, t = valuesFrom)
+ self$Values$presentValuesCosts = mergeValues3D(starting = self$Values$presentValuesCosts, ending = pvCost, t = valuesFrom)
} else {
# Recalculate present value for times before start, i.e. make all PV consistent with the current cash flows
self$Values$presentValues = pv
@@ -217,42 +219,44 @@ InsuranceContract = R6Class(
# the premiumCalculation function returns the premiums AND the cofficients,
# so we have to extract the coefficients and store them in a separate variable
- res = private$calculatePremiums(start = start);
- self$Values$premiumCoefficients = res[["coefficients"]];
- # TODO: Store premiums in a data.frame???
- self$Values$premiums = res[["premiums"]]
- self$Values$int$premiumCalculationTime = start
+ if (recalculatePremiums) {
+ res = private$calculatePremiums(premiumCalculationTime = premiumCalculationTime);
+ self$Values$premiumCoefficients = res[["coefficients"]];
+ # TODO: Store premiums in a data.frame, including the time they are calculated???
+ self$Values$premiums = res[["premiums"]]
+ self$Values$int$premiumCalculationTime = premiumCalculationTime
+ }
if (calculate == "premiums") return(invisible(self));
# Update the cash flows and present values with the values of the premium
- pvAllBenefits = private$calculatePresentValuesBenefits(start = start)
+ pvAllBenefits = private$calculatePresentValuesBenefits()
if (preservePastPV) {
- self$Values$presentValues = mergeValues(starting = oldPV, ending = cbind(pv, pvAllBenefits), t = start)
+ self$Values$presentValues = mergeValues(starting = oldPV, ending = cbind(pv, pvAllBenefits), t = valuesFrom)
} else {
self$Values$presentValues = cbind(pv, pvAllBenefits)
}
- self$Values$absCashFlows = mergeValues(starting = self$Values$absCashFlows, ending = private$calculateAbsCashFlows(start = start), t = start);
- self$Values$absPresentValues = mergeValues(starting = self$Values$absPresentValues, ending = private$calculateAbsPresentValues(start = start), t = start);
+ self$Values$absCashFlows = mergeValues(starting = self$Values$absCashFlows, ending = private$calculateAbsCashFlows(), t = valuesFrom);
+ self$Values$absPresentValues = mergeValues(starting = self$Values$absPresentValues, ending = private$calculateAbsPresentValues(), t = valuesFrom);
if (calculate == "absvalues") return(invisible(self));
- self$Values$reserves = mergeValues(starting = self$Values$reserves, ending = private$calculateReserves(start = start), t = start);
- self$Values$reservesBalanceSheet = mergeValues(starting = self$Values$reservesBalanceSheet,ending = private$calculateReservesBalanceSheet(start = start), t = start);
+ self$Values$reserves = mergeValues(starting = self$Values$reserves, ending = private$calculateReserves(), t = valuesFrom);
+ self$Values$reservesBalanceSheet = mergeValues(starting = self$Values$reservesBalanceSheet,ending = private$calculateReservesBalanceSheet(), t = valuesFrom);
if (calculate == "reserves") return(invisible(self));
- self$Values$premiumComposition = mergeValues(starting = self$Values$premiumComposition, ending = private$premiumAnalysis(start = start), t = start);
- self$Values$premiumCompositionSums = mergeValues(starting = self$Values$premiumCompositionSums, ending = private$premiumCompositionSums(start = start), t = start);
- self$Values$premiumCompositionPV = mergeValues(starting = self$Values$premiumCompositionPV, ending = private$premiumCompositionPV(start = start), t = start);
- self$Values$basicData = mergeValues(starting = self$Values$basicData, ending = private$getBasicDataTimeseries(start = start), t = start);
+ self$Values$premiumComposition = mergeValues(starting = self$Values$premiumComposition, ending = private$premiumAnalysis(), t = valuesFrom);
+ self$Values$premiumCompositionSums = mergeValues(starting = self$Values$premiumCompositionSums, ending = private$premiumCompositionSums(), t = valuesFrom);
+ self$Values$premiumCompositionPV = mergeValues(starting = self$Values$premiumCompositionPV, ending = private$premiumCompositionPV(), t = valuesFrom);
+ self$Values$basicData = mergeValues(starting = self$Values$basicData, ending = private$getBasicDataTimeseries(), t = valuesFrom);
if (calculate == "premiumcomposition") return(invisible(self));
- private$profitParticipation(start = start); # TODO-start
+ private$profitParticipation();
if (calculate == "profitparticipation") return(invisible(self));
self$addHistorySnapshot(
- time = start,
+ time = valuesFrom,
comment = ifelse(is.null(history_comment),
- ifelse(start == 0, "Initial contract values", paste("Contract recalculation at time ", start)),
- history_comment),,
+ ifelse(valuesFrom == 0, "Initial contract values", paste("Contract recalculation at time", premiumCalculationTime)),
+ history_comment),
type = history_type,
params = self$Parameters,
values = self$Values
@@ -261,11 +265,12 @@ InsuranceContract = R6Class(
invisible(self)
},
- consolidateBlocks = function(start = 0) {
+ consolidateBlocks = function(valuesFrom = 0) {
# First, Re-calculate all children that have children on their own
for (b in self$blocks) {
if (length(b$blocks) > 0) {
- b$consolidateBlocks(start = start)
+ # correctly shift the valuesFrom by each block's blockStart parameter
+ b$consolidateBlocks(valuesFrom = max(0, valuesFrom - b$Parameters$ContractData$blockStart))
}
}
@@ -297,12 +302,12 @@ InsuranceContract = R6Class(
consolidateField = function(field) {
vals = NULL
if (length(self$blocks) == 0) {
- vals = padArray(self$Values[[field]], pad = self$Values$int$startsAt)
+ vals = self$Values[[field]]
}
for (b in self$blocks) {
- vals = sumPaddedArrays(arr1 = vals, arr2 = b$Values[[field]], pad2 = b$Values$int$startsAt)
+ vals = sumPaddedArrays(arr1 = vals, arr2 = b$Values[[field]], pad2 = b$Parameters$ContractData$blockStart)
}
- mergeValues(starting = self$Values[[field]], ending = vals, t = start);
+ mergeValues(starting = self$Values[[field]], ending = vals, t = valuesFrom);
}
@@ -337,7 +342,7 @@ InsuranceContract = R6Class(
# Premium Waiver: Stop all premium payments at time t
# the SumInsured is determined from the available
- premiumWaiverNew = function(t) {
+ premiumWaiver = function(t) {
newSumInsured = self$Values$reserves[[toString(t), "PremiumFreeSumInsured"]];
self$Parameters$ContractState$premiumWaiver = TRUE;
self$Parameters$ContractState$surrenderPenalty = FALSE; # Surrender penalty has already been applied, don't apply a second time
@@ -346,7 +351,8 @@ InsuranceContract = R6Class(
self$Parameters$ContractData$sumInsured = newSumInsured;
self$calculateContract(
- start = t,
+ valuesFrom = t,
+ premiumCalculationTime = t,
preservePastPV = TRUE, recalculatePremiums = TRUE, recalculatePremiumSum = FALSE,
history_comment = sprintf("Premium waiver at time %d", t), history_type = "PremiumWaiver")
@@ -357,7 +363,7 @@ InsuranceContract = R6Class(
# Premium Waiver: Stop all premium payments at time t
# the SumInsured is determined from the available
- premiumWaiver = function(t) {
+ premiumWaiverOLD = function(t) {
newSumInsured = self$Values$reserves[[toString(t), "PremiumFreeSumInsured"]];
self$Parameters$ContractState$premiumWaiver = TRUE;
self$Parameters$ContractState$surrenderPenalty = FALSE; # Surrender penalty has already been applied, don't apply a second time
@@ -506,57 +512,57 @@ InsuranceContract = R6Class(
self$tarif$getCostValues(costs, params = self$Parameters)
},
- determineInternalValues = function(start = 0) {
- self$tarif$getInternalValues(params = self$Parameters, start = start);
+ determineInternalValues = function(...) {
+ self$tarif$getInternalValues(params = self$Parameters, ...);
},
- determineTransitionProbabilities = function(start = 0) {
- self$tarif$getTransitionProbabilities(params = self$Parameters, values = self$Values, start = start);
+ determineTransitionProbabilities = function(...) {
+ self$tarif$getTransitionProbabilities(params = self$Parameters, values = self$Values, ...);
},
- determineCashFlowsBasic = function(start = 0) {
- self$tarif$getBasicCashFlows(params = self$Parameters, values = self$Values, start = start);
+ determineCashFlowsBasic = function(...) {
+ self$tarif$getBasicCashFlows(params = self$Parameters, values = self$Values, ...);
},
- determineCashFlows = function(start = 0) {
- self$tarif$getCashFlows(params = self$Parameters, values = self$Values, start = start);
+ determineCashFlows = function(...) {
+ self$tarif$getCashFlows(params = self$Parameters, values = self$Values, ...);
},
- determinePremiumSum = function(start = 0) {
+ determinePremiumSum = function(...) {
sum(self$Values$cashFlows$premiums_advance + self$Values$cashFlows$premiums_arrears);
},
- determineCashFlowsCosts = function(start = 0) {
- self$tarif$getCashFlowsCosts(params = self$Parameters, values = self$Values, start = start);
+ determineCashFlowsCosts = function(...) {
+ self$tarif$getCashFlowsCosts(params = self$Parameters, values = self$Values, ...);
},
- calculatePresentValues = function(start = 0) {
- self$tarif$presentValueCashFlows(params = self$Parameters, values = self$Values, start = start);
+ calculatePresentValues = function(...) {
+ self$tarif$presentValueCashFlows(params = self$Parameters, values = self$Values, ...);
},
- calculatePresentValuesCosts = function(start = 0) {
- self$tarif$presentValueCashFlowsCosts(params = self$Parameters, values = self$Values, start = start);
+ calculatePresentValuesCosts = function(...) {
+ self$tarif$presentValueCashFlowsCosts(params = self$Parameters, values = self$Values, ...);
},
- calculatePremiums = function(start = 0) {
- self$tarif$premiumCalculation(params = self$Parameters, values = self$Values, start = start);
+ calculatePremiums = function(...) {
+ self$tarif$premiumCalculation(params = self$Parameters, values = self$Values, ...);
},
- calculatePresentValuesBenefits = function(start = 0) {
- self$tarif$presentValueBenefits(params = self$Parameters, values = self$Values, start = start);
+ calculatePresentValuesBenefits = function(...) {
+ self$tarif$presentValueBenefits(params = self$Parameters, values = self$Values, ...);
},
- calculateAbsCashFlows = function(start = 0) {
- self$tarif$getAbsCashFlows(params = self$Parameters, values = self$Values, start = start);
+ calculateAbsCashFlows = function(...) {
+ self$tarif$getAbsCashFlows(params = self$Parameters, values = self$Values, ...);
},
- calculateAbsPresentValues = function(start = 0) {
- self$tarif$getAbsPresentValues(params = self$Parameters, values = self$Values, start = start);
+ calculateAbsPresentValues = function(...) {
+ self$tarif$getAbsPresentValues(params = self$Parameters, values = self$Values, ...);
},
- calculateReserves = function(start = 0) {
- self$tarif$reserveCalculation(params = self$Parameters, values = self$Values, start = start);
+ calculateReserves = function(...) {
+ self$tarif$reserveCalculation(params = self$Parameters, values = self$Values, ...);
},
- calculateReservesBalanceSheet = function(start = 0) {
- self$tarif$reserveCalculationBalanceSheet(params = self$Parameters, values = self$Values, start = start);
+ calculateReservesBalanceSheet = function(...) {
+ self$tarif$reserveCalculationBalanceSheet(params = self$Parameters, values = self$Values, ...);
},
- premiumAnalysis = function(start = 0) {
- self$tarif$premiumDecomposition(params = self$Parameters, values = self$Values, start = start);
+ premiumAnalysis = function(...) {
+ self$tarif$premiumDecomposition(params = self$Parameters, values = self$Values, ...);
},
- premiumCompositionSums = function(start = 0) {
- self$tarif$calculateFutureSums(self$Values$premiumComposition, start = start);
+ premiumCompositionSums = function(...) {
+ self$tarif$calculateFutureSums(self$Values$premiumComposition, ...);
},
- premiumCompositionPV = function(start = 0) {
- self$tarif$calculatePresentValues(self$Values$premiumComposition, params = self$Parameters, start = start);
+ premiumCompositionPV = function(...) {
+ self$tarif$calculatePresentValues(self$Values$premiumComposition, params = self$Parameters, ...);
},
profitParticipation = function(...) {
@@ -575,11 +581,11 @@ InsuranceContract = R6Class(
},
- getBasicDataTimeseries = function(start = 0) {
- self$tarif$getBasicDataTimeseries(params = self$Parameters, values = self$Values, start = start);
+ getBasicDataTimeseries = function(...) {
+ self$tarif$getBasicDataTimeseries(params = self$Parameters, values = self$Values, ...);
},
dummy.private = NULL
)
)
-# InsuranceContract$debug("premiumWaiver")
+
diff --git a/R/InsuranceParameters.R b/R/InsuranceParameters.R
index 10cf6c0b8380d5d04d35b28c07c50e12b9b556dc..9e93bbf9941ccc6ac2ffab25d8347e08f8c1bf19 100644
--- a/R/InsuranceParameters.R
+++ b/R/InsuranceParameters.R
@@ -96,7 +96,7 @@ InsuranceContract.ParameterDefaults = list(
deferralPeriod = 0, # Aufschubzeit bei Leibrenten
guaranteedPeriod = 0, # Garantiezeit bei Leibrenten
contractClosing = NULL, # Contract closing date (day/month is relevant for balance sheet reserves)
- blockStart = 0, # When the current tariff block starts (main block starts a 0, dynamic increases start leter!)
+ blockStart = 0, # When the current tariff block starts (main block starts a 0, dynamic increases start later!), only used by the parent block (i.e. t=0 of child is aligned with t=blockStart of parent)
premiumPayments = "in advance", # Prämienzahlungsweise (vor-/nachschüssig)
benefitPayments = "in advance", # Leistungszahlungsweise (vor-/nachschüssig)
diff --git a/R/InsuranceTarif.R b/R/InsuranceTarif.R
index 844319cac46c43e24e05c0a350f4b223a03e954d..ccd5fd7f6c3756a734727b6439215063481626a6 100644
--- a/R/InsuranceTarif.R
+++ b/R/InsuranceTarif.R
@@ -69,14 +69,12 @@ InsuranceTarif = R6Class(
},
# Get some internal parameters cached (length of data.frames, policy periods cut at max.age, etc.)
- getInternalValues = function(params, start = 0) {
- p = c()
+ getInternalValues = function(params, ...) {
age = params$ContractData$technicalAge
maxAge = getOmega(params$ActuarialBases$mortalityTable)
policyPeriod = params$ContractData$policyPeriod
list(
l = min(maxAge - age, policyPeriod) + 1,
- startsAt = start,
policyTerm = min(maxAge - age, policyPeriod),
premiumTerm = min(policyPeriod, params$ContractData$premiumPeriod)
)
@@ -92,10 +90,9 @@ InsuranceTarif = R6Class(
ages
},
- getTransitionProbabilities = function(params, values, start = 0) {
+ getTransitionProbabilities = function(params, values) {
age = params$ContractData$technicalAge;
ages = self$getAges(params);
- # TODO: Use the start parameter to include possible selection tables (i.e. contract/block starts at time 'start' => qx depend on when contract started, e.g. immediate annuities in DAV 2004-R)
q = deathProbabilities(params$ActuarialBases$mortalityTable, YOB = params$ContractData$YOB, ageDifferences = params$ContractData$ageDifferences);
if (age > 0) {
q = q[-age:-1];
@@ -123,19 +120,19 @@ InsuranceTarif = R6Class(
# - for single premiums it will be c(1, 0, 0, ...),
# - for increasing premiums it will be (1+increase)^(0:(premiumPeriod-1))
# and 0 after the premium period
- getPremiumCF = function(len, params, values, start = 0) {
+ getPremiumCF = function(len, params, values) {
premPeriod = min(params$ContractData$premiumPeriod, params$ContractData$policyPeriod, len);
if (is.null(params$ContractData$premiumIncrease)) {
- pad0(rep(1, premPeriod - 1), len, start = start);
+ pad0(rep(1, premPeriod - 1), len)
} else {
inc = valueOrFunction(params$ContractData$premiumIncrease, premiumPeriod = premPeriod, params = params, values = values)
if (is.vector(inc) && length(inc) > 1) {
# If premiumIncrease is (or returns) a vector, treat it as
# relative premium amounts, ie. c(1, 1.1, 1.2) means +10% of
# the initial premium for the second and third year
- pad0(inc, len, start = start)
+ pad0(inc, len)
} else {
- pad0(inc ^ (0:(premPeriod - start - 1)), len, start = start)
+ pad0(inc ^ (0:(premPeriod - 1)), len)
}
}
},
@@ -144,20 +141,20 @@ InsuranceTarif = R6Class(
# - For constant annuity it will be rep(1, annuityPeriod),
# - for increasing annuities it will be (1+increase)^(0:(premiumPeriod-1))
# and 0 after the premium period
- getAnnuityCF = function(len, params, values, start = 0) {
+ getAnnuityCF = function(len, params, values) {
annuityPeriod = min(params$ContractData$policyPeriod - params$ContractData$deferralPeriod, len);
if (is.null(params$ContractData$annuityIncrease)) {
- pad0(rep(1, annuityPeriod), len, start = start);
+ pad0(rep(1, annuityPeriod), len);
} else {
inc = valueOrFunction(params$ContractData$annuityIncrease, annuityPeriod = annuityPeriod, params = params, values = values)
if (is.vector(inc) && length(inc) > 1) {
# If annuityIncrease is (or returns) a vector, treat it as
# relative annuity amounts, ie. c(1, 1.1, 1.2) means +10% of
# the initial annuity for the second and third year
- pad0(inc, len, start = start)
+ pad0(inc, len)
} else {
# a numeric value means constant yearly increases (multiplicative)
- pad0(inc ^ (0:annuityPeriod), len, start = start)
+ pad0(inc ^ (0:annuityPeriod), len)
}
}
},
@@ -165,25 +162,25 @@ InsuranceTarif = R6Class(
# Get the unit death cash flow for the whole protection period (after potential deferral period!)
# - For constant death benefit it will be rep(1, policyPeriod),
# - for linearly decreasing sum insured it will be (policyPeriod:0)/policyPeriod
- getDeathCF = function(len, params, values, start = 0) {
+ getDeathCF = function(len, params, values) {
period = params$ContractData$policyPeriod - params$ContractData$deferralPeriod;
if (is.null(params$ContractData$deathBenefit)) {
- pad0(rep(1, period), len, start = start)
+ pad0(rep(1, period), len)
} else {
benefit = valueOrFunction(params$ContractData$deathBenefit, len = len, params = params, values = values)
if (is.vector(benefit) && length(benefit) > 1) {
# If deathBenefit is (or returns) a vector, treat it as
# relative annuity amounts, ie. c(1, 1.1, 1.2) means +10% of
# the initial annuity for the second and third year
- pad0(benefit, len, start = start)
+ pad0(benefit, len)
} else {
# constant death benefit
- pad0(rep(benefit, period), len, start = start)
+ pad0(rep(benefit, period), len)
}
}
},
- getBasicCashFlows = function(params, values, start = 0) {
+ getBasicCashFlows = function(params, values) {
deferralPeriod = params$ContractData$deferralPeriod;
guaranteedPeriod = params$ContractData$guaranteedPeriod;
@@ -194,12 +191,11 @@ InsuranceTarif = R6Class(
survival = zeroes,
death = zeroes,
disease = zeroes,
- sumInsured = c(rep(0, start), rep(1, values$int$l - start))
+ sumInsured = rep(1, values$int$l)
);
if (self$tariffType == "annuity") {
annuityPeriod = values$int$policyTerm - deferralPeriod;
- # getAnnuityCF correctly handles start inside and after deferral period!
- annuityCF = self$getAnnuityCF(len = annuityPeriod, params = params, values = values, start = max(0, start - deferralPeriod))
+ annuityCF = self$getAnnuityCF(len = annuityPeriod, params = params, values = values)
# guaranteed payments exist only with annuities (first n years of the payment)
cf$guaranteed = pad0(
c(
@@ -211,60 +207,47 @@ InsuranceTarif = R6Class(
if (guaranteedPeriod > 0) tail(annuityCF, n = -guaranteedPeriod) else annuityCF,
0), values$int$l)
- if (start <= deferralPeriod) {
- # start current contract block within deferral period
- # increases/decreases of annuities happen only after deferral!
- cf$sumInsured = c(rep(0, start), rep(1, deferralPeriod - start), annuityCF, 0)
- } else {
- # start current contract block after deferral period
- cf$sumInsured = c(rep(0, deferralPeriod), annuityCF, 0)
- }
+ # start current contract block after deferral period
+ cf$sumInsured = c(rep(0, deferralPeriod), annuityCF, 0)
} else if (self$tariffType == "terme-fix") {
# Begin of bock does not have any influence
- cf$guaranteed = c(rep(0, values$int$policyTerm), 1);
+ cf$guaranteed = c(rep(0, values$int$policyTerm), 1)
} else if (self$tariffType == "dread-disease") {
- # potential Payments start after deferral period and after start of this block
+ # potential Payments start after deferral period
cf$disease = c(
- rep(0, max(deferralPeriod, start)),
- rep(1, values$int$l - 1 - max(deferralPeriod, start)),
- 0);
+ rep(0, deferralPeriod),
+ rep(1, values$int$l - 1 - deferralPeriod),
+ 0)
} else {
# For endowments, use the death factor here in the basic death CF
# to fix the relation of death to survival benefit
- deathCF = self$getDeathCF(values$int$l - 1 - deferralPeriod, params = params, values = values, start = max(0, start - deferralPeriod))
+ deathCF = self$getDeathCF(values$int$l - 1 - deferralPeriod, params = params, values = values)
if (self$tariffType == "endowment" || self$tariffType == "pureendowment" || self$tariffType == "endowment + dread-disease") {
- cf$survival = c(rep(0, values$int$policyTerm), 1); # start of block does not have any influence!
+ cf$survival = c(rep(0, values$int$policyTerm), 1)
}
if (self$tariffType == "endowment" || self$tariffType == "wholelife" || self$tariffType == "endowment + dread-disease") {
- # start of block already properly handled in deathCF
- cf$death = c(
- rep(0, deferralPeriod),
- deathCF,
- 0);
- cf$sumInsured = c(
- rep(0, deferralPeriod),
- deathCF,
- 1);
+ cf$death = c(rep(0, deferralPeriod), deathCF, 0)
+ cf$sumInsured = c(rep(0, deferralPeriod), deathCF, 1);
}
if (self$tariffType == "endowment + dread-disease") {
cf$disease = c(
- rep(0, max(deferralPeriod, start)),
- rep(1, values$int$l - 1 - max(deferralPeriod, start)),
+ rep(0, deferralPeriod),
+ rep(1, values$int$l - 1 - deferralPeriod),
0);
}
}
cf
},
- getCashFlows = function(params, values, start = 0) {
+ getCashFlows = function(params, values) {
age = params$ContractData$technicalAge;
if (is.null(values$cashFlowsBasic)) {
- values$cashFlowsBasic = self$getBasicCashFlows(params, values, start = start);
+ values$cashFlowsBasic = self$getBasicCashFlows(params, values);
}
cflen = values$int$l
zeroes = pad0(0, cflen)
@@ -286,7 +269,7 @@ InsuranceTarif = R6Class(
# Premiums:
if (!params$ContractState$premiumWaiver) {
- premiums = self$getPremiumCF(len = cflen, params = params, values = values, start = start)
+ premiums = self$getPremiumCF(len = cflen, params = params, values = values)
if (params$ContractData$premiumPayments == "in advance") {
cf$premiums_advance = premiums;
} else {
@@ -320,21 +303,20 @@ InsuranceTarif = R6Class(
applyHook(params$Hooks$adjustCashFlows, cf, params, values)
},
- getCashFlowsCosts = function(params, values, start = 0) {
- # Cost cash flows start at block start time (function argument "start" => one-off alpha costs start are charged at that time!)
+ getCashFlowsCosts = function(params, values) {
dm = dim(params$Costs);
dmnames = dimnames(params$Costs);
cf = array(0, dim = list(values$int$l, dm[1], dm[2]), dimnames = list(0:(values$int$l - 1), dmnames[[1]], dmnames[[2]]));
- cf[start + 1,,] = cf[start + 1,,] + params$Costs[,,"once"]
- for (i in (start + 1):values$int$premiumTerm) {
+ cf[1,,] = cf[1,,] + params$Costs[,,"once"]
+ for (i in 1:values$int$premiumTerm) {
cf[i,,] = cf[i,,] + params$Costs[,,"PremiumPeriod"];
}
if (values$int$premiumTerm < values$int$policyTerm) {
- for (i in (max(start, values$int$premiumTerm) + 1):values$int$policyTerm) {
+ for (i in (values$int$premiumTerm + 1):values$int$policyTerm) {
cf[i,,] = cf[i,,] + params$Costs[,,"PremiumFree"];
}
}
- for (i in (start + 1):values$int$policyTerm) {
+ for (i in 1:values$int$policyTerm) {
cf[i,,] = cf[i,,] + params$Costs[,,"PolicyPeriod"];
}
@@ -350,7 +332,7 @@ InsuranceTarif = R6Class(
applyHook(params$Hooks$adjustCashFlowsCosts, cf, params, values)
},
- presentValueCashFlows = function(cashFlows, params, values, start = 0) {
+ presentValueCashFlows = function(cashFlows, params, values) {
qq = self$getTransitionProbabilities(params);
qx = pad0(qq$q, values$int$l);
@@ -366,62 +348,59 @@ InsuranceTarif = R6Class(
m = params$ContractData$premiumFrequency,
order = params$ActuarialBases$premiumFrequencyOrder);
- # TODO: Calculate all present values only from start time of block onwards!
- pvRefund = calculatePVDeath(
- px, qx,
- values$cashFlows$death_GrossPremium,
- v = v, start = start);
+ pvRefund = calculatePVDeath(px, qx, values$cashFlows$death_GrossPremium, v = v);
pvRefundPast = calculatePVDeath(
px, qx,
values$cashFlows$death_Refund_past,
- v = v, start = start) * (values$cashFlows[,"death_GrossPremium"] - values$cashFlows[,"premiums_advance"]);
+ v = v) *
+ (values$cashFlows[,"death_GrossPremium"] - values$cashFlows[,"premiums_advance"]);
pv = cbind(
premiums = calculatePVSurvival(
px, qx,
values$cashFlows$premiums_advance, values$cashFlows$premiums_arrears,
m = params$ContractData$premiumFrequency, mCorrection = premiumFreqCorr,
- v = v, start = start),
+ v = v),
guaranteed = calculatePVGuaranteed(
values$cashFlows$guaranteed_advance, values$cashFlows$guaranteed_arrears,
m = params$ContractData$benefitFrequency, mCorrection = benefitFreqCorr,
- v = v, start = start),
+ v = v),
survival = calculatePVSurvival(
px, qx,
values$cashFlows$survival_advance, values$cashFlows$survival_arrears,
m = params$ContractData$benefitFrequency, mCorrection = benefitFreqCorr,
- v = v, start = start),
+ v = v),
death_SumInsured = calculatePVDeath(
px, qx,
values$cashFlows$death_SumInsured,
- v = v, start = start),
+ v = v),
disease_SumInsured = calculatePVDisease(
px, qx, ix,
- values$cashFlows$disease_SumInsured, v = v, start = start),
+ values$cashFlows$disease_SumInsured, v = v),
death_GrossPremium = pvRefund,
death_Refund_past = pvRefundPast,
death_Refund_future = pvRefund - pvRefundPast,
death_PremiumFree = calculatePVDeath(
px, qx,
- values$cashFlows$death_PremiumFree, v = v, start = start)
+ values$cashFlows$death_PremiumFree, v = v)
);
rownames(pv) <- pad0(rownames(qq), values$int$l);
pv
},
- presentValueCashFlowsCosts = function(params, values, start = 0) {
+ presentValueCashFlowsCosts = function(params, values) {
len = values$int$l;
q = self$getTransitionProbabilities(params);
qx = pad0(q$q, len);
px = pad0(q$p, len);
v = 1/(1 + params$ActuarialBases$i)
- pvc = calculatePVCosts(px, qx, values$cashFlowsCosts, v = v, start = start);
+ pvc = calculatePVCosts(px, qx, values$cashFlowsCosts, v = v);
pvc
},
# Cost values (CF, present values, etc.) are an Tx5x3 matrix => convert to Tx15 matrix (alpha | Zillmer | beta | gamma)
- costValuesAsMatrix = function(costValues, start = 0) {
+ costValuesAsMatrix = function(costValues) {
dm = dim(costValues);
nm = dimnames(costValues);
colnames = t(outer(nm[[2]], nm[[3]], paste, sep = "."));
@@ -432,7 +411,7 @@ InsuranceTarif = R6Class(
res
},
- getAbsCashFlows = function(params, values, start = 0) {
+ getAbsCashFlows = function(params, values) {
# TODO: Set up a nice list with coefficients for each type of cashflow,
# rather than multiplying each item manually (this also mitigates the risk
@@ -468,7 +447,7 @@ InsuranceTarif = R6Class(
cbind(values$cashFlows, values$cashFlowsCosts)
},
- getAbsPresentValues = function(params, values, start = 0) {
+ getAbsPresentValues = function(params, values) {
pv = values$presentValues;
#pv[,"age"] = pv[,"premiums"];
@@ -490,7 +469,7 @@ InsuranceTarif = R6Class(
},
- presentValueBenefits = function(params, values, start = 0) {
+ presentValueBenefits = function(params, values) {
# TODO: Here we don't use the securityLoading parameter => Shall it be used or are these values to be understood without additional security loading?
benefits = values$presentValues[,"survival"] +
values$presentValues[,"guaranteed"] +
@@ -514,10 +493,10 @@ InsuranceTarif = R6Class(
# When getPremiumCoefficients is called, the values$premiums array has NOT been filled! Instead,
# some of the premium fields (all required for the current calculation) have
# been set in the passed "premiums" argument.
- getPremiumCoefficients = function(type = "gross", coeffBenefits, coeffCosts, premiums, params, values, start = 0) {
+ getPremiumCoefficients = function(type = "gross", coeffBenefits, coeffCosts, premiums, params, values, premiumCalculationTime = values$int$premiumCalculationTime) {
# Merge a possibly passed loadings override with the defaults of this class:
securityLoading = valueOrFunction(params$Loadings$security, params = params, values = values);
- t = as.character(start)
+ t = as.character(premiumCalculationTime)
coeff = list(
"SumInsured" = list("benefits" = coeffBenefits*0, "costs" = coeffCosts*0),
@@ -583,7 +562,7 @@ InsuranceTarif = R6Class(
coeff
},
- premiumCalculation = function(params, values, start = 0) {
+ premiumCalculation = function(params, values, premiumCalculationTime = values$int$premiumCalculationTime) {
loadings = params$Loadings;
sumInsured = params$ContractData$sumInsured
values$premiums = c(
@@ -593,8 +572,8 @@ InsuranceTarif = R6Class(
"written_beforetax" = 0, "tax" = 0, "written" = 0);
coefficients = list("gross" = c(), "Zillmer" = c(), "net" = c());
- # Get the present values of the premiums, claims and costs at time 'start' (where the premium is to be calculated)
- t = as.character(start)
+ # Get the present values of the premiums, claims and costs at time 'premiumCalculationTime' (where the premium is to be calculated)
+ t = as.character(premiumCalculationTime)
pv = values$presentValues[t,]
pvCost = values$presentValuesCosts[t,,]
@@ -604,21 +583,21 @@ InsuranceTarif = R6Class(
# net, gross and Zillmer premiums are calculated from the present values using the coefficients on each present value as described in the formulas document
- coeff = self$getPremiumCoefficients("gross", pv * 0, pvCost * 0, premiums = values$premiums, params = params, values = values, start = start)
+ coeff = self$getPremiumCoefficients("gross", pv * 0, pvCost * 0, premiums = values$premiums, params = params, values = values, premiumCalculationTime = premiumCalculationTime)
enumerator = sum(coeff[["SumInsured"]][["benefits"]] * pv) + sum(coeff[["SumInsured"]][["costs"]] * pvCost);
denominator = sum(coeff[["Premium" ]][["benefits"]] * pv) + sum(coeff[["Premium" ]][["costs"]] * pvCost);
values$premiums[["unit.gross"]] = enumerator/denominator * (1 + loadings$ongoingAlphaGrossPremium);
values$premiums[["gross"]] = values$premiums[["unit.gross"]] * sumInsured;
coefficients[["gross"]] = coeff;
- coeff = self$getPremiumCoefficients("net", pv*0, pvCost*0, premiums = values$premiums, params = params, values = values, start = start)
+ coeff = self$getPremiumCoefficients("net", pv*0, pvCost*0, premiums = values$premiums, params = params, values = values, premiumCalculationTime = premiumCalculationTime)
enumerator = sum(coeff[["SumInsured"]][["benefits"]] * pv) + sum(coeff[["SumInsured"]][["costs"]] * pvCost);
denominator = sum(coeff[["Premium" ]][["benefits"]] * pv) + sum(coeff[["Premium" ]][["costs"]] * pvCost);
values$premiums[["unit.net"]] = enumerator/denominator;
values$premiums[["net"]] = values$premiums[["unit.net"]] * sumInsured;
coefficients[["net"]] = coeff;
- coeff = self$getPremiumCoefficients("Zillmer", pv * 0, pvCost * 0, premiums = values$premiums, params = params, values = values, start = start);
+ coeff = self$getPremiumCoefficients("Zillmer", pv * 0, pvCost * 0, premiums = values$premiums, params = params, values = values, premiumCalculationTime = premiumCalculationTime);
enumerator = sum(coeff[["SumInsured"]][["benefits"]] * pv) + sum(coeff[["SumInsured"]][["costs"]] * pvCost);
denominator = sum(coeff[["Premium" ]][["benefits"]] * pv) + sum(coeff[["Premium" ]][["costs"]] * pvCost);
values$premiums[["unit.Zillmer"]] = enumerator/denominator;
@@ -670,8 +649,8 @@ InsuranceTarif = R6Class(
list("premiums" = values$premiums, "coefficients" = coefficients)
},
- reserveCalculation = function(params, values, start = 0) {
- t = as.character(start)
+ reserveCalculation = function(params, values) {
+ t = "0"
securityFactor = (1 + valueOrFunction(params$Loadings$security, params = params, values = values));
ppScheme = params$ProfitParticipation$profitParticipationScheme;
@@ -696,21 +675,21 @@ InsuranceTarif = R6Class(
}
resConversion = (resZ + resGamma) * (1 - advanceProfitParticipation);
- # Alpha refund: Distribute alpha-costs to 5 years (or if shorter, the policy period), always starting at time 'start':
+ # Alpha refund: Distribute alpha-costs to 5 years (or if shorter, the policy period), always starting at time 0:
# If alphaRefunded==TRUE, don't refund a second time!
if (params$ContractState$alphaRefunded) {
alphaRefund = 0
} else {
- r = min(params$ContractData$policyPeriod - start, 5);
+ r = min(params$ContractData$policyPeriod, 5);
ZillmerSoFar = Reduce("+", values$absCashFlows$Zillmer, accumulate = TRUE);
ZillmerTotal = sum(values$absCashFlows$Zillmer);
len = length(ZillmerSoFar);
if (params$Features$alphaRefundLinear) {
- ZillmerVerteilungCoeff = pad0((0:r)/r, len, 1, start = start);
+ ZillmerVerteilungCoeff = pad0((0:r)/r, len, 1);
} else {
q = self$getTransitionProbabilities(params);
# vector of all ä_{x+t, r-t}
- pvAlphaTmp = calculatePVSurvival(q = pad0(q$q, len), advance = pad0(rep(1,r), len), v = 1/(1 + params$ActuarialBases$i), start = start);
+ pvAlphaTmp = calculatePVSurvival(q = pad0(q$q, len), advance = pad0(rep(1,r), len), v = 1/(1 + params$ActuarialBases$i));
ZillmerVerteilungCoeff = (1 - pvAlphaTmp/pvAlphaTmp[[1]]);
}
alphaRefund = ZillmerSoFar - ZillmerVerteilungCoeff * ZillmerTotal;
@@ -721,7 +700,7 @@ InsuranceTarif = R6Class(
# Collect all reserves to one large matrix
res = cbind(
- "SumInsured" = head0(rep(params$ContractData$sumInsured, values$int$l), start = start),
+ "SumInsured" = head0(rep(params$ContractData$sumInsured, values$int$l)),
"net" = resNet,
"Zillmer" = resZ,
"adequate" = resAdeq,
@@ -769,7 +748,7 @@ InsuranceTarif = R6Class(
)
},
- getBalanceSheetReserveFactor = function(params, years = 1, start = 0) {
+ getBalanceSheetReserveFactor = function(params, years = 1) {
balanceDate = params$ActuarialBases$balanceSheetDate
year(balanceDate) = year(params$ContractData$contractClosing);
if (balanceDate < params$ContractData$contractClosing) {
@@ -791,7 +770,7 @@ InsuranceTarif = R6Class(
baf
},
- reserveCalculationBalanceSheet = function(params, values, start = 0) {
+ reserveCalculationBalanceSheet = function(params, values) {
reserves = values$reserves;
years = length(reserves[,"Zillmer"]);
# Balance sheet reserves:
@@ -839,7 +818,7 @@ InsuranceTarif = R6Class(
},
- getBasicDataTimeseries = function(params, values, start = 0) {
+ getBasicDataTimeseries = function(params, values) {
res = cbind(
"PremiumPayment" = values$premiumComposition[, "charged"] > 0,
"SumInsured" = values$reserves[, "SumInsured"],
@@ -852,14 +831,14 @@ InsuranceTarif = R6Class(
res
},
- premiumDecomposition = function(params, values, start = 0) {
+ premiumDecomposition = function(params, values) {
loadings = params$Loadings;
sumInsured = params$ContractData$sumInsured;
premiums = values$premiums;
v = 1/(1 + params$ActuarialBases$i);
l = dim(values$reserves)[[1]];
ppScheme = params$ProfitParticipation$profitParticipationScheme;
- t = as.character(start)
+ t = as.character(0) # Time for original premium calculation => TODO: Use values stored in ContractData?
# TODO: This assumes all premiums are paid in advance!
premium.gross = values$absCashFlows[,"premiums_advance"];
@@ -927,51 +906,58 @@ InsuranceTarif = R6Class(
# Gross premium = net + zillmeredAlpha + unzillmeredAlpha + beta + gamma premium
- unit.premiumCF = premium.gross / premiums[["gross"]];
- premium.gamma = unit.premiumCF * values$absPresentValues[t, "gamma"] / values$absPresentValues[t, "premiums.unit"];
- premium.beta = unit.premiumCF * values$absPresentValues[t, "beta"] / values$absPresentValues[t, "premiums.unit"];
- premium.alpha = unit.premiumCF * values$absPresentValues[t, "alpha"] / values$absPresentValues[t, "premiums.unit"];
+ unit.premiumCF = ifelse(premiums[["gross"]] == 0, premium.gross * 0, premium.gross / premiums[["gross"]]);
+ if (values$absPresentValues[t, "premiums.unit"] == 0) {
+ premium.gamma = 0
+ premium.beta = 0
+ premium.alpha = 0
+ premium.alpha.Zillmer = 0
+ } else {
+ premium.gamma = unit.premiumCF * values$absPresentValues[t, "gamma"] / values$absPresentValues[t, "premiums.unit"];
+ premium.beta = unit.premiumCF * values$absPresentValues[t, "beta"] / values$absPresentValues[t, "premiums.unit"];
+ premium.alpha = unit.premiumCF * values$absPresentValues[t, "alpha"] / values$absPresentValues[t, "premiums.unit"];
+ premium.alpha.Zillmer = unit.premiumCF * values$absPresentValues[t, "Zillmer"] / values$absPresentValues[t, "premiums.unit"];
+ }
premium.Zillmer = unit.premiumCF * premiums[["Zillmer"]];
- premium.alpha.Zillmer = unit.premiumCF * values$absPresentValues[t, "Zillmer"] / values$absPresentValues[t, "premiums.unit"];
premium.alpha.noZ = premium.alpha - premium.alpha.Zillmer; # ungezillmerter Teil der Abschlusskosten
premium.net = unit.premiumCF * premiums[["net"]];
securityLoading = valueOrFunction(params$Loadings$security, params = params, values = values);
- premium.risk.actual = v * head0(values$absCashFlows[,"death"] - c(values$reserves[,"net"][-1], 0), start = start) * pad0(values$transitionProbabilities$q, l);
+ premium.risk.actual = v * (values$absCashFlows[,"death"] - c(values$reserves[,"net"][-1], 0)) * pad0(values$transitionProbabilities$q, l);
premium.risk.security = v * (values$absCashFlows[,"death"] * securityLoading) * pad0(values$transitionProbabilities$q, l);
premium.risk = premium.risk.actual + premium.risk.security;
- # TODO-start: Make sure the premium components are 0 before start!
- premium.risk.disease.actual = v * head0(values$absCashFlows[,"disease_SumInsured"] - c(values$reserves[,"net"][-1], 0), start = start) * pad0(values$transitionProbabilities$i, l);
+
+ premium.risk.disease.actual = v * (values$absCashFlows[,"disease_SumInsured"] - c(values$reserves[,"net"][-1], 0)) * pad0(values$transitionProbabilities$i, l);
premium.risk.disease.security = v * (values$absCashFlows[,"disease_SumInsured"] * securityLoading) * pad0(values$transitionProbabilities$i, l);
premium.risk.disease = premium.risk.disease.actual + premium.risk.disease.security;
- premium.savings = head0(getSavingsPremium(
+ premium.savings = getSavingsPremium(
values$reserves[,"net"], v = v,
survival_advance = values$absCashFlows[,"survival_advance"] + values$absCashFlows[,"guaranteed_advance"],
survival_arrears = values$absCashFlows[,"survival_arrears"] + values$absCashFlows[,"guaranteed_arrears"]
- ), start = start)
+ )
- premium.Zillmer.risk.actual = v * head0(values$absCashFlows[,"death"] - c(values$reserves[,"contractual"][-1], 0), start = start) * pad0(values$transitionProbabilities$q, l);
+ premium.Zillmer.risk.actual = v * (values$absCashFlows[,"death"] - c(values$reserves[,"contractual"][-1], 0)) * pad0(values$transitionProbabilities$q, l);
premium.Zillmer.risk.security = v * (values$absCashFlows[,"death"] * securityLoading) * pad0(values$transitionProbabilities$q, l);
premium.Zillmer.risk = premium.Zillmer.risk.actual + premium.Zillmer.risk.security;
- premium.Zillmer.risk.disease.actual = v * head0(values$absCashFlows[,"disease_SumInsured"] - c(values$reserves[,"contractual"][-1], 0), start = start) * pad0(values$transitionProbabilities$i, l);
+ premium.Zillmer.risk.disease.actual = v * (values$absCashFlows[,"disease_SumInsured"] - c(values$reserves[,"contractual"][-1], 0)) * pad0(values$transitionProbabilities$i, l);
premium.Zillmer.risk.disease.security = v * (values$absCashFlows[,"disease_SumInsured"] * securityLoading) * pad0(values$transitionProbabilities$i, l);
premium.Zillmer.risk.disease = premium.Zillmer.risk.disease.actual + premium.Zillmer.risk.disease.security;
- premium.Zillmer.savings = head0(getSavingsPremium(
+ premium.Zillmer.savings = getSavingsPremium(
values$reserves[,"contractual"], v = v,
survival_advance = values$absCashFlows[,"survival_advance"] + values$absCashFlows[,"guaranteed_advance"],
survival_arrears = values$absCashFlows[,"survival_arrears"] + values$absCashFlows[,"guaranteed_arrears"]
- ), start = start)
- premium.Zillmer.amortization = head0(getSavingsPremium(
+ )
+ premium.Zillmer.amortization = getSavingsPremium(
pmin(0, values$reserves[,"contractual"]), v = v
- ), start = start)
- premium.Zillmer.actsavings = head0(getSavingsPremium(
+ )
+ premium.Zillmer.actsavings = getSavingsPremium(
pmax(0, values$reserves[,"contractual"]), v = v,
survival_advance = values$absCashFlows[,"survival_advance"] + values$absCashFlows[,"guaranteed_advance"],
survival_arrears = values$absCashFlows[,"survival_arrears"] + values$absCashFlows[,"guaranteed_arrears"]
- ), start = start)
+ )
res = cbind(
"charged" = premium.charged,
@@ -1017,17 +1003,14 @@ InsuranceTarif = R6Class(
res
},
- calculateFutureSums = function(values, ..., start = 0) {
- rcumsum = function(vec) c(
- head(vec, start),
- rev(cumsum(rev(tail(vec, length(vec) - start))))
- )
+ calculateFutureSums = function(values, ...) {
+ rcumsum = function(vec) rev(cumsum(rev(vec)))
apply(values, 2, rcumsum)
},
- calculatePresentValues = function(values, params, start = 0) {
+ calculatePresentValues = function(values, params) {
len = dim(values)[1];
q = self$getTransitionProbabilities(params);
- pv = function(vec) calculatePVSurvival(px = pad0(q$p, len), advance = vec, v = 1/(1 + params$ActuarialBases$i), start = start);
+ pv = function(vec) calculatePVSurvival(px = pad0(q$p, len), advance = vec, v = 1/(1 + params$ActuarialBases$i));
apply(values, 2, pv)
},
diff --git a/inst/Beispiele/Example_Endowment.R b/inst/Beispiele/Example_Endowment.R
index c197325832b42f7b56d49a238dae8d1feaf64f67..2de12a6cfbbabe042d1180e8e9a308d909518dc9 100644
--- a/inst/Beispiele/Example_Endowment.R
+++ b/inst/Beispiele/Example_Endowment.R
@@ -69,23 +69,28 @@ contract.Bsp = InsuranceContract$
contractClosing = as.Date("2020-07-01"),
id = "Hauptvertrag"
)$
- addDynamics(t = 5, NewSumInsured = 200000, id = "Dynamik 1", i = 0.00)$
+ addDynamics(t = 5, NewSumInsured = 200000, id = "Dynamik 1", i = 0.05, age = 70)$
addDynamics(t = 10, NewSumInsured = 250000, id = "Dynamik 2", i = 0.01);
# exportInsuranceContractExample(contract.Bsp, t = 5);
# showVmGlgExamples(contract.Bsp, t = 10)
-
-exportInsuranceContract.xlsx(contract.Bsp, filename = "BEISPIEL_Contract.xlsx")
+#
+# exportInsuranceContract.xlsx(contract.Bsp, filename = "BEISPIEL_Contract.xlsx")
+#
+#
+# contract.Bsp$Values$cashFlowsBasic
+# contract.Bsp$Values$cashFlows
+# contract.Bsp$Values$cashFlowsCosts
+# contract.Bsp$Values$presentValues
+# # contract.U17_3J$Values$presentValuesCosts
+# contract.Bsp$Values$premiumSum
+# contract.Bsp$Values$premiums
+# contract.Bsp$Values$premiumComposition
+# contract.Bsp$Values$reserves
-contract.Bsp$Values$cashFlowsBasic
-contract.Bsp$Values$cashFlows
-contract.Bsp$Values$cashFlowsCosts
-contract.Bsp$Values$presentValues
-# contract.U17_3J$Values$presentValuesCosts
-contract.Bsp$Values$premiumSum
-contract.Bsp$Values$premiums
-contract.Bsp$Values$premiumComposition
-contract.Bsp$Values$reserves
+################################################################### #
+# Testing premium waivers ####
+################################################################### #
contract.Bsp.waiver = InsuranceContract$
@@ -97,6 +102,7 @@ contract.Bsp.waiver = InsuranceContract$
contractClosing = as.Date("2020-07-01"),
id = "Hauptvertrag"
)$premiumWaiver(t = 5)
+exportInsuranceContract.xlsx(contract.Bsp.waiver, filename = "BEISPIEL_Contract_PrfALT.xlsx")
contract.Bsp.waiverNew = InsuranceContract$
new(
@@ -107,6 +113,7 @@ contract.Bsp.waiverNew = InsuranceContract$
contractClosing = as.Date("2020-07-01"),
id = "Hauptvertrag"
)$premiumWaiverNew(t = 5)
+exportInsuranceContract.xlsx(contract.Bsp.waiverNew, filename = "BEISPIEL_Contract_PrfNEU.xlsx")
contract.Bsp.waiver$Values$cashFlowsBasic == contract.Bsp.waiverNew$Values$cashFlowsBasic
contract.Bsp.waiver$Values$cashFlows == contract.Bsp.waiverNew$Values$cashFlows