-1

我正在尝试编写一些代码来分析我公司的保险计划产品......但它们很复杂！PPO 计划很简单，但高免赔额健康计划很复杂，因为他们为家庭计划引入了“拆分”免赔额和自付费用最高限额（个人和总计）。它是这样工作的：

  • 一旦个人达到个人免赔额，他/她将获得 90% 的保障
  • 一旦计划中剩余的 1+ 个人达到总免赔额，整个家庭将获得 90% 的保障
  • 个人仅靠医疗费用无法满足家庭免赔额

我想为我的家庭成员（其中有四个）输入一个费用向量，并输出每个计划的总成本。下表列出了可能的情况，并带有以下列代码：

  • ded_ind: 一个人是否达到了个人免赔额？
  • ded_tot: 总免赔额达到了吗？
  • oop_ind: 个人自掏腰包是否达到最大值
  • oop_tot: 是否达到了自付费用的最大值？
  • exp_ind= 最高支出者的支出
  • exp_rem=其余/other/家庭成员的支出（不是最高支出者）
  • oop_max_ind= 个人支付最高自付费用的费用水平（当个人自付费用最高时ded_ind + 0.1 * exp_ind =）
  • oop_max_fam= 与个人相同，但针对其余家庭成员

桌子：

| ded_ind | oop_ind | ded_rem | oop_rem | formula                                       
|---------+---------+---------+---------+---------------------------------------------------------------------------|
|       0 |       0 |       0 |       0 | exp_ind + exp_rem                                                         |
|       1 |       0 |       0 |       0 | ded_ind + 0.1 * (exp_ind - ded_ind) + exp_rem                             |
|       0 |       0 |       1 |       0 | exp_ind + ded_rem + 0.1 * (exp_rem - ded_rem)                             |
|       1 |       1 |       0 |       0 | oop_max_ind + exp_fam                                                     |
|       1 |       0 |       1 |       0 | ded_ind + 0.1 * (exp_ind - ded_ind) + ded_rem + 0.1 * (exp_rem - ded_rem) |
|       0 |       0 |       1 |       1 | oop_max_rem + exp_ind                                                     |
|       1 |       0 |       1 |       1 | ded_ind + 0.1 * (exp_ind - ded_ind) + oop_max_rem                         |
|       1 |       1 |       1 |       0 | oop_ind_max + ded_rem + 0.1 * (exp_rem - ded_rem)                         |
|       1 |       1 |       1 |       1 | oop_ind_max + oop_rem_max                                                 |

省略： 0 1 0 0、0 0 0 1、0 1 1 0、 和0 1 0 1不存在，因为如果oop_ind和分别没有满足，则无法满足。oop_remded_indded_rem

我当前的代码是一个有点ifelse像这样的大循环（不是代码，而是它的作用）：

check if plan is ppo or hsa
  if hsa plan
    if exp_ind + exp_rem < ded_rem # didn't meet family deductible
      if exp_ind < ded_ind # individual deductible also not met
        cost = exp_ind + exp_rem
      else is exp_ind > oop_ind_max # ded_ind met, is oop_ind?
        ded_ind + 0.1 * (exp_ind - ded_ind) + exp_fam # didn't reach oop_max_ind
        else oop_max_ind + exp_fam # reached oop_max_ind

    else ...

在else之后，总和大于家庭免赔额。我检查它是否由两个以上的人贡献，然后继续这样。

我的问题，既然我已经给出了问题的一些背景知识：有没有比ifelse循环一次过滤它们更好的方法来管理这样的条件情况？

代码最终看起来是多余的，因为一个检查一些更高级别的条件（考虑ded_rem满足或不满足的表......在这两种情况下仍然需要检查ded_ind和oop_max_ind代码是相同的......只是定位在ifelse结构中的两个不同位置）。

这可以通过某种矩阵运算来完成吗？网上还有其他更聪明的方法来处理条件过滤的例子吗？

非常感谢您的任何建议。

PS 我正在使用 R 并将创建一个交互，shiny以便其他员工可以为他们的每个家庭成员输入最佳和最坏的情况，并通过点或条形图查看哪个计划提前出现。

4

2 回答 2

0

由于这个问题不是很具体，这里有一个更简单的例子/答案：

# example data
test <- expand.grid(opt1=0:1,opt2=0:1)
# create a unique identifier to represent the binary variables
test$code <- with(allopts,paste(opt1,opt2,sep=""))
# create an input variable to be used in functions
test$var1 <- 1:4

#  opt1 opt2 code var1
#1    0    0   00    1
#2    1    0   10    2
#3    0    1   01    3
#4    1    1   11    4

根据二进制条件应用的各个函数，以及每个组合的预期结果：

var1 + 10    #code 00 - intended result =   11
var1 + 100   #code 10 - intended result =  102
var1 + 1000  #code 01 - intended result = 1003
var1 + var1  #code 11 - intended result =    8

使用ifelse组合进行计算：

test$result <- with(test,
  ifelse(code == "00", var1 + 10,
  ifelse(code == "10", var1 + 100,
  ifelse(code == "01", var1 + 1000,
  ifelse(code == "11", var1 + var1,
  NA
)))))

结果：

  opt1 opt2 code var1 result
1    0    0   00    1     11
2    1    0   10    2    102
3    0    1   01    3   1003
4    1    1   11    4      8
于 2013-08-08T05:53:16.763 回答
0

根据结果​​转换为二进制值的建议给了我一个想法，这也帮助我了解到可以进行矢量化TRUE/FALSE检查（我想这对很多人来说可能很明显）。

这是我目前的想法：

expenses将是当年个人预测医疗费用的向量（以三个人为例）：

expenses <- c(1500, 100, 400)

我们设置exp_ind为最大值，并将其余部分相加exp_rem

exp_ind <- max(expenses)

# [1] index of which() for cases with multiple max values
exp_rem <- sum(expenses[-which(expenses == exp_ind)[1]])

对于任何给定的计划，我可以设置一个带有截止点的向量，例如：

  • 个人免赔额 = 1000
  • 个人自付费用 max = 2000（需要承担 11k 的费用才能到达那里）
  • 家庭免赔额 = 2000
  • 家庭自掏腰包 max = 4000（需要承担 22k 的费用才能到达那里）

设置这些值：

ded_ind <- 1000
oop_max_ind <- 11000
ded_tot <- 2000
oop_max_tot <- 22000

cutoffs <- c(ded_ind, oop_max_ind, ded_tot, oop_max_tot)

现在我们可以根据截止检查输入费用：

result <- as.numeric(rep(c(exp_ind, exp_rem), each = 2) > cutoffs)

最后，转换为二进制：

result_bin <- sum(2^(seq_along(result) - 1) * result)

现在我可以根据中的值为可能的结果设置函数result_bin：

if(result_bin == 1) {cost <- ded_ind + 0.1 * (exp_ind - ded_ind) + exp_rem }

cost
[1] 1550

我们可以检查这个...

  • 高消费者会支付他的 1000，然后支付剩余 500 的 10% = 1050
  • 其他成员未达到家庭免赔额并支付全额400 + 100 = 500
  • 总计：1550

我仍然需要创建一个值到相应函数的映射，但是在我看来，进行矢量化检查并转换一个唯一的二进制值比我的嵌套混乱results_bin要好得多。ifelse

我是这样看的：无论如何我都必须设置变量并编写函数；这节省了我 1) 显式编写所有条件，2) 我所说的冗余问题，即最终在ifelse结构中编写父拆分的相同“兄弟”分支，最后，3) 代码很远，很远，更容易遵循。

于 2013-08-08T04:31:06.137 回答