概述 | 软件包 | 类 | 树 | 索引 | 帮助

上一个类 下一个类 | 框架 无框架
摘要： 嵌套 | 字段 | 构造函数 | 方法 | 详细信息： 字段 | 构造函数 | 方法

## application.workbooks.workbook.worksheets
类 WorksheetFunction

    java.lang.Object
      application.workbooks.workbook.worksheets.WorksheetFunction

    public class WorksheetFunction

extends java.lang.Object

该类定义了工作表的一些函数。

自从：
  V1.1

构造函数摘要
`WorksheetFunction()`

方法摘要
`static double` | `abs(double number)` 返回指定数字的绝对值。
`static double` | `accrint(java.lang.String issue, java.lang.String first_interest, java.lang.String settlement, double rate, double par, double frequency, double basis)` 返回定期付息有价证券的应计利息。
`static double` | `accrintm(java.lang.String issue, java.lang.String maturity, double rate, double par, double basis)` 返回到期一次性付息的有价证券的应计利息。
`static double` | `acos(double number)` 返回指定数值的反余弦值。
`static double` | `acosh(double number)` 求反双曲余弦值。
`static java.lang.String` | `address(int row_num, int column_num, int abs_num, boolean a1, java.lang.String sheet_text)` 根据指定行号与列标，建立文本类型的单元格地址。
`static double` | `amordegrc(double cost, java.lang.String date_purchased, java.lang.String first_period, double salvage, double period, double rate, double basis)` 返回每个会计期间资产的按比例线性折旧率。
`static double` | `amorlinc(double cost, java.lang.String date_purchased, java.lang.String first_period, double salvage, double period, double rate, double basis)` 返回每个结算期间的折旧值，该函数为法国会计系统提供。
`static boolean` | `and(Range range)` 所有参数的逻辑值为真时，返回 TRUE；只要一个参数的逻辑值为假，即返回 FALSE。
`static int` | `areas(Range reference)` 返回包含在引用中的单元格区域个数。
`static java.lang.String` | `asc(java.lang.String string)` 将字符串中的全角（双字节）英文字母或数字更改为半角（单字节）字符。
`static double` | `asin(double number)` 返回指定数值的反正弦值。
`static double` | `asinh(double number)` 求反双曲正弦值。
`static double` | `atan(double number)` 返回指定数字的绝对值。
`static double` | `atan2(double X_num, double Y_num)` 求给定X，Y坐标的反正切值。
`static double` | `atanh(double number)` 求反双曲正切值。
`static double` | `avedev(Range range)` 用于评测这组数据的离散度。
`static double` | `average(Range range)` 返回指定数据的平均值。
`static double` | `averagea(Range values)` 返回一组参数的算术平均值。
`static double` | `besseli(double x, double n)` 返回修正 Bessel 函数值，它与用纯虚数参数运算时的 Bessel 函数值相等, 该方法会去调用封装算法中的各方法，返回最终函数的结果。
`static double` | `besselj(double x, double n)` 返回 Bessel 函数值。
`static double` | `besselk(double x, int n)` 返回修正 Bessel 函数值，它与纯虚数参数运算的 Bessel 函数值相等。
`static double` | `bessely(double x, int n)` 返回 Bessel 函数值，也称为 Weber 函数或 Neumann 函数。
`static double` | `betadist(double x, double alpha, double beta, double a, double b)` 返回 beta 累积分布函数。
`static double` | `betainv(double probability, double alpha, double beta, double a, double b)` 返回 beta 累积分布函数。
`static long` | `bin2dec(long number)` 将二进制数转化为十进制数。
`static java.lang.String` | `bin2hex(long number, int places)` 将二进制数转化为十六进制数。
`static java.lang.String` | `bin2oct(long number, int places)` 将二进制数转化为八进制数。
`static double` | `binomdist(double number_s, double trials, double probability_s, boolean cumulative)` 一元二项式分布的概率值。
`static double` | `ceiling(double number, double significance)` 求number向上舍入（延绝对值增大方向）接近的significance的倍数。
`static java.lang.String` | `cell(java.lang.String info_type, Range reference)` 返回某一引用范围中的左上角单元格的格式、位置或内容等信息。
`static java.lang.String` | `character(int number)` 根据指定数字返回对应的字符。
`static double` | `chidist(double x, double degrees_freedom)` 返回 γ2 分布的单尾概率。
`static double` | `chiinv(double probability, double degrees_freedom)` 返回 γ2 分布单尾概率的反函数值。
`static double` | `chitest(Range actual_range, Range expected_range)` 返回独立性检验值。
`static java.lang.String` | `choose(int index_num, java.lang.String[] values)` 根据索引号，返回已输入的数值中任一数值。
`static java.lang.String` | `clean(java.lang.String string)` 删除文本中的所有不可打印字符。
`static int` | `code(java.lang.String text)` 计算文本串中第一个字符的数字代码。
`static int` | `column(Range reference)` 返回引用的列标。
`static int` | `columns(Range reference)` 返回引用或数组的列数。
`static double` | `combin(double number, double number_chosen)` 求从给定数目的对象集合中提取若干对象的组合数。
`static java.lang.String` | `complex(double real_num, double i_number)` 将实系数和虚系数转换为 x+yi 形式的复数形式。
`static java.lang.String` | `concatenate(java.lang.String text1, java.lang.String text2)` 将数个字符串合并成一个字符串。
`static double` | `confidence(double alpha, double standard_dev, double size)` 总体平均值的置信区间。
`static double` | `convert(double number, java.lang.String from_unit, java.lang.String to_unit)` 将数值从一个度量系统转换到另一个度量系统。
`static double` | `correl(Range range1, Range range2)` 单元格区域 array1 和 array2 之间的相关系数。
`static double` | `cos(double number)` 返回指定角度的余弦值。
`static double` | `cosh(double number)` 求双曲余弦值。
`static double` | `count(Range range)` 包含数字以及包含参数列表中的数字的单元格的个数。
`static double` | `counta(Range range)` 包含数字以及包含参数列表中的数字的单元格的个数， 参数值可以是任何类型，它们可以包括空字符 ("")，但不包括空白单元格。
`static double` | `countBlank(Range range)` 计算指定单元格区域中空白单元格的个数。
`static long` | `countif(Range array, double criteria)` 求计算区域中满足给定条件的单元格的个数。
`static long` | `countif(Range array, java.lang.String criteria)` 求计算区域中满足给定条件的单元格的个数。
`static double` | `coupdaybs(java.lang.String settlement, java.lang.String maturity, double frequency, double basis)` 返回每个会计期间资产的按比例线性折旧率。
`static double` | `coupdays(java.lang.String settlement, java.lang.String maturity, double frequency, double basis)` 返回成交日所在的付息期的天数。
`static double` | `coupdaysnc(java.lang.String settlement, java.lang.String maturity, double frequency, double basis)` 返回从成交日到下一个付息日之间的天数。
`static long` | `coupncd(java.lang.String settlement, java.lang.String maturity, double frequency, double basis)` 返回成交日后的下一个付息日期。
`static int` | `coupnum(java.lang.String settlement, java.lang.String maturity, int frequency, int basis)` 返回成交日和到期日之间的付息次数，该值向上舍入到最近的整数。
`static long` | `couppcd(java.lang.String settlement, java.lang.String maturity, double frequency, double basis)` 返回成交日之前的上一个付息日的日期。
`static double` | `covar(double[] array1, double[] array2)` 协方差，即每对数据点的偏差乘积的平均数，利用协方差可以决定两个数据集之间的关系。
`static double` | `covar(Range range1, Range range2)` 协方差，即每对数据点的偏差乘积的平均数，利用协方差可以决定两个数据集之间的关系。
`static double` | `critbinom(double trials, double probability_s, double alpha)` 使累积二项式分布大于等于临界值的最小值。
`static double` | `cumipmt(double rate, double nper, double pv, double start_period, double end_period, int type)` 计算一笔贷款在某一段指定的付息期内从首期到末期所应支付的累计利息数额。
`static double` | `cumprinc(double rate, double nper, double pv, double start_period, double end_period, int type)` 计算一笔贷款在某一段指定的付款期内从首期到末期所需偿还的累计本金数额。
`static long` | `date(int year, int month, int day)` 返回表示某一特定日期的序列号。
`static java.lang.String` | `date(long serial_number)` 返回表示某一特定日期。
`static long` | `datedif(java.lang.String start_date, java.lang.String end_date, java.lang.String unit)` 返回两个指定日期间的天数、月数或年数。
`static long` | `datevalue(java.lang.String date_text)` 返回代表 date_text 的序列号。
`static double` | `daverage(Range database, double field, Range criteria)` 返回清单或数据库中满足指定条件的列中数值的平均值。
`static java.lang.String` | `daverage(Range database, int field, Range criteria)` 返回数据列表或数据库的列中满足指定条件的数值的平均值。
`static int` | `day(long serial_number)` 返回以序列号表示的某日期的天数，用整数 1 到 31 表示。
`static int` | `day(java.lang.String serial_number)` 返回以序列号表示的某日期的天数，用整数 1 到 31 表示。
`static long` | `days360(java.lang.String start_date, java.lang.String end_date, boolean method)` 按照一年 360 天的算法（每个月以 30 天计，一年共计 12 个月）， 返回两日期间相差的天数，这在一些会计计算中将会用到。
`static double` | `db(double cost, double salvage, double life, double period, double month)` 使用固定余额递减法，计算一笔资产在给定期间内的折旧值。
`static double` | `dcount(Range database, double field, Range criteria)` 返回数据库或数据清单的列中满足指定条件并且包含数字的单元格个数。
`static double` | `dcounta(Range database, double field, Range criteria)` 返回数据库或数据清单的列中满足指定条件的非空单元格个数。
`static double` | `ddb(double cost, double salvage, double life, double period, double factor)` 使用双倍余额递减法或其他指定方法，计算一笔资产在给定期间内的折旧值。
`static java.lang.String` | `dec2bin(long number, int places)` 将十进制数转换为二进制数。
`static java.lang.String` | `dec2hex(long number, int places)` 将十进制数转换为十六进制数。
`static java.lang.String` | `dec2oct(long number, int places)` 将十进制数转换为八进制数。
`static double` | `degrees(double angle)` 将弧度转化为度。
`static int` | `delta(double number1, double number2)` 测试两个数是否等值。
`static double` | `devsq(Range range)` 数据点与各自样本平均值偏差的平方和。
`static java.lang.String` | `dget(Range database, java.lang.String field, Range criteria)` 从数据列表或数据库的列中抽取符合指定条件的单一值。
`static double` | `disc(java.lang.String settlement, java.lang.String maturity, double pr, double redemption, int basis)` 返回有价证券的贴现率。
`static double` | `dmax(Range database, double field, Range criteria)` 返回数据库或数据清单的列中满足指定条件的最大数值。
`static double` | `dmin(Range database, double field, Range criteria)` 返回数据库或数据清单的列中满足指定条件的最小数值。
`static java.lang.String` | `dollar(double currencyNumber, double decimalNumber)` 使用当前格式将数字转换为文本。
`static double` | `dollarde(double fractional_dollar, int fraction)` 将以分数形式表示的价格转换为以小数形式表示的价格。
`static double` | `dollarfr(double decimal_dollar, int fraction)` 将以小数形式表示的价格转换为以分数形式表示的价格。
`static double` | `dproduct(Range database, double field, Range criteria)` 将数据库中满足条件的记录的特定字段中的数值相乘。
`static double` | `dstdev(Range database, double field, Range criteria)` 基于选定数据库项中的单个样本估算标准偏差。
`static double` | `dstdevp(Range database, double field, Range criteria)` 基于选定数据库项中的样本总体计算标准偏差。
`static double` | `dsum(Range database, double field, Range criteria)` 对数据库中满足条件的记录的字段列中的数字求和。
`static double` | `duration(java.lang.String settlement, java.lang.String maturity, double coupon, double yld, double frequency, int basis)` 返回按周期付息的有价证券的年周期。
`static double` | `dvar(Range database, double field, Range criteria)` 基于选定的数据库项的单个样本估算方差。
`static double` | `dvarp(Range database, double field, Range criteria)` 基于选定的数据库项的样本总体估算方差。
`static long` | `edate(java.lang.String start_date, int method)` 返回指定日期 start_date 之前或之后的指定月份数的序列号。
`static double` | `effect(double norminal_rate, int npery)` 根据指定的名义年利率和每年的复利期数，计算实际年利率。
`static long` | `eomonth(java.lang.String start_date, int method)` 返回 start_date 之前或之后指定月份的最后一天的序列号。
`static double` | `erf(double lower_limit, double upper_limit)` 返回误差函数的定积分。
`static double` | `erfc(double x)` 返回 x 到 ∞（无穷）积分的 ERF 函数的余误差函数。
`static int` | `error_type(Range error_val)` 返回对应于永中集成Office 中某一错误值的数字，如果没有错误则返回 *N/A。
`static double` | `even(double number)` 求沿绝对值增大方向取整后最接近的偶数。
`static boolean` | `exact(java.lang.String text1, java.lang.String text2)` 检测两组文本是否相同。
`static double` | `exp(double number)` 返回 e 的 n 次幂。
`static double` | `expondist(double x, double lambda, boolean cumulative)` 指数分布。
`static double` | `fact(double number)` 求返回数的阶乘，一个数的阶乘等于。
`static double` | `factdouble(double number)` 返回数的双阶乘。
`static double` | `fdist(double x, double degrees_freedom1, double degrees_freedom2)` 返回 F 概率分布。
`static int` | `find(java.lang.String findString, java.lang.String withinString, int startNumber)` 在其他文本值中查找文本值（区分大小写）。
`static int` | `findb(java.lang.String findString, java.lang.String withinString, int startNumber)` 在其他文本值中查找文本值（区分大小写）。
`static double` | `finv(double Probability, double degrees_freedom1, double degrees_freedom2)` 返回 F 概率分布。
`static double` | `fisher(double x)` 点 x 的 Fisher 变换。
`static double` | `fisherinv(double y)` Fisher 变换的反函数值。
`static java.lang.String` | `fixed(double currencyNumber, double decimalNumber, boolean noComma)` 使用固定的十进制数将数字设置为文本格式。
`static double` | `floor(double number, double significance)` 求将参数 Number 沿绝对值减小的方向向下舍入，使其等于最接近的 significance 的倍数。
`static double` | `forecast(double x, Range known_ys, Range known_xs)` 根据已有的数值计算或预测未来值。
`static double` | `frequency(Range data_array, Range bins_array)` 以一列垂直数组返回某个数据段中数据的频率分布。
`static double` | `ftest(Range array1, Range array2)` 返回 F 检验的结果。
`static double` | `fv(double rate, double nper, double pmt, double pv, double type)` 基于固定利率及等额分期付款方式，返回某项投资的未来值。
`static double` | `fvschedule(double principal, double[] schedule)` 根据指定的名义年利率和每年的复利期数，计算实际年利率。
`static double` | `gammadist(double x, double alpha, double beta, boolean cumulative)` 返回伽玛分布。
`static double` | `gammainv(double probability, double alpha, double beta)` 返回伽玛累积分布函数的反函数。
`static double` | `gammaln(double x)` 伽玛函数的自然对数，Γ(x)。
`static int` | `gcd(double number1, double number2)` 返回指定数字的最大公约数。
`static double` | `geomean(Range range)` 正数数组或区域的几何平均值。
`static double` | `gestep(double number, double upper_limit)` 对一组数据进行筛选。
`static double` | `getpivotdata(java.lang.String data_field, Range pivot_table)` 提取数据透视表中的数据。
`static double` | `getpivotdata(java.lang.String data_field, Range pivot_table, java.lang.String field1, java.lang.String item1)` 提取数据透视表中的数据。
`static double` | `getpivotdata(java.lang.String data_field, Range pivot_table, java.lang.String field1, java.lang.String item1, java.lang.String field2, java.lang.String item2)` 提取数据透视表中的数据。
`static double` | `growth(Range known_ys, Range known_xs, double new_xs, boolean const1)` 根据现有的数据预测指数增长值。
`static double` | `harmean(Range range)` 数据集合的调和平均值。
`static java.lang.String` | `hex2bin(java.lang.String number, int places)` 将十六进制数转换为二进制数。
`static long` | `hex2dec(java.lang.String number)` 将十六进制数转换为十进制数。
`static java.lang.String` | `hex2oct(java.lang.String number, int places)` 将十六进制数转换为八进制数。
`static java.lang.String` | `hlookup(Range lookup_value, Range table_array, int row_index_num, boolean range_lookup)` 在数值表格或数组的首行获取指定值，并返回在指定值所在列中某一指定行的数值。
`static java.lang.String` | `hlookup(java.lang.String lookup_value, java.lang.String table_array, int row_index_num, boolean range_lookup)` 在数值表格或数组的首行获取指定值，并返回在指定值所在列中某一指定行的数值。
`static int` | `hour(double serial_number)` 返回某一指定时间的小时数。
`static int` | `hour(java.lang.String serial_number)` 返回某一指定时间的小时数。
`static void` | `hyperlink(java.lang.String ref_text, java.lang.String caption)` 返回由文本字符串指定的引用。
`static double` | `hypgeomdist(int sample_s, int number_sample, int population_s, int number_population)` 解决有限整体的问题，其中每个观察值为成功或失败，而且指定样本的所有子集有相同的发生概率。
`static double` | `imabs(java.lang.String inumber)` 返回复数的绝对值（又叫模数）。
`static double` | `imaginary(java.lang.String inumber)` 返回以 x+yi 或 x+yj 文本格式表示的复数的虚系数。
`static double` | `imargument(java.lang.String inumber)` 计算指定复数对应的角度 θ，θ 用弧度表示。
`static java.lang.String` | `imconjugate(java.lang.String inumber)` 返回以 x+yi 或 x+yj 文本格式表示的复数的共轭复数。
`static java.lang.String` | `imcos(java.lang.String inumber)` 返回以 x+yi 或 x+yj 文本格式表示的复数的余弦。
`static java.lang.String` | `imdiv(java.lang.String inumber1, java.lang.String inumber2)` 计算 x+yi 或 x+yj 这两个形式表达的复数的商。
`static java.lang.String` | `imexp(java.lang.String inumber)` 计算以 x+yi 或 x+yj 形式表达的复数的指数。
`static java.lang.String` | `imln(java.lang.String inumber)` 返回形式为 x+yi 或 x+yj 的复数的自然对数。
`static java.lang.String` | `imlog10(java.lang.String inumber)` 返回形式为 x+yi 或 x+yj 的复数的常用对数（底数为 10）。
`static java.lang.String` | `imlog2(java.lang.String inumber)` 返回形式为 x+yi 或 x+yj 的复数的常用对数（底数为 2）。
`static java.lang.String` | `impower(java.lang.String inumber1, double inumber2)` 计算以 x+yi 或 x+yj 形式表达的复数的幂值。
`static java.lang.String` | `improduct(java.lang.String inumber1, java.lang.String inumber2)` 计算以 x+yi 或 x+yj 形式表达的复数的乘积。
`static double` | `imreal(java.lang.String inumber)` 返回形式为 x+yi 或 x+yj 的复数的实系数。
`static java.lang.String` | `imsin(java.lang.String inumber)` 计算以 x+yi 或 x+yj 形式表达的复数的正弦值。
`static java.lang.String` | `imsqrt(java.lang.String inumber)` 返回以 x+yi 或 x+yj 形式表示的复数的平方根。
`static java.lang.String` | `imsub(java.lang.String inumber1, java.lang.String inumber2)` 返回形式为 x+yi 或 x+yj 的两个复数的差。
`static java.lang.String` | `imsum(java.lang.String inumber1, java.lang.String inumber2)` 返回形式为 x+yi 或 x+yj 的复数的和。
`static java.lang.String` | `index(Range reference, int row_num, int column_num)` 返回引用中指定单元格或单元格区域的引用。
`static java.lang.String` | `indirect(Range ref_text, boolean a1)` 返回由文本字符串指定的引用。
`static java.lang.String` | `info(java.lang.String type_text)` 返回有关当前操作环境的信息。
`static int` | `integer(double number)` 返回数字舍入（数值减小的方向）后最接近的整数值。
`static double` | `intercept(Range known_y, Range known_x)` 根据已知 x、y 值计算直线与 y 轴的交点，即截距。
`static double` | `intrate(java.lang.String settlement, java.lang.String maturity, double investment, double redemption, int basis)` 计算一次性付息证券的利率。
`static double` | `ipmt(double rate, double per, double nper, double pv, double fv, double type)` 基于固定利率及等额分期付款方式，返回给定期数内对投资的利息偿还额。
`static double` | `irr(double[] value, double guess)` 返回由数值代表的一组现金流的内部收益率。
`static double` | `irr(Range value)` 返回由数值代表的一组现金流的内部收益率。
`static boolean` | `isblank(Range val)` 在被测值为空白单元格时返回 TRUE。
`static boolean` | `iserr(Range range)` 判断单元格区域中的值是否是除*N/A值以外任意错误值。
`static boolean` | `iserror(Range range)` 判断单元格区域中的值是否是错误值。
`static boolean` | `iseven(double number)` 在被测值为偶数时返回 TRUE，否则返回 FALSE。
`static boolean` | `islogical(Range range)` 判断单元格区域中的值是否是逻辑值。
`static boolean` | `isna(Range range)` 判断单元格区域中的值是否是*N/A错误值。
`static boolean` | `isnontext(Range range)` 判断单元格区域中的值是否是非文本的任意项。
`static boolean` | `isnumber(Range range)` 判断单元格区域中的值是否是数字。
`static boolean` | `isodd(double number)` 在被测值为奇数时返回 TRUE，否则返回 FALSE。
`static double` | `ispmt(double rate, double per, double nper, double pv)` 计算特定投资期内要支付的利息。
`static boolean` | `isref(java.lang.Object ref)` 当待测值为引用时返回 TRUE，其他情况则返回 FALSE。
`static boolean` | `istext(Range range)` 判断单元格区域中的值是否是文本。
`static int` | `jdate()` 返回今天是今年的第几天。
`static double` | `kurt(Range range)` 数据集的峰值。
`static double` | `large(Range range, double k)` 数据集中第 k 个最大值。
`static int` | `lcm(double number1, double number2)` 返回整数的最小公倍数。
`static java.lang.String` | `left(java.lang.String text, int num_chars)` 根据指定的字符数返回文本串中的第一个或前几个字符。
`static java.lang.String` | `leftb(java.lang.String text, int num_bytes)` 根据指定的字节数返回文本串中的第一个或前几个字符，常用于双字节字符。
`static int` | `len(java.lang.String text)` 返回文本串中的字符数。
`static int` | `lenb(java.lang.String text)` 返回在文本串中代表字符的字节数，常用于双字节字符。
`static double` | `linest(Range known_y, Range known_x, boolean consts)` 根据已知 x、y 值计算直线与 y 轴的交点，即截距。
`static double` | `ln(double number)` 求一个数的自然对数，自然对数以常数项e为底。
`static double` | `log(double number, double base)` 求按所指定的底数，返回一个数的对数。
`static double` | `log10(double number)` 求以 10 为底的对数。
`static void` | `logest(Range known_ys, Range known_xs, boolean consts, boolean stats)` 在回归分析中，计算最符合数据的指数回归拟合曲线，并返回描述该曲线的数值数组。
`static double` | `loginv(double probability, double mean, double standard_dev)` x 的对数累积分布函数的反函数，此处的 ln(x) 是含有 mean 与 standard-dev 参数的正态分布。
`static double` | `lognormdist(double x, double mean, double standard_dev)` x 的对数累积分布函数，其中 ln(x) 是服从参数 mean 和 standard_dev 的正态分布。
`static java.lang.String` | `lookup(java.lang.String lookup_value, Range lookup_vector, Range result_vector)` 返回数组或单行单列区域中的值。
`static java.lang.String` | `lower(java.lang.String text)` 将所有的大写字母转化为小写字母。
`static double` | `match(double lookupValue, Range range, double matchType)` 返回在指定方式下与指定数值匹配的区域中元素的相应位置。
`static double` | `match(Range lookupValue, Range range, double matchType)` 返回在指定方式下与指定数值匹配的区域中元素的相应位置。
`static double` | `max(Range range)` 一组值中的最大值。
`static double` | `maxa(Range values)` 返回参数列表中的最大值。
`static double` | `mdeterm(Range range)` 求一个数组的矩阵行列式的值。
`static double` | `mduration(java.lang.String settlement, java.lang.String maturity, double coupon, double yld, double frequency, int basis)` 返回假设面值 ￥100 的有价证券的 Macauley 修正期限。
`static double` | `median(Range range)` 给定数值集合的中值。
`static java.lang.String` | `mid(java.lang.String text, int start_num, int num_chars)` 返回文本串中从指定位置开始的一定数目的字符，该数目由用户指定。
`static java.lang.String` | `midb(java.lang.String text, int start_num, int num_bytes)` 返回文本串中从指定位置开始的一定数目的双字节字符，该数目由用户指定。
`static double` | `min(Range range)` 一组值中的最小值。
`static double` | `mina(Range values)` 返回参数列表中的最小值。
`static int` | `minute(double serial_number)` 返回某一指定时间的分钟数，其值是介于 0 到 59 之间的一个整数。
`static int` | `minute(java.lang.String serial_number)` 返回某一指定时间的分钟数，其值是介于 0 到 59 之间的一个整数。
`static double` | `minverse(Range range)` 求数组矩阵的逆距阵。
`static double` | `mirr(double[] value, double frate, double rrate)` 计算某一连续期间内现金流的修正内部收益率。
`static double` | `mirr(Range value, double frate, double rrate)` 计算某一连续期间内现金流的修正内部收益率。
`static double` | `mmult(Range array1, Range array2)` 返回两数组的矩阵乘积。
`static int` | `mod(double number, double divisor)` 返回两数相除的余数。
`static double` | `mode(Range range)` 在某一数组或数据区域中出现频率最多的数值。
`static int` | `month(long serial_number)` 返回某日期对应的月份，用整数 1 到 12 表示。
`static int` | `month(java.lang.String serial_number)` 返回某日期对应的月份，用整数 1 到 12 表示。
`static int` | `mround(double number, double multiple)` 返回指定参数按指定基数舍入后的数值。
`static int` | `multinomial(double number1, double number2, double number3)` 计算参数和的阶乘与各参数阶乘乘积的比值。
`static long` | `n(Range val)` 返回转化为数值后的值。
`static java.lang.String` | `na()` 返回错误值 *N/A。
`static double` | `negbinomdist(double number_f, double number_s, double probability_s)` 负二项式分布。
`static long` | `networkdays(java.lang.String start_date, java.lang.String end_date, java.lang.String[] holidays)` 返回指定开始日期和结束日期间的完整工作日数值，其中要除去周末和节假日的天数。
`static double` | `nominal(double effect_rate, int npery)` 根据指定的实际利率和年复利期数，返回名义年利率。
`static double` | `normdist(double x, double mean, double standard_dev, boolean cumulative)` 指定平均值和标准偏差的正态分布函数。
`static double` | `norminv(double probability, double mean, double standard_dev)` 返回指定平均值和标准偏差的正态累积分布函数的逆函数。
`static double` | `normsdist(double z)` 标准正态累积分布函数，该分布的平均值为 0，标准偏差为 1。
`static double` | `normsinv(double probability)` 标准正态累积分布函数的反函数。
`static double` | `now()` 返回当前日期和时间所对应的序列号。
`static double` | `nper(double rate, double pmt, double pv, double fv, double type)` 基于固定利率及等额分期付款方式，返回某项投资的总期数。
`static double` | `npv(double rate, double[] value)` 通过使用贴现率以及一系列未来支出（负值）和收入（正值），返回一项投资的净现值。
`static double` | `npv(double rate, Range value)` 通过使用贴现率以及一系列未来支出（负值）和收入（正值），返回一项投资的净现值。
`static java.lang.String` | `num2txt(double number, int info_type)` 将阿拉伯数字转换为英文货币大写。
`static java.lang.String` | `oct2bin(long number, int places)` 将八进制数转换为二进制数。
`static long` | `oct2dec(long number)` 将八进制数转换为十进制数。
`static java.lang.String` | `oct2hex(long number, int places)` 将八进制数转换为十六进制数。
`static double` | `odd(double number)` 求对指定数值进行向上舍入后的奇数。
`static double` | `oddfprice(java.lang.String settlement, java.lang.String maturity, java.lang.String issue, java.lang.String first_coupon, double rate, double yld, double redemption, double frequency, double basis)` 返回首期付息日不固定（长期或短期）的面值 $100 的有价证券价格。
`static double` | `oddfyield(java.lang.String settlement, java.lang.String maturity, java.lang.String issue, java.lang.String first_coupon, double rate, double pr, double redemption, double frequency, double basis)` 返回首期付息日不固定的有价证券（长期或短期）的收益率。
`static double` | `oddlprice(java.lang.String settlement, java.lang.String maturity, java.lang.String last_interest, double rate, double yld, double redemption, double frequency, int basis)` 返回末期付息日不固定的有价证券之每 ￥100 票面价值的实际价值。
`static double` | `oddlyield(java.lang.String settlement, java.lang.String maturity, java.lang.String last_interest, double rate, double pr, double redemption, double frequency, int basis)` 返回末期付息日不固定的有价证券的收益率。
`static Range` | `offset(Range reference, int rows, int cols, int height, int width)` 通过指定偏移量，返回一个区域的引用，这个引用是一个单元格或单元格区域的行数列数。
`static boolean` | `or(Range range)` 在其参数组中，任何一个参数逻辑值为 TRUE，即返回 TRUE；任何一个参数的逻辑值为 FALSE，即返回 FALSE。
`static double` | `pearson(Range range1, Range range2)` Pearson（皮尔生）乘积矩相关系数 r， 这是一个范围在 -1.0 到 1.0 之间（包括 -1.0 和 1.0 在内）的无量纲指数， 反映了两个数据集合之间的线性相关程度。
`static double` | `percentile(Range range, double k)` 区域中数值的第 K 个百分点的值。
`static double` | `percentrank(Range array, int x, int significance)` 返回特定数值在一个数据集中的百分比排位。
`static double` | `permut(double number, double number_chosen)` 从给定数目的对象集合中选取的若干对象的排列数。
`static double` | `pi()` 返回数字 3.141592653589793，即数学常量 pi，精确到小数点后 15 位。
`static double` | `pmt(double rate, double nper, double pv, double fv, double type)` 基于固定利率及等额分期付款方式，返回贷款的每期付款额。
`static double` | `poisson(double x, double mean, boolean cumulative)` 泊松分布。
`static double` | `postTax(double amt, double tax_rate, double num_digits)` 计算按指定位数返回舍入后的含税价。
`static double` | `power(double number, double power)` 求给定数字的乘幂。
`static double` | `ppmt(double rate, double per, double nper, double pv, double fv, double type)` 基于固定利率及等额分期付款方式，返回投资在某一给定期间内的本金偿还额。
`static double` | `preTax(double amt, double tax_rate, double num_digits)` 计算按指定位数返回舍入后的不含税价。
`static double` | `price(java.lang.String settlement, java.lang.String maturity, double rate, double yld, double redemption, double frequency, int basis)` 返回按周期付息的有价证券每 ￥100 票面价值的实际价格。
`static double` | `pricedisc(java.lang.String settlement, java.lang.String maturity, double discount, double redemption, int basis)` 返回折价发行的面值为 ￥100 的有价证券的价格。
`static double` | `pricemat(java.lang.String settlement, java.lang.String maturity, java.lang.String issue, double rate, double yld, int basis)` 返回到期付息的面值为 ￥100 的有价证券的价格。
`static double` | `prob(Range range1, Range range2, double lower_limit, double upper_limit)` 区域中的数值落在指定区间内的概率。
`static double` | `product(Range range)` 求所有以参数形式给出的数字相乘，并返回乘积值。
`static java.lang.String` | `proper(java.lang.String string)` 将文本值中每个单词的首字母设置为大写。
`static double` | `pv(double rate, double nper, double pmt, double fv, double type)` 返回投资的现值。
`static double` | `quartile(Range range, double quart)` 数据集的四分位数。
`static int` | `quotient(double numerator, double denominator)` 返回商的整数部分。
`static double` | `radians(double angle)` 将角度转换成弧度。
`static double` | `rand()` 返回均匀分布的随机数。
`static double` | `randbetween(double bottom, double top)` 返回位于指定的任意两数之间的随机数。
`static void` | `range(Range range)` 将一个特定的单元格区域链接到其他单元格中，当源数据发生变化时，链接后的数据将会作相应变化。
`static double` | `rank(double number, Range range, double order)` 一个数字在数字列表中的排位。
`static double` | `rate(double nper, double pmt, double pv, double fv, double type, double guess)` 返回年金的各期利率。
`static double` | `received(java.lang.String settlement, java.lang.String maturity, double investment, double discount, int basis)` 返回一次性付息的有价证券到期收回的金额。
`static java.lang.String` | `replace(java.lang.String originString, int startNumber, int charNumbers, java.lang.String newString)` 根据指定的字符数，用其他文本串来替换某个文本串中的部分内容。
`static java.lang.String` | `replaceb(java.lang.String originString, int startNumber, int charNumbers, java.lang.String newString)` 根据指定的字符数，用其他文本串来替换某个文本串中的部分内容，常用于双字节字符。
`static java.lang.String` | `rept(java.lang.String text, int number_times)` 根据指定的次数重复显示文本。
`static java.lang.String` | `right(java.lang.String text, int num_chars)` 根据指定的字符数从右开始返回文本串中的最后一个或几个字符。
`static java.lang.String` | `rightb(java.lang.String text, int num_bytes)` 根据所指定的字节数从右开始返回文本串中的最后一个或几个字符，常用于双字节字符。
`static java.lang.String` | `rmb(double number, int decimals)` 使用 ￥（人民币）货币格式将数字转换为文本，并四舍五入至指定位数。
`static java.lang.String` | `roman(double number)` 求将阿拉伯数字转换为文本形式的罗马数字。
`static java.lang.String` | `roman(double number, double form)` 求将阿拉伯数字转换为文本形式的罗马数字。
`static double` | `round(double number, double digits)` 求从给定数目的对象集合中提取若干对象的组合数。
`static double` | `rounddown(double number, double digits)` 求从靠近零值，向下（绝对值减小的方向）舍入数字。
`static double` | `roundup(double number, double digits)` 求远离零值，向上舍入数字。
`static int` | `row(Range reference)` 返回指定引用的行号。
`static int` | `rows(Range reference)` 返回一个数组或引用的行数。
`static double` | `rsq(Range range1, Range range2)` 根据 known_ys 和 known_xs 中数据点计算得出的 Pearson 乘积矩相关系数的平方。
`static int` | `search(java.lang.String findString, java.lang.String withinString, int startNumber)` 在其他文本值中查找文本值（不区分大小写）。
`static int` | `searchb(java.lang.String findText, java.lang.String withinText, int startNumber)` 在其他文本值中查找文本值（不区分大小写）。
`static int` | `second(double serial_number)` 返回指定日期值的秒数，其值为介于 0 到 59 之间的整数。
`static int` | `second(java.lang.String serial_number)` 返回指定日期值的秒数，其值为介于 0 到 59 之间的整数。
`static double` | `seriessum(Range x, double n, double m, Range coefficients)` 返回幂级数之和。
`static int` | `sign(double number)` 返回数字或可计算的数式结果的符号。
`static double` | `sin(double number)` 计算指定角度的正弦值。
`static double` | `sinh(double number)` 求双曲正弦值。
`static double` | `skew(Range range)` 分布的偏斜度。
`static double` | `sln(double cost, double salvage, double life)` 返回某项资产在一个期间中的线性折旧值。
`static double` | `slope(Range range1, Range range2)` 根据 known_ys 和 known_xs 中的数据点拟合的线性回归直线的斜率。
`static double` | `small(Range range, double k)` 数据集中第 k 个最小值。
`static double` | `sqrt(double number)` 返回一个平方根。
`static double` | `sqrtpi(double number)` 返回数值与 pi 乘积的平方根。
`static double` | `standardize(double x, double mean, double standard_dev)` 以 mean 为平均值，以 standard-dev 为标准偏差的分布的正态化数值。
`static double` | `stdev(Range range)` 估算样本的标准偏差。
`static double` | `stdeva(Range values)` 估算基于指定样本的标准偏差。
`static double` | `stdevp(Range range)` 以参数形式给出的整个样本总体的标准偏差。
`static double` | `stdevpa(Range values)` 计算样本总体的标准偏差。
`static double` | `steyx(Range range1, Range range2)` 通过线性回归法计算每个 x 的 y 预测值时所产生的标准误差。
`static java.lang.String` | `substitute(java.lang.String originString, java.lang.String oldString, java.lang.String newString, int orderNumber)` 在文本串中使用新文本替换旧文本。
`static double` | `subtotal(double criteria, Range array)` 求数据清单或数据库中的分类汇总。
`static double` | `sum(Range range)` 求某一单元格区域中所有数字之和。
`static double` | `sumif(Range array, java.lang.String criteria, Range sum_array)` 求指定条件对若干单元格的和。
`static double` | `sumproduct(Range range1, Range range2)` 求在给定的两组区域中对应的元素相乘之和，(两个单元格区域的行列数必须对应相等)。
`static double` | `sumsq(Range range)` 求参数的平方和。
`static double` | `sumx2my2(Range array1, Range array2)` 求两数组中对应数值的平方差之和。
`static double` | `sumx2py2(Range array1, Range array2)` 求两两数组中对应数值的平方和之和。
`static double` | `sumxmy2(Range array1, Range array2)` 求两数组中对应数值之差的平方和。
`static double` | `syd(double cost, double salvage, double life, double per)` 返回某项资产按年限总和折旧法计算的指定期间的折旧值。
`static java.lang.String` | `t(java.lang.String value)` 返回参数所引用的文本。
`static double` | `tan(double number)` 返回指定角度的正切值。
`static double` | `tanh(double number)` 求某一数字的双曲正切。
`static double` | `tbilleq(java.lang.String settlement, java.lang.String maturity, double discount)` 返回国库券的等效收益率。
`static double` | `tbillprice(java.lang.String settlement, java.lang.String maturity, double discount)` 返回面值为 ￥100 的短期国库券的价格。
`static double` | `tbillyield(java.lang.String settlement, java.lang.String maturity, double pr)` 返回短期国库券的收益率。
`static double` | `tdist(double x, int degrees_freedom, int tails)` 返回学生 t 分布的百分点（概率），t 分布中数值 (x) 是 t 的计算值（将计算其百分点）。
`static java.lang.String` | `text(double v, java.lang.String formatText)` 获得格式化后的字符串
`static double` | `time(int hour, int minute, int second)` 返回代表指定时间的序列数。
`static double` | `timevalue(java.lang.String time_text)` 将表示时间的文本串转化为表示时间的小数值。
`static double` | `tinv(double probability, int degrees_freedom)` 返回给定自由度和双尾概率的学生 t 分布的区间点。
`static long` | `today()` 获取当前日期并返回表示此日期的序列号。
`static void` | `transpose(Range range)` 返回转置单元格区域，即将一行单元格区域转置成一列单元格区域，反之亦然。
`static double` | `trend(Range range1, Range range2, double new_xs, boolean const1)` 一条线性回归拟合线的值。
`static java.lang.String` | `trim(java.lang.String string)` 删除文本中的空格。
`static double` | `trimmean(Range range, double percent)` 数据集的内部平均值。
`static double` | `trunc(double number, double num_digits)` 通过舍弃数字的部分或全部小数点位数，使数字的小数点位数符合指定条件。
`static double` | `ttest(Range array1, Range array2, int tails, int type)` 返回与学生 t 检验相关的概率。
`static int` | `type(Range val)` 返回数值类型。
`static java.lang.String` | `upper(java.lang.String text)` 将文本中所有的字符转化为大写。
`static long` | `value(java.lang.String text)` 将表示数值的文本转化为数字。
`static double` | `var(Range range)` 计算基于给定样本的方差。
`static double` | `vara(Range values)` 估算指定样本的方差。
`static double` | `varp(Range range)` 计算基于整个样本总体的方差。
`static double` | `varpa(Range values)` 计算样本总体的方差。
`static double` | `vdb(double cost, double salvage, double life, double start_period, double end_period, double factor, boolean no_switch)` 使用双倍余额递减法或其他指定的方法，返回指定的任何期间内（包括部分期间）的资产折旧值。
`static double` | `vdb(double cost, double salvage, double life, double startPeriod, double endPeriod, double factor, double type)` 使用双倍余额递减法或其他指定的方法，返回指定的任何期间内（包括部分期间）的资产折旧值。
`static java.lang.String` | `vlookup(Range lookup_value, Range table_array, int col_index_num, boolean range_lookup)` 在数值组成的表格或数组的首列获取指定值，并返回指定值所在行中某一指定列的数值。
`static java.lang.String` | `vlookup(java.lang.String lookup_value, java.lang.String table_array, int col_index_num, boolean range_lookup)` 在数值组成的表格或数组的首列获取指定值，并返回指定值所在行中某一指定列的数值。
`static int` | `weekday(java.lang.String Serial_number, int return_type)` 获取日期并返回星期数。
`static int` | `weeknum(java.lang.String Serial_number, int return_type)` 返回一个数字，该数字代表一年中的第几周。
`static double` | `weibull(double x, double alpha, double beta, boolean cumulative)` 韦伯分布。
`static java.lang.String` | `widechar(java.lang.String text)` 将字符串中的单字节（半角）英文字母转换为双字节（全角）字符。
`static long` | `workday(java.lang.String start_date, int days, long[] holidays)` 返回某日期（起始日期）之前或之后相隔指定工作日的某一日期的序列号。
`static double` | `xirr(double[] values, java.lang.String[] dates, double guess)` 返回一组不定期发生的现金流的内部收益率。
`static double` | `xnpv(double rate, double[] values, long[] dates)` 返回一组不定期发生的现金流的净现值。
`static int` | `year(double serial_number)` 返回某日期对应的年份，用整数 1899 和 9999 表示。
`static int` | `year(long serial_number)` 返回某日期对应的年份，用整数 1899 和 9999 表示。
`static int` | `year(java.lang.String serial_number)` 返回某日期对应的年份，用整数 1899 和 9999 表示。
`static double` | `yearfrac(java.lang.String start_date, java.lang.String end_date, int basis)` 返回指定起止日期之间的天数占全年天数的百分比。
`static double` | `yield(java.lang.String settlement, java.lang.String maturity, double rate, double pr, double redemption, double frequency, int basis)` 返回按周期付息的有价证券的收益率，一般用于计算债券收益率。
`static double` | `yielddisc(java.lang.String settlement, java.lang.String maturity, double pr, double redemption, int basis)` 返回折价发行的有价证券的年收益率。
`static double` | `yieldmat(java.lang.String settlement, java.lang.String maturity, java.lang.String issue, double rate, double pr, int basis)` 返回到期付息的有价证券的年收益率。
`static double` | `ztest(Range array, double x)` 返回 Z 检验的单尾概率值。

从类 java.lang.Object 继承的方法
`equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

构造函数详细信息

### WorksheetFunction

    public WorksheetFunction()

方法详细信息

### abs

    public static double abs(double number)

  返回指定数字的绝对值。

  参数：
    `number` - 需要求出绝对值的任意实数

    例子：

           WorksheetFunction.abs(-1.5) 等于 1.5。

### accrint

    public static double accrint(java.lang.String issue,
                                 java.lang.String first_interest,
                                 java.lang.String settlement,
                                 double rate,
                                 double par,
                                 double frequency,
                                 double basis)

  返回定期付息有价证券的应计利息。

  参数：
    `issue` - 为有价证券的发行日。
    `first_interest` - 是证券的起息日。
    `settlement` - 是证券的成交日。
    `rate` - 为有价证券的年息票利率。
    `par` - 为有价证券的票面价。
    `frequency` - 为年付息次数，如果按年支付，frequency = 1；按半年期支付，frequency = 2；按季支付，frequency = 4。
    `basis` - 日计数基准类型。

    例子：

          double result = WorksheetFunction.accrint("1997/1/1","1997/1/2","1997/4/15",0.08,1000,2,2);
          System.out.print(result);

### accrintm

    public static double accrintm(java.lang.String issue,
                                  java.lang.String maturity,
                                  double rate,
                                  double par,
                                  double basis)

  返回到期一次性付息的有价证券的应计利息。 应计利息指一段时间后有价证券应付的利息，到期日指有价证券的有效期截止日。

  参数：
    `issue` - 为证券的发行日期
    `maturity` - 为有价证券的到期日，即有价证券的最后一个有效日。
    `rate` - 为有价证券的年息票利率，即有价证券上标明的利率。
    `par` - 为有价证券首次卖出时的票面价值
    `basis` - 为日计数基准类型

    例子：

           债券是企业发行的一种书面证书，企业在该证书上许诺将来偿还债权人一定数量的金额及利息。某债券的交易情况如下：
           发行日：1997 年 1 月 1 日
           到期日：1997 年 4 月 15 日
           息票利率：8.0%
           票面价值：￥1,000
           日计数基准：实际天数/360
           该债券的应计利息为：
           WorksheetFunction.accrintm("1997/1/1","1997/4/15",0.08,1000,2) 等于 23.11111111。

### acos

    public static double acos(double number)

  返回指定数值的反余弦值。反余弦值为一个角度，返回角度以弧度形式表示。

  参数：
    `number` - 需要返回角度的余弦值

    例子：

           WorksheetFunction.acos(1) 等于 0（弧度）
           WorksheetFunction.acos(0.5) 等于 1.047197551（pi/3 弧度）
           WorksheetFunction.acos(0.5)*180/WorksheetFunction.pi() 等于 60（度）

### acosh

    public static double acosh(double number)

  求反双曲余弦值。

  参数：
    `number` - 参数必须大于或等于 1实数值，如"2.17"
  返回：
    一个实数的反双曲余弦值

    例子：

         double value = WorksheetFunction.acosh(2.17);
         System.out.println("value is " + value);

### address

    public static java.lang.String address(int row_num,
                                           int column_num,
                                           int abs_num,
                                           boolean a1,
                                           java.lang.String sheet_text)

  根据指定行号与列标，建立文本类型的单元格地址。

  参数：
    `row_num` - 应用在单元格引用中的行号
    `column_num` - 应用在单元格引用中的列标
    `abs_num` - 返回的引用类型

          备注
          若 abs_num 是 1 或省略，则函数返回引用类型是绝对引用。
          若 abs_num 是 2，则函数返回引用类型是绝对行号，相对列标。
          若 abs_num 是 3，则函数返回引用类型是相对行号，绝对列标。
          若 abs_num 是 4，则函数返回引用类型是相对引用。

    `a1` - 任意值
    `sheet_text` - 任意值

    例子：

           如果单元格 A2 中含有文本“English”，则：
           WorksheetFunction.address(3,6,3,false,"WORKSHEET") 等于 'WORKSHEET'!R[3]C6。

### amordegrc

    public static double amordegrc(double cost,
                                   java.lang.String date_purchased,
                                   java.lang.String first_period,
                                   double salvage,
                                   double period,
                                   double rate,
                                   double basis)

  返回每个会计期间资产的按比例线性折旧率。该函数为法国会计系统提供。如果某项资产是在结算期间的中期购入的，则按直线折旧法计算。

  参数：
    `cost` - 资产原值
    `date_purchased` - 购入资产的日期
    `first_period` - 第一个期间结束时的日期
    `salvage` - 资产在使用寿命结束时的残值
    `period` - 期间
    `rate` - 为折旧率
    `basis` - 所使用的年基准

    例子：

           某项资产的折旧情况如下：
           资产原值：￥2800
           购入资产的日期：2004 年 8 月 10 日
           第一个期间结束的日期：2004 年 10 月 31 日
           资产残值：￥500
           期间：1
           折旧率：20%
           所使用的年基准：实际天数
           第一个期间的折旧值为：
           WorksheetFunction.amordegrc(2800,"2004/8/10","2004/10/31",500,1,0.2,1) 等于 1019。

### amorlinc

    public static double amorlinc(double cost,
                                  java.lang.String date_purchased,
                                  java.lang.String first_period,
                                  double salvage,
                                  double period,
                                  double rate,
                                  double basis)

  返回每个结算期间的折旧值，该函数为法国会计系统提供。

  参数：
    `cost` - 为有价证券的发行日
    `date_purchased` - 为有价证券的到期日
    `first_period` - 为有价证券的年息票利率
    `salvage` - 为有价证券的票面价值，如果省略 par，函数 ACCRINTM 视 par 为 $1000
    `period` - 日计数基准类型
    `rate` - 为折旧率
    `basis` - 所使用的年基准，其中 1表示实际天数，3表示一年365天，4表示欧洲 360 天
  返回：
    double 返回到期一次性付息有价证券的应计利息

    例子：

         double value = WorksheetFunction.amorlinc(3500, "2004/6/23", "2004/10/1", 600,
                        1, 0.2, 1);
         System.out.println("value is " + value);

### and

    public static boolean and(Range range)

  所有参数的逻辑值为真时，返回 TRUE；只要一个参数的逻辑值为假，即返回 FALSE。

  参数：
    `range` - 单元格区域引用，如"a1:a2"
  返回：
    所有参数的逻辑值为真时，返回 TRUE；只要一个参数的逻辑值为假，即返回 FALSE

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range range = sheet.getRange("a1:a2");
         range.fillRandom(10, 1, 0);
         boolean result = WorksheetFunction.and(range);
         System.out.println("result is " + result);

### areas

    public static int areas(Range reference)

  返回包含在引用中的单元格区域个数。一个区域是任一单元格或一个相连的单元格区域。

  参数：
    `reference` - 对一个单元格或单元格区域的引用，也可对多个单元格区域引用。 若参数为多个单元格区域引用，必须使用括号，否则会把逗号作为参数间的分隔符。

    例子：

           //等于 1。
           Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
           Range range = sheet.getRange("C3:E5");
           WorksheetFunction.areas(range);

### asc

    public static java.lang.String asc(java.lang.String string)

  将字符串中的全角（双字节）英文字母或数字更改为半角（单字节）字符。

  参数：
    `string` - 字符串类型
  返回：
    半角(单字节)字符串

    例子：

         String result = WorksheetFunction.asc("ｔｅｘｔ");
         System.out.println("result is " + result);

### asin

    public static double asin(double number)

  返回指定数值的反正弦值。反正弦值为一个角度，返回角度以弧度形式表示。

  参数：
    `number` - 需要返回角度的正弦值

    例子：

           WorksheetFunction.asin(0.5) 等于 0.523598776（pi/6 弧度）
           WorksheetFunction.asin(1) 等于 1.570796327（pi/2 弧度）
           WorksheetFunction.asin(0.5)*180/PI() 等于 30（度）

### asinh

    public static double asinh(double number)

  求反双曲正弦值。

  参数：
    `number` - 实数值，如"2.17"
  返回：
    一个实数的反双曲正弦值

    例子：

         double value = WorksheetFunction.asinh(2.17);
         System.out.println("value is " + value);

### atan

    public static double atan(double number)

  返回指定数字的绝对值。

  参数：
    `number` - 返回角度的正切

    例子：

           WorksheetFunction.atan(-1) 等于 -0.785398163（-pi/4 弧度）。

### atan2

    public static double atan2(double X_num,
                               double Y_num)

  求给定X，Y坐标的反正切值。

  参数：
    `X_num` - 点的 X 坐标，如"3"
    `Y_num` - 点的 Y 坐标，如"4"
  返回：
    一个给定X，Y坐标的反正切值，-pi 到 pi 之间（不包括 -pi）

    例子：

         double value = WorksheetFunction.atan2(3, 4);
         System.out.println("value is " + value);

### atanh

    public static double atanh(double number)

  求反双曲正切值。

  参数：
    `number` - 实数值，如"0.3"，-1 到 1 之间的任意实数
  返回：
    参数的反双曲正切值，参数必须介于（-1，1）

    例子：

         double value = WorksheetFunction.atanh(0.3);
         System.out.println("value is " + value);

### avedev

    public static double avedev(Range range)

  用于评测这组数据的离散度。

  参数：
    `range` - 单元格区域引用，如"a1:a2"
  返回：
    一组数据与其均值的绝对偏差的平均值

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range range = sheet.getRange("a1:a2");
         range.fillRandom(100, 120, 0);
         double value = WorksheetFunction.avedev(range);
         System.out.println("value is " + value);

### average

    public static double average(Range range)

  返回指定数据的平均值。 如果数组或引用参数中含有文字、逻辑值或空白单元格，这些值将被忽略；但是，单元格中的零值则参与计算。

  参数：
    `range` - 单元格区域引用

    例子：

          如果 A1:A6 被命名为“ages”，分别等于 10、23、14、24、33 及 25，则：
          Worksheet sheet = Application.getWorkbooks().getActiveWrokbook().getWorksheets().getActiveWorksheet();
          Range range = sheet.getRange("A1:A6");
          WorksheetFunction.average(A1:A6); 等于 21.5。

### averagea

    public static double averagea(Range values)

  返回一组参数的算术平均值。数字、文本值和逻辑值也参与计算。 如果数组或引用中的单元格包含文本值或空白文本时，该单元格计算为 0。如果不把文本值计算在内，需用 AVERAGE 函数。 逻辑值 TRUE 作为 1 计算；逻辑值 FALSE 作为 0 计算。

  参数：
    `values` - 含数值的单元格区域

    例子：

          Worksheet sheet = Application.getWorkbooks().getActiveWrokbook().getWorksheets().getActiveWorksheet();
          Range range = sheet.getRange("A1:A5");
          WorksheetFunction.averagea(range); 等于3.6。

### besseli

    public static double besseli(double x,
                                 double n)

  返回修正 Bessel 函数值，它与用纯虚数参数运算时的 Bessel 函数值相等, 该方法会去调用封装算法中的各方法，返回最终函数的结果。

  参数：
    `x` - 参数值
    `n` - 函数的阶数，如果 n 非整数，则截尾取整
  返回：
    double 返回修正 Bessel 函数值，它与用纯虚数参数运算时的 Bessel 函数值相等

    例子：

         double value = WorksheetFunction.besseli(1.5, 1);
         System.out.println("value is " + value);

### besselj

    public static double besselj(double x,
                                 double n)

  返回 Bessel 函数值。 该方法会去调用封装算法中的各方法，返回最终函数的结果。

  参数：
    `x` - 参数值
    `n` - 函数的阶数，如果 n 非整数，则截尾取整
  返回：
    double 返回 Bessel 函数值

    例子：

         double value = WorksheetFunction.besselj(10000, 4);
         System.out.println("value is " + value);

### besselk

    public static double besselk(double x,
                                 int n)

  返回修正 Bessel 函数值，它与纯虚数参数运算的 Bessel 函数值相等。

  参数：
    `x` - 参数值
    `n` - 函数的阶数

    例子：

           WorksheetFunction.besselk(3.52,2) 等于 0.031503902。

### bessely

    public static double bessely(double x,
                                 int n)

  返回 Bessel 函数值，也称为 Weber 函数或 Neumann 函数。

  参数：
    `x` - 参数值
    `n` - 函数的阶数

    例子：

           WorksheetFunction.bessely(3.5,1) 等于 0.410188417。

### betadist

    public static double betadist(double x,
                                  double alpha,
                                  double beta,
                                  double a,
                                  double b)

  返回 beta 累积分布函数。

  参数：
    `x` - 用来进行函数计算的值，位于可选性上下限值（A 和 B）之间
    `alpha` - 分布参数
    `beta` - 分布参数
    `a` - 数值 x 所属区间的可选下限值
    `b` - 数值 x 所属区间的可选上限值

    例子：

           WorksheetFunction.betadist(2,8,10,1,3) 等于 0.685470581

### betainv

    public static double betainv(double probability,
                                 double alpha,
                                 double beta,
                                 double a,
                                 double b)

  返回 beta 累积分布函数。

  参数：
    `probability` - Beta 分布的概率值
    `alpha` - 分布参数
    `beta` - 分布参数
    `a` - 数值 x 所属区间的可选下限值
    `b` - 数值 x 所属区间的可选上限值

    例子：

           WorksheetFunction.betainv(0.789564231,7,9,2,4) 等于 3.07381287

### bin2dec

    public static long bin2dec(long number)

  将二进制数转化为十进制数。

  参数：
    `number` - 待转化的二进制数

    例子：

           WorksheetFunction.bin2dec(1110011) 等于 115。
           WorksheetFunction.bin2dec(1111111110) 等于 -2。

### bin2hex

    public static java.lang.String bin2hex(long number,
                                           int places)

  将二进制数转化为十六进制数。

  参数：
    `number` - 待转化的二进制数
    `places` - 字符数，可省略

    例子：

           WorksheetFunction.bin2hex(11110110,2) 等于 F6。

### bin2oct

    public static java.lang.String bin2oct(long number,
                                           int places)

  将二进制数转化为八进制数。

  参数：
    `number` - 待转化的二进制数
    `places` - 字符数，可省略

    例子：

           WorksheetFunction.bin2oct(11110110,3) 等于 366。

### binomdist

    public static double binomdist(double number_s,
                                   double trials,
                                   double probability_s,
                                   boolean cumulative)

  一元二项式分布的概率值。

  参数：
    `number_s` - 为试验成功的次数
    `trials` - 为独立试验的次数
    `probability_s` - 为每次试验中成功的概率
    `cumulative` - 为一逻辑值，用于确定函数的形式。如果 cumulative 为 TRUE， 函数 boo 返回累积分布函数，即至多 number_s 次成功的概率； 如果为 FALSE，返回概率密度函数，即 number_s 次成功的概率
  返回：
    一元二项式分布的概率值

    例子：

         double value = WorksheetFunction.binomdist(5, 10, 0.3, true);
         System.out.println("value is " + value);

### ceiling

    public static double ceiling(double number,
                                 double significance)

  求number向上舍入（延绝对值增大方向）接近的significance的倍数。

  参数：
    `number` - 实数值，如"3.16"
    `significance` - 实数值，如"0.2"

    例子：

         double value = WorksheetFunction.ceiling(3.16, 0.2);
         System.out.println("value is " + value);

  返回：
    number向上舍入（延绝对值增大方向）接近的ignificance的倍数

### cell

    public static java.lang.String cell(java.lang.String info_type,
                                        Range reference)

  返回某一引用范围中的左上角单元格的格式、位置或内容等信息。

  参数：
    `info_type` - 用来指定单元格信息类型的文本值
    `reference` - 指所需要有关信息的单元格

    例子：

           如果单元格 A7 中含有 TOTAL，则等于“TOTAL”。
           Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
           Range range = sheet.getRange("A7");
           WorksheetFunction.cell("contents",range);

### character

    public static java.lang.String character(int number)

  根据指定数字返回对应的字符。函数 CHAR 可将其他类型计算机文件中的数字代码转换为字符。

  参数：
    `number` - 用于指定字符的数字，介于 1 到 65535 之间（包括 1 和 65535）。

    例子：

          WorksheetFunction.character(88) 等于“X”。

### chidist

    public static double chidist(double x,
                                 double degrees_freedom)

  返回 γ2 分布的单尾概率。

  参数：
    `x` - 用来计算分布首尾概率的数值
    `degrees_freedom` - 自由度

    例子：

           WorksheetFunction.chidist(16.588,10) 等于 0.083992261

### chiinv

    public static double chiinv(double probability,
                                double degrees_freedom)

  返回 γ2 分布单尾概率的反函数值。

  参数：
    `probability` - 为 γ2 分布的单尾概率
    `degrees_freedom` - 自由度

    例子：

           WorksheetFunction.chiinv(0.05,10) 等于 18.30703805

### chitest

    public static double chitest(Range actual_range,
                                 Range expected_range)

  返回独立性检验值。函数 CHITEST 返回 (c2 ) 分布的统计值及相应的自由度。 可以使用 (c2 ) 检验，从而确定假设值是否被试验所证实。

  参数：
    `actual_range` - 观察值的数据区域，将和期望值作比较
    `expected_range` - 行列汇总的乘积与总计值之比率的数据区域

    例子：

           等于 0.265119471
           Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
           Range range = sheet.getRange("A2:B4");
           Range range1 = sheet.getRange("A6:B8");
           WorksheetFunction.chitest(range,range1);

### choose

    public static java.lang.String choose(int index_num,
                                          java.lang.String[] values)

  根据索引号，返回已输入的数值中任一数值。

  参数：
    `index_num` - 指明选择的参数值
    `values` - 一组数值
  返回：
    返回已输入的数值中任一数值

    例子：

         String[] values = {"January","February","May","April"};
         String value = WorksheetFunction.choose(2,values);
         System.out.println("value :" + value);

### clean

    public static java.lang.String clean(java.lang.String string)

  删除文本中的所有不可打印字符。

  参数：
    `string` - 字符串类型
  返回：
    删除不可打印字符后的字符串

    例子：

         String result = WorksheetFunction.clean((char) 15 + "file" + (char) 15);
         System.out.println("result is " + result);

### code

    public static int code(java.lang.String text)

  计算文本串中第一个字符的数字代码。返回的代码对应于计算机使用的字符集。

  参数：
    `text` - 需要计算第一个字符代码的文本或单元格引用

    例子：

          WorksheetFunction.code("S") 等于 83。

### column

    public static int column(Range reference)

  返回引用的列标。

  参数：
    `reference` - 一个包含所求列标的单元格或单元格区域

    例子：

           // 等于 2
          Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
          Range range = sheet.getRange("B4:E6");
          WorksheetFunction.column(range);

### columns

    public static int columns(Range reference)

  返回引用或数组的列数。

  参数：
    `reference` - 对一个单元格区域的引用

    例子：

           //等于 4。
          Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
          Range range = sheet.getRange("B2:E5");
          WorksheetFunction.columns(range);

### combin

    public static double combin(double number,
                                double number_chosen)

  求从给定数目的对象集合中提取若干对象的组合数。

  参数：
    `number` - 对象的总数量，如"8"
    `number_chosen` - 每一组合中对象的数量，如"2"
  返回：
    给定数目的对象集合中提取若干对象的组合数

    例子：

         double value = WorksheetFunction.combin(8, 2);
         System.out.println("value is " + value);

### complex

    public static java.lang.String complex(double real_num,
                                           double i_number)

  将实系数和虚系数转换为 x+yi 形式的复数形式。

  参数：
    `real_num` - 为复数的实部
    `i_number` - 为复数的虚部

    例子：

           WorksheetFunction.complex(2,1) 等于 2+i。

### concatenate

    public static java.lang.String concatenate(java.lang.String text1,
                                               java.lang.String text2)

  将数个字符串合并成一个字符串。

  参数：
    `text1` - 需要合并成单个文本的文本项
    `text2` - 需要合并成单个文本的文本项

    例子：

          WorksheetFunction.concatenate("Average ","Price") 等于“Average Price”。

### confidence

    public static double confidence(double alpha,
                                    double standard_dev,
                                    double size)

  总体平均值的置信区间。置信区间是样本平均值任意一侧的区域。

  参数：
    `alpha` - 是用于计算置信度的显著水平参数 置信度等于 100*(1 - alpha)%，亦即，如果 alpha 为 0.05，则置信度为 95%
    `standard_dev` - 数据区域的总体标准偏差，假设为已知
    `size` - 样本容量
  返回：
    总体平均值的置信区间

    例子：

         double value = WorksheetFunction.confidence(0.05, 100, 5);
         System.out.println("value is " + value);

### convert

    public static double convert(double number,
                                 java.lang.String from_unit,
                                 java.lang.String to_unit)

  将数值从一个度量系统转换到另一个度量系统。

  参数：
    `number` - 以 from_unit 为单位的待转换成 to_unit 单位的数值
    `from_unit` - 最初单位
    `to_unit` - 结果单位

    例子：

           WorksheetFunction.convert(1.5,"m","ft") 等于 4.921259843。
           WorksheetFunction.convert(2,"Pa","atm") 等于 1.97385E-05。

### correl

    public static double correl(Range range1,
                                Range range2)

  单元格区域 array1 和 array2 之间的相关系数。 使用相关系数可以确定两种属性之间的关系。例如，可以检测某地的平均温度和空调使用情况之间的关系。

  参数：
    `range1` - 单元格区域引用，如"a1:a2"，第一组数值单元格区域
    `range2` - 单元格区域引用，如"a1:a2"，第二组数值单元格区域
  返回：
    单元格区域 array1 和 array2 之间的相关系数

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range range1 = sheet.getRange("a1:a2");
         Range range2 = sheet.getRange("b1:b2");
         range1.fillRandom(10, 1, 0);
         range2.fillRandom(10, 1, 0);
         double value = WorksheetFunction.correl(range1, range2);
         System.out.println("value is " + value);

### cos

    public static double cos(double number)

  返回指定角度的余弦值。

  参数：
    `number` - 以弧度表示的需要求余弦值的角度

    例子：

           WorksheetFunction.cos(0.5) 等于 0.877582562。

### cosh

    public static double cosh(double number)

  求双曲余弦值。

  参数：
    `number` - 实数值，如"2.17"
  返回：
    一个实数的双曲余弦值

    例子：

         double value = WorksheetFunction.cosh(2.17);
         System.out.println("value is " + value);

### count

    public static double count(Range range)

  包含数字以及包含参数列表中的数字的单元格的个数。

  参数：
    `range` - 单元格区域引用，如"a1:a2"
  返回：
    包含数字以及包含参数列表中的数字的单元格的个数

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range range = sheet.getRange("a1:a5");
         range.fillRandom(100, 120, 0);
         range = sheet.getRange("a1:a15");
         double value = WorksheetFunction.count(range);
         System.out.println("value is " + value);

### counta

    public static double counta(Range range)

  包含数字以及包含参数列表中的数字的单元格的个数， 参数值可以是任何类型，它们可以包括空字符 ("")，但不包括空白单元格。

  参数：
    `range` - 单元格区域引用，如"a1:a2"
  返回：
    包含数字以及包含参数列表中的数字的单元格的个数

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range range = sheet.getRange("a1:a2");
         range.fillRandom(100, 120, 0);
         range = sheet.getRange("a1:a15");
         double value = WorksheetFunction.counta(range);
         System.out.println("value is " + value);

### countBlank

    public static double countBlank(Range range)

  计算指定单元格区域中空白单元格的个数。

  参数：
    `range` - 为需要计算其中空白单元格个数的区域
  返回：
    空白单元格的个数

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range range = sheet.getRange("a1:c3");
         double result = WorksheetFunction.countBlank(range);
         System.out.println("result is " + result);

### countif

    public static long countif(Range array,
                               double criteria)

  求计算区域中满足给定条件的单元格的个数。

  参数：
    `array` - 为需要计算其中满足条件的单元格数目的单元格区域
    `criteria` - 为确定哪些单元格将被计算在内的条件
  返回：
    计算区域中满足给定条件的单元格的个数

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range data = sheet.getRange("a1:b2");
         data.fillRandom(100, 10, 0);
         long value = WorksheetFunction.countif(data, 3);
         System.out.println("value is " + value);

### countif

    public static long countif(Range array,
                               java.lang.String criteria)

  求计算区域中满足给定条件的单元格的个数。

  参数：
    `array` - 为需要计算其中满足条件的单元格数目的单元格区域
    `criteria` - 为确定哪些单元格将被计算在内的条件
  返回：
    计算区域中满足给定条件的单元格的个数

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range data = sheet.getRange("a1:b2");
         data.fillRandom(100, 10, 0);
         double value = WorksheetFunction.countif(data, "8");
         System.out.println("value is " + value);

### coupdaybs

    public static double coupdaybs(java.lang.String settlement,
                                   java.lang.String maturity,
                                   double frequency,
                                   double basis)

  返回每个会计期间资产的按比例线性折旧率。该函数为法国会计系统提供。如果某项资产是在结算期间的中期购入的，则按直线折旧法计算。

  参数：
    `settlement` - 为证券的成交日，即证券发行后投资者购买证券的日期。
    `maturity` - 为有价证券的到期日，即证券有效期的截止日期。
    `frequency` - 为年付息次数。如果每年付息一次，则 frequency=1；如果半年付息一次，则 frequency=2；如果一季度付息一次，则 frequency=4。
    `basis` - 为日计数基准类型。

    例子：

           某债券的交易情况如下：
           成交日：1996 年 8 月 20 日
           到期日：1998 年 10 月 10 日
           年付息次数：2
           日计数基准：实际天数/365
           该债券从付息期起始日到成交日之间的天数为：
           WorksheetFunction.coupdaybs("1996/8/20","1998/10/10",2,3) 等于 132。

### coupdays

    public static double coupdays(java.lang.String settlement,
                                  java.lang.String maturity,
                                  double frequency,
                                  double basis)

  返回成交日所在的付息期的天数。

  参数：
    `settlement` - 为证券的成交日，即证券发行后投资者购买证券的日期。
    `maturity` - 为有价证券的到期日，即证券有效期的截止日期。
    `frequency` - 为年付息次数。如果每年付息一次，则 frequency=1；如果半年付息一次，则 frequency=2；如果一季度付息一次，则 frequency=4。
    `basis` - 为日计数基准类型。

    例子：

           某债券的交易情况如下：
           成交日：1996 年 9 月 11 日
           到期日：1997 年 11 月 15 日
           每年付息次数：2
           日计数基准：实际天数/365
           该债券成交日所在的付息期的天数为：
           WorksheetFunction.coupdays("1996/9/11","1997/11/15",2,3) 等于 182.5。

### coupdaysnc

    public static double coupdaysnc(java.lang.String settlement,
                                    java.lang.String maturity,
                                    double frequency,
                                    double basis)

  返回从成交日到下一个付息日之间的天数。

  参数：
    `settlement` - 为证券的成交日，即证券发行后投资者购买证券的日期。
    `maturity` - 为有价证券的到期日，即证券有效期的截止日期。
    `frequency` - 为年付息次数。如果每年付息一次，则 frequency=1；如果半年付息一次，则 frequency=2；如果一季度付息一次，则 frequency=4。
    `basis` - 为日计数基准类型。

    例子：

           某债券的交易情况如下：
           成交日：1998 年 2 月 7 日
           到期日：1999 年 7 月 20 日
           每年付息次数：2
           日计数基准：实际天数/实际天数
           该债券从成交日到下一个付息期日之间的天数为：
           WorksheetFunction.coupdaysnc("1998/2/7","1999/7/20",2,1) 等于 163。

### coupncd

    public static long coupncd(java.lang.String settlement,
                               java.lang.String maturity,
                               double frequency,
                               double basis)

  返回成交日后的下一个付息日期。

  参数：
    `settlement` - 为证券的成交日，即证券发行后投资者购买证券的日期。
    `maturity` - 为有价证券的到期日，即证券有效期的截止日期。
    `frequency` - 为年付息次数。如果每年付息一次，则 frequency=1；如果半年付息一次，则 frequency=2；如果一季度付息一次，则 frequency=4。
    `basis` - 为日计数基准类型。

    例子：

           某债券的交易情况如下：
           成交日：1997 年 6 月 30 日
           到期日：1998 年 10 月 15 日
           按季支付利息
           日计数基准：实际天数/实际天数
           该债券成交后的第一个付息日期为：
           WorksheetFunction.coupncd("1997/6/30","1998/10/15",4,1) 等于 35626 或 1997 年 7 月 15 日。

### coupnum

    public static int coupnum(java.lang.String settlement,
                              java.lang.String maturity,
                              int frequency,
                              int basis)

  返回成交日和到期日之间的付息次数，该值向上舍入到最近的整数。

  参数：
    `settlement` - 为证券的成交日，即证券发行后投资者购买证券的日期。
    `maturity` - 为有价证券的到期日，即证券有效期的截止日期。
    `frequency` - 为年付息次数。如果每年付息一次，则 frequency=1；如果半年付息一次，则 frequency=2；如果一季度付息一次，则 frequency=4。
    `basis` - 为日计数基准类型。

    例子：

           某债券的交易情况如下：
           成交日：2000 年 4 月 14 日
           到期日：2002 年 9 月 15 日
           每年付息次数：2
           日计数基准：实际天数/实际天数
           该债券成交日和到期日之间的付息次数为：
           WorksheetFunction.coupnum("2000/4/14","2002/9/15",2,1) 等于 5。

### couppcd

    public static long couppcd(java.lang.String settlement,
                               java.lang.String maturity,
                               double frequency,
                               double basis)

  返回成交日之前的上一个付息日的日期。

  参数：
    `settlement` - 为证券的成交日，即证券发行后投资者购买证券的日期。
    `maturity` - 为有价证券的到期日，即证券有效期的截止日期。
    `frequency` - 为年付息次数。如果每年付息一次，则 frequency=1；如果半年付息一次，则 frequency=2；如果一季度付息一次，则 frequency=4。
    `basis` - 为日计数基准类型。

    例子：

           债券是企业发行的一种书面证书，企业在该证书上许诺将来偿还债权人一定数量的金额及利息。某债券的交易情况如下：
           成交日：2000 年 5 月 1 日
           到期日：2001 年 12 月 15 日
           每年付息次数：2
           日计数基准：实际天数/360
           该债券成交日之前的上一个付息日的日期为：
           WorksheetFunction.couppcd("2000/5/1","2001/12/15",2,2) 等于 36509 或 1999 年 12 月 15 日。

### covar

    public static double covar(double[] array1,
                               double[] array2)

  协方差，即每对数据点的偏差乘积的平均数，利用协方差可以决定两个数据集之间的关系。 例如，可利用它来检验教育程度与收入档次之间的关系。

  参数：
    `array1` - 第一个双精度数组
    `array2` - 第二个双精度数组
  返回：
    协方差

    例子：

         double[] array1 = new double[]
         { 11, 12, 13, 14, 15 };
         double[] array2 = new double[]
         { 21, 21, 22, 23, 24 };
         double value = WorksheetFunction.covar(array1, array2);
         System.out.println("value is " + value);

### covar

    public static double covar(Range range1,
                               Range range2)

  协方差，即每对数据点的偏差乘积的平均数，利用协方差可以决定两个数据集之间的关系。 例如，可利用它来检验教育程度与收入档次之间的关系。

  参数：
    `range1` - 单元格区域引用，如"a1:a2"，第一个所含数据为整数的单元格区域
    `range2` - 单元格区域引用，如"a1:a2"，第二个所含数据为整数的单元格区域
  返回：
    协方差

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range range1 = sheet.getRange("a1:a2");
         Range range2 = sheet.getRange("b1:b2");
         range1.fillRandom(100, 10, 0);
         range2.fillRandom(100, 10, 0);
         double value = WorksheetFunction.covar(range1, range2);
         System.out.println("value is " + value);

### critbinom

    public static double critbinom(double trials,
                                   double probability_s,
                                   double alpha)

  使累积二项式分布大于等于临界值的最小值。此函数可以用于质量检验。

  参数：
    `trials` - 伯努利试验次数
    `probability_s` - 每次试验中成功的概率
    `alpha` - 临界值
  返回：
    使累积二项式分布大于等于临界值的最小值

    例子：

         double value = WorksheetFunction.critbinom(10, 0.2, 0.8);
         System.out.println("value is " + value);

### cumipmt

    public static double cumipmt(double rate,
                                 double nper,
                                 double pv,
                                 double start_period,
                                 double end_period,
                                 int type)

  计算一笔贷款在某一段指定的付息期内从首期到末期所应支付的累计利息数额。

  参数：
    `rate` - 为利率
    `nper` - 为付息期总数
    `pv` - 为现值
    `start_period` - 为计算中的付息首期，付息期数从 1 开始计数
    `end_period` - 为计算中的付息末期
    `type` - 为付息时间类型。0 代表付息时间在期末

    例子：

           某贷款的交易情况如下：
           年利率：12.00%（rate=12.00%/12=0.01）
           期限：12 年（nper=12*12=144）
           现值：￥2,512,000
           该贷款在第二年中应付的利息总额（从第 13 期到第 24 期）为：
           WorksheetFunction.cumipmt(0.01,144,2512000,13,24,0) 等于 -283403.0539。
           该贷款在第一个月应付的利息为：
           WorksheetFunction.cumipmt(0.01,144,2512000,1,1,0) 等于 -25120。

### cumprinc

    public static double cumprinc(double rate,
                                  double nper,
                                  double pv,
                                  double start_period,
                                  double end_period,
                                  int type)

  计算一笔贷款在某一段指定的付款期内从首期到末期所需偿还的累计本金数额。

  参数：
    `rate` - 为利率
    `nper` - 为付息期总数
    `pv` - 为现值
    `start_period` - 为计算中的付息首期，付息期数从 1 开始计数
    `end_period` - 为计算中的付息末期
    `type` - 为付息时间类型。0 代表付息时间在期末

    例子：

           某项贷款的交易情况如下：
           年利率：12.00%（rate=12.00%/12=0.01）
           期限：12 年（nper=12*12=144）
           现值：￥2,512,000
           该贷款在第二年中累计应偿还的本金数额（从第 13 期到第 24 期）为：
           WorksheetFunction.cumprinc(0.01,144,2512000,13,24,0) 等于 -112514.0121。
           该贷款在第一个月应偿还的本金数额为：
           WorksheetFunction.cumprinc(0.01,144,2512000,1,1,0) 等于 -7873.088833。

### date

    public static long date(int year,
                            int month,
                            int day)

  返回表示某一特定日期的序列号。如果在插入函数前，单元格格式为“常规型”，则函数结果为日期格式。

  参数：
    `year` - 代表年，可以为一到四位数。计算形式由所使用的日期系统决定，
    `month` - 代表月份。若 1≤month≤12，则函数将该值作为月份。若 month＞12，则函数从指定年份的一月份开始往上加算。
    `day` - 代表日。若日期小于等于某指定月的天数，则函数将此参数值作为日。

    例子：

         WorksheetFunction.date(12,3,2) 返回 4445。即1912 年 3 月 2 日（Year＝12＋1900）。
         WorksheetFunction.date(2050,3,2) 返回 54849。 即2050 年 3 月 2 日（Year＝2050）。

### date

    public static java.lang.String date(long serial_number)

  返回表示某一特定日期。如果在插入函数前，单元格格式为“常规型”，则函数结果为日期格式。

  参数：
    `serial_number` - 序列号

    例子：

         String date = WorksheetFunction.date(4445); 返回 1912/3/2。即1912 年 3 月 2 日（Year＝12＋1900）。
         String date = WorksheetFunction.date(54849); 返回 2050/3/2。 即2050 年 3 月 2 日（Year＝2050）。

### datedif

    public static long datedif(java.lang.String start_date,
                               java.lang.String end_date,
                               java.lang.String unit)

  返回两个指定日期间的天数、月数或年数。

  参数：
    `start_date` - 指定时间段的初始日期。日期的输入形式：带双引号的字符串如“2001/2/28”。
    `end_date` - 指定时间段的终止日期。
    `unit` - 函数返回信息的类型。

         若 unit=“Y”，则 DATEDIF 返回指定时间段的年差数。
         若 unit=“M”，则 DATEDIF 返回指定时间段的月差数。
         若 unit=“D”，则 DATEDIF 返回指定时间段的日差数。
         若 unit=“MD”，则 DATEDIF 忽略年和月，返回指定时间段的日差数。
         若 unit=“YM”，则 DATEDIF 忽略年和日，返回指定时间段的月差数。
         若 unit=“YD”，则 DATEDIF 忽略年，返回指定时间段的日差数。

  返回：
    返回两个指定日期间的天数、月数或年数

    例子：

         WorksheetFunction.datedif("2001/2/28","2004/3/20","Y") 等于 3，即在 2001 年 2 月 28 日与 2004 年 3 月 20 日之间有 3 个整年。
         WorksheetFunction.datedif("2001/2/28","2004/3/20","M") 等于 36，即在 2001 年 2 月 28 日与 2004 年 3 月 20 日之间有 36 个整月。
         WorksheetFunction.datedif("2001/2/28","2004/3/20","MD") 等于 21，即忽略月和年后，2001 年 2 月 28 日与 2004 年 3 月 20 日的差为 21 天。

### datevalue

    public static long datevalue(java.lang.String date_text)

  返回代表 date_text 的序列号。此函数可将文本形式的日期转化为序列号。

  参数：
    `date_text` - 代表电子表格中日期格式表示的日期文本。例如“2000/2/28” 和“2000-2-28” 等带双引号的代表日期的字符串都可作为 date_text。 在永中集成Office 中，date_text 代表的日期必须为 1899 年 12 月 30 日与 9999 年 12 月 31 日之间的某一日。

    例子：

                WorksheetFunction.datevalue("2000/1/1") 等于 36526。
          WorksheetFunction.datevalue("1-JAN-2000") 等于 36526。
          WorksheetFunction.datevalue("2005/08/25") 等于 38589。

### daverage

    public static double daverage(Range database,
                                  double field,
                                  Range criteria)

  返回清单或数据库中满足指定条件的列中数值的平均值。

  参数：
    `database` - 构成数据清单或数据库的单元格区域
    `field` - 指定函数所使用的列
    `criteria` - 为一组包含给定条件的单元格区域
  返回：
    满足指定条件的列中数值的平均值

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range database = sheet.getRange("a1:e5");
         database.fillRandom(100, 120, 0);
         Range criteria = sheet.getRange("f1:g2");
         criteria.fillRandom(10, 12, 0);
         double result = WorksheetFunction.daverage(database, 2, criteria);
         System.out.println("result is " + result);

### daverage

    public static java.lang.String daverage(Range database,
                                            int field,
                                            Range criteria)

  返回数据列表或数据库的列中满足指定条件的数值的平均值。

  参数：
    `database` - 组成数据列表或数据库的单元格区域
    `field` - 指定函数所使用的数据列
    `criteria` - 表示包含指定条件的单元格区域，用来设定函数的匹配条件

### day

    public static int day(long serial_number)

  返回以序列号表示的某日期的天数，用整数 1 到 31 表示。

  参数：
    `serial_number` - 日期（可包含年、月、日）

    例子：

          WorksheetFunction.day(6) 等于 6。
          WorksheetFunction.day(18) 等于 18。

### day

    public static int day(java.lang.String serial_number)

  返回以序列号表示的某日期的天数，用整数 1 到 31 表示。

  参数：
    `serial_number` - 日期（可包含年、月、日）

    例子：

          WorksheetFunction.day("6-Jan") 等于 6。
          WorksheetFunction.day("18-April-1998") 等于 18。

### days360

    public static long days360(java.lang.String start_date,
                               java.lang.String end_date,
                               boolean method)

  按照一年 360 天的算法（每个月以 30 天计，一年共计 12 个月）， 返回两日期间相差的天数，这在一些会计计算中将会用到。 如果财务系统是基于一年 12 个月，每月 30 天，可用此函数帮助计算支付款项。

  参数：
    `start_date` - 是用于计算期间天数的起始日期
    `end_date` - 是用于计算期间天数的终止日期
    `method` - 为一个逻辑值，它指定了在计算中是采用欧洲方法还是美国方法

    例子：

          WorksheetFunction.days360("2000/2/23","2000/3/2", false) 等于 9。

### db

    public static double db(double cost,
                            double salvage,
                            double life,
                            double period,
                            double month)

  使用固定余额递减法，计算一笔资产在给定期间内的折旧值。

  参数：
    `cost` - 资产原值
    `salvage` - 资产残值
    `life` - 折旧期限
    `period` - 需要计算折旧值的期间
    `month` - 为第一年的月份数
  返回：
    一笔资产用固定余额递减法计算的在给定期间内的折旧值

    例子：

         double value = WorksheetFunction.db(10000, 200, 10, 3, 4);
         System.out.println("value is " + value);

### dcount

    public static double dcount(Range database,
                                double field,
                                Range criteria)

  返回数据库或数据清单的列中满足指定条件并且包含数字的单元格个数。

  参数：
    `database` - 构成数据清单或数据库的单元格区域
    `field` - 指定函数所使用的列
    `criteria` - 为一组包含给定条件的单元格区域
  返回：
    满足条件单元格个数

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range database = sheet.getRange("a1:e5");
         database.fillRandom(100, 120, 0);
         Range criteria = sheet.getRange("f1:g2");
         criteria.fillRandom(10, 12, 0);
         double result = WorksheetFunction.dcount(database, 2, criteria);
         System.out.println("result is " + result);

### dcounta

    public static double dcounta(Range database,
                                 double field,
                                 Range criteria)

  返回数据库或数据清单的列中满足指定条件的非空单元格个数。

  参数：
    `database` - 构成数据清单或数据库的单元格区域
    `field` - 指定函数所使用的列
    `criteria` - 为一组包含给定条件的单元格区域
  返回：
    满足条件单元格个数

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range database = sheet.getRange("a1:e5");
         database.fillRandom(100, 120, 0);
         Range criteria = sheet.getRange("f1:g2");
         criteria.fillRandom(10, 12, 0);
         double result = WorksheetFunction.dcounta(database, 2, criteria);
         System.out.println("result is " + result);

### ddb

    public static double ddb(double cost,
                             double salvage,
                             double life,
                             double period,
                             double factor)

  使用双倍余额递减法或其他指定方法，计算一笔资产在给定期间内的折旧值。

  参数：
    `cost` - 资产原值
    `salvage` - 资产残值
    `life` - 折旧期限
    `period` - 需要计算折旧值的期间
    `factor` - 为余额递减速率
  返回：
    一笔资产用双倍余额递减法或其他指定方法计算的在给定期间内的折旧值

    例子：

         double value = WorksheetFunction.ddb(10000, 200, 10, 3, 4);
         System.out.println("value is " + value);

### dec2bin

    public static java.lang.String dec2bin(long number,
                                           int places)

  将十进制数转换为二进制数。

  参数：
    `number` - 待转换的十进制数
    `places` - 字符数，可省略

    例子：

           WorksheetFunction.dec2bin(15) 等于 1111。

### dec2hex

    public static java.lang.String dec2hex(long number,
                                           int places)

  将十进制数转换为十六进制数。

  参数：
    `number` - 待转换的十进制数
    `places` - 字符数，可省略

    例子：

           WorksheetFunction.dec2hex(15) 等于 F。

### dec2oct

    public static java.lang.String dec2oct(long number,
                                           int places)

  将十进制数转换为八进制数。

  参数：
    `number` - 待转换的十进制数
    `places` - 字符数，可省略

    例子：

           WorksheetFunction.dec2oct(25,4) 等于 31。

### degrees

    public static double degrees(double angle)

  将弧度转化为度。

  参数：
    `angle` - 待转换的弧度角

    例子：

           WorksheetFunction.degrees(WorksheetFunction.pi()/2) 等于 90
           WorksheetFunction.degrees(3.1415926) 等于 179.9999969

### delta

    public static int delta(double number1,
                            double number2)

  测试两个数是否等值。如果 number1 和 number2 相等，则函数 DELTA 返回 1，否则返回 0。

  参数：
    `number1` - 第一个待测值
    `number2` - 第二个待测值

    例子：

           WorksheetFunction.delta(7,8) 等于 0。

### devsq

    public static double devsq(Range range)

  数据点与各自样本平均值偏差的平方和。

  参数：
    `range` - 单元格区域引用，如"a1:a2"
  返回：
    数据点与各自样本平均值偏差的平方和

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range range = sheet.getRange("a1:a2");
         range.fillRandom(100, 120, 0);
         double value = WorksheetFunction.devsq(range);
         System.out.println("value is " + value);

### dget

    public static java.lang.String dget(Range database,
                                        java.lang.String field,
                                        Range criteria)

  从数据列表或数据库的列中抽取符合指定条件的单一值。

  参数：
    `database` - 组成数据列表或数据库的单元格区域
    `field` - 指定函数所使用的数据列
    `criteria` - 包含指定条件的单元格区域

    例子：

           // 等于 3500，即李杰的月薪为 3500 元
           Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
           Range range = sheet.getRange("A5:E8");
           Range range1 = sheet.getRange("A1:A2");
           WorksheetFunction.dget(range,"月薪",range1);

### disc

    public static double disc(java.lang.String settlement,
                              java.lang.String maturity,
                              double pr,
                              double redemption,
                              int basis)

  返回有价证券的贴现率。

  参数：
    `settlement` - 为利率
    `maturity` - 为付息期总数
    `pr` - 为现值
    `redemption` - 为计算中的付息首期，付息期数从 1 开始计数
    `basis` - 为日计数基准类型

    例子：

           某债券的交易情况如下：
           成交日：2000 年 3 月 18 日
           到期日：2000 年 10 月 20 日
           价格：￥98.7526
           清偿价格：￥100
           日计数基准：实际天数/360
           该债券的贴现率为：
           WorksheetFunction.disc("2000/3/18","2000/10/20",98.7526,100,2) 等于 0.02079 或 2.079％。

### dmax

    public static double dmax(Range database,
                              double field,
                              Range criteria)

  返回数据库或数据清单的列中满足指定条件的最大数值。

  参数：
    `database` - 构成数据清单或数据库的单元格区域
    `field` - 指定函数所使用的列
    `criteria` - 为一组包含给定条件的单元格区域
  返回：
    满足条件的最大数值

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range database = sheet.getRange("a1:e5");
         database.fillRandom(100, 120, 0);
         Range criteria = sheet.getRange("f1:g2");
         criteria.fillRandom(10, 12, 0);
         double result = WorksheetFunction.dmax(database, 2, criteria);
         System.out.println("result is " + result);

### dmin

    public static double dmin(Range database,
                              double field,
                              Range criteria)

  返回数据库或数据清单的列中满足指定条件的最小数值。

  参数：
    `database` - 构成数据清单或数据库的单元格区域
    `field` - 指定函数所使用的列
    `criteria` - 为一组包含给定条件的单元格区域
  返回：
    满足条件的最小数值

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range database = sheet.getRange("a1:e5");
         database.fillRandom(100, 120, 0);
         Range criteria = sheet.getRange("f1:g2");
         criteria.fillRandom(10, 12, 0);
         double result = WorksheetFunction.dmin(database, 2, criteria);
         System.out.println("result is " + result);

### dollar

    public static java.lang.String dollar(double currencyNumber,
                                          double decimalNumber)

  使用当前格式将数字转换为文本。

  参数：
    `currencyNumber` - 货币数值
    `decimalNumber` - 小数位数
  返回：
    货币格式字符串

    例子：

         String result = WorksheetFunction.dollar(500, 2);
         System.out.println("result is " + result);

### dollarde

    public static double dollarde(double fractional_dollar,
                                  int fraction)

  将以分数形式表示的价格转换为以小数形式表示的价格。

  参数：
    `fractional_dollar` - 以分数表示的数字
    `fraction` - 分数的分母，必须为整数

    例子：

           WorksheetFunction.dollarde(3.13,32) 等于 3.40625。

### dollarfr

    public static double dollarfr(double decimal_dollar,
                                  int fraction)

  将以小数形式表示的价格转换为以分数形式表示的价格。

  参数：
    `decimal_dollar` - 为小数形式的数字
    `fraction` - 一个整数，将作为分数的分母

    例子：

           WorksheetFunction.dollarfr(2.08,5) 等于 2.04。

### dproduct

    public static double dproduct(Range database,
                                  double field,
                                  Range criteria)

  将数据库中满足条件的记录的特定字段中的数值相乘。

  参数：
    `database` - 构成数据清单或数据库的单元格区域
    `field` - 指定函数所使用的列
    `criteria` - 为一组包含给定条件的单元格区域
  返回：
    满足条件字段中数值相乘的结果

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range database = sheet.getRange("a1:e5");
         database.fillRandom(100, 120, 0);
         Range criteria = sheet.getRange("f1:g2");
         criteria.fillRandom(10, 12, 0);
         double result = WorksheetFunction.dproduct(database, 2, criteria);
         System.out.println("result is " + result);

### dstdev

    public static double dstdev(Range database,
                                double field,
                                Range criteria)

  基于选定数据库项中的单个样本估算标准偏差。

  参数：
    `database` - 构成数据清单或数据库的单元格区域
    `field` - 指定函数所使用的列
    `criteria` - 为一组包含给定条件的单元格区域
  返回：
    选定数据库项中的单个样本估算标准偏差

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range database = sheet.getRange("a1:e5");
         database.fillRandom(100, 120, 0);
         Range criteria = sheet.getRange("f1:g2");
         criteria.fillRandom(10, 12, 0);
         double result = WorksheetFunction.dstdev(database, 2, criteria);
         System.out.println("result is " + result);

### dstdevp

    public static double dstdevp(Range database,
                                 double field,
                                 Range criteria)

  基于选定数据库项中的样本总体计算标准偏差。

  参数：
    `database` - 构成数据清单或数据库的单元格区域
    `field` - 指定函数所使用的列
    `criteria` - 为一组包含给定条件的单元格区域
  返回：
    选定数据库项中的样本总体计算标准偏差

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range database = sheet.getRange("a1:e5");
         database.fillRandom(100, 120, 0);
         Range criteria = sheet.getRange("f1:g2");
         criteria.fillRandom(10, 12, 0);
         double result = WorksheetFunction.dstdevp(database, 2, criteria);
         System.out.println("result is " + result);

### dsum

    public static double dsum(Range database,
                              double field,
                              Range criteria)

  对数据库中满足条件的记录的字段列中的数字求和。

  参数：
    `database` - 构成数据清单或数据库的单元格区域
    `field` - 指定函数所使用的列
    `criteria` - 为一组包含给定条件的单元格区域
  返回：
    满足条件字段列中的数字求和结果

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range database = sheet.getRange("a1:e5");
         database.fillRandom(100, 120, 0);
         Range criteria = sheet.getRange("f1:g2");
         criteria.fillRandom(10, 12, 0);
         double result = WorksheetFunction.dsum(database, 2, criteria);
         System.out.println("result is " + result);

### duration

    public static double duration(java.lang.String settlement,
                                  java.lang.String maturity,
                                  double coupon,
                                  double yld,
                                  double frequency,
                                  int basis)

  返回按周期付息的有价证券的年周期。

  参数：
    `settlement` - 为证券的成交日，即证券发行后投资者购买证券的日期。
    `maturity` - 为有价证券的到期日，即证券有效期的截止日期。
    `coupon` - 为有价证券的年息票利率。
    `yld` - 为有价证券的年收益率。
    `frequency` - 为每年的付息次数。如果每年付息一次，则 frequency=1；如果半年付息一次，则 frequency=2；如果一季度付息一次，则 frequency=4。
    `basis` - 为日计数基准类型。

    例子：

           某债券的交易情况如下：
           成交日：2005 年 2 月 14 日
           到期日：2005 年 7 月 7 日
           息票利率：7％
           收益率：8.0％
           年付息次数：2
           日计数基准：实际天数/实际天数
           该债券的贴现率为：
           WorksheetFunction.duration("2005/2/14","2005/7/7",0.07,0.08,2,1) 等于 0.395027624。

### dvar

    public static double dvar(Range database,
                              double field,
                              Range criteria)

  基于选定的数据库项的单个样本估算方差。

  参数：
    `database` - 构成数据清单或数据库的单元格区域
    `field` - 指定函数所使用的列
    `criteria` - 为一组包含给定条件的单元格区域
  返回：
    选定的数据库项的单个样本估算方差

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range database = sheet.getRange("a1:e5");
         database.fillRandom(100, 120, 0);
         Range criteria = sheet.getRange("f1:g2");
         criteria.fillRandom(10, 12, 0);
         double result = WorksheetFunction.dvar(database, 2, criteria);
         System.out.println("result is " + result);

### dvarp

    public static double dvarp(Range database,
                               double field,
                               Range criteria)

  基于选定的数据库项的样本总体估算方差。

  参数：
    `database` - 构成数据清单或数据库的单元格区域
    `field` - 指定函数所使用的列
    `criteria` - 为一组包含给定条件的单元格区域
  返回：
    选定的数据库项的样本总体估算方差

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range database = sheet.getRange("a1:e5");
         database.fillRandom(100, 120, 0);
         Range criteria = sheet.getRange("f1:g2");
         criteria.fillRandom(10, 12, 0);
         double result = WorksheetFunction.dvarp(database, 2, criteria);
         System.out.println("result is " + result);

### edate

    public static long edate(java.lang.String start_date,
                             int method)

  返回指定日期 start_date 之前或之后的指定月份数的序列号。此函数可计算与发行日处于一月中同一天的到期日的日期。

  参数：
    `start_date` - 起始日期
    `method` - 在 start_date 之前或之后的月份数，正数表示未来日期，负数表示过去日期。

    例子：

          WorksheetFunction.edate("2001/05/05",3) 等于 37108（2001/8/5）。

### effect

    public static double effect(double norminal_rate,
                                int npery)

  根据指定的名义年利率和每年的复利期数，计算实际年利率。

  参数：
    `norminal_rate` - 名义年利率
    `npery` - 每年的复利期数

    例子：

           WorksheetFunction.effect(0.07,5) 等于 0.071987633 或者 7.199%。

### eomonth

    public static long eomonth(java.lang.String start_date,
                               int method)

  返回 start_date 之前或之后指定月份的最后一天的序列号。

  参数：
    `start_date` - 起始日期
    `method` - 在 start_date 之前或之后的月份数，正数表示未来日期，负数表示过去日期。

    例子：

          WorksheetFunction.eomonth("2000/01/01",1) 等于 36585（2000/2/29）。

### erf

    public static double erf(double lower_limit,
                             double upper_limit)

  返回误差函数的定积分。

  参数：
    `lower_limit` - 积分下限
    `upper_limit` - 积分上限

    例子：

           WorksheetFunction.erf(1,1.2515) 等于 0.080553452。

### erfc

    public static double erfc(double x)

  返回 x 到 ∞（无穷）积分的 ERF 函数的余误差函数。

  参数：
    `x` - ERF 函数积分的下限

    例子：

           WorksheetFunction.erfc(1.5) 等于 0.033894854。

### error_type

    public static int error_type(Range error_val)

  返回对应于永中集成Office 中某一错误值的数字，如果没有错误则返回 *N/A。

  参数：
    `error_val` - 指需要以数字形式指明错误类型的错误值。Error_val 可以是一个实际错误值，也可以是对一个包含了您将要测试的公式的单元格引用。

    例子：

           Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
           Range range = sheet.getRange("A3");
           WorksheetFunction.error_type(range);

### even

    public static double even(double number)

  求沿绝对值增大方向取整后最接近的偶数。

  参数：
    `number` - 实数值，如"2.17"
  返回：
    沿绝对值增大方向取整后最接近的偶数

    例子：

         double value = WorksheetFunction.even(2.17);
         System.out.println("value is " + value);

### exact

    public static boolean exact(java.lang.String text1,
                                java.lang.String text2)

  检测两组文本是否相同。如果完全相同，函数返回 TRUE；否则返回 FALSE。函数 EXACT 可以区分大小写，但忽略格式的不同。同时也可以利用函数 EXACT 来检测输入的文本。

  参数：
    `text1` - 文本项1
    `text2` - 文本项2

    例子：

          WorksheetFunction.exact("Spreadsheet","spreadsheet") 等于 FALSE。

### exp

    public static double exp(double number)

  返回 e 的 n 次幂。

  参数：
    `number` - 为任意实数

    例子：

           WorksheetFunction.exp(3) 等于 e3，或 20.08553692。

### expondist

    public static double expondist(double x,
                                   double lambda,
                                   boolean cumulative)

  指数分布。

  参数：
    `x` - 函数的数值
    `lambda` - 参数值
    `cumulative` - 为一逻辑值，指定指数函数的形式，

          如果 cumulative 为 TRUE，函数 EXPONDIST 返回累积分布函数；
          如果 cumulative 为 FALSE，返回概率密度函数

  返回：
    指数分布

    例子：

         double value = WorksheetFunction.expondist(5, 2, false);
         System.out.println("value is " + value);

### fact

    public static double fact(double number)

  求返回数的阶乘，一个数的阶乘等于。 数的最小值为0，最大值为170。

  参数：
    `number` - 实数值，如"2"
  返回：
    返回数的阶乘

    例子：

         double value = WorksheetFunction.fact(8);
         System.out.println("value is " + value);

### factdouble

    public static double factdouble(double number)

  返回数的双阶乘。数的双阶乘可以表现为数学表达式 n!!。

  参数：
    `number` - 为任意非负数。如果 number 为一个非整数，将被取整。

    例子：

           WorksheetFunction.factdouble(6.9) 等于 factdouble(6) 等于 6*4*2*1 等于 48。

### fdist

    public static double fdist(double x,
                               double degrees_freedom1,
                               double degrees_freedom2)

  返回 F 概率分布。

  参数：
    `x` - 参数值
    `degrees_freedom1` - 分子自由度
    `degrees_freedom2` - 分母自由度

    例子：

           WorksheetFunction.fdist(12.2567,5,2) 等于 0.077146688

### find

    public static int find(java.lang.String findString,
                           java.lang.String withinString,
                           int startNumber)

  在其他文本值中查找文本值（区分大小写）。

  参数：
    `findString` - 所要查找的字符串
    `withinString` - 被查找的字符串
    `startNumber` - 开始查找的起始位置
  返回：
    从开始查找位置起所查字符串在被查字符串中所在的位置

    例子：

         int result = WorksheetFunction.find("ab", "abcAbsdfabd", 2);
         System.out.println("result is " + result);

### findb

    public static int findb(java.lang.String findString,
                            java.lang.String withinString,
                            int startNumber)

  在其他文本值中查找文本值（区分大小写）。

  参数：
    `findString` - 所要查找的字符串
    `withinString` - 被查找的字符串
    `startNumber` - 开始查找的起始位置
  返回：
    从开始查找位置起所查字符串在被查字符串中所在的位置

    例子：

         int result = WorksheetFunction.findb("永", "无锡永中", 1);
         System.out.println("result is " + result);

### finv

    public static double finv(double Probability,
                              double degrees_freedom1,
                              double degrees_freedom2)

  返回 F 概率分布。

  参数：
    `Probability` - 与 F 累积分布相关的概率值
    `degrees_freedom1` - 分子自由度
    `degrees_freedom2` - 分母自由度

    例子：

           WorksheetFunction.finv(0.077146688,5,2) 等于 12.25670002

### fisher

    public static double fisher(double x)

  点 x 的 Fisher 变换。该变换生成一个正态分布而非偏斜的函数。

  参数：
    `x` - 在该点进行变换的数值
  返回：
    点 x 的 Fisher 变换

    例子：

         double value = WorksheetFunction.fisher(0.5);
         System.out.println("value is " + value);

### fisherinv

    public static double fisherinv(double y)

  Fisher 变换的反函数值。使用此变换可以分析数据区域或数组之间的相关性。

  参数：
    `y` - 在该点进行反变换的数值
  返回：
    Fisher 变换的反函数值

    例子：

         double value = WorksheetFunction.fisherinv(0.5);
         System.out.println("value is " + value);

### fixed

    public static java.lang.String fixed(double currencyNumber,
                                         double decimalNumber,
                                         boolean noComma)

  使用固定的十进制数将数字设置为文本格式。

  参数：
    `currencyNumber` - 十进制数
    `decimalNumber` - 小数位数
    `noComma` - 是否以逗号隔开,TRUE表示以逗号隔开
  返回：
    文本格式

    例子：

         String result = WorksheetFunction.fixed(1250.234, 2, true);
         System.out.println("result is " + result);

### floor

    public static double floor(double number,
                               double significance)

  求将参数 Number 沿绝对值减小的方向向下舍入，使其等于最接近的 significance 的倍数。

  参数：
    `number` - 所要四舍五入的数值，如"8"
    `Significance` - 基数，如"2"
  返回：
    将参数 Number 沿绝对值减小的方向向下舍入，使其等于最接近的 significance 的倍数

    例子：

         double value = WorksheetFunction.floor(8, 2);
         System.out.println("value is " + value);

### forecast

    public static double forecast(double x,
                                  Range known_ys,
                                  Range known_xs)

  根据已有的数值计算或预测未来值。此预测值为基于给定的 x 值推导出的 y 值。 已知的数值为已有的 x 值和 y 值，再利用线性回归对新值进行预测。

  参数：
    `x` - 为需要进行预测的数据点
    `known_ys` - 为因变量数组或数据区域
    `known_xs` - 为因变量数组或数据区域
  返回：
    根据已有的数值计算或预测未来值

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range known_ys = sheet.getRange("a1:a2");
         known_ys.fillRandom(100, 120, 0);
         Range known_xs = sheet.getRange("a1:a2");
         known_xs.fillRandom(100, 120, 0);
         double value = WorksheetFunction.forecast(100, known_ys, known_xs);
         System.out.println("value is " + value);

### frequency

    public static double frequency(Range data_array,
                                   Range bins_array)

  以一列垂直数组返回某个数据段中数据的频率分布。例如，全班期中考试成绩出来后，使用此函数可以统计出各分数段的人数。

  参数：
    `data_array` - 一数组或对一组数值的引用，用于计算数据频率
    `bins_array` - 分段的数组或对分段的引用，用于将 data_array 中的数值进行分组 若 bins_array 中不包含数值，FREQUENCY 返回 data_array 中元素的个数

    例子：

           Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
           Range range = sheet.getRange("A2:A10");
           Range range1 = sheet.getRange("B2:B5");
           WorksheetFunction.frequency(range, range1);

### ftest

    public static double ftest(Range array1,
                               Range array2)

  返回 F 检验的结果。F 检验返回的是当数组 1 和数组 2 的方差无明显差异时的单尾概率。可以使用此函数来判断两个样本的方差是否不同。

  参数：
    `array1` - 第一个数组或数据区域
    `array2` - 第二个数组或数据区域

    例子：

            返回 0.885162922
           Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
           Range range = sheet.getRange("A2:A6");
           Range range1 = sheet.getRange("B2:B6");
           WorksheetFunction.ftest(range, range1);

### fv

    public static double fv(double rate,
                            double nper,
                            double pmt,
                            double pv,
                            double type)

  基于固定利率及等额分期付款方式，返回某项投资的未来值。

  参数：
    `rate` - 为各期利率
    `nper` - 为总投资期
    `pmt` - 为各期所应支付的金额，其数值在整个年金期间保持不变
    `pv` - 为现值，即从该项投资开始计算时已经入帐的款项，或一系列未来付款的当前值的累积和
    `type` - 数字0或1，用以指定各期的付款时间是在期初还是期末，0 为期末，1 为期初
  返回：
    某项投资的未来值

    例子：

         double value = WorksheetFunction.fv(0.2, 10, 250, 1200, 1);
         System.out.println("value is " + value);

### fvschedule

    public static double fvschedule(double principal,
                                    double[] schedule)

  根据指定的名义年利率和每年的复利期数，计算实际年利率。

  参数：
    `principal` - 投资的现值
    `schedule` - 待用的利率数组

    例子：

           WorksheetFunction.fvschedule(2,new double[]{0.08,0.12,0.2}) 等于 2.90304。

### gammadist

    public static double gammadist(double x,
                                   double alpha,
                                   double beta,
                                   boolean cumulative)

  返回伽玛分布。

  参数：
    `x` - 用于计算伽玛分布的数值
    `alpha` - 分布参数
    `beta` - 分布参数
    `cumulative` - 逻辑值，决定函数的形式。若 cumulative 为 TRUE，GAMMADIST 返回累积分布函数； 若为 FALSE，则返回概率密度函数

    例子：

           WorksheetFunction.gammadist(8,7,1,false) 等于 0.122138215

### gammainv

    public static double gammainv(double probability,
                                  double alpha,
                                  double beta)

  返回伽玛累积分布函数的反函数。

  参数：
    `probability` - 为伽玛分布的概率值
    `alpha` - 分布参数
    `beta` - 分布参数。如果 beta=1，函数 GAMMAINV 返回标准伽玛分布

    例子：

           WorksheetFunction.gammainv(0.068094,9,2) 等于 10.00001131

### gammaln

    public static double gammaln(double x)

  伽玛函数的自然对数，Γ(x)。

  参数：
    `x` - 为需要计算函数 GAMMALN 的数值
  返回：
    伽玛函数的自然对数，Γ(x)

    例子：

         double value = WorksheetFunction.gammaln(10);
         System.out.println("value is " + value);

### gcd

    public static int gcd(double number1,
                          double number2)

  返回指定数字的最大公约数。最大公约数指能被两个或多个指定的数字除尽的最大整数。

  参数：
    `number1` - 指需要求其最大公约数的数值
    `number2` - 指需要求其最大公约数的数值

    例子：

           WorksheetFunction.gcd(6,9) 等于 3。

### geomean

    public static double geomean(Range range)

  正数数组或区域的几何平均值。例如，可以使用函数 GEOMEAN 计算可变复利的平均增长率。

  参数：
    `range` - 单元格区域引用，如"a1:a2"
  返回：
    正数数组或区域的几何平均值

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range range = sheet.getRange("a1:a2");
         range.fillRandom(100, 120, 0);
         double value = WorksheetFunction.geomean(range);
         System.out.println("value is " + value);

### gestep

    public static double gestep(double number,
                                double upper_limit)

  对一组数据进行筛选。例如，通过计算多个函数 GESTEP 的返回值，可以检测出数据集中超过某个临界值的数据个数。 当 number 大于等于 step 时，函数 GESTEP 返回 1，否则返回 0。

  参数：
    `number` - 将和临界值进行比较的待测数值
    `upper_limit` - 临界值

    例子：

           WorksheetFunction.gestep(7,9) 等于 0。
           WorksheetFunction.gestep(4,2) 等于 1。

### getpivotdata

    public static double getpivotdata(java.lang.String data_field,
                                      Range pivot_table)

  提取数据透视表中的数据。如果报表中的汇总数据可见，则从报表中提取汇总数据。

  参数：
    `data_field` - 数据字段的名称，该字段包含需要提取的数据。字段名用引号引起。
    `pivot_table` - 数据透视表中的任何单元格或单元格区域的引用

    例子：

           // 等于 24287，函数提取了“账户余额”字段的总计值。
           Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
           Range range = sheet.getRange("A3");
           WorksheetFunction.getpivotdata("账户余额",range);

### getpivotdata

    public static double getpivotdata(java.lang.String data_field,
                                      Range pivot_table,
                                      java.lang.String field1,
                                      java.lang.String item1)

  提取数据透视表中的数据。如果报表中的汇总数据可见，则从报表中提取汇总数据。

  参数：
    `data_field` - 数据字段的名称，该字段包含需要提取的数据。字段名用引号引起。
    `pivot_table` - 数据透视表中的任何单元格或单元格区域的引用
    `field1` - 用于描述需要从中提取数据的字段名
    `item1` - 需要从中提取数据的项名

    例子：

           //等于 10212，函数提取了开户人为王一的账户余额。
           Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
           Range range = sheet.getRange("A3");
           WorksheetFunction.getpivotdata("账户余额",range,"开户人","王一");

### getpivotdata

    public static double getpivotdata(java.lang.String data_field,
                                      Range pivot_table,
                                      java.lang.String field1,
                                      java.lang.String item1,
                                      java.lang.String field2,
                                      java.lang.String item2)

  提取数据透视表中的数据。如果报表中的汇总数据可见，则从报表中提取汇总数据。

  参数：
    `data_field` - 数据字段的名称，该字段包含需要提取的数据。字段名用引号引起。
    `pivot_table` - 数据透视表中的任何单元格或单元格区域的引用
    `field1` - 用于描述需要从中提取数据的字段名
    `item1` - 需要从中提取数据的项名
    `field2` - 用于描述需要从中提取数据的字段名
    `item2` - 需要从中提取数据的项名

    例子：

           // 等于 5675，函数提取了开户人为张三的现金汇总值。
           Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
           Range range = sheet.getRange("A3");
           WorksheetFunction.getpivotdata("账户余额",range,"账户类型","现金","开户人","张三");

### growth

    public static double growth(Range known_ys,
                                Range known_xs,
                                double new_xs,
                                boolean const1)

  根据现有的数据预测指数增长值。根据现有的 x 值和 y 值，GROWTH 函数返回一组新的 x 值对应的 y 值。

  参数：
    `known_ys` - 满足指数回归拟合曲线 y=b*m^x 的一组已知的 y 值
    `known_xs` - 满足指数回归拟合曲线 y=b*m^x 的一组已知的 x 值，为可选参数
    `new_xs` - 为需要通过 GROWTH 函数返回的对应 y 值的一组新 x 值
    `const1` - 为一逻辑值，用于指定是否将常数 b 强制设为 1。 如果 const1 为 TRUE 或省略，b 将按正常计算。 如果 const1 为 FALSE，b 将设为 1，m 值将被调整以满足 y = m^x
  返回：
    根据现有的数据预测指数增长值

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range known_ys = sheet.getRange("a1:a2");
         known_ys.fillRandom(100, 120, 0);
         Range known_xs = sheet.getRange("a1:a2");
         known_xs.fillRandom(100, 120, 0);
         double value = WorksheetFunction.growth(known_ys, known_xs, 100, true);
         System.out.println("value is " + value);

### harmean

    public static double harmean(Range range)

  数据集合的调和平均值。调和平均值与倒数的算术平均值互为倒数。

  参数：
    `range` - 单元格区域引用，如"a1:a2"
  返回：
    数据集合的调和平均值

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range range = sheet.getRange("a1:a20");
         range.fillRandom(100, 120, 0);
         double value = WorksheetFunction.harmean(range);
         System.out.println("value is " + value);

### hex2bin

    public static java.lang.String hex2bin(java.lang.String number,
                                           int places)

  将十六进制数转换为二进制数。

  参数：
    `number` - 待转换的十六进制数
    `places` - 字符数，可省略

    例子：

           WorksheetFunction.hex2bin("A2",8) 等于 10100010。

### hex2dec

    public static long hex2dec(java.lang.String number)

  将十六进制数转换为十进制数。

  参数：
    `number` - 待转换的十六进制数

    例子：

           WorksheetFunction.hex2dec("E3") 等于 227。

### hex2oct

    public static java.lang.String hex2oct(java.lang.String number,
                                           int places)

  将十六进制数转换为八进制数。

  参数：
    `number` - 待转换的十六进制数
    `places` - 字符数

    例子：

           WorksheetFunction.hex2oct("A2",8) 等于 242。

### hlookup

    public static java.lang.String hlookup(Range lookup_value,
                                           Range table_array,
                                           int row_index_num,
                                           boolean range_lookup)

  在数值表格或数组的首行获取指定值，并返回在指定值所在列中某一指定行的数值。

  参数：
    `lookup_value` - 为在表格首行需要查找的值的单元格
    `table_array` - 包含所查找数据的单元格区域
    `row_index_num` - 若 row_index_num 等于 1，则函数返回 table_array 中的第一行的值； 若 row_index_num 等于 2，则函数返回 table_array 中的第二行的值；依此类推
    `range_lookup` - 一个决定函数 HLOOKUP 找到精确匹配或近似匹配的逻辑值。若 range_lookup 等于 TRUE 或省略，则函数返回近似匹配。 若 range_lookup 等于 FALSE，而且若存在精确匹配，则返回精确匹配； 若精确匹配值不存在，则函数返回错误值 *N/A。

    例子：

           Range vRange = sheet.getRange("B1");
           Range tRange = sheet.getRange("A1:C5");
           WorksheetFunction.hlookup(vRange,tRange,4,true);

### hlookup

    public static java.lang.String hlookup(java.lang.String lookup_value,
                                           java.lang.String table_array,
                                           int row_index_num,
                                           boolean range_lookup)

  在数值表格或数组的首行获取指定值，并返回在指定值所在列中某一指定行的数值。

  参数：
    `lookup_value` - 为在表格首行需要查找的值,或需要查找的值的单元格地址
    `table_array` - 包含所查找数据的单元格地址
    `row_index_num` - 若 row_index_num 等于 1，则函数返回 table_array 中的第一行的值； 若 row_index_num 等于 2，则函数返回 table_array 中的第二行的值；依此类推
    `range_lookup` - 一个决定函数 HLOOKUP 找到精确匹配或近似匹配的逻辑值。若 range_lookup 等于 TRUE 或省略，则函数返回近似匹配。 若 range_lookup 等于 FALSE，而且若存在精确匹配，则返回精确匹配； 若精确匹配值不存在，则函数返回错误值 *N/A。

    例子：

           WorksheetFunction.hlookup("B2","C2:E7",3,true)

### hour

    public static int hour(double serial_number)

  返回某一指定时间的小时数。该值为介于 0（12:00 A.M.）到 23（11:00 P.M.）之间的整数。

  参数：
    `serial_number` - 包含所求小时的时间

    例子：

          WorksheetFunction.hour(0.8) 等于 19。

### hour

    public static int hour(java.lang.String serial_number)

  返回某一指定时间的小时数。该值为介于 0（12:00 A.M.）到 23（11:00 P.M.）之间的整数。

  参数：
    `serial_number` - 包含所求小时的时间

    例子：

          WorksheetFunction.hour("11:32:40 AM") 等于 11。

### hyperlink

    public static void hyperlink(java.lang.String ref_text,
                                 java.lang.String caption)

  返回由文本字符串指定的引用。此函数立即对引用进行计算，并显示其内容。当需要更改公式中单元格的引用，而不更改公式本身，请使用函数 INDIRECT。

  参数：
    `ref_text` - 为对单元格的引用
    `caption` - 指单元格中显示的跳转文本值或数字值。

    例子：

           //注意：须先选中一个单元格，再运用此函数，结果显示在此选中的单元格上
           WorksheetFunction.hyperlink("www.sohu.com", "sohu");

### hypgeomdist

    public static double hypgeomdist(int sample_s,
                                     int number_sample,
                                     int population_s,
                                     int number_population)

  解决有限整体的问题，其中每个观察值为成功或失败，而且指定样本的所有子集有相同的发生概率。

  参数：
    `sample_s` - 样本中成功的次数
    `number_sample` - 样本容量
    `population_s` - 样本总体中成功次数
    `number_population` - 样本总体的容量

    例子：

           WorksheetFunction.hypgeomdist(1,3,5,15) 等于 0.494505495

### imabs

    public static double imabs(java.lang.String inumber)

  返回复数的绝对值（又叫模数）。复数必须以 x+yi 或者 x+yj 的文本格式表示。

  参数：
    `inumber` - 需要获得绝对值的复数

    例子：

           WorksheetFunction.imabs("3+4i") 等于 5。
           WorksheetFunction.imabs("4-6i") 等于 7.211102551。

### imaginary

    public static double imaginary(java.lang.String inumber)

  返回以 x+yi 或 x+yj 文本格式表示的复数的虚系数。

  参数：
    `inumber` - 待计算虚系数的复数。

    例子：

           WorksheetFunction.imaginary("2+6i") 等于 6。

### imargument

    public static double imargument(java.lang.String inumber)

  计算指定复数对应的角度 θ，θ 用弧度表示。

  参数：
    `inumber` - 待计算其角度值 θ 的复数

    例子：

           WorksheetFunction.imargument("7+9i") 等于 0.909753158。

### imconjugate

    public static java.lang.String imconjugate(java.lang.String inumber)

  返回以 x+yi 或 x+yj 文本格式表示的复数的共轭复数。

  参数：
    `inumber` - 待计算共轭复数的复数。

    例子：

           WorksheetFunction.imconjugate("5+4i") 等于 5-4i。

### imcos

    public static java.lang.String imcos(java.lang.String inumber)

  返回以 x+yi 或 x+yj 文本格式表示的复数的余弦。

  参数：
    `inumber` - 待求余弦值的复数。

    例子：

           WorksheetFunction.imcos("2+3i") 等于 -4.18962569096881-9.10922789375534i。

### imdiv

    public static java.lang.String imdiv(java.lang.String inumber1,
                                         java.lang.String inumber2)

  计算 x+yi 或 x+yj 这两个形式表达的复数的商。

  参数：
    `inumber1` - 复数的分子或被除数
    `inumber1` - 复数的分母或除数

    例子：

           WorksheetFunction.imdiv("10-10i","1+2i") 等于 -2-6i。

### imexp

    public static java.lang.String imexp(java.lang.String inumber)

  计算以 x+yi 或 x+yj 形式表达的复数的指数。

  参数：
    `inumber` - 需要求指数的复数

    例子：

           WorksheetFunction.imexp("1+4i") 等于 -1.77678757688173-2.057202470728i。

### imln

    public static java.lang.String imln(java.lang.String inumber)

  返回形式为 x+yi 或 x+yj 的复数的自然对数。

  参数：
    `inumber` - 需要计算自然对数的复数。

    例子：

           WorksheetFunction.imln("4+5i") 等于 1.85678603335215+0.896055384571344i。

### imlog10

    public static java.lang.String imlog10(java.lang.String inumber)

  返回形式为 x+yi 或 x+yj 的复数的常用对数（底数为 10）。

  参数：
    `inumber` - 为其计算常用对数的复数

    例子：

           WorksheetFunction.imlog10("24+4i") 等于 1.38616085336146+7.17231592947926E-02i。

### imlog2

    public static java.lang.String imlog2(java.lang.String inumber)

  返回形式为 x+yi 或 x+yj 的复数的常用对数（底数为 2）。

  参数：
    `inumber` - 为其计算常用对数的复数

    例子：

           WorksheetFunction.imlog2("6+7i") 等于 3.2046954683155+1.24384846236711i。

### impower

    public static java.lang.String impower(java.lang.String inumber1,
                                           double inumber2)

  计算以 x+yi 或 x+yj 形式表达的复数的幂值。

  参数：
    `inumber1` - 需要求幂值的指定复数
    `inumber2` - 用于复数的幂

    例子：

           WorksheetFunction.impower("5+7i",4) 等于 -4324-3360i。

### improduct

    public static java.lang.String improduct(java.lang.String inumber1,
                                             java.lang.String inumber2)

  计算以 x+yi 或 x+yj 形式表达的复数的乘积。

  参数：
    `inumber1` - 需要相乘的复数
    `inumber2` - 需要相乘的复数

    例子：

           WorksheetFunction.improduct("8+4i","7-3i") 等于 68+4i。

### imreal

    public static double imreal(java.lang.String inumber)

  返回形式为 x+yi 或 x+yj 的复数的实系数。

  参数：
    `inumber` - 需要计算实系数的复数

    例子：

           WorksheetFunction.imreal("19-8i") 等于 19。

### imsin

    public static java.lang.String imsin(java.lang.String inumber)

  计算以 x+yi 或 x+yj 形式表达的复数的正弦值。

  参数：
    `inumber` - 需要计算正弦值的复数

    例子：

           WorksheetFunction.imsin("5+7i") 等于 -525.794515221654+155.536549852413i。

### imsqrt

    public static java.lang.String imsqrt(java.lang.String inumber)

  返回以 x+yi 或 x+yj 形式表示的复数的平方根。

  参数：
    `inumber` - 待求其平方根的复数

    例子：

           WorksheetFunction.imsqrt("2+3i") 等于 1.67414922803554+0.895977476129838i。

### imsub

    public static java.lang.String imsub(java.lang.String inumber1,
                                         java.lang.String inumber2)

  返回形式为 x+yi 或 x+yj 的两个复数的差。

  参数：
    `inumber1` - 作为被减数的复数
    `inumber2` - 作为减数的复数

    例子：

           WorksheetFunction.imsub("18+8i","6+3i") 等于 12+5i。

### imsum

    public static java.lang.String imsum(java.lang.String inumber1,
                                         java.lang.String inumber2)

  返回形式为 x+yi 或 x+yj 的复数的和。

  参数：
    `inumber1` - 需要计算和的复数
    `inumber2` - 需要计算和的复数

    例子：

           WorksheetFunction.imsum("6+8i","9-3i") 等于 15+5i。

### index

    public static java.lang.String index(Range reference,
                                         int row_num,
                                         int column_num)

  返回引用中指定单元格或单元格区域的引用。

  参数：
    `reference` - 一个单元格区域
    `row_num` - 数组中某行的行号
    `column_num` - 数组中某列的列标

    例子：

           // 等于 4.5，即单元格 B2 中的值。
           Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
           Range range = sheet.getRange("A1:D10");
           WorksheetFunction.index(range,2,2);

### indirect

    public static java.lang.String indirect(Range ref_text,
                                            boolean a1)

  返回由文本字符串指定的引用。此函数立即对引用进行计算，并显示其内容。当需要更改公式中单元格的引用，而不更改公式本身，请使用函数 INDIRECT。

  参数：
    `ref_text` - 为对单元格的引用
    `a1` - 为一逻辑值，指明包含在单元格 ref_text 中的引用的类型

    例子：

           //等于 2.1，返回单元格 A2 中的引用值 2.1。
           Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
           Range range = sheet.getRange("A2");
           WorksheetFunction.indirect(range , true);

### info

    public static java.lang.String info(java.lang.String type_text)

  返回有关当前操作环境的信息。

  参数：
    `type_text` - 指定返回信息的类型。

          如果 type_text 是 "memavail"、"memused" 或 "totmem"，INFO 返回 *VALUE!。
          如果 type_text 是 "directory"，INFO 返回当前工作表的路径和位置。
          如果 type_text 是 "memavail_jvm"，INFO 返回 jvm 可用的内存空间，以字节为单位。
          如果 type_text 是 "memused_jvm"，INFO 返回数据占用 jvm 的内存空间，以字节为单位。
          如果 type_text 是 "numfile"，INFO 返回当前打开的工作表的数量。
          如果 type_text 是 "origin"，INFO 返回在当前窗口中最左端可见单元格的绝对地址。该返回值以 "$A:" 开头。
          如果 type_text 是 "osversion"，INFO 返回当前操作系统的版本号。
          如果 type_text 是 "recalc"，INFO 返回当前的重运算格式是 "Automatic" 还是 "Manual"。
          如果 type_text 是 "release"，INFO 返回当前永中集成Office 的版本号。
          如果 type_text 是 "system"，INFO 返回操作系统的名称。

    例子：

           如果当前窗口中最左端的可见单元格是 A18
           WorksheetFunction.info("origin") 返回 $A:$A$18。

### integer

    public static int integer(double number)

  返回数字舍入（数值减小的方向）后最接近的整数值。

  参数：
    `number` - 需要舍入为整数的实数

    例子：

         WorksheetFunction.integer(4.8) 等于 4。

### intercept

    public static double intercept(Range known_y,
                                   Range known_x)

  根据已知 x、y 值计算直线与 y 轴的交点，即截距。截距即穿过已知 x、y 值数据点的线性回归线与 y 轴的交点。当自变量为零时，就可利用截距来决定应变量的值。

  参数：
    `known_y` - 已知因变量数据的单元格区域
    `known_x` - 已知自变量数据的单元格区域

    例子：

           Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
           Range range = sheet.getRange("B3:B8");
           Range range1 = sheet.getRange("A3:A8");
           WorksheetFunction.intercept(range,range1);

### intrate

    public static double intrate(java.lang.String settlement,
                                 java.lang.String maturity,
                                 double investment,
                                 double redemption,
                                 int basis)

  计算一次性付息证券的利率。

  参数：
    `settlement` - 为证券的成交日，即证券发行后投资者购买证券的日期。
    `maturity` - 为有价证券的到期日，即证券有效期的截止日期。
    `investment` - 证券的投资额
    `redemption` - 面值为 ￥100 的有价证券的清偿价值。
    `basis` - 为日计数基准类型。

    例子：

           某债券的交易情况如下：
           成交日：1998 年 1 月 3 日
           到期日：1998 年 5 月 5 日
           清偿价格：￥100324
           投资额：￥100000
           日计数基准：实际天数/360
           该债券的贴现率为：
           WorksheetFunction.intrate("1998/1/3","1998/5/5",100000,100324,2) 等于 0.009560656。

### ipmt

    public static double ipmt(double rate,
                              double per,
                              double nper,
                              double pv,
                              double fv,
                              double type)

  基于固定利率及等额分期付款方式，返回给定期数内对投资的利息偿还额。

  参数：
    `rate` - 为各期利率
    `per` - 用于计算其利息数额的期数
    `nper` - 为总投资期
    `pv` - 为现值
    `fv` - 为未来值
    `type` - 数字 0 或 1，用以指定各期的付款时间是在期初还是期末
  返回：
    给定期数内对投资的利息偿还额

    例子：

         double value = WorksheetFunction.ipmt(0.2, 10, 250, 1200, 0, 1);
         System.out.println("value is " + value);

### irr

    public static double irr(double[] value,
                             double guess)

  返回由数值代表的一组现金流的内部收益率。

  参数：
    `value` - 用来计算返回的内部收益率的数字
    `guess` - 与 irr 的返回值相近的估计值。
  返回：
    由数值代表的一组现金流的内部收益率

    例子：

         double[] value =
         { 3, 4, -6 };
         double result = WorksheetFunction.irr(value, 0.1);
         System.out.println("result is " + result);

### irr

    public static double irr(Range value)

  返回由数值代表的一组现金流的内部收益率。

  参数：
    `value` - 用来计算返回的内部收益率的数字
  返回：
    由数值代表的一组现金流的内部收益率

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook()
                        .getWorksheets().getActiveWorksheet();
         double[] value =
         { 3, 4, -6 };
         sheet.setCellValue(2, 2, value, false);
         Range range = sheet.getRange("B2:B4");
         double result = WorksheetFunction.irr(range);
         System.out.println("result is " + result);

### isblank

    public static boolean isblank(Range val)

  在被测值为空白单元格时返回 TRUE。

  参数：
    `val` - 为需要测试的值。Value 可能是空白（空白单元格）、错误值、逻辑值、文本、数字、引用值或者对以上任何参数的名称引用。 若函数 ISBLANK 值为空白单元格，则返回 TRUE；否则返回 FALSE。

    例子：

           //等于 FALSE。
           Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
           Range range = sheet.getRange("A1");
           WorksheetFunction.isblank(range);

### iserr

    public static boolean iserr(Range range)

  判断单元格区域中的值是否是除*N/A值以外任意错误值。

  参数：
    `range` - 为需要判断的区域
  返回：
    是除*N/A值以外任意错误值返回true，否则返回false

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range range = sheet.getRange("a1");
         boolean result = WorksheetFunction.iserr(range);
         System.out.println("result is " + result);

### iserror

    public static boolean iserror(Range range)

  判断单元格区域中的值是否是错误值。

  参数：
    `range` - 为需要判断的区域
  返回：
    布尔型值，如是错误值返回true；否则，返回false

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range range = sheet.getRange("a1");
         boolean result = WorksheetFunction.iserror(range);
         System.out.println("result is " + result);

### iseven

    public static boolean iseven(double number)

  在被测值为偶数时返回 TRUE，否则返回 FALSE。

  参数：
    `number` - 待测试的数值。如果 number 不是整数，则被截尾取整。

    例子：

           WorksheetFunction.iseven(9) 等于 FALSE。

### islogical

    public static boolean islogical(Range range)

  判断单元格区域中的值是否是逻辑值。

  参数：
    `range` - 为需要判断的区域
  返回：
    布尔型值，如是逻辑值返回true；否则，返回false

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range range = sheet.getRange("a1");
         boolean result = WorksheetFunction.islogical(range);
         System.out.println("result is " + result);

### isna

    public static boolean isna(Range range)

  判断单元格区域中的值是否是*N/A错误值。

  参数：
    `range` - 为需要判断的区域
  返回：
    布尔型值，如是*N/A错误值返回true；否则返回false

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range range = sheet.getRange("a1");
         boolean result = WorksheetFunction.isna(range);
         System.out.println("result is " + result);

### isnontext

    public static boolean isnontext(Range range)

  判断单元格区域中的值是否是非文本的任意项。

  参数：
    `range` - 为需要判断的区域
  返回：
    布尔型值，如是非文本的任意项返回true；否则返回false

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range range = sheet.getRange("a1");
         boolean result = WorksheetFunction.isnontext(range);
         System.out.println("result is " + result);

### isnumber

    public static boolean isnumber(Range range)

  判断单元格区域中的值是否是数字。

  参数：
    `range` - 为需要判断的区域
  返回：
    布尔型值，如是数字返回true；否则返回false

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range range = sheet.getRange("a1");
         boolean result = WorksheetFunction.isnumber(range);
         System.out.println("result is " + result);

### isodd

    public static boolean isodd(double number)

  在被测值为奇数时返回 TRUE，否则返回 FALSE。

  参数：
    `number` - 待测试的数值。如果 number 不是整数，则被截尾取整。

    例子：

           WorksheetFunction.isodd(7) 等于 TRUE。

### ispmt

    public static double ispmt(double rate,
                               double per,
                               double nper,
                               double pv)

  计算特定投资期内要支付的利息。

  参数：
    `rate` - 为投资的利率
    `per` - 为要计算利息的期数
    `nper` - 为投资的总支付期数
    `pv` - 为投资的当前值
  返回：
    特定投资期内要支付的利息

    例子：

         double value = WorksheetFunction.ispmt(0.25, 5, 20, 10000);
         System.out.println("value is " + value);

### isref

    public static boolean isref(java.lang.Object ref)

  当待测值为引用时返回 TRUE，其他情况则返回 FALSE。

  参数：
    `ref` - 待测值

           Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
           Range range = sheet.getRange("A3");
           WorksheetFunction.isref(range) 值为true.

### istext

    public static boolean istext(Range range)

  判断单元格区域中的值是否是文本。

  参数：
    `range` - 为需要判断的区域
  返回：
    布尔型值，如是文本返回true；否则，返回false

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range range = sheet.getRange("a1");
         boolean result = WorksheetFunction.istext(range);
         System.out.println("result is " + result);

### jdate

    public static int jdate()

  返回今天是今年的第几天。此函数将一年中的 1 月 1 日认定为一年的第一天，将 12 月 31 日认定为最后一天。

  例子：

        WorksheetFunction.jdate();

### kurt

    public static double kurt(Range range)

  数据集的峰值。峰值反映与正态分布相比某一分布的尖锐度或平坦度。 正峰值表示相对尖锐的分布；负峰值表示相对平坦的分布。

  参数：
    `range` - 单元格区域引用，如"a1:a2"
  返回：
    数据集的峰值

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range range = sheet.getRange("a1:a23");
         range.fillRandom(100, 120, 0);
         double value = WorksheetFunction.kurt(range);
         System.out.println("value is " + value);

### large

    public static double large(Range range,
                               double k)

  数据集中第 k 个最大值。使用此函数可以根据相对标准来选择数值。 例如，可以使用函数 LARGE 得到第一名、第二名或第三名的得分。

  参数：
    `range` - 单元格区域引用，如"a1:a2"，为需要从中选择第 k 个最大值的数组或数据区域
    `k` - 为返回值在数组或数据单元格区域中的位置（从大到小排）
  返回：
    数据集中第 k 个最大值

    例子：

         Worksheet sheet  = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range range = sheet.getRange("a1:a20");
         range.fillRandom(10, 1, 0);
         double value = WorksheetFunction.large(range, 1);
         System.out.println("value is " + value);

### lcm

    public static int lcm(double number1,
                          double number2)

  返回整数的最小公倍数。最小公倍数指所有整数参数（number1,number2）的最小正整数倍数。

  参数：
    `number1` - 指需要求其最大公约数的数值
    `number2` - 指需要求其最大公约数的数值

    例子：

           WorksheetFunction.lcm(6,8) 等于 24。

### left

    public static java.lang.String left(java.lang.String text,
                                        int num_chars)

  根据指定的字符数返回文本串中的第一个或前几个字符。

  参数：
    `text` - 包含需要选取字符的文本串
    `num_chars` - 指定返回的字符串长度

    例子：

          WorksheetFunction.left("Evermore software",8) 等于“Evermore”。

### leftb

    public static java.lang.String leftb(java.lang.String text,
                                         int num_bytes)

  根据指定的字节数返回文本串中的第一个或前几个字符，常用于双字节字符。

  参数：
    `text` - 包含需要选取字符的文本串
    `num_bytes` - 指定返回的字符串长度

    例子：

          WorksheetFunction.leftb("中华民族",4) 等于“中华”。

### len

    public static int len(java.lang.String text)

  返回文本串中的字符数。

  参数：
    `text` - 需要求其长度的文本，空格也计为字符。

    例子：

          WorksheetFunction.len("Evermore software") 等于 17。

### lenb

    public static int lenb(java.lang.String text)

  返回在文本串中代表字符的字节数，常用于双字节字符。

  参数：
    `text` - 需要求其长度的文本，空格也计为字节。

    例子：

          WorksheetFunction.lenb("中华民族") 等于 8。
          WorksheetFunction.lenb("中华 民族") 等于 9。

### linest

    public static double linest(Range known_y,
                                Range known_x,
                                boolean consts)

  根据已知 x、y 值计算直线与 y 轴的交点，即截距。截距即穿过已知 x、y 值数据点的线性回归线与 y 轴的交点。当自变量为零时，就可利用截距来决定应变量的值。

  参数：
    `known_y` - 关系表达式 y=mx+b 中已知的 y 值集合。
    `known_x` - 关系表达式 y=mx+b 中已知的可选 x 值集合
    `consts` - 逻辑值，用于指定是否将常数 b 强制设为 0

### ln

    public static double ln(double number)

  求一个数的自然对数，自然对数以常数项e为底。

  参数：
    `number` - 正实数值，如"2.17"
  返回：
    一个数的自然对数，自然对数以常数项为e底

    例子：

         double value = WorksheetFunction.ln(2.17);
         System.out.println("value is " + value);

### log

    public static double log(double number,
                             double base)

  求按所指定的底数，返回一个数的对数。

  参数：
    `number` - 用于计算对数的正实数，如"8"
    `base` - 对数的底数。如果省略底数，假定其值为10，如"10"
  返回：
    按所指定的底数，返回一个数的对数

    例子：

         double value = WorksheetFunction.log(8, 10);
         System.out.println("value is " + value);

### log10

    public static double log10(double number)

  求以 10 为底的对数。

  参数：
    `number` - 用于计算对数的正实数，如"8"
  返回：
    按以 10 为底的对数

    例子：

         double value = WorksheetFunction.log10(8);
         System.out.println("value is " + value);

### logest

    public static void logest(Range known_ys,
                              Range known_xs,
                              boolean consts,
                              boolean stats)

  在回归分析中，计算最符合数据的指数回归拟合曲线，并返回描述该曲线的数值数组。由于此函数返回数值数组，所以必须以数组公式的形式输入。

  参数：
    `known_ys` - 满足指数回归拟合曲线 y=b*m^x 的一组已知的 y 值
    `known_xs` - 满足指数回归拟合曲线 y=b*m^x 的一组已知的 x 值
    `consts` - 逻辑值，用于指定是否将常数 b 强制设为 1
    `stats` - 逻辑值，指定是否返回附加回归统计值

    例子：

           //注意：须先选中一个单元格，再运用此函数，结果显示在此选中的单元格上
           Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
           Range range1 = sheet.getRange("B2:B7");
           Range range2 = sheet.getRange("A2:A7");
           WorksheetFunction.logest(range1, range2, true, false);

### loginv

    public static double loginv(double probability,
                                double mean,
                                double standard_dev)

  x 的对数累积分布函数的反函数，此处的 ln(x) 是含有 mean 与 standard-dev 参数的正态分布。 如果 p=LOGNORMDIST(x,...)，则 LOGINV（p,...）=x。

  参数：
    `probability` - 是与对数分布相关的概率
    `mean` - 为 ln(x) 的平均值
    `standard_dev` - 为 ln(x) 的标准偏差
  返回：
    x 的对数累积分布函数的反函数，此处的 ln(x) 是含有 mean 与 standard-dev 参数的正态分布

    例子：

         double value = WorksheetFunction.loginv(0.1, 0.2, 0.5);
         System.out.println("value is " + value);

### lognormdist

    public static double lognormdist(double x,
                                     double mean,
                                     double standard_dev)

  x 的对数累积分布函数，其中 ln(x) 是服从参数 mean 和 standard_dev 的正态分布。 使用此函数可以分析经过对数变换的数据。

  参数：
    `x` - 参数值
    `mean` - 为 ln(x) 的平均值
    `standard_dev` - 为 ln(x) 的标准偏差
  返回：
    x 的对数累积分布函数，其中 ln(x) 是服从参数 mean 和 standard_dev 的正态分布

    例子：

         double value = WorksheetFunction.lognormdist(10, 20, 50);
         System.out.println("value is " + value);

### lookup

    public static java.lang.String lookup(java.lang.String lookup_value,
                                          Range lookup_vector,
                                          Range result_vector)

  返回数组或单行单列区域中的值。

  参数：
    `lookup_value` - 在第一个向量中查找的数值，可为数字、文本、逻辑值或包含数值的名称或引用
    `lookup_vector` - 单行或单列区域,Lookup_vector 中的数值必须按照升序排列
    `result_vector` - 与 lookup_vector 大小相同的单行或单列区域

    例子：

           Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
           Range range = sheet.getRange("A2:A10");
           Range range1 = sheet.getRange("B2:B10");
           WorksheetFunction.lookup("蔡惠",range,range1) 等于 80，即蔡惠的语文成绩是 80。

### lower

    public static java.lang.String lower(java.lang.String text)

  将所有的大写字母转化为小写字母。

  参数：
    `text` - 需要转化为小写字母的文本串。函数 LOWER 不转化文本串中非字母的字符。

    例子：

          WorksheetFunction.lower("China") 等于“china”。

### match

    public static double match(double lookupValue,
                               Range range,
                               double matchType)

  返回在指定方式下与指定数值匹配的区域中元素的相应位置。

  参数：
    `lookupValue` - 需要查找的值
    `range` - 可能包含所要查找的数值的连续单元格区域
    `matchType` - 为数字 -1、0 或 1， -1 表示函数 MATCH 查找大于或等于 lookupValue 的最小数值，range中的值必须按降序排列； 0 表示函数 MATCH 查找等于 lookupValue 的第一个数值，range中的值可以按任何顺序排列， 1 表示MATCH 查找小于或等于 lookupValue 的最大数值，range中的值必须按升序排列

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range range = sheet.getRange("a1:c12");
         range.fillRandom(100, 105, 0);
         range = sheet.getRange("a1:a12");
         double result = WorksheetFunction.match(100, range, -1);
         System.out.println("result is " + result);

  返回：
    匹配元素的位置

### match

    public static double match(Range lookupValue,
                               Range range,
                               double matchType)

  返回在指定方式下与指定数值匹配的区域中元素的相应位置。

  参数：
    `lookupValue` - 需要查找值所在的区域
    `range` - 可能包含所要查找的数值的连续单元格区域
    `matchType` - 为数字 -1、0 或 1， -1 表示函数 MATCH 查找大于或等于 lookupValue 的最小数值，range中的值必须按降序排列； 0 表示函数 MATCH 查找等于 lookupValue 的第一个数值，range中的值可以按任何顺序排列； 1 表示MATCH 查找小于或等于 lookupValue 的最大数值，range中的值必须按升序排列
  返回：
    匹配元素的位置

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range range = sheet.getRange("a1:c12");
         range.fillRandom(100, 105, 0);
         range = sheet.getRange("a1:a12");
         Range range1 = sheet.getRange("a2");
         double result = WorksheetFunction.match(range1, range, 1);
         System.out.println("result is " + result);

### max

    public static double max(Range range)

  一组值中的最大值。

  参数：
    `range` - 单元格区域引用，如"a1:a2"
  返回：
    一组值中的最大值

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range range = sheet.getRange("a1:a2");
         range.fillRandom(10, 1, 0);
         double value = WorksheetFunction.max(range);
         System.out.println("value is " + value);

### maxa

    public static double maxa(Range values)

  返回参数列表中的最大值。

  参数：
    `values` - 含数值的单元格区域

### mdeterm

    public static double mdeterm(Range range)

  求一个数组的矩阵行列式的值。

  参数：
    `range` - 行数和列数相等的区域
  返回：
    一个数组的矩阵行列式的值

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range data = sheet.getRange("a1:e5");
         data.fillRandom(1, 10, 0);
         double value = WorksheetFunction.mdeterm(data);
         System.out.println("value is " + value);

### mduration

    public static double mduration(java.lang.String settlement,
                                   java.lang.String maturity,
                                   double coupon,
                                   double yld,
                                   double frequency,
                                   int basis)

  返回假设面值 ￥100 的有价证券的 Macauley 修正期限。期限定义为一系列现金流现值的加权平均值，用于计量债券价格对于收益率变化的敏感程度。

  参数：
    `settlement` - 为证券的成交日，即证券发行后投资者购买证券的日期。
    `maturity` - 为有价证券的到期日，即证券有效期的截止日期。
    `coupon` - 为有价证券的年息票利率。
    `yld` - 为有价证券的年收益率。
    `frequency` - 为每年的付息次数。如果每年付息一次，则 frequency=1；如果半年付息一次，则 frequency=2；如果一季度付息一次，则 frequency=4。
    `basis` - 为日计数基准类型。

    例子：

           某债券的交易情况如下：
           成交日：2000 年 3 月 1 日
           到期日：2003 年 3 月 1 日
           年息票利率：8％
           年收益率：9％
           年付息次数：2
           日计数基准：实际天数/实际天数
           该债券的贴现率为：
           WorksheetFunction.mduration("2000/3/1","2003/3/1",0.08,0.09,2,1) 等于 2.604498957。

### median

    public static double median(Range range)

  给定数值集合的中值。 中值是在一组数据中居于中间的数，即在这组数据中，有一半的数据比它大，有一半的数据比它小。

  参数：
    `range` - 单元格区域引用，如"a1:a2"
  返回：
    给定数值集合的中值

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range range = sheet.getRange("a1:a2");
         range.fillRandom(10, 1, 0);
         double value = WorksheetFunction.median(range);
         System.out.println("value is " + value);

### mid

    public static java.lang.String mid(java.lang.String text,
                                       int start_num,
                                       int num_chars)

  返回文本串中从指定位置开始的一定数目的字符，该数目由用户指定。

  参数：
    `text` - 包含要提取字符的文本串
    `start_num` - 文本中需要提取字符的起始位置。文本中第一个字符的 start_num 为 1，依此类推。
    `num_chars` - 指定返回的字符串长度

    例子：

          WorksheetFunction.mid("Evermore software",10,8) 返回“software”。

### midb

    public static java.lang.String midb(java.lang.String text,
                                        int start_num,
                                        int num_bytes)

  返回文本串中从指定位置开始的一定数目的双字节字符，该数目由用户指定。

  参数：
    `text` - 包含要提取字符的文本串
    `start_num` - 文本中需要提取字符的起始位置。文本中第一个字节的 start_num 为 1，依此类推。
    `num_bytes` - 返回字符的长度。

    例子：

          WorksheetFunction.midb("中华民族",5,7) 等于“民族”。

### min

    public static double min(Range range)

  一组值中的最小值。

  参数：
    `range` - 单元格区域引用，如"a1:a2"
  返回：
    一组值中的最小值

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range range = sheet.getRange("a1:a2");
         range.fillRandom(10, 1, 0);
         double value = WorksheetFunction.min(range);
         System.out.println("value is " + value);

### mina

    public static double mina(Range values)

  返回参数列表中的最小值。

  参数：
    `values` - 含数值的单元格区域

### minute

    public static int minute(double serial_number)

  返回某一指定时间的分钟数，其值是介于 0 到 59 之间的一个整数。

  参数：
    `serial_number` - 包含所求分钟数的时间

    例子：

          WorksheetFunction.minute(0.02) 等于 28。

### minute

    public static int minute(java.lang.String serial_number)

  返回某一指定时间的分钟数，其值是介于 0 到 59 之间的一个整数。

  参数：
    `serial_number` - 包含所求分钟数的时间

    例子：

          WorksheetFunction.minute("5:36:25 PM") 等于 36。

### minverse

    public static double minverse(Range range)

  求数组矩阵的逆距阵。

  参数：
    `range` - 是具有相等行数和列数的数值数组
  返回：
    数组矩阵的逆距阵

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range data = sheet.getRange("a1:e5");
         data.fillRandom(1, 10, 0);
         double value = WorksheetFunction.minverse(data);
         System.out.println("value is " + value);

### mirr

    public static double mirr(double[] value,
                              double frate,
                              double rrate)

  计算某一连续期间内现金流的修正内部收益率。

  参数：
    `value` - 为一个数组，这些数值代表着各期的一系列支出（负值）及收入（正值）
    `frate` - 为现金流中使用的资金支付的利率
    `rrate` - 为将现金流再投资的收益率
  返回：
    某一连续期间内现金流的修正内部收益率

    例子：

         double[] value =
         { 3, 4, -6 };
         double result = WorksheetFunction.mirr(value, 0.25, 0.3);
         System.out.println("result is " + result);

### mirr

    public static double mirr(Range value,
                              double frate,
                              double rrate)

  计算某一连续期间内现金流的修正内部收益率。

  参数：
    `value` - 为一个数组，这些数值代表着各期的一系列支出（负值）及收入（正值）
    `frate` - 为现金流中使用的资金支付的利率
    `rrate` - 为将现金流再投资的收益率
  返回：
    某一连续期间内现金流的修正内部收益率

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook()
                        .getWorksheets().getActiveWorksheet();
         double[] value =
         { 3, 4, -6 };
         sheet.setCellValue(2, 2, value, false);
         Range range = sheet.getRange("B2:B4");
         double result = WorksheetFunction.mirr(range, 0.25, 0.3);
         sheet.setCellValue(2, 7, result);

### mmult

    public static double mmult(Range array1,
                               Range array2)

  返回两数组的矩阵乘积。返回矩阵的行数与 array1 的行数相同，列数与 array2 的列数相同。

  参数：
    `array1` - 运算的区域1
    `array2` - 运算的区域2
  返回：
    两数组的矩阵乘积,矩阵的列数与 array2 的列数相同

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook()
                        .getWorksheets().getActiveWorksheet();
         Range range1 = sheet.getRange("A1:C4");
         range1.fillRandom();
         Range range2 = sheet.getRange("A7:E9");
         range2.fillRandom();
         double value = WorksheetFunction.mmult(range1, range2);
         System.out.println("value :" + value);

### mod

    public static int mod(double number,
                          double divisor)

  返回两数相除的余数。返回值的符号与除数相同。

  参数：
    `number` - 指需要求其最大公约数的数值
    `divisor` - 指需要求其最大公约数的数值

    例子：

           WorksheetFunction.mod(4,-3) 等于 -2。

### mode

    public static double mode(Range range)

  在某一数组或数据区域中出现频率最多的数值。同 MEDIAN 一样，MODE 也是一个位置测量函数。

  参数：
    `range` - 单元格区域引用，如"a1:a2"
  返回：
    在某一数组或数据区域中出现频率最多的数值

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range range = sheet.getRange("a1:a2");
         range.fillRandom(10, 1, 0);
         double value = WorksheetFunction.mode(range);
         System.out.println("value is " + value);

### month

    public static int month(long serial_number)

  返回某日期对应的月份，用整数 1 到 12 表示。

  参数：
    `serial_number` - 包含所求月份的日期

    例子：

          WorksheetFunction.month(36525) 等于 12。

### month

    public static int month(java.lang.String serial_number)

  返回某日期对应的月份，用整数 1 到 12 表示。

  参数：
    `serial_number` - 包含所求月份的日期

    例子：

          WorksheetFunction.month("9-Jan") 等于 1。

### mround

    public static int mround(double number,
                             double multiple)

  返回指定参数按指定基数舍入后的数值。

  参数：
    `number` - 需要舍入的数值
    `multiple` - 对 number 进行舍入的基数

    例子：

           WorksheetFunction.mround(15,5) 等于 15。

### multinomial

    public static int multinomial(double number1,
                                  double number2,
                                  double number3)

  计算参数和的阶乘与各参数阶乘乘积的比值。

  参数：
    `number1` - 用于计算函数 MULTINOMIAL 的 1 到 30 个数字
    `number2` - 用于计算函数 MULTINOMIAL 的 1 到 30 个数字
    `number3` - 用于计算函数 MULTINOMIAL 的 1 到 30 个数字

    例子：

           WorksheetFunction.multinomial(4,5,6) 等于 630630。

### n

    public static long n(Range val)

  返回转化为数值后的值。

  参数：
    `val` - 指需要转化的值的单元格。TRUE 等于 1，FALSE 等于 0。数字将返回数字本身，错误值将返回错误值，其他值将返回 0。

    例子：

           如果单元格 A2 中含有 5，单元格 A3 中含有“Good”，单元格 A4 中含有 FALSE，则：
           Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
           Range range = sheet.getRange("A2");
           Range range1 = sheet.getRange("A3");
           Range range2 = sheet.getRange("A4");
           WorksheetFunction.n(range); 等于 5。
           WorksheetFunction.n(range1); 等于 0，因为单元格 A3 中包含的是文本。
           WorksheetFunction.n(range2); 等于 0，因为单元格 A4 中包含的是 FALSE。

### na

    public static java.lang.String na()

  返回错误值 *N/A。 *N/A 表示“无法得到有效值”，*N/A 的这一特性被用来标识空白单元格。

### negbinomdist

    public static double negbinomdist(double number_f,
                                      double number_s,
                                      double probability_s)

  负二项式分布。 当成功概率为常量 probability_s 时，函数 NEGBINOMDIST。 返回在到达 number_s 次成功之前，出现 number_f 次失败的概率。

  参数：
    `number_f` - 失败次数
    `number_s` - 成功的极限次数
    `probability_s` - 成功的概率
  返回：
    负二项式分布

    例子：

         double value = WorksheetFunction.negbinomdist(100, 200, 0.7);
         System.out.println("value is " + value);

### networkdays

    public static long networkdays(java.lang.String start_date,
                                   java.lang.String end_date,
                                   java.lang.String[] holidays)

  返回指定开始日期和结束日期间的完整工作日数值，其中要除去周末和节假日的天数。

  参数：
    `start_date` - 指定时间段的开始日期
    `end_date` - 指定时间段的结束日期
    `holidays` - 工作日中需除去的法定节假日

    例子：

          假设一个项目开始日期是 2000 年 4 月 4 日，结束日期是 2002 年 4 月 4 日，在此期间 2000 年 12 月 24 日和 2001 年 12 月 24 日是节假日，则公式如下：
          WorksheetFunction.networkdays("2000/04/04","2002/04/04",new String[]{"2000/12/24","2001/12/24"}) 等于 522。

### nominal

    public static double nominal(double effect_rate,
                                 int npery)

  根据指定的实际利率和年复利期数，返回名义年利率。

  参数：
    `effect_rate` - 实际利率
    `npery` - 每年的复利期数

    例子：

           WorksheetFunction.nominal(0.089,6) 等于 0.085868494 或 8.587%。

### normdist

    public static double normdist(double x,
                                  double mean,
                                  double standard_dev,
                                  boolean cumulative)

  指定平均值和标准偏差的正态分布函数。

  参数：
    `x` - 为需要计算其分布的数值
    `mean` - 分布的算术平均值
    `standard_dev` - 分布的标准偏差
    `cumulative` - 为一逻辑值，指明函数的形式。 如果 cumulative 为 TRUE，函数 NORMDIST 返回累积分布函数； 如果为 FALSE，返回概率密度函数
  返回：
    指定平均值和标准偏差的正态分布函数

    例子：

         double value = WorksheetFunction.normdist(10, 50, 4.0, false);
         System.out.println("value is " + value);

### norminv

    public static double norminv(double probability,
                                 double mean,
                                 double standard_dev)

  返回指定平均值和标准偏差的正态累积分布函数的逆函数。

  参数：
    `probability` - 正态分布的概率值
    `mean` - 分布的算术平均值
    `standard_dev` - 分布的标准偏差

    例子：

           WorksheetFunction.norminv(0.879546,50,2.5) 等于 52.93180068

### normsdist

    public static double normsdist(double z)

  标准正态累积分布函数，该分布的平均值为 0，标准偏差为 1。可以使用该函数代替标准正态曲线面积表。

  参数：
    `z` - 为需要计算其分布的数值
  返回：
    标准正态累积分布函数，该分布的平均值为 0，标准偏差为 1

    例子：

         double value = WorksheetFunction.normsdist(10);
         System.out.println("value is " + value);

### normsinv

    public static double normsinv(double probability)

  标准正态累积分布函数的反函数。该分布的平均值为 0，标准偏差为 1。

  参数：
    `probability` - 正态分布的概率值
  返回：
    标准正态累积分布函数的反函数

    例子：

         double value = WorksheetFunction.normsinv(0.5);
         System.out.println("value is " + value);

### now

    public static double now()

  返回当前日期和时间所对应的序列号。如果在输入函数前，单元格的格式为“常规型”，则函数结果返回日期格式。

  例子：

        WorksheetFunction.now();

### nper

    public static double nper(double rate,
                              double pmt,
                              double pv,
                              double fv,
                              double type)

  基于固定利率及等额分期付款方式，返回某项投资的总期数。

  参数：
    `rate` - 为各期利率，是一固定值
    `pmt` - 为各期所应支付的金额，其数值在整个年金期间保持不变
    `pv` - 为现值
    `fv` - 为未来值
    `type` - 为数字0或1，用以指定各期的付款时间是在期初还是期末，0 表示期末，1 表示期初
  返回：
    总期数

    例子：

         double value = WorksheetFunction.nper(0.25, 1450, 18000, 0, 1);
         System.out.println("value is " + value);

### npv

    public static double npv(double rate,
                             double[] value)

  通过使用贴现率以及一系列未来支出（负值）和收入（正值），返回一项投资的净现值。

  参数：
    `rate` - 为某一期间的贴现率，是一固定值
    `value` - 一系列未来支出（负值）和收入（正值），在时间上必须具有相等间隔，并且都发生在期末
  返回：
    一项投资的净现值

    例子：

         double[] value =
         { 1, 2, -3 };
         double result = WorksheetFunction.npv(0.25, value);
         System.out.println("result is " + result);

### npv

    public static double npv(double rate,
                             Range value)

  通过使用贴现率以及一系列未来支出（负值）和收入（正值），返回一项投资的净现值。

  参数：
    `rate` - 为某一期间的贴现率，是一固定值
    `value` - 一系列未来支出（负值）和收入（正值），在时间上必须具有相等间隔，并且都发生在期末
  返回：
    一项投资的净现值

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook()
                        .getWorksheets().getActiveWorksheet();
         double[] value =
         { 1, 2, -3 };
         sheet.setCellValue(2, 2, value, false);
         Range range = sheet.getRange("B2:B4");
         double result = WorksheetFunction.npv(0.25, range);
         sheet.setCellValue(2, 7, result);

### num2txt

    public static java.lang.String num2txt(double number,
                                           int info_type)

  将阿拉伯数字转换为英文货币大写。

  参数：
    `number` - 被转换的数字或单元格引用
    `info_type` - 为数字 1 或 2

    例子：

           WorksheetFunction.num2txt(21,2) 等于 Twenty-One and Zero Cent。

### oct2bin

    public static java.lang.String oct2bin(long number,
                                           int places)

  将八进制数转换为二进制数。

  参数：
    `number` - 待转换的八进制数
    `places` - 字符数

    例子：

           WorksheetFunction.oct2bin(4) 等于 100。

### oct2dec

    public static long oct2dec(long number)

  将八进制数转换为十进制数。

  参数：
    `number` - 待转换的八进制数

    例子：

           WorksheetFunction.oct2dec(64) 等于 52。

### oct2hex

    public static java.lang.String oct2hex(long number,
                                           int places)

  将八进制数转换为十六进制数。

  参数：
    `number` - 待转换的八进制数
    `places` - 字符数

    例子：

           WorksheetFunction.oct2hex(400) 等于 100。

### odd

    public static double odd(double number)

  求对指定数值进行向上舍入后的奇数。

  参数：
    `number` - 是将进行四舍五入的数值，如"2.17"
  返回：
    对指定数值进行向上舍入后的奇数

    例子：

         double value = WorksheetFunction.odd(2.17);
         System.out.println("value is " + value);

### oddfprice

    public static double oddfprice(java.lang.String settlement,
                                   java.lang.String maturity,
                                   java.lang.String issue,
                                   java.lang.String first_coupon,
                                   double rate,
                                   double yld,
                                   double redemption,
                                   double frequency,
                                   double basis)

  返回首期付息日不固定（长期或短期）的面值 $100 的有价证券价格。

  参数：
    `settlement` - 为证券的成交日。即在发行日之后，证券卖给购买者的日期。
    `maturity` - 为有价证券的到期日。到期日是有价证券有效期截止时的日期。
    `issue` - 为有价证券的发行日。
    `first_coupon` - 为有价证券的首期付息日。
    `rate` - 为有价证券的利率。
    `yld` - 为有价证券的年收益率。
    `redemption` - 为面值 $100 的有价证券的清偿价值。
    `frequency` - 为年付息次数，如果按年支付，frequency = 1；按半年期支付，frequency = 2；按季支付，frequency = 4。
    `basis` - 日计数基准类型。
  返回：

### oddfyield

    public static double oddfyield(java.lang.String settlement,
                                   java.lang.String maturity,
                                   java.lang.String issue,
                                   java.lang.String first_coupon,
                                   double rate,
                                   double pr,
                                   double redemption,
                                   double frequency,
                                   double basis)

  返回首期付息日不固定的有价证券（长期或短期）的收益率。

  参数：
    `settlement` - 是证券的成交日。
    `maturity` - 为有价证券的到期日。
    `issue` - 为有价证券的发行日。
    `first_coupon` - 为有价证券的首期付息日。
    `rate` - 为有价证券的利率
    `pr` - 为有价证券的价格。
    `redemption` - 为面值 $100 的有价证券的清偿价值。
    `frequency` - 为年付息次数，如果按年支付，frequency = 1；按半年期支付，frequency = 2；按季支付，frequency = 4。
    `basis` - 日计数基准类型。

### oddlprice

    public static double oddlprice(java.lang.String settlement,
                                   java.lang.String maturity,
                                   java.lang.String last_interest,
                                   double rate,
                                   double yld,
                                   double redemption,
                                   double frequency,
                                   int basis)

  返回末期付息日不固定的有价证券之每 ￥100 票面价值的实际价值。

  参数：
    `settlement` - 为证券的成交日，即证券发行后投资者购买证券的日期。
    `maturity` - 为有价证券的到期日，即证券有效期的截止日期。
    `last_interest` - 为有价证券的末期付息日。
    `rate` - 为利率
    `yld` - 为年收益率
    `redemption` - 面值为 ￥100 的有价证券的清偿价值
    `frequency` - 为每年的付息次数。如果每年付息一次，则 frequency=1；如果半年付息一次，则 frequency=2；如果一季度付息一次，则 frequency=4。
    `basis` - 为日计数基准类型。

    例子：

           某债券的交易情况如下：
           成交日：2000 年 5 月 14 日
           到期日：2000 年 10 月 28 日
           末期付息日：1994 年 8 月 1 日
           付息利率：4.77％
           年收益率：5％
           清偿价值：￥100
           年付息次数：2
           日计数基准：实际天数/实际天数
           该债券的贴现率为：
           WorksheetFunction.oddlprice("2000/5/14","2000/10/28","1994/8/1",0.0477,0.05,100,2,1) 等于 99.28229424。

### oddlyield

    public static double oddlyield(java.lang.String settlement,
                                   java.lang.String maturity,
                                   java.lang.String last_interest,
                                   double rate,
                                   double pr,
                                   double redemption,
                                   double frequency,
                                   int basis)

  返回末期付息日不固定的有价证券的收益率。

  参数：
    `settlement` - 为证券的成交日，即证券发行后投资者购买证券的日期。
    `maturity` - 为有价证券的到期日，即证券有效期的截止日期。
    `last_interest` - 为有价证券的末期付息日。
    `rate` - 为利率
    `pr` - 为有价证券的价格
    `redemption` - 面值为 ￥100 的有价证券的清偿价值
    `frequency` - 为每年的付息次数。如果每年付息一次，则 frequency=1；如果半年付息一次，则 frequency=2；如果一季度付息一次，则 frequency=4。
    `basis` - 为日计数基准类型。

    例子：

           某债券的交易情况如下：
           成交日：2006 年 6 月 26 日
           到期日：2006 年 8 月 15 日
           末期付息日：2005 年 11 月 11 日
           付息利率：3.54％
           价格：￥99.956
           清偿价值：￥100
           年付息次数：2
           日计数基准：实际天数/360
           该债券的贴现率为：
           WorksheetFunction.oddlyield("2006/6/26","2006/8/15","2005/11/11",0.0354,99.956,100,2,2) 等于 0.037742139 或 3.7742％。

### offset

    public static Range offset(Range reference,
                               int rows,
                               int cols,
                               int height,
                               int width)

  通过指定偏移量，返回一个区域的引用，这个引用是一个单元格或单元格区域的行数列数。 这个返回的引用可为一个单元格，也可为一个单元格区域。

  参数：
    `reference` - 基于偏移量的引用
    `rows` - 参照区域左上角的单元格向上或向下偏移的行数
    `cols` - 参照区域左上角的单元格向左或向右偏移的列数
    `height` - 返回引用区域的行数，必须为正值
    `width` - 返回引用区域的列数，必须为正值

    例子：

           // 引用返回单元格 B3 下 2 行右 4 列共 3 行 2 列的单元格区域，即 F5:G7。
           Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
           Range range = sheet.getRange("B3");
           WorksheetFunction.offset(range,2,4,3,2);

### or

    public static boolean or(Range range)

  在其参数组中，任何一个参数逻辑值为 TRUE，即返回 TRUE；任何一个参数的逻辑值为 FALSE，即返回 FALSE。

  参数：
    `range` - 单元格区域引用，如"a1:a2"
  返回：
    在其参数组中，任何一个参数逻辑值为 TRUE，即返回 TRUE； 任何一个参数的逻辑值为 FALSE，即返回 FALSE

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range range = sheet.getRange("a1:a2");
         range.fillRandom(10, 1, 0);
         boolean value = WorksheetFunction.or(range);
         System.out.println("value is " + value);

### pearson

    public static double pearson(Range range1,
                                 Range range2)

  Pearson（皮尔生）乘积矩相关系数 r， 这是一个范围在 -1.0 到 1.0 之间（包括 -1.0 和 1.0 在内）的无量纲指数， 反映了两个数据集合之间的线性相关程度。

  参数：
    `range1` - 单元格区域引用，如"a1:a2"，为自变量集合
    `range2` - 单元格区域引用，如"a1:a2"，为因变量集合
  返回：
    Pearson（皮尔生）乘积矩相关系数 r

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range range1 = sheet.getRange("a1:a2");
         Range range2 = sheet.getRange("b1:b2");
         range1.fillRandom(10, 1, 0);
         range2.fillRandom(10, 1, 0);
         double value = WorksheetFunction.pearson(range1, range2);
         System.out.println("value is " + value);

### percentile

    public static double percentile(Range range,
                                    double k)

  区域中数值的第 K 个百分点的值。可以使用此函数来建立接受阈值。 例如，可以确定得分排名在第 90 个百分点之上的检测侯选人。

  参数：
    `range` - 单元格区域引用，如"a1:a2"，为定义相对位置的数组或数据区域
    `k` - 0 到 1 之间的百分点值，包含 0 和 1
  返回：
    区域中数值的第 K 个百分点的值。可以使用此函数来建立接受阈值

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range range = sheet.getRange("a1:a2");
         range.fillRandom(100, 10, 0);
         double value = WorksheetFunction.percentile(range, 0.4);
         System.out.println("value is " + value);

### percentrank

    public static double percentrank(Range array,
                                     int x,
                                     int significance)

  返回特定数值在一个数据集中的百分比排位。

  参数：
    `array` - 定义相对位置的数组或数字区域
    `x` - 为数组中需要得到其排位的值
    `significance` - 表示返回的百分数值的有效位数

    例子：

           //等于 52.93180068
           Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
           Range range = sheet.getRange("B3:B11");
           WorksheetFunction.percentrank(range,2, 3);

### permut

    public static double permut(double number,
                                double number_chosen)

  从给定数目的对象集合中选取的若干对象的排列数。 排列为有内部顺序的对象或事件的任意集合或子集。 排列与组合不同，组合的内部顺序无意义。

  参数：
    `number` - 表示对象个数的整数
    `number_chosen` - 表示每个排列中对象个数的整数
  返回：
    从给定数目的对象集合中选取的若干对象的排列数

    例子：

         double value = WorksheetFunction.permut(5, 2);
         System.out.println("value is " + value);

### pi

    public static double pi()

  返回数字 3.141592653589793，即数学常量 pi，精确到小数点后 15 位。

  例子：

         WorksheetFunction.pi();

### pmt

    public static double pmt(double rate,
                             double nper,
                             double pv,
                             double fv,
                             double type)

  基于固定利率及等额分期付款方式，返回贷款的每期付款额。

  参数：
    `rate` - 贷款利率
    `nper` - 该项贷款的付款期总数
    `pv` - 现值
    `fv` - 未来值
    `type` - 数字0或1，用以指定各期的付款时间是在期初还是期末，0 表示期末，1 表示期初
  返回：
    贷款的每期付款额

    例子：

         double value = WorksheetFunction.pmt(0.25, 100, 10000, 1500, 1);
         System.out.println("value is " + value);

### poisson

    public static double poisson(double x,
                                 double mean,
                                 boolean cumulative)

  泊松分布。泊松分布通常用于预测一段时间内事件发生的次数，比如一分钟内通过收费站的轿车的数量。

  参数：
    `x` - 事件数
    `mean` - 期望值
    `cumulative` - 为一逻辑值，确定所返回的概率分布形式 如果 cumulative 为 TRUE，函数 POISSON 返回泊松累积分布概率， 即，随机事件发生的次数在 0 到 x 之间（包含 0 和 1）； 如果为 FALSE，则返回泊松概率密度函数，即，随机事件发生的次数恰好为 x
  返回：
    泊松分布

    例子：

         double value = WorksheetFunction.poisson(5, 20, false);
         System.out.println("value is " + value);

### postTax

    public static double postTax(double amt,
                                 double tax_rate,
                                 double num_digits)

  计算按指定位数返回舍入后的含税价。

  参数：
    `amt` - 不含税价,必须为非负数
    `tax_rate` - 增值税征收税率。必须为正数,否则函数结果返回“*NUM!”值
    `num_digits` - 指定的位数，按此位数进行四舍五入
  返回：
    计算按指定位数返回舍入后的含税价

    例子：

         double value = WorksheetFunction.postTax(100, 0.2, 5);
         System.out.println("value is " + value);

### power

    public static double power(double number,
                               double power)

  求给定数字的乘幂。

  参数：
    `number` - 底数，可以为任意实数，如"8"
    `power` - 指数，底数按该指数次幂乘方，如"2"
  返回：
    给定数字的乘幂

    例子：

         double value = WorksheetFunction.power(8, 2);

### ppmt

    public static double ppmt(double rate,
                              double per,
                              double nper,
                              double pv,
                              double fv,
                              double type)

  基于固定利率及等额分期付款方式，返回投资在某一给定期间内的本金偿还额。

  参数：
    `rate` - 为各期利率
    `per` - 用于计算其本金数额的期数，必须介于 1 到 nper 之间
    `nper` - 为总投资期，即该项投资的付款期总数
    `pv` - 为现值，即从该项投资开始计算时已经入帐的款项，或一系列未来付款当前值的累积和
    `fv` - 为未来值，或在最后一次付款后希望得到的现金余额
    `type` - 数字 0 或 1，用以指定各期的付款时间是在期初还是期末，0 表示期末，1 表示期初
  返回：
    投资在某一给定期间内的本金偿还额

    例子：

         double result = WorksheetFunction.ppmt(-0.25, 2, 100, 1500, 3000, 1);
         System.out.println("result is " + result);

### preTax

    public static double preTax(double amt,
                                double tax_rate,
                                double num_digits)

  计算按指定位数返回舍入后的不含税价。

  参数：
    `amt` - 含税价，即开具发票金额。必须为非负数
    `tax_rate` - 增值税征收税率.必须为正数,否则函数结果返回“*NUM!”值
    `num_digits` - 指定的位数，按此位数进行四舍五入
  返回：
    计算按指定位数返回舍入后的不含税价

    例子：

         double value = WorksheetFunction.preTax(100, 0.2, 5);
         System.out.println("value is " + value);

### price

    public static double price(java.lang.String settlement,
                               java.lang.String maturity,
                               double rate,
                               double yld,
                               double redemption,
                               double frequency,
                               int basis)

  返回按周期付息的有价证券每 ￥100 票面价值的实际价格。

  参数：
    `settlement` - 为证券的成交日，即证券发行后投资者购买证券的日期。
    `maturity` - 为有价证券的到期日，即证券有效期的截止日期。
    `rate` - 为有价证券的利率
    `yld` - 为有价证券的年收益率
    `redemption` - 面值为 ￥100 的有价证券的清偿价值
    `frequency` - 为每年的付息次数。如果每年付息一次，则 frequency=1；如果半年付息一次，则 frequency=2；如果一季度付息一次，则 frequency=4。
    `basis` - 为日计数基准类型。

    例子：

           某债券的交易情况如下：
           成交日：2000 年 3 月 15 日
           到期日：2006 年 9 月 15 日
           半年息票利率：5.55%
           收益率：6.50%
           清偿价值：￥100
           年付息次数：2
           日计数基准：30/360
           该证券的价格为：
           WorksheetFunction.price("2000/3/15","2006/9/15",0.0555,0.065,100,2,4) 等于 95.02822152。

### pricedisc

    public static double pricedisc(java.lang.String settlement,
                                   java.lang.String maturity,
                                   double discount,
                                   double redemption,
                                   int basis)

  返回折价发行的面值为 ￥100 的有价证券的价格。

  参数：
    `settlement` - 为证券的成交日，即证券发行后投资者购买证券的日期。
    `maturity` - 为有价证券的到期日，即证券有效期的截止日期。
    `discount` - 为有价证券的末期付息日。
    `redemption` - 面值为 ￥100 的有价证券的清偿价值
    `basis` - 为日计数基准类型。

    例子：

           某债券的交易情况如下：
           成交日：2000 年 7 月 1 日
           到期日：2000 年 10 月 1 日
           贴现率：4.25%
           清偿价值：￥100
           日计数基准：实际天数/360
           该证券的价格为：
           WorksheetFunction.pricedisc("2000/7/1","2000/10/1",0.0425,100,2) 等于 98.91388889。

### pricemat

    public static double pricemat(java.lang.String settlement,
                                  java.lang.String maturity,
                                  java.lang.String issue,
                                  double rate,
                                  double yld,
                                  int basis)

  返回到期付息的面值为 ￥100 的有价证券的价格。

  参数：
    `settlement` - 为证券的成交日，即证券发行后投资者购买证券的日期。
    `maturity` - 为有价证券的到期日，即证券有效期的截止日期。
    `issue` - 为有价证券的末期付息日。
    `rate` - 为有价证券的利率
    `yld` - 为有价证券的年收益率
    `basis` - 为日计数基准类型。

    例子：

           某债券的交易情况如下：
           成交日：1998 年 10 月 3 日
           到期日：2002 年 7 月 1 日
           发行日：1998 年 2 月 15 日
           半年息票利率：6.5%
           收益率：6.50%
           日计数基准：30/360
           该证券的价格为：
           WorksheetFunction.pricemat("1998/10/3","2002/7/1","1998/2/15",0.065,0.065,0) 等于 99.19417735。

### prob

    public static double prob(Range range1,
                              Range range2,
                              double lower_limit,
                              double upper_limit)

  区域中的数值落在指定区间内的概率。 如果没有给出上限 (upper_limit)，则返回区间 x_range 内的值等于下限 lower_limit 的概率。

  参数：
    `range1` - 单元格区域引用，如"a1:a2"，具有各自相应概率值的 x 数值区域
    `range2` - 单元格区域引用，如"a1:a2"，与 x_range 中的值相对应的一组概率值
    `lower_limit` - 用于计算概率的数值下界
    `upper_limit` - 用于计算概率的可选数值上界
  返回：
    区域中的数值落在指定区间内的概率

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook()
                        .getWorksheets().getActiveWorksheet();
         double[] xvalues =
         { 2, 3.5, 4.2, 5 };
         double[] probvalues =
         { 0.3, 0.4, 0.2, 0.1 };
         sheet.setCellValue(1, 1, xvalues, true);
         sheet.setCellValue(2, 1, probvalues, true);
         Range range1 = sheet.getRange("A1:D1");
         Range range2 = sheet.getRange("A2:D2");
         double value = WorksheetFunction.prob(range1, range2, 2, 4);
         System.out.println("value :" + value);

### product

    public static double product(Range range)

  求所有以参数形式给出的数字相乘，并返回乘积值。

  参数：
    `range` - 单元格区域，如:"A1:B2"
  返回：
    所有以参数形式给出的数字相乘，并返回乘积值

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range data = sheet.getRange("a1:e5");
         data.fillRandom(1, 10, 0);
         double value = WorksheetFunction.product(data);
         System.out.println("value is " + value);

### proper

    public static java.lang.String proper(java.lang.String string)

  将文本值中每个单词的首字母设置为大写。

  参数：
    `string` - 字符串类型
  返回：
    字母设置为大写后的字符串

    例子：

         String result = WorksheetFunction.proper("abc");
         System.out.println("result is " + result);

### pv

    public static double pv(double rate,
                            double nper,
                            double pmt,
                            double fv,
                            double type)

  返回投资的现值。现值为一系列未来付款的当前值的累积和。

  参数：
    `rate` - 为各期利率
    `nper` - 为总投资（或贷款）期，即该项投资（或贷款）的付款期总数
    `pmt` - 为各期所应支付的金额，其数值在整个年金期间保持不变
    `fv` - 为未来值，或在最后一次支付后希望得到的现金余额
    `type` - 数字 0 或 1，用以指定各期的付款时间是在期初还是期末，0 表示期末，1 表示期初
  返回：
    投资的现值

    例子：

         double result = WorksheetFunction.pv(0.25, 100, -1000, 150000, 0);
         System.out.println("result is " + result);

### quartile

    public static double quartile(Range range,
                                  double quart)

  数据集的四分位数。四分位数通常用于在销售额和测量数据中对总体进行分组。 例如，可以使用函数 QUARTILE 求得总体中前 25% 的收入值。

  参数：
    `range` - 单元格区域引用，如"a1:a2"，为需要求得四分位数值的数组或数字型单元格区域
    `quart` - 决定返回哪一个四分位值
  返回：
    数据集的四分位数

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range range = sheet.getRange("a1:a2");
         range.fillRandom(100, 10, 0);
         double value = WorksheetFunction.quartile(range, 1);
         System.out.println("value is " + value);

### quotient

    public static int quotient(double numerator,
                               double denominator)

  返回商的整数部分。该函数可以舍去商的小数部分。

  参数：
    `numerator` - 被除数
    `denominator` - 除数

    例子：

           WorksheetFunction.quotient(9,5) 等于 1。

### radians

    public static double radians(double angle)

  将角度转换成弧度。

  参数：
    `angle` - 需要转换为弧度的角度

    例子：

           WorksheetFunction.radians(90) 等于 1.570796327（π/2 弧度）

### rand

    public static double rand()

  返回均匀分布的随机数。每计算一次工作表，函数都会返回一个新的随机数值。

  例子：

         假如需要生成一个大于等于 0，小于 60 的随机数，使用公式：WorksheetFunction.rand()*60。

### randbetween

    public static double randbetween(double bottom,
                                     double top)

  返回位于指定的任意两数之间的随机数。

  参数：
    `bottom` - 函数返回的最小整数
    `top` - 函数返回的最大整数

    例子：

          如果您想生成一个位于 1 和 10 之间的随机数，可以使用公式：randbetween(1,10)。

### range

    public static void range(Range range)

  将一个特定的单元格区域链接到其他单元格中，当源数据发生变化时，链接后的数据将会作相应变化。 注意：须先选中一块单元格，再运用此函数，结果显示在此选中的单元格上

  参数：
    `range` - 为对单元格区域的引用

### rank

    public static double rank(double number,
                              Range range,
                              double order)

  一个数字在数字列表中的排位。 数字的排位是其大小与列表中其他值的比值（如果列表已排过序，则数字的排位就是它当前的位置）。

  参数：
    `number` - 为需要找到排位的数字
    `range` - 单元格区域引用，如"a1:a2"，为数字列表数组或对数字列表的引用， Ref 中的非数值型参数将被忽略
    `order` - 为一数字，指明排位的方式
  返回：
    一个数字在数字列表中的排位

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range range = sheet.getRange("a1:d20");
         range.fillRandom(10, 1, 0);
         double value = WorksheetFunction.rank(5, range, 2);
         System.out.println("value is " + value);

### rate

    public static double rate(double nper,
                              double pmt,
                              double pv,
                              double fv,
                              double type,
                              double guess)

  返回年金的各期利率。

  参数：
    `nper` - 为总投资期，即该项投资的付款期总数
    `pmt` - 为各期付款额，其数值在整个投资期内保持不变
    `pv` - 为现值，即从该项投资开始计算时已经入帐的款项，或一系列未来付款当前值的累积和
    `fv` - 为未来值，或在最后一次付款后希望得到的现金余额
    `type` - 数字 0 或 1，用以指定各期的付款时间是在期初还是期末，0 表示期末，1 表示期初
    `guess` - 为预期利率
  返回：
    年金的各期利率

    例子：

         double result = WorksheetFunction.rate(100, -1000, 150000, 4000, 0, 1);
         System.out.println("result is " + result);

### received

    public static double received(java.lang.String settlement,
                                  java.lang.String maturity,
                                  double investment,
                                  double discount,
                                  int basis)

  返回一次性付息的有价证券到期收回的金额。

  参数：
    `settlement` - 为证券的成交日，即证券发行后投资者购买证券的日期。
    `maturity` - 为有价证券的到期日，即证券有效期的截止日期。
    `investment` - 为有价证券的末期付息日。
    `discount` - 面值为 ￥100 的有价证券的清偿价值
    `basis` - 为日计数基准类型。

    例子：

           某债券的交易情况如下：
           成交日：2000 年 5 月 15 日
           到期日：2000 年 6 月 15 日
           投资金额：5,000,000
           贴现率：3.25%
           日计数基准：实际天数/360
           该证券在到期日可收回的总金额为：
           WorksheetFunction.received("2000/5/15","2000/6/15",5000000,0.0325,2) 等于 5014032.327 或 ￥5,014,032.327。

### replace

    public static java.lang.String replace(java.lang.String originString,
                                           int startNumber,
                                           int charNumbers,
                                           java.lang.String newString)

  根据指定的字符数，用其他文本串来替换某个文本串中的部分内容。

  参数：
    `originString` - 原来的字符串
    `startNumber` - 开始替换的起始位置
    `charNumbers` - 需要替换的字符个数
    `newString` - 替换的字符串
  返回：
    替换后的字符串

    例子：

          String result = WorksheetFunction.replace("0123456789",5,4,"*");
          System.out.println("result is "+result);

### replaceb

    public static java.lang.String replaceb(java.lang.String originString,
                                            int startNumber,
                                            int charNumbers,
                                            java.lang.String newString)

  根据指定的字符数，用其他文本串来替换某个文本串中的部分内容，常用于双字节字符。

  参数：
    `originString` - 原来的字符串
    `startNumber` - 开始替换的起始位置
    `charNumbers` - 需要替换的字符个数
    `newString` - 替换的字符串
  返回：
    替换后的字符串

    例子：

         String result = WorksheetFunction.replaceb("从2000年4月1日起", 3, 4, "2001");
         System.out.println("result is " + result);

### rept

    public static java.lang.String rept(java.lang.String text,
                                        int number_times)

  根据指定的次数重复显示文本。

  参数：
    `text` - 需要重复显示的文本
    `number_times` - 指定文本重复的次数

    例子：

          WorksheetFunction.rept("$",4) 等于“$$$$”。

### right

    public static java.lang.String right(java.lang.String text,
                                         int num_chars)

  根据指定的字符数从右开始返回文本串中的最后一个或几个字符。

  参数：
    `text` - 包含需要提取字符的文本串
    `num_chars` - 指定 RIGHT 函数从文本串中提取的字符数

    例子：

          WorksheetFunction.right("Huge sale",4) 等于“sale”。

### rightb

    public static java.lang.String rightb(java.lang.String text,
                                          int num_bytes)

  根据所指定的字节数从右开始返回文本串中的最后一个或几个字符，常用于双字节字符。

  参数：
    `text` - 包含需要提取字符的文本串
    `num_bytes` - 指定 RIGHTB 函数从文本串中提取的字节数

    例子：

          WorksheetFunction.rightb("北京",2) 等于“京”。

### rmb

    public static java.lang.String rmb(double number,
                                       int decimals)

  使用 ￥（人民币）货币格式将数字转换为文本，并四舍五入至指定位数。

  参数：
    `number` - 需要转化为文本的数字
    `decimals` - 为数字四舍五入后的位数

    例子：

          WorksheetFunction.rmb(2435.43534,3) 等于 ￥2,435.435。

### roman

    public static java.lang.String roman(double number)

  求将阿拉伯数字转换为文本形式的罗马数字。

  参数：
    `number` - 对象的总数量，如"8"
  返回：
    将阿拉伯数字转换为文本形式的罗马数字

    例子：

         String value = WorksheetFunction.roman(8);
         System.out.println("value is " + value);

### roman

    public static java.lang.String roman(double number,
                                         double form)

  求将阿拉伯数字转换为文本形式的罗马数字。

  参数：
    `number` - 对象的总数量，如"8"
    `form` - 一数字，指定所需的罗马数字类型，如"2"
  返回：
    将阿拉伯数字转换为文本形式的罗马数字

    例子：

         String value = WorksheetFunction.roman(8, 2);
         System.out.println("value is " + value);

### round

    public static double round(double number,
                               double digits)

  求从给定数目的对象集合中提取若干对象的组合数。

  参数：
    `number` - 需要进行四舍五入的数字，如"8.2354"
    `digits` - 指定的位数，按此位数进行四舍五入，如"2"
  返回：
    给定数目的对象集合中提取若干对象的组合数

    例子：

         double value = WorksheetFunction.round(8.2354, 2);
         System.out.println("value is " + value);

### rounddown

    public static double rounddown(double number,
                                   double digits)

  求从靠近零值，向下（绝对值减小的方向）舍入数字。

  参数：
    `number` - 需要向下舍入的任意实数，如"8.54234"
    `digits` - 四舍五入后的数字的位数，如"2"
  返回：
    靠近零值，向下（绝对值减小的方向）舍入数字

    例子：

         double value = WorksheetFunction.rounddown(8.54234, 2);
         System.out.println("value is " + value);

### roundup

    public static double roundup(double number,
                                 double digits)

  求远离零值，向上舍入数字。

  参数：
    `number` - 需要向上舍入的任意实数，如"8.54234"
    `digits` - 四舍五入后的数字的位数，如"2"
  返回：
    远离零值，向上舍入数字

    例子：

         double value = WorksheetFunction.roundup(8.54234, 2);
         System.out.println("value is " + value);

### row

    public static int row(Range reference)

  返回指定引用的行号。

  参数：
    `reference` - 一个包含所求行号的单元格或单元格区域

    例子：

           //等于 4
          Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
          Range range = sheet.getRange("B4:E6");
          WorksheetFunction.row(range);

### rows

    public static int rows(Range reference)

  返回一个数组或引用的行数。

  参数：
    `reference` - 对一个单元格区域的引用

    例子：

          //等于 4。
          Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
          Range range = sheet.getRange("B2:E5");
          WorksheetFunction.rows(range);

### rsq

    public static double rsq(Range range1,
                             Range range2)

  根据 known_ys 和 known_xs 中数据点计算得出的 Pearson 乘积矩相关系数的平方。

  参数：
    `range1` - 单元格区域引用，如"a1:a2"
    `range2` - 单元格区域引用，如"a1:a2"
  返回：
    根据 known_ys 和 known_xs 中数据点计算得出的 Pearson 乘积矩相关系数的平方

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range range1 = sheet.getRange("a1:a2");
         Range range2 = sheet.getRange("b1:b2");
         range1.fillRandom(100, 10, 0);
         range2.fillRandom(100, 10, 0);
         double value = WorksheetFunction.rsq(range1, range2);
         System.out.println("value is " + value);

### search

    public static int search(java.lang.String findString,
                             java.lang.String withinString,
                             int startNumber)

  在其他文本值中查找文本值（不区分大小写）。

  参数：
    `findString` - 所要查找的字符串
    `withinString` - 被查找的字符串
    `startNumber` - 开始查找的起始位置
  返回：
    从开始查找位置起所查字符串在被查字符串中所在的位置

    例子：

         int result = WorksheetFunction.search("ca", "abcabcabc", 4);
         System.out.println("result is " + result);

### searchb

    public static int searchb(java.lang.String findText,
                              java.lang.String withinText,
                              int startNumber)

  在其他文本值中查找文本值（不区分大小写）。

  参数：
    `findText` - 所要查找的字符串
    `withinText` - 被查找的字符串
    `startNumber` - 开始查找的起始位置
  返回：
    从开始查找位置起所查字符串在被查字符串中所在的位置

    例子：

         int result = WorksheetFunction.searchb("ca", "abcabcabc", 4);
         System.out.println("result is " + result);

### second

    public static int second(double serial_number)

  返回指定日期值的秒数，其值为介于 0 到 59 之间的整数。

  参数：
    `serial_number` - 包含所求秒的时间

    例子：

          WorksheetFunction.second(0.03) 等于 12。

### second

    public static int second(java.lang.String serial_number)

  返回指定日期值的秒数，其值为介于 0 到 59 之间的整数。

  参数：
    `serial_number` - 包含所求秒的时间

    例子：

          WorksheetFunction.second("6:15:56") 等于 56。

### seriessum

    public static double seriessum(Range x,
                                   double n,
                                   double m,
                                   Range coefficients)

  返回幂级数之和。

  参数：
    `x` - 幂级数的输入值
    `n` - 为 x 的首项乘幂
    `m` - 为幂级数中每一项的乘幂 n 的步长增加值
    `coefficients` - 为一系列与 x 各级乘幂相乘的系数

### sign

    public static int sign(double number)

  返回数字或可计算的数式结果的符号。

  参数：
    `number` - 为任意实数或可计算的数式

    例子：

           WorksheetFunction.sign(10) 等于 1。

### sin

    public static double sin(double number)

  计算指定角度的正弦值。

  参数：
    `number` - 待求正弦值的以弧度表示的角度

    例子：

           WorksheetFunction.sin(10) 等于 -0.544021111。

### sinh

    public static double sinh(double number)

  求双曲正弦值。

  参数：
    `number` - 实数值，如"0.3"
  返回：
    双曲正弦值

    例子：

         double value = WorksheetFunction.sinh(0.3);
         System.out.println("value is " + value);

### skew

    public static double skew(Range range)

  分布的偏斜度。偏斜度反映以平均值为中心的分布的不对称程度。 正偏斜度表示不对称部分的分布更趋向正值。负偏斜度表示不对称部分的分布更趋向负值。

  参数：
    `range` - 单元格区域引用，如"a1:a2"
  返回：
    分布的偏斜度

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range range = sheet.getRange("a1:a20");
         range.fillRandom(100, 200, 0);
         double value = WorksheetFunction.skew(range);
         System.out.println("value is " + value);

### sln

    public static double sln(double cost,
                             double salvage,
                             double life)

  返回某项资产在一个期间中的线性折旧值。

  参数：
    `cost` - 为资产原值
    `salvage` - 为资产在折旧期末的价值（也称为资产残值）
    `life` - 为折旧期限（有时也称作资产的使用寿命）
  返回：
    某项资产在一个期间中的线性折旧值

    例子：

         double result = WorksheetFunction.sln(10000, 100, 15);
         System.out.println("result is " + result);

### slope

    public static double slope(Range range1,
                               Range range2)

  根据 known_ys 和 known_xs 中的数据点拟合的线性回归直线的斜率。 斜率为直线上任意两点的重直距离与水平距离的比值，也就是回归直线的变化率。

  参数：
    `range1` - 单元格区域引用，如"a1:a2"
    `range2` - 单元格区域引用，如"a1:a2"
  返回：
    根据 known_ys 和 known_xs 中的数据点拟合的线性回归直线的斜率

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range range1 = sheet.getRange("a1:a2");
         Range range2 = sheet.getRange("b1:b2");
         range1.fillRandom(100, 10, 0);
         range2.fillRandom(100, 10, 0);
         double value = WorksheetFunction.slope(range1, range2);
         System.out.println("value is " + value);

### small

    public static double small(Range range,
                               double k)

  数据集中第 k 个最小值。使用此函数可以返回数据集中特定位置上的数值。

  参数：
    `range` - 单元格区域引用，如"a1:a2"，为需要找到第 k 个最小值的数组或数字型数据区域
    `k` - 为返回的数据在数组或数据区域里的位置（从小到大）
  返回：
    数据集中第 k 个最小值

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range range = sheet.getRange("a1:a20");
         range.fillRandom(100, 10, 0);
         double value = WorksheetFunction.small(range, 5);
         System.out.println("value is " + value);

### sqrt

    public static double sqrt(double number)

  返回一个平方根。

  参数：
    `number` - 要求其平方根的任一数

    例子：

           WorksheetFunction.sqrt(64) 等于 8。

### sqrtpi

    public static double sqrtpi(double number)

  返回数值与 pi 乘积的平方根。

  参数：
    `number` - 将与 pi 相乘的任一数

    例子：

           WorksheetFunction.sqrtpi(10) 等于 5.604991216。

### standardize

    public static double standardize(double x,
                                     double mean,
                                     double standard_dev)

  以 mean 为平均值，以 standard-dev 为标准偏差的分布的正态化数值。

  参数：
    `x` - 为需要进行正态化的数值
    `mean` - 分布的算术平均值
    `standard_dev` - 分布的标准偏差
  返回：
    以 mean 为平均值，以 standard-dev 为标准偏差的分布的正态化数值

    例子：

         double value = WorksheetFunction.standardize(5, 20, 10);
         System.out.println("value is " + value);

### stdev

    public static double stdev(Range range)

  估算样本的标准偏差。标准偏差反映相对于平均值 (mean) 的离散程度。

  参数：
    `range` - 单元格区域引用，如"a1:a2"
  返回：
    估算样本的标准偏差

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range range = sheet.getRange("a1:a2");
         range.fillRandom(10, 20, 0);
         double value = WorksheetFunction.stdev(range);
         System.out.println("value is " + value);

### stdeva

    public static double stdeva(Range values)

  估算基于指定样本的标准偏差。标准偏差是指相对于平均值（mean）的离散程度。与 STDEV 不同的是，STDEVA 计算时可以识别文本和逻辑值。

  参数：
    `values` - 含数值的单元格区域

### stdevp

    public static double stdevp(Range range)

  以参数形式给出的整个样本总体的标准偏差。标准偏差反映相对于平均值 (mean) 的离散程度。

  参数：
    `range` - 单元格区域引用，如"a1:a2"
  返回：
    以参数形式给出的整个样本总体的标准偏差

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range range = sheet.getRange("a1:a2");
         range.fillRandom(10, 20, 0);
         double value = WorksheetFunction.stdevp(range);
         System.out.println("value is " + value);

### stdevpa

    public static double stdevpa(Range values)

  计算样本总体的标准偏差。它反映了数值相对于平均值的离散程度。

  参数：
    `values` - 含数值的单元格区域

### steyx

    public static double steyx(Range range1,
                               Range range2)

  通过线性回归法计算每个 x 的 y 预测值时所产生的标准误差。 标准误差用来度量根据单个 x 变量计算出的 y 预测值的误差量。

  参数：
    `range1` - 单元格区域引用，如"a1:a2"
    `range2` - 单元格区域引用，如"a1:a2"
  返回：
    通过线性回归法计算每个 x 的 y 预测值时所产生的标准误差

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range range1 = sheet.getRange("a1:a2");
         Range range2 = sheet.getRange("b1:b2");
         range1.fillRandom(100, 10, 0);
         range2.fillRandom(100, 10, 0);
         double value = WorksheetFunction.steyx(range1, range2);
         System.out.println("value is " + value);

### substitute

    public static java.lang.String substitute(java.lang.String originString,
                                              java.lang.String oldString,
                                              java.lang.String newString,
                                              int orderNumber)

  在文本串中使用新文本替换旧文本。

  参数：
    `originString` - 原来的字符串
    `oldString` - 旧字符串
    `newString` - 新字符串
    `orderNumber` - 旧字符串的次序
  返回：
    替换后的字符串

    例子：

         String result = WorksheetFunction.substitute("abcabcabc", "ca", "ee", 1);
         System.out.println("result is " + result);

### subtotal

    public static double subtotal(double criteria,
                                  Range array)

  求数据清单或数据库中的分类汇总。

  参数：
    `criteria` - 选择分类总汇中所需的方式
    `array` - 为分类总汇所选择的区域
  返回：
    数据清单或数据库中的分类汇总

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range data = sheet.getRange("a1:e5");
         data.fillRandom(1, 10, 0);
         double value = WorksheetFunction.subtotal(9, data);
         System.out.println("value is " + value);

### sum

    public static double sum(Range range)

  求某一单元格区域中所有数字之和。

  参数：
    `range` - 为单元格区域，如＂A1:B2"
  返回：
    某一单元格区域中所有数字之和

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range data = sheet.getRange("a1:e5");
         data.fillRandom(1, 10, 0);
         double value = WorksheetFunction.sum(data);
         System.out.println("value is " + value);

### sumif

    public static double sumif(Range array,
                               java.lang.String criteria,
                               Range sum_array)

  求指定条件对若干单元格的和。

  参数：
    `array` - 为用于条件判断的单元格区域
    `criteria` - 为确定哪些单元格将被相加求和的条件
    `sum_array` - 是需要求和的实际单元格
  返回：
    指定条件对若干单元格的和

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range data1 = sheet.getRange("a1:b2");
         data1.fillRandom(10, 1, 0);
         Range data2 = sheet.getRange("a3:b4");
         data2.fillRandom(10, 1, 0);
         double value = WorksheetFunction.sumif(data1, ">2", data2);
         System.out.println("value is " + value);

### sumproduct

    public static double sumproduct(Range range1,
                                    Range range2)

  求在给定的两组区域中对应的元素相乘之和，(两个单元格区域的行列数必须对应相等)。

  参数：
    `range1` - 单元格区域
    `range2` - 单元格区域
  返回：
    在给定的两组数组中，将数组间对应的元素相乘之和

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range data = sheet.getRange("a1:c3");
         data.fillRandom(1, 10, 0);
         double value = WorksheetFunction.sumproduct(data, data);
         System.out.println("value is " + value);

### sumsq

    public static double sumsq(Range range)

  求参数的平方和。

  参数：
    `range` - 为单元格区域，如＂A1:B2"
  返回：
    参数的平方和

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range data = sheet.getRange("a1:e5");
         data.fillRandom(1, 10, 0);
         double value = WorksheetFunction.sumsq(data);
         System.out.println("value is " + value);

### sumx2my2

    public static double sumx2my2(Range array1,
                                  Range array2)

  求两数组中对应数值的平方差之和。

  参数：
    `array1` - 为第一个数组或数值区域
    `array2` - 为第二个数组或数值区域
  返回：
    两数组中对应数值的平方差之和

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook()
                        .getWorksheets().getActiveWorksheet();
         Range range1 = sheet.getRange("A1:C1");
         range1.fillRandom();
         Range range2 = sheet.getRange("A2:C2");
         range2.fillRandom();
         double value = WorksheetFunction.sumx2my2(range1, range2);
         System.out.println("value :" + value);

### sumx2py2

    public static double sumx2py2(Range array1,
                                  Range array2)

  求两两数组中对应数值的平方和之和。

  参数：
    `array1` - 为第一个数组或数值区域
    `array2` - 为第二个数组或数值区域
  返回：
    两数组中对应数值的平方和之和

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook()
                        .getWorksheets().getActiveWorksheet();
         Range range1 = sheet.getRange("A1:C1");
         range1.fillRandom();
         Range range2 = sheet.getRange("A2:C2");
         range2.fillRandom();
         double value = WorksheetFunction.sumx2py2(range1, range2);
         System.out.println("value :" + value);

### sumxmy2

    public static double sumxmy2(Range array1,
                                 Range array2)

  求两数组中对应数值之差的平方和。

  参数：
    `array1` - 为第一个数组或数值区域
    `array2` - 为第二个数组或数值区域
  返回：
    两数组中对应数值之差的平方和

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range data1 = sheet.getRange("a1:b2");
         data1.fillRandom(10, 1, 0);
         Range data2 = sheet.getRange("a3:b4");
         data2.fillRandom(10, 1, 0);
         double value = WorksheetFunction.sumxmy2(data1, data2);
         System.out.println("value is " + value);

### syd

    public static double syd(double cost,
                             double salvage,
                             double life,
                             double per)

  返回某项资产按年限总和折旧法计算的指定期间的折旧值。

  参数：
    `cost` - 资产原值
    `salvage` - 资产残值
    `life` - 为折旧期限
    `per` - 为期间，其单位与 life 相同
  返回：
    某项资产按年限总和折旧法计算的指定期间的折旧值

    例子：

         double result = WorksheetFunction.syd(10000, 100, 15, 4);
         System.out.println("result is " + result);

### t

    public static java.lang.String t(java.lang.String value)

  返回参数所引用的文本。

  参数：
    `value` - 需要转化为文本的数字

    例子：

          WorksheetFunction.t("China") 等于“China”。

### tan

    public static double tan(double number)

  返回指定角度的正切值。

  参数：
    `number` - 待求正切值的角度，以弧度表示

    例子：

           WorksheetFunction.tan(0.8) 等于 1.029638557。

### tanh

    public static double tanh(double number)

  求某一数字的双曲正切。

  参数：
    `number` - 实数值，如"0.3"
  返回：
    某一数字的双曲正切

    例子：

         double value = WorksheetFunction.tanh(0.3);
         System.out.println("value is " + value);

### tbilleq

    public static double tbilleq(java.lang.String settlement,
                                 java.lang.String maturity,
                                 double discount)

  返回国库券的等效收益率。

  参数：
    `settlement` - 国库券的成交日，即国库券发行后投资者购买国库券的日期。
    `maturity` - 国库券的到期日，即国库券有效期的截止日期。
    `discount` - 国库券的贴现率

    例子：

           某债券的交易情况如下：
           成交日：2005 年 1 月 31 日
           到期日：2005 年 10 月 22 日
           贴现率：6.82%
           该国库券的等效收益率为：
           WorksheetFunction.tbilleq("2005/01/31","2005/10/22",0.0682) 等于 0.071987664

### tbillprice

    public static double tbillprice(java.lang.String settlement,
                                    java.lang.String maturity,
                                    double discount)

  返回面值为 ￥100 的短期国库券的价格。

  参数：
    `settlement` - 国库券的成交日，即国库券发行后投资者购买国库券的日期。
    `maturity` - 国库券的到期日，即国库券有效期的截止日期。
    `discount` - 国库券的贴现率

    例子：

           某债券的交易情况如下：
           成交日：2000 年 3 月 15 日
           到期日：2000 年 7 月 15 日
           贴现率：9%
           该短期国库券的价格为：
           WorksheetFunction.tbillprice("2000/3/15","2000/7/15",0.09) 等于 96.95。

### tbillyield

    public static double tbillyield(java.lang.String settlement,
                                    java.lang.String maturity,
                                    double pr)

  返回短期国库券的收益率。

  参数：
    `settlement` - 国库券的成交日，即国库券发行后投资者购买国库券的日期。
    `maturity` - 国库券的到期日，即国库券有效期的截止日期。
    `pr` - 面值为 ￥100 短期国库券的价格。

    例子：

           某债券的交易情况如下：
           成交日：2000 年 5 月 1 日
           到期日：2000 年 10 月 1 日
           每 ￥100 短期国库券的价格：￥98
           该短期国库券的收益率为：
           WorksheetFunction.tbillyield("2000/5/1","2000/10/1",98) 等于 0.048019208 或 4.802%。

### tdist

    public static double tdist(double x,
                               int degrees_freedom,
                               int tails)

  返回学生 t 分布的百分点（概率），t 分布中数值 (x) 是 t 的计算值（将计算其百分点）。

  参数：
    `x` - 需要计算分布的数字
    `degrees_freedom` - 表示自由度的整数
    `tails` - 指明返回的分布函数是单尾分布还是双尾分布

    例子：

           WorksheetFunction.tdist(1.55,80,2) 等于 0.125088706
           WorksheetFunction.tdist(1.55,80,1) 等于 0.062544353

### text

    public static java.lang.String text(double v,
                                        java.lang.String formatText)

  获得格式化后的字符串

  参数：
    `v` - 将要被格式化的数值
    `formatText` - 函数使用的格式化字符串
  返回：
    返回按照 formatText 格式化后的字符串

    例子：

         String value = WorksheetFunction.text(100, "#,##0.00");
         System.out.println("value is " + value);

### time

    public static double time(int hour,
                              int minute,
                              int second)

  返回代表指定时间的序列数。

  参数：
    `hour` - 介于 0 到 32767 之间的数值，代表小时。任何大于 23 的数值将除以 24，其余数将视为小时。
    `minute` - 介于 0 到 32767 之间的数值，代表分钟。任何大于 59 的数值将被转换为小时和分钟。
    `second` - 介于 0 到 32767 之间的数值，代表秒。任何大于 59 的数值将被转换为小时、分钟和秒（转换后的秒数将忽略不计）。

    例子：

          WorksheetFunction.time(14,40,0) 等于 2:40 PM，转换成小数形式为 0.6111。

### timevalue

    public static double timevalue(java.lang.String time_text)

  将表示时间的文本串转化为表示时间的小数值。此值介于 0 到 0.99999999 之间。 该小数值代表一个介于 0:00:00（即 12:00:00 A.M.）到 23:59:59（11:59:59 P.M.）之间的时间。

  参数：
    `time_text` - 文本字符串，代表任一时间格式表示的时间

    例子：

          WorksheetFunction.timevalue("7:12 AM") 等于 0.3。

### tinv

    public static double tinv(double probability,
                              int degrees_freedom)

  返回给定自由度和双尾概率的学生 t 分布的区间点。

  参数：
    `probability` - 对应于双尾学生 t 分布的概率
    `degrees_freedom` - 表示自由度的整数

    例子：

           WorksheetFunction.tinv(0.78654,30) 等于 0.273241342

### today

    public static long today()

  获取当前日期并返回表示此日期的序列号。

  例子：

       WorksheetFunction.today();

### transpose

    public static void transpose(Range range)

  返回转置单元格区域，即将一行单元格区域转置成一列单元格区域，反之亦然。 注意：须先选中一块单元格区域，再运用此函数，结果显示在此选中的单元格区域上

### trend

    public static double trend(Range range1,
                               Range range2,
                               double new_xs,
                               boolean const1)

  一条线性回归拟合线的值。 即找到适合已知数组 known_ys 和 known_xs 的直线（用最小二乘法）， 并返回指定数组 new_xs 在直线上对应的 y 值。

  参数：
    `range1` - 单元格区域引用，如"a1:a2"，是关系表达式 y = mx + b 中已知的 y 值集合
    `range2` - 单元格区域引用，如"a1:a2"，是关系表达式 y = mx + b 中已知的可选 x 值集合
    `new_xs` - 为需要函数 TREND 返回对应 y 值的新 x 值
    `const1` - 为一逻辑值，用于指定是否将常量 b 强制设为 0
  返回：
    一条线性回归拟合线的值

    例子：

         Worksheet sheet  = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range range1 = sheet.getRange("a1:a10");
         range1.fillRandom(1, 100, 0);
         Range range2 = sheet.getRange("b1:b10");
         range2.fillRandom(1, 10, 0);
         double value = WorksheetFunction.trend(range1, range2, 15, true);
         System.out.println("value is " + value);

### trim

    public static java.lang.String trim(java.lang.String string)

  删除文本中的空格。

  参数：
    `string` - 字符串类型
  返回：
    删除空格后的字符串

    例子：

         String result = WorksheetFunction.trim("ab   cd");
         System.out.println("result is " + result);

### trimmean

    public static double trimmean(Range range,
                                  double percent)

  数据集的内部平均值。函数 TRIMMEAN 先从数据集的头部和尾部除去一定百分比的数据点，然后再求平均值。 当希望在分析中剔除一部分数据的计算时，可以使用此函数。

  参数：
    `range` - 单元格区域引用，如"a1:a2"，为需要进行整理并求平均值的数组或数值区域
    `percent` - 为计算时所要除去的数据点的比例， 例如，如果 percent = 0.2，在 20 个数据点的集合中，就要除去 4 个数据点 (20 x 0.2)： 头部除去 2 个，尾部除去 2 个
  返回：
    数据集的内部平均值

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range range = sheet.getRange("a1:a20");
         range.fillRandom(100, 10, 0);
         double value = WorksheetFunction.trimmean(range, 0.2);
         System.out.println("value is " + value);

### trunc

    public static double trunc(double number,
                               double num_digits)

  通过舍弃数字的部分或全部小数点位数，使数字的小数点位数符合指定条件。

  参数：
    `number` - 需要舍弃小数点位数的数字
    `num_digits` - 数字要返回的小数点位数，其默认值为 0。

    例子：

           WorksheetFunction.trunc(3.1415926,3) 等于 3.141。

### ttest

    public static double ttest(Range array1,
                               Range array2,
                               int tails,
                               int type)

  返回与学生 t 检验相关的概率。

  参数：
    `array1` - 第一个数据集
    `array2` - 第二个数据集
    `tails` - 指示分布曲线的尾数
    `type` - 为 t 检验的类型

    例子：

           Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
           Range range = sheet.getRange("A1:A9");
           Range range1 = sheet.getRange("B1:B9");
           WorksheetFunction.ttest(range,range1,2,1) 等于 0.602696491

### type

    public static int type(Range val)

  返回数值类型。当函数的计算取决于特定单元格中的数值类型时，请使用 TYPE 函数。

  参数：
    `val` - 含任意值的单元格
  返回：
    TYPE 函数返回

          数字   1
          文本   2
          逻辑值 4
          错误值 16
          数值   64

    例子：

           如果单元格 A2 中含有文本“English”，则：
           Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
           Range range = sheet.getRange("A2");
           WorksheetFunction.type(range);

### upper

    public static java.lang.String upper(java.lang.String text)

  将文本中所有的字符转化为大写。

  参数：
    `text` - 需要转化为大写字符的文本

    例子：

          WorksheetFunction.upper("notes") 等于“NOTES”。

### value

    public static long value(java.lang.String text)

  将表示数值的文本转化为数字。

  参数：
    `text` - 需要转化的文本

    例子：

          WorksheetFunction.value("$400") 等于 400。

### var

    public static double var(Range range)

  计算基于给定样本的方差。

  参数：
    `range` - 单元格区域引用，如"a1:a2"
  返回：
    计算基于给定样本的方差

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range range = sheet.getRange("a1:a2");
         range.fillRandom(10, 20, 0);
         double value = WorksheetFunction.var(range);
         System.out.println("value is " + value);

### vara

    public static double vara(Range values)

  估算指定样本的方差。文本、逻辑值和数字将被计算在内。

  参数：
    `values` - 含数值的单元格区域

### varp

    public static double varp(Range range)

  计算基于整个样本总体的方差。

  参数：
    `range` - 单元格区域引用，如"a1:a2"
  返回：
    计算基于整个样本总体的方差

    例子：

         Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
         Range range = sheet.getRange("a1:a2");
         range.fillRandom(10, 20, 0);
         double value = WorksheetFunction.varp(range);
         System.out.println("value is " + value);

### varpa

    public static double varpa(Range values)

  计算样本总体的方差。文本值、逻辑值和数字也参与计算。

  参数：
    `values` - 含数值的单元格区域

### vdb

    public static double vdb(double cost,
                             double salvage,
                             double life,
                             double start_period,
                             double end_period,
                             double factor,
                             boolean no_switch)

  使用双倍余额递减法或其他指定的方法，返回指定的任何期间内（包括部分期间）的资产折旧值。函数 VDB 代表可变余额递减法。

  参数：
    `cost` - 为资产原值。
    `salvage` - 为资产在折旧期末的价值（也称为资产残值）。
    `life` - 为折旧期限（有时也称作资产的使用寿命）。
    `start_period` - 为进行折旧计算的起始期间，Start_period 必须与 life 的单位相同。
    `end_period` - 为进行折旧计算的截止期间，End_period 必须与 life 的单位相同。
    `factor` - 为余额递减速率（折旧因子）。
    `no_switch` - 布尔型值。为true，即使折旧值大于余额递减计算值，不使用直线折旧法；false表示当折旧值大于余额递减计算值时，使用线性折旧法。

    例子：

         double result = WorksheetFunction.vdb(10000, 100, 15, 4, 6, 3, true);
         System.out.println("result is " + result);

### vdb

    public static double vdb(double cost,
                             double salvage,
                             double life,
                             double startPeriod,
                             double endPeriod,
                             double factor,
                             double type)

  使用双倍余额递减法或其他指定的方法，返回指定的任何期间内（包括部分期间）的资产折旧值。函数 VDB 代表可变余额递减法。

  参数：
    `cost` - 为资产原值
    `salvage` - 为资产在折旧期末的价值（也称为资产残值）
    `life` - 为折旧期限（有时也称作资产的使用寿命）
    `startPeriod` - 为进行折旧计算的起始期间
    `endPeriod` - 为进行折旧计算的截止期间
    `factor` - 为余额递减速率（折旧因子）
    `type` - 数字 0 或 1， 0 表示当折旧值大于余额递减计算值时，转用直线折旧法； 1 表示当折旧值大于余额递减计算值时，不转用直线折旧法
  返回：
    指定的任何期间内（包括部分期间）的资产折旧值

    例子：

         double result = WorksheetFunction.vdb(10000, 100, 15, 4, 6, 3, 1);
         System.out.println("result is " + result);

### vlookup

    public static java.lang.String vlookup(Range lookup_value,
                                           Range table_array,
                                           int col_index_num,
                                           boolean range_lookup)

  在数值组成的表格或数组的首列获取指定值，并返回指定值所在行中某一指定列的数值。

  参数：
    `lookup_value` - 为在表格首行需要查找的值的单元格
    `table_array` - 包含所查找数据的单元格区域
    `col_index_num` - 返回的匹配值所在的 table_array 中列的列标，列标从1开始
    `range_lookup` - 一个决定函数 VLOOKUP 找到精确匹配或近似匹配的逻辑值。若 range_lookup 等于 TRUE 或省略，则函数返回近似匹配。 若 range_lookup 等于 FALSE，而且若存在精确匹配，则返回精确匹配； 若精确匹配值不存在，则函数返回错误值 *N/A。

    例子：

           //将下列表格中区域 A1:C6 命名为 Data：
           Range vRange = sheet.getRange("A3");
           Range tRange = sheet.getRange("A1:C6");
           WorksheetFunction.vlookup(vRange,tRange,3,true);

### vlookup

    public static java.lang.String vlookup(java.lang.String lookup_value,
                                           java.lang.String table_array,
                                           int col_index_num,
                                           boolean range_lookup)

  在数值组成的表格或数组的首列获取指定值，并返回指定值所在行中某一指定列的数值。

  参数：
    `lookup_value` - 为在表格首行需要查找的值,或需要查找的值的单元格地址
    `table_array` - 包含所查找数据的单元格地址
    `col_index_num` - 返回的匹配值所在的 table_array 中列的列标，列标从1开始
    `range_lookup` - 一个决定函数 VLOOKUP 找到精确匹配或近似匹配的逻辑值。若 range_lookup 等于 TRUE ，则函数返回近似匹配。 若 range_lookup 等于 FALSE，而且若存在精确匹配，则返回精确匹配； 若精确匹配值不存在，则函数返回错误值 *N/A。

    例子：

           WorksheetFunction.vlookup("A3","A1:C6",3,true)

### weekday

    public static int weekday(java.lang.String Serial_number,
                              int return_type)

  获取日期并返回星期数。永中集成Office 默认返回值为介于 1（星期日）到 7（星期六）之间的某一整数。

  参数：
    `Serial_number` - 一个代表日期的序列号
    `return_type` - 设置返回值的类型

    例子：

          WorksheetFunction.weekday("2000/7/31",2) 等于 1（星期日）。

### weeknum

    public static int weeknum(java.lang.String Serial_number,
                              int return_type)

  返回一个数字，该数字代表一年中的第几周。

  参数：
    `Serial_number` - 表示一周中的日期
    `return_type` - 为一数字，确定星期从哪一天开始计算，默认值为 1。若 return_type 为 1，则星期日为一周的第一天；若 return_type 为 2，则星期一为一周的第一天。

    例子：

          WorksheetFunction.weeknum("2000/10/1", 1) 等于 41。

### weibull

    public static double weibull(double x,
                                 double alpha,
                                 double beta,
                                 boolean cumulative)

  韦伯分布。使用此函数可以进行可靠性分析，比如计算设备的平均故障时间。

  参数：
    `x` - 参数值
    `alpha` - 分布参数
    `beta` - 分布参数
    `cumulative` - 为一逻辑值，指明函数的形式
  返回：
    韦伯分布

    例子：

         double value = WorksheetFunction.weibull(10, 1, 10, false);
         System.out.println("value is " + value);

### widechar

    public static java.lang.String widechar(java.lang.String text)

  将字符串中的单字节（半角）英文字母转换为双字节（全角）字符。该函数功能与 ASC 函数相反。

  参数：
    `text` - 文本

    例子：

          WorksheetFunction.widechar("Evermore") 等于“Ｅｖｅｒｍｏｒｅ”。

### workday

    public static long workday(java.lang.String start_date,
                               int days,
                               long[] holidays)

  返回某日期（起始日期）之前或之后相隔指定工作日的某一日期的序列号。工作日不包含周末和法定假日。

  参数：
    `start_date` - 指定时间段的开始日期
    `days` - 指开始日期前后不包括周末和节假日的天数
    `holidays` - 工作日历中需排除的法定节假日

    例子：

          long[] holidays = {36537,36538};
          WorksheetFunction.workday("2000/1/8",8,holidays) 等于 36546。

### xirr

    public static double xirr(double[] values,
                              java.lang.String[] dates,
                              double guess)

  返回一组不定期发生的现金流的内部收益率。如要计算一系列定期现金流的内部收益率，请使用函数 IRR。

  参数：
    `values` - 与支付时间相应的一系列现金流
    `dates` - 与现金流支付相应的支付日期表
    `guess` - 函数 XIRR 的估计值

    例子：

           假设某项投资要求在 1997 年 5 月 1 日支付现金 ￥10.000，并在 1997 年 10 月 1 日回收 ￥2,500，1998 年 5 月 1 日回收 ￥4,000，1998 年 10 月 1 日回收 ￥2,500，1999 年 3 月 1 日回收 ￥2,500，则该项投资的内部收益率为：
           WorksheetFunction.xirr(new double[]{-10000,2500,4000,3000,2500},new String[]{"1997/5/1","1997/10/1","1998/5/1","1998/10/1","1999/3/1"},0.1) 等于 0.173676 或者 17.3676%。

### xnpv

    public static double xnpv(double rate,
                              double[] values,
                              long[] dates)

  返回一组不定期发生的现金流的净现值。如要计算一组定期现金流的净现值，请使用函数 NPV。

  参数：
    `rate` - 为现金流的贴现率
    `values` - 与支付时间相对应的一系列现金流
    `dates` - 与现金流支付相应的支付日期表

    例子：

           假设某项投资要求在 1997 年 5 月 1 日支付现金 ￥10,000，并在 1997 年 10 月 1 日收回 ￥2,500，1998 年 5 月 1 日收回 ￥4,000，1998 年 10 月 1 日收回 ￥3,000，1999 年 3 月 1 日收回 ￥2,500，假设现金流的贴现率为 8.5%，则该项投资的净现值为：
           WorksheetFunction.xnpv(0.085,new double[]{-10000,2500,4000,3000,2500},new long[]{35551,35704,35916,36069,36220}) 等于 927.4025397 或 ￥927.40。

### year

    public static int year(double serial_number)

  返回某日期对应的年份，用整数 1899 和 9999 表示。

  参数：
    `serial_number` - 含有所求的年的日期

    例子：

          WorksheetFunction.year(36526.08) 等于 2000。

### year

    public static int year(long serial_number)

  返回某日期对应的年份，用整数 1899 和 9999 表示。

  参数：
    `serial_number` - 含有所求的年的日期

    例子：

          WorksheetFunction.year(37824) 等于 2003。

### year

    public static int year(java.lang.String serial_number)

  返回某日期对应的年份，用整数 1899 和 9999 表示。

  参数：
    `serial_number` - 含有所求的年的日期

    例子：

          WorksheetFunction.year("2006/05/05") 等于 2006。

### yearfrac

    public static double yearfrac(java.lang.String start_date,
                                  java.lang.String end_date,
                                  int basis)

  返回指定起止日期之间的天数占全年天数的百分比。

  参数：
    `start_date` - 开始日期
    `end_date` - 结束日期
    `basis` - 日计数基准类型

    例子：

          WorksheetFunction.yearfrac("2000/01/01","2000/6/30",0) 等于 0.497222222。

### yield

    public static double yield(java.lang.String settlement,
                               java.lang.String maturity,
                               double rate,
                               double pr,
                               double redemption,
                               double frequency,
                               int basis)

  返回按周期付息的有价证券的收益率，一般用于计算债券收益率。

  参数：
    `settlement` - 为证券的成交日，即证券发行后投资者购买证券的日期。
    `maturity` - 为有价证券的到期日，即证券有效期的截止日期。
    `rate` - 为有价证券在发行日的利率
    `pr` - 面值为 ￥100 的有价证券价格
    `redemption` - 面值为 ￥100 的有价证券的清偿价值
    `frequency` - 为每年的付息次数。如果每年付息一次，则 frequency=1；如果半年付息一次，则 frequency=2；如果一季度付息一次，则 frequency=4。
    `basis` - 为日计数基准类型。

    例子：

           某债券的交易情况如下：
           成交日：2000 年 3 月 15 日
           到期日：2006 年 11 月 15 日
           息票利率：6.75%
           价格：￥93.685
           清偿价格：￥100
           日计数基准：实际天数/实际天数
           该证券的收益率为：
           WorksheetFunction.yield("2000/3/15","2006/11/15",0.0675,93.685,100,1, 0) 等于 0.079971939 或 7.998%。

### yielddisc

    public static double yielddisc(java.lang.String settlement,
                                   java.lang.String maturity,
                                   double pr,
                                   double redemption,
                                   int basis)

  返回折价发行的有价证券的年收益率。

  参数：
    `settlement` - 为证券的成交日，即证券发行后投资者购买证券的日期。
    `maturity` - 为有价证券的到期日，即证券有效期的截止日期。
    `pr` - 面值为 ￥100 的有价证券价格
    `redemption` - 面值为 ￥100 的有价证券的清偿价值
    `basis` - 为日计数基准类型。

    例子：

           某债券的交易情况如下：
           成交日：2000 年 1 月 1 日
           到期日：2000 年 5 月 1 日
           价格：99.985
           清偿价值：￥100
           日计数基准：实际天数/360
           该证券的收益率为：
           WorksheetFunction.yielddisc("2000/1/1","2000/5/1",99.985,100,2) 等于 0.000446348 或 0.0446348%。

### yieldmat

    public static double yieldmat(java.lang.String settlement,
                                  java.lang.String maturity,
                                  java.lang.String issue,
                                  double rate,
                                  double pr,
                                  int basis)

  返回到期付息的有价证券的年收益率。

  参数：
    `settlement` - 为证券的成交日，即证券发行后投资者购买证券的日期。
    `maturity` - 为有价证券的到期日，即证券有效期的截止日期。
    `issue` - 为有价证券的发行日，以日期序列数表示。
    `rate` - 为有价证券在发行日的利率。
    `pr` - 面值为 ￥100 的有价证券价格
    `basis` - 为日计数基准类型。

    例子：

           某债券的交易情况如下：
           成交日：2000 年 3 月 20 日
           到期日：2000 年 12 月 8 日
           发行日：1999 年 11 月 8 日
           半年息票利率：6.75%
           每 ￥100 有价证券的清偿价格：100.0213
           日计数基准：30/360
           该证券的收益率为：
           WorksheetFunction.yieldmat("2000/3/20","2010/12/18","1999/11/18",0.0675,100.0213,0) 等于 0.065957352 或 6.5957352%。

### ztest

    public static double ztest(Range array,
                               double x)

  返回 Z 检验的单尾概率值。

  参数：
    `array` - 检验 x 的数组或数据区域
    `x` - 被检验的值

    例子：

           假设总体平均值为 4，以上数据集的 z 检验单尾概率值为：
           Worksheet sheet = Application.getWorkbooks().getActiveWorkbook().getWorksheets().getActiveWorksheet();
           Range range = sheet.getRange("A1:A10");
           WorksheetFunction.ztest(range,4) 等于 0.019916691

概述 | 软件包 | 类 | 树 | 索引 | 帮助

上一个类 下一个类 | 框架 无框架
摘要： 嵌套 | 字段 | 构造函数 | 方法 | 详细信息： 字段 | 构造函数 | 方法

版权所有 2001-2008 无锡永中科技有限公司