p71924506
/
excelize
forked from p30928647/excelize
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
excelize/calc_test.go

2815 lines
111 KiB
Go
Raw Normal View History

init formula calculation engine, ref #65 and #599
2020-05-03 18:44:43 +08:00
package excelize
import (
Fix #701, init new formula function AND and OR, prevent formula lexer panic on retrieving the top token type
2020-10-17 00:57:12 +08:00
"container/list"
fn: SUMIF
2020-05-30 23:21:02 +08:00
"path/filepath"
Fix #701, init new formula function AND and OR, prevent formula lexer panic on retrieving the top token type
2020-10-17 00:57:12 +08:00
"strings"
init formula calculation engine, ref #65 and #599
2020-05-03 18:44:43 +08:00
"testing"
"github.com/stretchr/testify/assert"
Fix #724, standardize variable naming and update unit tests
2020-11-10 23:48:09 +08:00
"github.com/xuri/efp"
init formula calculation engine, ref #65 and #599
2020-05-03 18:44:43 +08:00
)
binary search in range lookup and new formula function: LOOKUP
2021-02-13 00:07:52 +08:00
func prepareCalcData(cellData [][]interface{}) *File {
f := NewFile()
for r, row := range cellData {
for c, value := range row {
cell, _ := CoordinatesToCellName(c+1, r+1)
lint issue fixed and new formula function: ATAN, AVERAGE, AVERAGEA, CONCAT, CONCATENATE, COUNT, COUNTBLANK, MAX
2021-02-15 00:09:35 +08:00
_ = f.SetCellValue("Sheet1", cell, value)
binary search in range lookup and new formula function: LOOKUP
2021-02-13 00:07:52 +08:00
}
}
return f
}
init formula calculation engine, ref #65 and #599
2020-05-03 18:44:43 +08:00
func TestCalcCellValue(t *testing.T) {
fn: SUMIF
2020-05-30 23:21:02 +08:00
cellData := [][]interface{}{
{1, 4, nil, "Month", "Team", "Sales"},
{2, 5, nil, "Jan", "North 1", 36693},
{3, nil, nil, "Jan", "North 2", 22100},
{0, nil, nil, "Jan", "South 1", 53321},
{nil, nil, nil, "Jan", "South 2", 34440},
{nil, nil, nil, "Feb", "North 1", 29889},
{nil, nil, nil, "Feb", "North 2", 50090},
{nil, nil, nil, "Feb", "South 1", 32080},
{nil, nil, nil, "Feb", "South 2", 45500},
}
init formula calculation engine, ref #65 and #599
2020-05-03 18:44:43 +08:00
mathCalc := map[string]string{
This closes #858 (#859) * fixes https://github.com/360EntSecGroup-Skylar/excelize/issues/858 * fixes https://github.com/360EntSecGroup-Skylar/excelize/issues/858 Co-authored-by: dvelderp <peter.de.velder@gmail.com>
2021-06-08 19:02:34 +08:00
"=2^3": "8",
"=1=1": "TRUE",
"=1=2": "FALSE",
"=1<2": "TRUE",
"=3<2": "FALSE",
"=2<=3": "TRUE",
"=2<=1": "FALSE",
"=2>1": "TRUE",
"=2>3": "FALSE",
"=2>=1": "TRUE",
"=2>=3": "FALSE",
"=1&2": "12",
This closes #993, closes #1014 - Fix formula percentages calculated incorrectly - Make UpdateLinkedValue skip macro sheet - Fix conditional format bottom N not working
2021-09-06 00:01:42 +08:00
"=15%": "0.15",
"=1+20%": "1.2",
This closes #858 (#859) * fixes https://github.com/360EntSecGroup-Skylar/excelize/issues/858 * fixes https://github.com/360EntSecGroup-Skylar/excelize/issues/858 Co-authored-by: dvelderp <peter.de.velder@gmail.com>
2021-06-08 19:02:34 +08:00
`="A"="A"`: "TRUE",
`="A"<>"A"`: "FALSE",
#65 fn: DEC2BIN, DEC2HEX, DEC2OCT
2021-02-18 08:13:22 +08:00
// Engineering Functions
#65 fn: BESSELI and BESSELJ
2021-04-02 22:41:33 +08:00
// BESSELI
"=BESSELI(4.5,1)": "15.389222753735925",
"=BESSELI(32,1)": "5.502845511211247e+12",
// BESSELJ
"=BESSELJ(1.9,2)": "0.329925727692387",
#65 fn: BESSELK and BESSELY
2021-05-09 14:20:17 +08:00
// BESSELK
"=BESSELK(0.05,0)": "3.114234034289662",
"=BESSELK(0.05,1)": "19.90967432724863",
"=BESSELK(0.05,2)": "799.501207124235",
"=BESSELK(3,2)": "0.061510458561912",
// BESSELY
"=BESSELY(0.05,0)": "-1.979311006841528",
"=BESSELY(0.05,1)": "-12.789855163794034",
"=BESSELY(0.05,2)": "-509.61489554491976",
"=BESSELY(9,2)": "-0.229082087487741",
This closes #787, avoid duplicate rich text string items, new formula fn: BIN2DEC, BIN2HEX, BIN2OCT, HEX2BIN, HEX2DEC, HEX2OCT, OCT2BIN, OCT2DEC, OCT2HEX
2021-02-21 00:21:45 +08:00
// BIN2DEC
"=BIN2DEC(\"10\")": "2",
"=BIN2DEC(\"11\")": "3",
"=BIN2DEC(\"0000000010\")": "2",
"=BIN2DEC(\"1111111110\")": "-2",
"=BIN2DEC(\"110\")": "6",
// BIN2HEX
"=BIN2HEX(\"10\")": "2",
"=BIN2HEX(\"0000000001\")": "1",
"=BIN2HEX(\"10\",10)": "0000000002",
"=BIN2HEX(\"1111111110\")": "FFFFFFFFFE",
"=BIN2HEX(\"11101\")": "1D",
// BIN2OCT
"=BIN2OCT(\"101\")": "5",
"=BIN2OCT(\"0000000001\")": "1",
"=BIN2OCT(\"10\",10)": "0000000002",
"=BIN2OCT(\"1111111110\")": "7777777776",
"=BIN2OCT(\"1110\")": "16",
ref: #756, set cell as blank when SetCellValue with nil #756, new formula fn: BITAND, BITLSHIFT, BITOR, BITRSHIFT, BITXOR
2021-02-19 00:03:51 +08:00
// BITAND
"=BITAND(13,14)": "12",
// BITLSHIFT
"=BITLSHIFT(5,2)": "20",
"=BITLSHIFT(3,5)": "96",
// BITOR
"=BITOR(9,12)": "13",
// BITRSHIFT
"=BITRSHIFT(20,2)": "5",
"=BITRSHIFT(52,4)": "3",
// BITXOR
"=BITXOR(5,6)": "3",
"=BITXOR(9,12)": "5",
Fixed #813, streaming data writer result missing after call normal API #65 formula function: COMPLEX
2021-04-03 22:56:02 +08:00
// COMPLEX
"=COMPLEX(5,2)": "5+2i",
"=COMPLEX(5,-9)": "5-9i",
"=COMPLEX(-1,2,\"j\")": "-1+2j",
"=COMPLEX(10,-5,\"i\")": "10-5i",
"=COMPLEX(0,5)": "5i",
"=COMPLEX(3,0)": "3",
Go 1.15 and later required, #65 fn: IMABS, IMCOS, IMCOSH, IMCOT, IMCSC, IMCSCH, IMEXP, IMLN and IMLOG10
2021-04-04 15:29:43 +08:00
"=COMPLEX(0,-2)": "-2i",
"=COMPLEX(0,0)": "0",
"=COMPLEX(0,-1,\"j\")": "-j",
#65 fn: DEC2BIN, DEC2HEX, DEC2OCT
2021-02-18 08:13:22 +08:00
// DEC2BIN
"=DEC2BIN(2)": "10",
"=DEC2BIN(3)": "11",
"=DEC2BIN(2,10)": "0000000010",
"=DEC2BIN(-2)": "1111111110",
"=DEC2BIN(6)": "110",
// DEC2HEX
"=DEC2HEX(10)": "A",
"=DEC2HEX(31)": "1F",
"=DEC2HEX(16,10)": "0000000010",
"=DEC2HEX(-16)": "FFFFFFFFF0",
"=DEC2HEX(273)": "111",
// DEC2OCT
"=DEC2OCT(8)": "10",
"=DEC2OCT(18)": "22",
"=DEC2OCT(8,10)": "0000000010",
"=DEC2OCT(-8)": "7777777770",
"=DEC2OCT(237)": "355",
This closes #787, avoid duplicate rich text string items, new formula fn: BIN2DEC, BIN2HEX, BIN2OCT, HEX2BIN, HEX2DEC, HEX2OCT, OCT2BIN, OCT2DEC, OCT2HEX
2021-02-21 00:21:45 +08:00
// HEX2BIN
"=HEX2BIN(\"2\")": "10",
"=HEX2BIN(\"0000000001\")": "1",
"=HEX2BIN(\"2\",10)": "0000000010",
"=HEX2BIN(\"F0\")": "11110000",
"=HEX2BIN(\"1D\")": "11101",
// HEX2DEC
"=HEX2DEC(\"A\")": "10",
"=HEX2DEC(\"1F\")": "31",
"=HEX2DEC(\"0000000010\")": "16",
"=HEX2DEC(\"FFFFFFFFF0\")": "-16",
"=HEX2DEC(\"111\")": "273",
"=HEX2DEC(\"\")": "0",
// HEX2OCT
"=HEX2OCT(\"A\")": "12",
"=HEX2OCT(\"000000000F\")": "17",
"=HEX2OCT(\"8\",10)": "0000000010",
"=HEX2OCT(\"FFFFFFFFF8\")": "7777777770",
"=HEX2OCT(\"1F3\")": "763",
Go 1.15 and later required, #65 fn: IMABS, IMCOS, IMCOSH, IMCOT, IMCSC, IMCSCH, IMEXP, IMLN and IMLOG10
2021-04-04 15:29:43 +08:00
// IMABS
"=IMABS(\"2j\")": "2",
"=IMABS(\"-1+2i\")": "2.23606797749979",
"=IMABS(COMPLEX(-1,2,\"j\"))": "2.23606797749979",
Fixed #819, read empty after streaming data writing #65 fn: IMAGINARY, IMARGUMENT, IMCONJUGATE and IMDIV
2021-04-08 00:50:59 +08:00
// IMAGINARY
"=IMAGINARY(\"5+2i\")": "2",
"=IMAGINARY(\"2-i\")": "-1",
"=IMAGINARY(6)": "0",
"=IMAGINARY(\"3i\")": "3",
"=IMAGINARY(\"4+i\")": "1",
// IMARGUMENT
"=IMARGUMENT(\"5+2i\")": "0.380506377112365",
"=IMARGUMENT(\"2-i\")": "-0.463647609000806",
"=IMARGUMENT(6)": "0",
// IMCONJUGATE
"=IMCONJUGATE(\"5+2i\")": "5-2i",
"=IMCONJUGATE(\"2-i\")": "2+i",
"=IMCONJUGATE(6)": "6",
"=IMCONJUGATE(\"3i\")": "-3i",
"=IMCONJUGATE(\"4+i\")": "4-i",
Go 1.15 and later required, #65 fn: IMABS, IMCOS, IMCOSH, IMCOT, IMCSC, IMCSCH, IMEXP, IMLN and IMLOG10
2021-04-04 15:29:43 +08:00
// IMCOS
"=IMCOS(0)": "1",
"=IMCOS(0.5)": "0.877582561890373",
"=IMCOS(\"3+0.5i\")": "-1.1163412445261518-0.0735369737112366i",
// IMCOSH
"=IMCOSH(0.5)": "1.127625965206381",
"=IMCOSH(\"3+0.5i\")": "8.835204606500994+4.802825082743033i",
"=IMCOSH(\"2-i\")": "2.0327230070196656-3.0518977991518i",
"=IMCOSH(COMPLEX(1,-1))": "0.8337300251311491-0.9888977057628651i",
// IMCOT
"=IMCOT(0.5)": "1.830487721712452",
"=IMCOT(\"3+0.5i\")": "-0.4793455787473728-2.016092521506228i",
"=IMCOT(\"2-i\")": "-0.171383612909185+0.8213297974938518i",
"=IMCOT(COMPLEX(1,-1))": "0.21762156185440268+0.868014142895925i",
// IMCSC
"=IMCSC(\"j\")": "-0.8509181282393216i",
// IMCSCH
"=IMCSCH(COMPLEX(1,-1))": "0.30393100162842646+0.6215180171704284i",
Fixed #819, read empty after streaming data writing #65 fn: IMAGINARY, IMARGUMENT, IMCONJUGATE and IMDIV
2021-04-08 00:50:59 +08:00
// IMDIV
"=IMDIV(\"5+2i\",\"1+i\")": "3.5-1.5i",
"=IMDIV(\"2+2i\",\"2+i\")": "1.2+0.4i",
"=IMDIV(COMPLEX(5,2),COMPLEX(0,1))": "2-5i",
Go 1.15 and later required, #65 fn: IMABS, IMCOS, IMCOSH, IMCOT, IMCSC, IMCSCH, IMEXP, IMLN and IMLOG10
2021-04-04 15:29:43 +08:00
// IMEXP
"=IMEXP(0)": "1",
"=IMEXP(0.5)": "1.648721270700128",
"=IMEXP(\"1-2i\")": "-1.1312043837568135-2.4717266720048183i",
"=IMEXP(COMPLEX(1,-1))": "1.4686939399158851-2.2873552871788423i",
// IMLN
"=IMLN(0.5)": "-0.693147180559945",
"=IMLN(\"3+0.5i\")": "1.1123117757621668+0.16514867741462683i",
"=IMLN(\"2-i\")": "0.8047189562170503-0.4636476090008061i",
"=IMLN(COMPLEX(1,-1))": "0.3465735902799727-0.7853981633974483i",
// IMLOG10
"=IMLOG10(0.5)": "-0.301029995663981",
"=IMLOG10(\"3+0.5i\")": "0.48307086636951624+0.07172315929479262i",
"=IMLOG10(\"2-i\")": "0.34948500216800943-0.20135959813668655i",
"=IMLOG10(COMPLEX(1,-1))": "0.1505149978319906-0.3410940884604603i",
#65 fn: IMLOG2, IMPOWER, IMPRODUCT, IMREAL, IMSEC, and IMSECH
2021-04-07 00:01:03 +08:00
// IMREAL
"=IMREAL(\"5+2i\")": "5",
"=IMREAL(\"2+2i\")": "2",
"=IMREAL(6)": "6",
"=IMREAL(\"3i\")": "0",
"=IMREAL(COMPLEX(4,1))": "4",
// IMSEC
"=IMSEC(0.5)": "1.139493927324549",
"=IMSEC(\"3+0.5i\")": "-0.8919131797403304+0.05875317818173977i",
"=IMSEC(\"2-i\")": "-0.4131493442669401-0.687527438655479i",
"=IMSEC(COMPLEX(1,-1))": "0.49833703055518686-0.5910838417210451i",
// IMSECH
"=IMSECH(0.5)": "0.886818883970074",
"=IMSECH(\"3+0.5i\")": "0.08736657796213027-0.047492549490160664i",
"=IMSECH(\"2-i\")": "0.1511762982655772+0.22697367539372157i",
"=IMSECH(COMPLEX(1,-1))": "0.49833703055518686+0.5910838417210451i",
#65 fn: IMSIN, IMSINH, IMSQRT, IMSUB, IMSUM, IMTAN
2021-04-05 13:00:34 +08:00
// IMSIN
"=IMSIN(0.5)": "0.479425538604203",
"=IMSIN(\"3+0.5i\")": "0.15913058529843999-0.5158804424525267i",
"=IMSIN(\"2-i\")": "1.4031192506220405+0.4890562590412937i",
"=IMSIN(COMPLEX(1,-1))": "1.2984575814159773-0.6349639147847361i",
// IMSINH
"=IMSINH(-0)": "0",
"=IMSINH(0.5)": "0.521095305493747",
"=IMSINH(\"3+0.5i\")": "8.791512343493714+4.82669427481082i",
"=IMSINH(\"2-i\")": "1.9596010414216063-3.165778513216168i",
"=IMSINH(COMPLEX(1,-1))": "0.6349639147847361-1.2984575814159773i",
// IMSQRT
"=IMSQRT(\"i\")": "0.7071067811865476+0.7071067811865476i",
"=IMSQRT(\"2-i\")": "1.455346690225355-0.34356074972251244i",
"=IMSQRT(\"5+2i\")": "2.27872385417085+0.4388421169022545i",
"=IMSQRT(6)": "2.449489742783178",
"=IMSQRT(\"-2-4i\")": "1.1117859405028423-1.7989074399478673i",
// IMSUB
"=IMSUB(\"5+i\",\"1+4i\")": "4-3i",
"=IMSUB(\"9+2i\",6)": "3+2i",
"=IMSUB(COMPLEX(5,2),COMPLEX(0,1))": "5+i",
// IMSUM
"=IMSUM(\"1-i\",\"5+10i\",2)": "8+9i",
"=IMSUM(COMPLEX(5,2),COMPLEX(0,1))": "5+3i",
// IMTAN
"=IMTAN(-0)": "0",
"=IMTAN(0.5)": "0.546302489843791",
"=IMTAN(\"3+0.5i\")": "-0.11162105077158344+0.46946999342588536i",
"=IMTAN(\"2-i\")": "-0.24345820118572523-1.16673625724092i",
"=IMTAN(COMPLEX(1,-1))": "0.2717525853195117-1.0839233273386948i",
This closes #787, avoid duplicate rich text string items, new formula fn: BIN2DEC, BIN2HEX, BIN2OCT, HEX2BIN, HEX2DEC, HEX2OCT, OCT2BIN, OCT2DEC, OCT2HEX
2021-02-21 00:21:45 +08:00
// OCT2BIN
"=OCT2BIN(\"5\")": "101",
"=OCT2BIN(\"0000000001\")": "1",
"=OCT2BIN(\"2\",10)": "0000000010",
"=OCT2BIN(\"7777777770\")": "1111111000",
"=OCT2BIN(\"16\")": "1110",
// OCT2DEC
"=OCT2DEC(\"10\")": "8",
"=OCT2DEC(\"22\")": "18",
"=OCT2DEC(\"0000000010\")": "8",
"=OCT2DEC(\"7777777770\")": "-8",
"=OCT2DEC(\"355\")": "237",
// OCT2HEX
"=OCT2HEX(\"10\")": "8",
"=OCT2HEX(\"0000000007\")": "7",
"=OCT2HEX(\"10\",10)": "0000000008",
"=OCT2HEX(\"7777777770\")": "FFFFFFFFF8",
"=OCT2HEX(\"763\")": "1F3",
// Math and Trigonometric Functions
fn: ABS, GCD, LCM, POWER, PRODUCT, SIGN, SQRT, SUM, QUOTIENT
2020-05-04 13:40:04 +08:00
// ABS
Nested formula function support cell references as arguments
2021-01-31 01:28:40 +08:00
"=ABS(-1)": "1",
"=ABS(-6.5)": "6.5",
"=ABS(6.5)": "6.5",
"=ABS(0)": "0",
"=ABS(2-4.5)": "2.5",
"=ABS(ABS(-1))": "1",
fn: ACOS, ACOSH, ACOT, ACOTH, ARABIC, ASIN, ASINH, ATANH, ATAN2, BASE
2020-05-04 18:18:05 +08:00
// ACOS
Nested formula function support cell references as arguments
2021-01-31 01:28:40 +08:00
"=ACOS(-1)": "3.141592653589793",
"=ACOS(0)": "1.570796326794897",
"=ACOS(ABS(0))": "1.570796326794897",
fn: ACOS, ACOSH, ACOT, ACOTH, ARABIC, ASIN, ASINH, ATANH, ATAN2, BASE
2020-05-04 18:18:05 +08:00
// ACOSH
Nested formula function support cell references as arguments
2021-01-31 01:28:40 +08:00
"=ACOSH(1)": "0",
"=ACOSH(2.5)": "1.566799236972411",
"=ACOSH(5)": "2.292431669561178",
"=ACOSH(ACOSH(5))": "1.471383321536679",
fn: ACOS, ACOSH, ACOT, ACOTH, ARABIC, ASIN, ASINH, ATANH, ATAN2, BASE
2020-05-04 18:18:05 +08:00
// ACOT
Nested formula function support cell references as arguments
2021-01-31 01:28:40 +08:00
"=_xlfn.ACOT(1)": "0.785398163397448",
"=_xlfn.ACOT(-2)": "2.677945044588987",
"=_xlfn.ACOT(0)": "1.570796326794897",
"=_xlfn.ACOT(_xlfn.ACOT(0))": "0.566911504941009",
fn: ACOS, ACOSH, ACOT, ACOTH, ARABIC, ASIN, ASINH, ATANH, ATAN2, BASE
2020-05-04 18:18:05 +08:00
// ACOTH
Nested formula function support cell references as arguments
2021-01-31 01:28:40 +08:00
"=_xlfn.ACOTH(-5)": "-0.202732554054082",
"=_xlfn.ACOTH(1.1)": "1.522261218861711",
"=_xlfn.ACOTH(2)": "0.549306144334055",
"=_xlfn.ACOTH(ABS(-2))": "0.549306144334055",
fn: ACOS, ACOSH, ACOT, ACOTH, ARABIC, ASIN, ASINH, ATANH, ATAN2, BASE
2020-05-04 18:18:05 +08:00
// ARABIC
#65 fn: LARGE, SMALL, SUBSTITUTE, refactor ARABIC
2021-03-02 22:34:09 +08:00
"=_xlfn.ARABIC(\"IV\")": "4",
"=_xlfn.ARABIC(\"-IV\")": "-4",
"=_xlfn.ARABIC(\"MCXX\")": "1120",
"=_xlfn.ARABIC(\"\")": "0",
"=_xlfn.ARABIC(\" ll lc \")": "-50",
fn: ACOS, ACOSH, ACOT, ACOTH, ARABIC, ASIN, ASINH, ATANH, ATAN2, BASE
2020-05-04 18:18:05 +08:00
// ASIN
Nested formula function support cell references as arguments
2021-01-31 01:28:40 +08:00
"=ASIN(-1)": "-1.570796326794897",
"=ASIN(0)": "0",
"=ASIN(ASIN(0))": "0",
fn: ACOS, ACOSH, ACOT, ACOTH, ARABIC, ASIN, ASINH, ATANH, ATAN2, BASE
2020-05-04 18:18:05 +08:00
// ASINH
Nested formula function support cell references as arguments
2021-01-31 01:28:40 +08:00
"=ASINH(0)": "0",
"=ASINH(-0.5)": "-0.481211825059604",
"=ASINH(2)": "1.44363547517881",
"=ASINH(ASINH(0))": "0",
fn: ACOS, ACOSH, ACOT, ACOTH, ARABIC, ASIN, ASINH, ATANH, ATAN2, BASE
2020-05-04 18:18:05 +08:00
// ATAN
Nested formula function support cell references as arguments
2021-01-31 01:28:40 +08:00
"=ATAN(-1)": "-0.785398163397448",
"=ATAN(0)": "0",
"=ATAN(1)": "0.785398163397448",
"=ATAN(ATAN(0))": "0",
fn: ACOS, ACOSH, ACOT, ACOTH, ARABIC, ASIN, ASINH, ATANH, ATAN2, BASE
2020-05-04 18:18:05 +08:00
// ATANH
Nested formula function support cell references as arguments
2021-01-31 01:28:40 +08:00
"=ATANH(-0.8)": "-1.09861228866811",
"=ATANH(0)": "0",
"=ATANH(0.5)": "0.549306144334055",
"=ATANH(ATANH(0))": "0",
fn: ACOS, ACOSH, ACOT, ACOTH, ARABIC, ASIN, ASINH, ATANH, ATAN2, BASE
2020-05-04 18:18:05 +08:00
// ATAN2
Fix hyperbolic cotangent calculation incorrect and unit test
2021-01-31 13:15:10 +08:00
"=ATAN2(1,1)": "0.785398163397448",
"=ATAN2(1,-1)": "-0.785398163397448",
"=ATAN2(4,0)": "0",
"=ATAN2(4,ATAN2(4,0))": "0",
fn: ACOS, ACOSH, ACOT, ACOTH, ARABIC, ASIN, ASINH, ATANH, ATAN2, BASE
2020-05-04 18:18:05 +08:00
// BASE
Fix hyperbolic cotangent calculation incorrect and unit test
2021-01-31 13:15:10 +08:00
"=BASE(12,2)": "1100",
"=BASE(12,2,8)": "00001100",
"=BASE(100000,16)": "186A0",
"=BASE(BASE(12,2),16)": "44C",
fn: CEILING, CEILING.MATH
2020-05-04 21:22:11 +08:00
// CEILING
Fix hyperbolic cotangent calculation incorrect and unit test
2021-01-31 13:15:10 +08:00
"=CEILING(22.25,0.1)": "22.3",
"=CEILING(22.25,0.5)": "22.5",
"=CEILING(22.25,1)": "23",
"=CEILING(22.25,10)": "30",
"=CEILING(22.25,20)": "40",
"=CEILING(-22.25,-0.1)": "-22.3",
"=CEILING(-22.25,-1)": "-23",
"=CEILING(-22.25,-5)": "-25",
"=CEILING(22.25)": "23",
"=CEILING(CEILING(22.25,0.1),0.1)": "22.3",
fn: CEILING, CEILING.MATH
2020-05-04 21:22:11 +08:00
// _xlfn.CEILING.MATH
Fix hyperbolic cotangent calculation incorrect and unit test
2021-01-31 13:15:10 +08:00
"=_xlfn.CEILING.MATH(15.25,1)": "16",
"=_xlfn.CEILING.MATH(15.25,0.1)": "15.3",
"=_xlfn.CEILING.MATH(15.25,5)": "20",
"=_xlfn.CEILING.MATH(-15.25,1)": "-15",
"=_xlfn.CEILING.MATH(-15.25,1,1)": "-15", // should be 16
"=_xlfn.CEILING.MATH(-15.25,10)": "-10",
"=_xlfn.CEILING.MATH(-15.25)": "-15",
"=_xlfn.CEILING.MATH(-15.25,-5,-1)": "-10",
"=_xlfn.CEILING.MATH(_xlfn.CEILING.MATH(15.25,1),1)": "16",
#65 fn: CEILING.PRECISE, COMBIN, COMBINA, COS, COSH, COT, COTH, CSC
2020-05-05 17:27:19 +08:00
// _xlfn.CEILING.PRECISE
Fix hyperbolic cotangent calculation incorrect and unit test
2021-01-31 13:15:10 +08:00
"=_xlfn.CEILING.PRECISE(22.25,0.1)": "22.3",
"=_xlfn.CEILING.PRECISE(22.25,0.5)": "22.5",
"=_xlfn.CEILING.PRECISE(22.25,1)": "23",
"=_xlfn.CEILING.PRECISE(22.25)": "23",
"=_xlfn.CEILING.PRECISE(22.25,10)": "30",
"=_xlfn.CEILING.PRECISE(22.25,0)": "0",
"=_xlfn.CEILING.PRECISE(-22.25,1)": "-22",
"=_xlfn.CEILING.PRECISE(-22.25,-1)": "-22",
"=_xlfn.CEILING.PRECISE(-22.25,5)": "-20",
"=_xlfn.CEILING.PRECISE(_xlfn.CEILING.PRECISE(22.25,0.1),5)": "25",
#65 fn: CEILING.PRECISE, COMBIN, COMBINA, COS, COSH, COT, COTH, CSC
2020-05-05 17:27:19 +08:00
// COMBIN
Fix hyperbolic cotangent calculation incorrect and unit test
2021-01-31 13:15:10 +08:00
"=COMBIN(6,1)": "6",
"=COMBIN(6,2)": "15",
"=COMBIN(6,3)": "20",
"=COMBIN(6,4)": "15",
"=COMBIN(6,5)": "6",
"=COMBIN(6,6)": "1",
"=COMBIN(0,0)": "1",
"=COMBIN(6,COMBIN(0,0))": "6",
#65 fn: CEILING.PRECISE, COMBIN, COMBINA, COS, COSH, COT, COTH, CSC
2020-05-05 17:27:19 +08:00
// _xlfn.COMBINA
Fix hyperbolic cotangent calculation incorrect and unit test
2021-01-31 13:15:10 +08:00
"=_xlfn.COMBINA(6,1)": "6",
"=_xlfn.COMBINA(6,2)": "21",
"=_xlfn.COMBINA(6,3)": "56",
"=_xlfn.COMBINA(6,4)": "126",
"=_xlfn.COMBINA(6,5)": "252",
"=_xlfn.COMBINA(6,6)": "462",
"=_xlfn.COMBINA(0,0)": "0",
"=_xlfn.COMBINA(0,_xlfn.COMBINA(0,0))": "0",
#65 fn: CEILING.PRECISE, COMBIN, COMBINA, COS, COSH, COT, COTH, CSC
2020-05-05 17:27:19 +08:00
// COS
"=COS(0.785398163)": "0.707106781467586",
"=COS(0)": "1",
Fix hyperbolic cotangent calculation incorrect and unit test
2021-01-31 13:15:10 +08:00
"=COS(COS(0))": "0.54030230586814",
#65 fn: CEILING.PRECISE, COMBIN, COMBINA, COS, COSH, COT, COTH, CSC
2020-05-05 17:27:19 +08:00
// COSH
Fix hyperbolic cotangent calculation incorrect and unit test
2021-01-31 13:15:10 +08:00
"=COSH(0)": "1",
"=COSH(0.5)": "1.127625965206381",
"=COSH(-2)": "3.762195691083632",
"=COSH(COSH(0))": "1.543080634815244",
#65 fn: CEILING.PRECISE, COMBIN, COMBINA, COS, COSH, COT, COTH, CSC
2020-05-05 17:27:19 +08:00
// _xlfn.COT
Fix hyperbolic cotangent calculation incorrect and unit test
2021-01-31 13:15:10 +08:00
"=_xlfn.COT(0.785398163397448)": "1.000000000000001",
"=_xlfn.COT(_xlfn.COT(0.45))": "-0.545473116787229",
#65 fn: CEILING.PRECISE, COMBIN, COMBINA, COS, COSH, COT, COTH, CSC
2020-05-05 17:27:19 +08:00
// _xlfn.COTH
Fix hyperbolic cotangent calculation incorrect and unit test
2021-01-31 13:15:10 +08:00
"=_xlfn.COTH(-3.14159265358979)": "-1.003741873197322",
"=_xlfn.COTH(_xlfn.COTH(1))": "1.156014018113954",
#65 fn: CEILING.PRECISE, COMBIN, COMBINA, COS, COSH, COT, COTH, CSC
2020-05-05 17:27:19 +08:00
// _xlfn.CSC
Fixed #727, rounding numeric with precision for formula calculation
2020-11-19 21:38:35 +08:00
"=_xlfn.CSC(-6)": "3.578899547254406",
#65 fn: CSCH, DECIMAL, DEGREES, EVEN, EXP, FACT, FACTDOUBLE, FLOOR, FLOOR.MATH, FLOOR.PRECISE, INT, ISO.CEILING, LN, LOG, LOG10, MDETERM
2020-05-06 00:01:31 +08:00
"=_xlfn.CSC(1.5707963267949)": "1",
Fix hyperbolic cotangent calculation incorrect and unit test
2021-01-31 13:15:10 +08:00
"=_xlfn.CSC(_xlfn.CSC(1))": "1.077851840310882",
#65 fn: CSCH, DECIMAL, DEGREES, EVEN, EXP, FACT, FACTDOUBLE, FLOOR, FLOOR.MATH, FLOOR.PRECISE, INT, ISO.CEILING, LN, LOG, LOG10, MDETERM
2020-05-06 00:01:31 +08:00
// _xlfn.CSCH
Fixed #727, rounding numeric with precision for formula calculation
2020-11-19 21:38:35 +08:00
"=_xlfn.CSCH(-3.14159265358979)": "-0.086589537530047",
update formula functions test
2021-02-01 00:07:51 +08:00
"=_xlfn.CSCH(_xlfn.CSCH(1))": "1.044510103955183",
#65 fn: CSCH, DECIMAL, DEGREES, EVEN, EXP, FACT, FACTDOUBLE, FLOOR, FLOOR.MATH, FLOOR.PRECISE, INT, ISO.CEILING, LN, LOG, LOG10, MDETERM
2020-05-06 00:01:31 +08:00
// _xlfn.DECIMAL
updated test and go.mod
2020-05-11 00:01:22 +08:00
`=_xlfn.DECIMAL("1100",2)`: "12",
`=_xlfn.DECIMAL("186A0",16)`: "100000",
`=_xlfn.DECIMAL("31L0",32)`: "100000",
`=_xlfn.DECIMAL("70122",8)`: "28754",
`=_xlfn.DECIMAL("0x70122",8)`: "28754",
#65 fn: CSCH, DECIMAL, DEGREES, EVEN, EXP, FACT, FACTDOUBLE, FLOOR, FLOOR.MATH, FLOOR.PRECISE, INT, ISO.CEILING, LN, LOG, LOG10, MDETERM
2020-05-06 00:01:31 +08:00
// DEGREES
update formula functions test
2021-02-01 00:07:51 +08:00
"=DEGREES(1)": "57.29577951308232",
"=DEGREES(2.5)": "143.2394487827058",
"=DEGREES(DEGREES(1))": "3282.806350011744",
#65 fn: CSCH, DECIMAL, DEGREES, EVEN, EXP, FACT, FACTDOUBLE, FLOOR, FLOOR.MATH, FLOOR.PRECISE, INT, ISO.CEILING, LN, LOG, LOG10, MDETERM
2020-05-06 00:01:31 +08:00
// EVEN
"=EVEN(23)": "24",
"=EVEN(2.22)": "4",
"=EVEN(0)": "0",
"=EVEN(-0.3)": "-2",
"=EVEN(-11)": "-12",
"=EVEN(-4)": "-4",
update formula functions test
2021-02-01 00:07:51 +08:00
"=EVEN((0))": "0",
#65 fn: CSCH, DECIMAL, DEGREES, EVEN, EXP, FACT, FACTDOUBLE, FLOOR, FLOOR.MATH, FLOOR.PRECISE, INT, ISO.CEILING, LN, LOG, LOG10, MDETERM
2020-05-06 00:01:31 +08:00
// EXP
update formula functions test
2021-02-01 00:07:51 +08:00
"=EXP(100)": "2.6881171418161356E+43",
"=EXP(0.1)": "1.105170918075648",
"=EXP(0)": "1",
"=EXP(-5)": "0.006737946999085",
"=EXP(EXP(0))": "2.718281828459045",
#65 fn: CSCH, DECIMAL, DEGREES, EVEN, EXP, FACT, FACTDOUBLE, FLOOR, FLOOR.MATH, FLOOR.PRECISE, INT, ISO.CEILING, LN, LOG, LOG10, MDETERM
2020-05-06 00:01:31 +08:00
// FACT
update formula functions test
2021-02-01 00:07:51 +08:00
"=FACT(3)": "6",
"=FACT(6)": "720",
This closes #785, support to change tab color; new formula function: FISHER, FISHERINV, GAMMA, GAMMALN, MIN, MINA, PERMUT
2021-02-16 00:02:14 +08:00
"=FACT(10)": "3.6288e+06",
update formula functions test
2021-02-01 00:07:51 +08:00
"=FACT(FACT(3))": "720",
#65 fn: CSCH, DECIMAL, DEGREES, EVEN, EXP, FACT, FACTDOUBLE, FLOOR, FLOOR.MATH, FLOOR.PRECISE, INT, ISO.CEILING, LN, LOG, LOG10, MDETERM
2020-05-06 00:01:31 +08:00
// FACTDOUBLE
update formula functions test
2021-02-01 00:07:51 +08:00
"=FACTDOUBLE(5)": "15",
"=FACTDOUBLE(8)": "384",
"=FACTDOUBLE(13)": "135135",
"=FACTDOUBLE(FACTDOUBLE(1))": "1",
#65 fn: CSCH, DECIMAL, DEGREES, EVEN, EXP, FACT, FACTDOUBLE, FLOOR, FLOOR.MATH, FLOOR.PRECISE, INT, ISO.CEILING, LN, LOG, LOG10, MDETERM
2020-05-06 00:01:31 +08:00
// FLOOR
update formula functions test
2021-02-01 00:07:51 +08:00
"=FLOOR(26.75,0.1)": "26.700000000000003",
"=FLOOR(26.75,0.5)": "26.5",
"=FLOOR(26.75,1)": "26",
"=FLOOR(26.75,10)": "20",
"=FLOOR(26.75,20)": "20",
"=FLOOR(-26.75,-0.1)": "-26.700000000000003",
"=FLOOR(-26.75,-1)": "-26",
"=FLOOR(-26.75,-5)": "-25",
"=FLOOR(FLOOR(26.75,1),1)": "26",
#65 fn: CSCH, DECIMAL, DEGREES, EVEN, EXP, FACT, FACTDOUBLE, FLOOR, FLOOR.MATH, FLOOR.PRECISE, INT, ISO.CEILING, LN, LOG, LOG10, MDETERM
2020-05-06 00:01:31 +08:00
// _xlfn.FLOOR.MATH
update formula functions test
2021-02-01 00:07:51 +08:00
"=_xlfn.FLOOR.MATH(58.55)": "58",
"=_xlfn.FLOOR.MATH(58.55,0.1)": "58.5",
"=_xlfn.FLOOR.MATH(58.55,5)": "55",
"=_xlfn.FLOOR.MATH(58.55,1,1)": "58",
"=_xlfn.FLOOR.MATH(-58.55,1)": "-59",
"=_xlfn.FLOOR.MATH(-58.55,1,-1)": "-58",
"=_xlfn.FLOOR.MATH(-58.55,1,1)": "-59", // should be -58
"=_xlfn.FLOOR.MATH(-58.55,10)": "-60",
"=_xlfn.FLOOR.MATH(_xlfn.FLOOR.MATH(1),10)": "0",
#65 fn: CSCH, DECIMAL, DEGREES, EVEN, EXP, FACT, FACTDOUBLE, FLOOR, FLOOR.MATH, FLOOR.PRECISE, INT, ISO.CEILING, LN, LOG, LOG10, MDETERM
2020-05-06 00:01:31 +08:00
// _xlfn.FLOOR.PRECISE
update formula functions test
2021-02-01 00:07:51 +08:00
"=_xlfn.FLOOR.PRECISE(26.75,0.1)": "26.700000000000003",
"=_xlfn.FLOOR.PRECISE(26.75,0.5)": "26.5",
"=_xlfn.FLOOR.PRECISE(26.75,1)": "26",
"=_xlfn.FLOOR.PRECISE(26.75)": "26",
"=_xlfn.FLOOR.PRECISE(26.75,10)": "20",
"=_xlfn.FLOOR.PRECISE(26.75,0)": "0",
"=_xlfn.FLOOR.PRECISE(-26.75,1)": "-27",
"=_xlfn.FLOOR.PRECISE(-26.75,-1)": "-27",
"=_xlfn.FLOOR.PRECISE(-26.75,-5)": "-30",
"=_xlfn.FLOOR.PRECISE(_xlfn.FLOOR.PRECISE(26.75),-5)": "25",
fn: ABS, GCD, LCM, POWER, PRODUCT, SIGN, SQRT, SUM, QUOTIENT
2020-05-04 13:40:04 +08:00
// GCD
updated test and go.mod
2020-05-11 00:01:22 +08:00
"=GCD(0)": "0",
"=GCD(1,0)": "1",
fn: ABS, GCD, LCM, POWER, PRODUCT, SIGN, SQRT, SUM, QUOTIENT
2020-05-04 13:40:04 +08:00
"=GCD(1,5)": "1",
"=GCD(15,10,25)": "5",
"=GCD(0,8,12)": "4",
"=GCD(7,2)": "1",
update formula functions test
2021-02-01 00:07:51 +08:00
"=GCD(1,GCD(1))": "1",
#65 fn: CSCH, DECIMAL, DEGREES, EVEN, EXP, FACT, FACTDOUBLE, FLOOR, FLOOR.MATH, FLOOR.PRECISE, INT, ISO.CEILING, LN, LOG, LOG10, MDETERM
2020-05-06 00:01:31 +08:00
// INT
"=INT(100.9)": "100",
"=INT(5.22)": "5",
"=INT(5.99)": "5",
"=INT(-6.1)": "-7",
"=INT(-100.9)": "-101",
update formula functions test
2021-02-01 00:07:51 +08:00
"=INT(INT(0))": "0",
#65 fn: CSCH, DECIMAL, DEGREES, EVEN, EXP, FACT, FACTDOUBLE, FLOOR, FLOOR.MATH, FLOOR.PRECISE, INT, ISO.CEILING, LN, LOG, LOG10, MDETERM
2020-05-06 00:01:31 +08:00
// ISO.CEILING
update formula functions test
2021-02-01 00:07:51 +08:00
"=ISO.CEILING(22.25)": "23",
"=ISO.CEILING(22.25,1)": "23",
"=ISO.CEILING(22.25,0.1)": "22.3",
"=ISO.CEILING(22.25,10)": "30",
"=ISO.CEILING(-22.25,1)": "-22",
"=ISO.CEILING(-22.25,0.1)": "-22.200000000000003",
"=ISO.CEILING(-22.25,5)": "-20",
"=ISO.CEILING(-22.25,0)": "0",
"=ISO.CEILING(1,ISO.CEILING(1,0))": "0",
fn: ABS, GCD, LCM, POWER, PRODUCT, SIGN, SQRT, SUM, QUOTIENT
2020-05-04 13:40:04 +08:00
// LCM
update formula functions test
2021-02-01 00:07:51 +08:00
"=LCM(1,5)": "5",
"=LCM(15,10,25)": "150",
"=LCM(1,8,12)": "24",
"=LCM(7,2)": "14",
"=LCM(7)": "7",
`=LCM("",1)`: "1",
`=LCM(0,0)`: "0",
`=LCM(0,LCM(0,0))`: "0",
#65 fn: CSCH, DECIMAL, DEGREES, EVEN, EXP, FACT, FACTDOUBLE, FLOOR, FLOOR.MATH, FLOOR.PRECISE, INT, ISO.CEILING, LN, LOG, LOG10, MDETERM
2020-05-06 00:01:31 +08:00
// LN
update formula functions test
2021-02-01 00:07:51 +08:00
"=LN(1)": "0",
"=LN(100)": "4.605170185988092",
"=LN(0.5)": "-0.693147180559945",
"=LN(LN(100))": "1.527179625807901",
#65 fn: CSCH, DECIMAL, DEGREES, EVEN, EXP, FACT, FACTDOUBLE, FLOOR, FLOOR.MATH, FLOOR.PRECISE, INT, ISO.CEILING, LN, LOG, LOG10, MDETERM
2020-05-06 00:01:31 +08:00
// LOG
update formula functions test
2021-02-01 00:07:51 +08:00
"=LOG(64,2)": "6",
"=LOG(100)": "2",
"=LOG(4,0.5)": "-2",
"=LOG(500)": "2.698970004336019",
"=LOG(LOG(100))": "0.301029995663981",
#65 fn: CSCH, DECIMAL, DEGREES, EVEN, EXP, FACT, FACTDOUBLE, FLOOR, FLOOR.MATH, FLOOR.PRECISE, INT, ISO.CEILING, LN, LOG, LOG10, MDETERM
2020-05-06 00:01:31 +08:00
// LOG10
update formula functions test
2021-02-01 00:07:51 +08:00
"=LOG10(100)": "2",
"=LOG10(1000)": "3",
"=LOG10(0.001)": "-3",
"=LOG10(25)": "1.397940008672038",
"=LOG10(LOG10(100))": "0.301029995663981",
#65 fn: IMLOG2, IMPOWER, IMPRODUCT, IMREAL, IMSEC, and IMSECH
2021-04-07 00:01:03 +08:00
// IMLOG2
"=IMLOG2(\"5+2i\")": "2.4289904975637864+0.5489546632866347i",
"=IMLOG2(\"2-i\")": "1.1609640474436813-0.6689021062254881i",
"=IMLOG2(6)": "2.584962500721156",
"=IMLOG2(\"3i\")": "1.584962500721156+2.266180070913597i",
"=IMLOG2(\"4+i\")": "2.04373142062517+0.3534295024167349i",
// IMPOWER
"=IMPOWER(\"2-i\",2)": "3.000000000000001-4i",
"=IMPOWER(\"2-i\",3)": "2.0000000000000018-11.000000000000002i",
"=IMPOWER(9,0.5)": "3",
"=IMPOWER(\"2+4i\",-2)": "-0.029999999999999985-0.039999999999999994i",
// IMPRODUCT
"=IMPRODUCT(3,6)": "18",
`=IMPRODUCT("",3,SUM(6))`: "18",
"=IMPRODUCT(\"1-i\",\"5+10i\",2)": "30+10i",
"=IMPRODUCT(COMPLEX(5,2),COMPLEX(0,1))": "-2+5i",
"=IMPRODUCT(A1:C1)": "4",
#65 fn: MOD, MROUND, MULTINOMIAL, MUNIT, ODD, PI, RADIANS, RAND, RANDBETWEEN, ROMAN
2020-05-07 00:15:54 +08:00
// MOD
update formula functions test
2021-02-01 00:07:51 +08:00
"=MOD(6,4)": "2",
"=MOD(6,3)": "0",
"=MOD(6,2.5)": "1",
"=MOD(6,1.333)": "0.668",
"=MOD(-10.23,1)": "0.77",
"=MOD(MOD(1,1),1)": "0",
#65 fn: MOD, MROUND, MULTINOMIAL, MUNIT, ODD, PI, RADIANS, RAND, RANDBETWEEN, ROMAN
2020-05-07 00:15:54 +08:00
// MROUND
update formula functions test
2021-02-01 00:07:51 +08:00
"=MROUND(333.7,0.5)": "333.5",
"=MROUND(333.8,1)": "334",
"=MROUND(333.3,2)": "334",
"=MROUND(555.3,400)": "400",
"=MROUND(555,1000)": "1000",
"=MROUND(-555.7,-1)": "-556",
"=MROUND(-555.4,-1)": "-555",
"=MROUND(-1555,-1000)": "-2000",
"=MROUND(MROUND(1,1),1)": "1",
#65 fn: MOD, MROUND, MULTINOMIAL, MUNIT, ODD, PI, RADIANS, RAND, RANDBETWEEN, ROMAN
2020-05-07 00:15:54 +08:00
// MULTINOMIAL
update formula functions test
2021-02-01 00:07:51 +08:00
"=MULTINOMIAL(3,1,2,5)": "27720",
`=MULTINOMIAL("",3,1,2,5)`: "27720",
"=MULTINOMIAL(MULTINOMIAL(1))": "1",
#65 fn: MOD, MROUND, MULTINOMIAL, MUNIT, ODD, PI, RADIANS, RAND, RANDBETWEEN, ROMAN
2020-05-07 00:15:54 +08:00
// _xlfn.MUNIT
Nested formula function support cell references as arguments
2021-01-31 01:28:40 +08:00
"=_xlfn.MUNIT(4)": "",
#65 fn: MOD, MROUND, MULTINOMIAL, MUNIT, ODD, PI, RADIANS, RAND, RANDBETWEEN, ROMAN
2020-05-07 00:15:54 +08:00
// ODD
"=ODD(22)": "23",
"=ODD(1.22)": "3",
"=ODD(1.22+4)": "7",
"=ODD(0)": "1",
"=ODD(-1.3)": "-3",
"=ODD(-10)": "-11",
"=ODD(-3)": "-3",
update formula functions test
2021-02-01 00:07:51 +08:00
"=ODD(ODD(1))": "1",
#65 fn: MOD, MROUND, MULTINOMIAL, MUNIT, ODD, PI, RADIANS, RAND, RANDBETWEEN, ROMAN
2020-05-07 00:15:54 +08:00
// PI
"=PI()": "3.141592653589793",
fn: ABS, GCD, LCM, POWER, PRODUCT, SIGN, SQRT, SUM, QUOTIENT
2020-05-04 13:40:04 +08:00
// POWER
update formula functions test
2021-02-01 00:07:51 +08:00
"=POWER(4,2)": "16",
"=POWER(4,POWER(1,1))": "4",
fn: ABS, GCD, LCM, POWER, PRODUCT, SIGN, SQRT, SUM, QUOTIENT
2020-05-04 13:40:04 +08:00
// PRODUCT
update formula functions test
2021-02-01 00:07:51 +08:00
"=PRODUCT(3,6)": "18",
`=PRODUCT("",3,6)`: "18",
`=PRODUCT(PRODUCT(1),3,6)`: "18",
#65 fn: MOD, MROUND, MULTINOMIAL, MUNIT, ODD, PI, RADIANS, RAND, RANDBETWEEN, ROMAN
2020-05-07 00:15:54 +08:00
// QUOTIENT
update formula functions test
2021-02-01 00:07:51 +08:00
"=QUOTIENT(5,2)": "2",
"=QUOTIENT(4.5,3.1)": "1",
"=QUOTIENT(-10,3)": "-3",
"=QUOTIENT(QUOTIENT(1,2),3)": "0",
#65 fn: MOD, MROUND, MULTINOMIAL, MUNIT, ODD, PI, RADIANS, RAND, RANDBETWEEN, ROMAN
2020-05-07 00:15:54 +08:00
// RADIANS
update formula functions test
2021-02-01 00:07:51 +08:00
"=RADIANS(50)": "0.872664625997165",
"=RADIANS(-180)": "-3.141592653589793",
"=RADIANS(180)": "3.141592653589793",
"=RADIANS(360)": "6.283185307179586",
"=RADIANS(RADIANS(360))": "0.109662271123215",
#65 fn: MOD, MROUND, MULTINOMIAL, MUNIT, ODD, PI, RADIANS, RAND, RANDBETWEEN, ROMAN
2020-05-07 00:15:54 +08:00
// ROMAN
update formula functions test
2021-02-01 00:07:51 +08:00
"=ROMAN(499,0)": "CDXCIX",
"=ROMAN(1999,0)": "MCMXCIX",
"=ROMAN(1999,1)": "MLMVLIV",
"=ROMAN(1999,2)": "MXMIX",
"=ROMAN(1999,3)": "MVMIV",
"=ROMAN(1999,4)": "MIM",
"=ROMAN(1999,-1)": "MCMXCIX",
"=ROMAN(1999,5)": "MIM",
"=ROMAN(1999,ODD(1))": "MLMVLIV",
#65, fn: ROUND, ROUNDDOWN, ROUNDUP, SEC, SECH, SIN, SINH, SQRTPI, TAN, TANH, TRUNC
2020-05-08 00:31:17 +08:00
// ROUND
update formula functions test
2021-02-01 00:07:51 +08:00
"=ROUND(100.319,1)": "100.30000000000001",
"=ROUND(5.28,1)": "5.300000000000001",
"=ROUND(5.9999,3)": "6.000000000000002",
"=ROUND(99.5,0)": "100",
"=ROUND(-6.3,0)": "-6",
"=ROUND(-100.5,0)": "-101",
"=ROUND(-22.45,1)": "-22.5",
"=ROUND(999,-1)": "1000",
"=ROUND(991,-1)": "990",
"=ROUND(ROUND(100,1),-1)": "100",
#65, fn: ROUND, ROUNDDOWN, ROUNDUP, SEC, SECH, SIN, SINH, SQRTPI, TAN, TANH, TRUNC
2020-05-08 00:31:17 +08:00
// ROUNDDOWN
update formula functions test
2021-02-01 00:07:51 +08:00
"=ROUNDDOWN(99.999,1)": "99.9",
"=ROUNDDOWN(99.999,2)": "99.99000000000002",
"=ROUNDDOWN(99.999,0)": "99",
"=ROUNDDOWN(99.999,-1)": "90",
"=ROUNDDOWN(-99.999,2)": "-99.99000000000002",
"=ROUNDDOWN(-99.999,-1)": "-90",
"=ROUNDDOWN(ROUNDDOWN(100,1),-1)": "100",
new formula fn: IF, LEN; not equal operator support and faster numeric precision process
2021-01-27 13:51:47 +08:00
// ROUNDUP`
update formula functions test
2021-02-01 00:07:51 +08:00
"=ROUNDUP(11.111,1)": "11.200000000000001",
"=ROUNDUP(11.111,2)": "11.120000000000003",
"=ROUNDUP(11.111,0)": "12",
"=ROUNDUP(11.111,-1)": "20",
"=ROUNDUP(-11.111,2)": "-11.120000000000003",
"=ROUNDUP(-11.111,-1)": "-20",
"=ROUNDUP(ROUNDUP(100,1),-1)": "100",
#65, fn: ROUND, ROUNDDOWN, ROUNDUP, SEC, SECH, SIN, SINH, SQRTPI, TAN, TANH, TRUNC
2020-05-08 00:31:17 +08:00
// SEC
"=_xlfn.SEC(-3.14159265358979)": "-1",
"=_xlfn.SEC(0)": "1",
update formula functions test
2021-02-01 00:07:51 +08:00
"=_xlfn.SEC(_xlfn.SEC(0))": "0.54030230586814",
#65, fn: ROUND, ROUNDDOWN, ROUNDUP, SEC, SECH, SIN, SINH, SQRTPI, TAN, TANH, TRUNC
2020-05-08 00:31:17 +08:00
// SECH
Fixed #727, rounding numeric with precision for formula calculation
2020-11-19 21:38:35 +08:00
"=_xlfn.SECH(-3.14159265358979)": "0.086266738334055",
#65, fn: ROUND, ROUNDDOWN, ROUNDUP, SEC, SECH, SIN, SINH, SQRTPI, TAN, TANH, TRUNC
2020-05-08 00:31:17 +08:00
"=_xlfn.SECH(0)": "1",
update formula functions test
2021-02-01 00:07:51 +08:00
"=_xlfn.SECH(_xlfn.SECH(0))": "0.648054273663886",
fn: ABS, GCD, LCM, POWER, PRODUCT, SIGN, SQRT, SUM, QUOTIENT
2020-05-04 13:40:04 +08:00
// SIGN
"=SIGN(9.5)": "1",
"=SIGN(-9.5)": "-1",
"=SIGN(0)": "0",
"=SIGN(0.00000001)": "1",
"=SIGN(6-7)": "-1",
update formula functions test
2021-02-01 00:07:51 +08:00
"=SIGN(SIGN(-1))": "-1",
#65, fn: ROUND, ROUNDDOWN, ROUNDUP, SEC, SECH, SIN, SINH, SQRTPI, TAN, TANH, TRUNC
2020-05-08 00:31:17 +08:00
// SIN
Fixed #727, rounding numeric with precision for formula calculation
2020-11-19 21:38:35 +08:00
"=SIN(0.785398163)": "0.707106780905509",
update formula functions test
2021-02-01 00:07:51 +08:00
"=SIN(SIN(1))": "0.745624141665558",
#65, fn: ROUND, ROUNDDOWN, ROUNDUP, SEC, SECH, SIN, SINH, SQRTPI, TAN, TANH, TRUNC
2020-05-08 00:31:17 +08:00
// SINH
update formula functions test
2021-02-01 00:07:51 +08:00
"=SINH(0)": "0",
"=SINH(0.5)": "0.521095305493747",
"=SINH(-2)": "-3.626860407847019",
"=SINH(SINH(0))": "0",
fn: ABS, GCD, LCM, POWER, PRODUCT, SIGN, SQRT, SUM, QUOTIENT
2020-05-04 13:40:04 +08:00
// SQRT
update formula functions test
2021-02-01 00:07:51 +08:00
"=SQRT(4)": "2",
"=SQRT(SQRT(16))": "2",
#65, fn: ROUND, ROUNDDOWN, ROUNDUP, SEC, SECH, SIN, SINH, SQRTPI, TAN, TANH, TRUNC
2020-05-08 00:31:17 +08:00
// SQRTPI
update formula functions test
2021-02-01 00:07:51 +08:00
"=SQRTPI(5)": "3.963327297606011",
"=SQRTPI(0.2)": "0.792665459521202",
"=SQRTPI(100)": "17.72453850905516",
"=SQRTPI(0)": "0",
"=SQRTPI(SQRTPI(0))": "0",
#65 fn: KURT, STDEV, STDEVA
2021-02-17 00:51:06 +08:00
// STDEV
"=STDEV(F2:F9)": "10724.978287523809",
"=STDEV(MUNIT(2))": "0.577350269189626",
"=STDEV(0,INT(0))": "0",
"=STDEV(INT(1),INT(1))": "0",
#65, new fn: POISSON.DIST, POISSON, SKEW, and STDEV.S
2021-03-26 00:17:29 +08:00
// STDEV.S
"=STDEV.S(F2:F9)": "10724.978287523809",
#65 fn: KURT, STDEV, STDEVA
2021-02-17 00:51:06 +08:00
// STDEVA
"=STDEVA(F2:F9)": "10724.978287523809",
"=STDEVA(MUNIT(2))": "0.577350269189626",
"=STDEVA(0,INT(0))": "0",
#65, new fn: POISSON.DIST, POISSON, SKEW, and STDEV.S
2021-03-26 00:17:29 +08:00
// POISSON.DIST
"=POISSON.DIST(20,25,FALSE)": "0.051917468608491",
"=POISSON.DIST(35,40,TRUE)": "0.242414197690103",
// POISSON
"=POISSON(20,25,FALSE)": "0.051917468608491",
"=POISSON(35,40,TRUE)": "0.242414197690103",
fn: ABS, GCD, LCM, POWER, PRODUCT, SIGN, SQRT, SUM, QUOTIENT
2020-05-04 13:40:04 +08:00
// SUM
init formula calculation engine, ref #65 and #599
2020-05-03 18:44:43 +08:00
"=SUM(1,2)": "3",
updated test and go.mod
2020-05-11 00:01:22 +08:00
`=SUM("",1,2)`: "3",
init formula calculation engine, ref #65 and #599
2020-05-03 18:44:43 +08:00
"=SUM(1,2+3)": "6",
"=SUM(SUM(1,2),2)": "5",
"=(-2-SUM(-4+7))*5": "-25",
"SUM(1,2,3,4,5,6,7)": "28",
"=SUM(1,2)+SUM(1,2)": "6",
"=1+SUM(SUM(1,2*3),4)": "12",
"=1+SUM(SUM(1,-2*3),4)": "0",
"=(-2-SUM(-4*(7+7)))*5": "270",
"=SUM(SUM(1+2/1)*2-3/2,2)": "6.5",
"=((3+5*2)+3)/5+(-6)/4*2+3": "3.2",
"=1+SUM(SUM(1,2*3),4)*-4/2+5+(4+2)*3": "2",
"=1+SUM(SUM(1,2*3),4)*4/3+5+(4+2)*3": "38.666666666666664",
fn: SUMIF
2020-05-30 23:21:02 +08:00
// SUMIF
- Resolve #711, update docs for the GetSheetIndex - Update unit test
2020-10-12 00:05:27 +08:00
`=SUMIF(F1:F5, "")`: "0",
`=SUMIF(A1:A5, "3")`: "3",
`=SUMIF(F1:F5, "=36693")`: "36693",
`=SUMIF(F1:F5, "<100")`: "0",
`=SUMIF(F1:F5, "<=36693")`: "93233",
fn: SUMIF
2020-05-30 23:21:02 +08:00
`=SUMIF(F1:F5, ">100")`: "146554",
- Resolve #711, update docs for the GetSheetIndex - Update unit test
2020-10-12 00:05:27 +08:00
`=SUMIF(F1:F5, ">=100")`: "146554",
`=SUMIF(F1:F5, ">=text")`: "0",
`=SUMIF(F1:F5, "*Jan",F2:F5)`: "0",
fn: SUMIF
2020-05-30 23:21:02 +08:00
`=SUMIF(D3:D7,"Jan",F2:F5)`: "112114",
`=SUMIF(D2:D9,"Feb",F2:F9)`: "157559",
`=SUMIF(E2:E9,"North 1",F2:F9)`: "66582",
`=SUMIF(E2:E9,"North*",F2:F9)`: "138772",
- fn: SUMSQ - resolve ineffectual assignment - handle exception with invalid formula - update range resolver
2020-05-09 00:32:36 +08:00
// SUMSQ
updated test and go.mod
2020-05-11 00:01:22 +08:00
"=SUMSQ(A1:A4)": "14",
"=SUMSQ(A1,B1,A2,B2,6)": "82",
`=SUMSQ("",A1,B1,A2,B2,6)`: "82",
update formula functions test
2021-02-01 00:07:51 +08:00
`=SUMSQ(1,SUMSQ(1))`: "2",
init new formula function: HLOOKUP
2021-02-09 00:12:53 +08:00
"=SUMSQ(MUNIT(3))": "0",
#65, fn: ROUND, ROUNDDOWN, ROUNDUP, SEC, SECH, SIN, SINH, SQRTPI, TAN, TANH, TRUNC
2020-05-08 00:31:17 +08:00
// TAN
"=TAN(1.047197551)": "1.732050806782486",
"=TAN(0)": "0",
update formula functions test
2021-02-01 00:07:51 +08:00
"=TAN(TAN(0))": "0",
#65, fn: ROUND, ROUNDDOWN, ROUNDUP, SEC, SECH, SIN, SINH, SQRTPI, TAN, TANH, TRUNC
2020-05-08 00:31:17 +08:00
// TANH
update formula functions test
2021-02-01 00:07:51 +08:00
"=TANH(0)": "0",
"=TANH(0.5)": "0.46211715726001",
"=TANH(-2)": "-0.964027580075817",
"=TANH(TANH(0))": "0",
#65, fn: ROUND, ROUNDDOWN, ROUNDUP, SEC, SECH, SIN, SINH, SQRTPI, TAN, TANH, TRUNC
2020-05-08 00:31:17 +08:00
// TRUNC
update formula functions test
2021-02-01 00:07:51 +08:00
"=TRUNC(99.999,1)": "99.9",
"=TRUNC(99.999,2)": "99.99",
"=TRUNC(99.999)": "99",
"=TRUNC(99.999,-1)": "90",
"=TRUNC(-99.999,2)": "-99.99",
"=TRUNC(-99.999,-1)": "-90",
"=TRUNC(TRUNC(1),-1)": "0",
New formula function AND (#701) and update doc for the NewSheet (#714)
2020-10-22 08:29:25 +08:00
// Statistical Functions
lint issue fixed and new formula function: ATAN, AVERAGE, AVERAGEA, CONCAT, CONCATENATE, COUNT, COUNTBLANK, MAX
2021-02-15 00:09:35 +08:00
// AVERAGE
"=AVERAGE(INT(1))": "1",
"=AVERAGE(A1)": "1",
"=AVERAGE(A1:A2)": "1.5",
"=AVERAGE(D2:F9)": "38014.125",
// AVERAGEA
"=AVERAGEA(INT(1))": "1",
"=AVERAGEA(A1)": "1",
"=AVERAGEA(A1:A2)": "1.5",
"=AVERAGEA(D2:F9)": "12671.375",
// COUNT
"=COUNT()": "0",
"=COUNT(E1:F2,\"text\",1,INT(2))": "3",
fn: COUNTA
2020-06-04 00:35:54 +08:00
// COUNTA
lint issue fixed and new formula function: ATAN, AVERAGE, AVERAGEA, CONCAT, CONCATENATE, COUNT, COUNTBLANK, MAX
2021-02-15 00:09:35 +08:00
"=COUNTA()": "0",
"=COUNTA(A1:A5,B2:B5,\"text\",1,INT(2))": "8",
"=COUNTA(COUNTA(1),MUNIT(1))": "2",
// COUNTBLANK
"=COUNTBLANK(MUNIT(1))": "0",
"=COUNTBLANK(1)": "0",
"=COUNTBLANK(B1:C1)": "1",
"=COUNTBLANK(C1)": "1",
This closes #785, support to change tab color; new formula function: FISHER, FISHERINV, GAMMA, GAMMALN, MIN, MINA, PERMUT
2021-02-16 00:02:14 +08:00
// FISHER
"=FISHER(-0.9)": "-1.47221948958322",
"=FISHER(-0.25)": "-0.255412811882995",
"=FISHER(0.8)": "1.09861228866811",
"=FISHER(INT(0))": "0",
// FISHERINV
"=FISHERINV(-0.2)": "-0.197375320224904",
"=FISHERINV(INT(0))": "0",
"=FISHERINV(2.8)": "0.992631520201128",
// GAMMA
"=GAMMA(0.1)": "9.513507698668732",
"=GAMMA(INT(1))": "1",
"=GAMMA(1.5)": "0.886226925452758",
"=GAMMA(5.5)": "52.34277778455352",
// GAMMALN
"=GAMMALN(4.5)": "2.453736570842443",
"=GAMMALN(INT(1))": "0",
This closes #809, and add new fn: HARMEAN
2021-03-25 00:05:02 +08:00
// HARMEAN
"=HARMEAN(2.5,3,0.5,1,3)": "1.229508196721312",
"=HARMEAN(\"2.5\",3,0.5,1,INT(3),\"\")": "1.229508196721312",
#65 fn: KURT, STDEV, STDEVA
2021-02-17 00:51:06 +08:00
// KURT
"=KURT(F1:F9)": "-1.033503502551368",
"=KURT(F1,F2:F9)": "-1.033503502551368",
"=KURT(INT(1),MUNIT(2))": "-3.333333333333336",
#64 fn: NORM.DIST, NORMDIST, NORM.INV, NORMINV, NORM.S.DIST, NORMSDIST, NORM.S.INV, and NORMSINV
2021-03-24 08:24:59 +08:00
// NORM.DIST
"=NORM.DIST(0.8,1,0.3,TRUE)": "0.252492537546923",
"=NORM.DIST(50,40,20,FALSE)": "0.017603266338215",
// NORMDIST
"=NORMDIST(0.8,1,0.3,TRUE)": "0.252492537546923",
"=NORMDIST(50,40,20,FALSE)": "0.017603266338215",
// NORM.INV
"=NORM.INV(0.6,5,2)": "5.506694205719997",
// NORMINV
"=NORMINV(0.6,5,2)": "5.506694205719997",
"=NORMINV(0.99,40,1.5)": "43.489521811582044",
"=NORMINV(0.02,40,1.5)": "36.91937663649545",
// NORM.S.DIST
"=NORM.S.DIST(0.8,TRUE)": "0.788144601416603",
// NORMSDIST
"=NORMSDIST(1.333333)": "0.908788725604095",
"=NORMSDIST(0)": "0.5",
// NORM.S.INV
"=NORM.S.INV(0.25)": "-0.674489750223423",
// NORMSINV
"=NORMSINV(0.25)": "-0.674489750223423",
#65 fn: LARGE, SMALL, SUBSTITUTE, refactor ARABIC
2021-03-02 22:34:09 +08:00
// LARGE
"=LARGE(A1:A5,1)": "3",
"=LARGE(A1:B5,2)": "4",
"=LARGE(A1,1)": "1",
"=LARGE(A1:F2,1)": "36693",
lint issue fixed and new formula function: ATAN, AVERAGE, AVERAGEA, CONCAT, CONCATENATE, COUNT, COUNTBLANK, MAX
2021-02-15 00:09:35 +08:00
// MAX
"=MAX(1)": "1",
"=MAX(TRUE())": "1",
"=MAX(0.5,TRUE())": "1",
"=MAX(FALSE())": "0",
"=MAX(MUNIT(2))": "1",
"=MAX(INT(1))": "1",
// MAXA
"=MAXA(1)": "1",
"=MAXA(TRUE())": "1",
"=MAXA(0.5,TRUE())": "1",
"=MAXA(FALSE())": "0",
"=MAXA(MUNIT(2))": "1",
"=MAXA(INT(1))": "1",
"=MAXA(A1:B4,MUNIT(1),INT(0),1,E1:F2,\"\")": "36693",
fn: MEDIAN, ISNUMBER
2020-06-02 23:39:41 +08:00
// MEDIAN
update formula functions test
2021-02-01 00:07:51 +08:00
"=MEDIAN(A1:A5,12)": "2",
"=MEDIAN(A1:A5)": "1.5",
"=MEDIAN(A1:A5,MEDIAN(A1:A5,12))": "2",
This closes #785, support to change tab color; new formula function: FISHER, FISHERINV, GAMMA, GAMMALN, MIN, MINA, PERMUT
2021-02-16 00:02:14 +08:00
// MIN
"=MIN(1)": "1",
"=MIN(TRUE())": "1",
"=MIN(0.5,FALSE())": "0",
"=MIN(FALSE())": "0",
"=MIN(MUNIT(2))": "0",
"=MIN(INT(1))": "1",
// MINA
"=MINA(1)": "1",
"=MINA(TRUE())": "1",
"=MINA(0.5,FALSE())": "0",
"=MINA(FALSE())": "0",
"=MINA(MUNIT(2))": "0",
"=MINA(INT(1))": "1",
"=MINA(A1:B4,MUNIT(1),INT(0),1,E1:F2,\"\")": "0",
#65 fn: N, PERCENTILE.INC and T typo fixed
2021-03-30 23:02:22 +08:00
// PERCENTILE.INC
"=PERCENTILE.INC(A1:A4,0.2)": "0.6",
#65 fn: PERCENTILE and PERMUTATIONA
2021-03-27 00:08:55 +08:00
// PERCENTILE
"=PERCENTILE(A1:A4,0.2)": "0.6",
"=PERCENTILE(0,0)": "0",
This closes #785, support to change tab color; new formula function: FISHER, FISHERINV, GAMMA, GAMMALN, MIN, MINA, PERMUT
2021-02-16 00:02:14 +08:00
// PERMUT
"=PERMUT(6,6)": "720",
"=PERMUT(7,6)": "5040",
"=PERMUT(10,6)": "151200",
#65 fn: PERCENTILE and PERMUTATIONA
2021-03-27 00:08:55 +08:00
// PERMUTATIONA
"=PERMUTATIONA(6,6)": "46656",
"=PERMUTATIONA(7,6)": "117649",
#65 fn: QUARTILE and QUARTILE.INC
2021-03-31 22:01:02 +08:00
// QUARTILE
"=QUARTILE(A1:A4,2)": "1.5",
// QUARTILE.INC
"=QUARTILE.INC(A1:A4,0)": "0",
#65, new fn: POISSON.DIST, POISSON, SKEW, and STDEV.S
2021-03-26 00:17:29 +08:00
// SKEW
"=SKEW(1,2,3,4,3)": "-0.404796008910937",
"=SKEW(A1:B2)": "0",
"=SKEW(A1:D3)": "0",
#65 fn: LARGE, SMALL, SUBSTITUTE, refactor ARABIC
2021-03-02 22:34:09 +08:00
// SMALL
"=SMALL(A1:A5,1)": "0",
"=SMALL(A1:B5,2)": "1",
"=SMALL(A1,1)": "1",
"=SMALL(A1:F2,1)": "1",
#65 fn: VAR.P and VARP and fix Yoda conditions issue
2021-04-01 21:52:43 +08:00
// VARP
"=VARP(A1:A5)": "1.25",
// VAR.P
"=VAR.P(A1:A5)": "1.25",
new formula functions: WEIBULL and WEIBULL.DIST, ref #65
2021-09-14 22:23:12 +08:00
// WEIBULL
"=WEIBULL(1,3,1,FALSE)": "1.103638323514327",
"=WEIBULL(2,5,1.5,TRUE)": "0.985212776817482",
// WEIBULL.DIST
"=WEIBULL.DIST(1,3,1,FALSE)": "1.103638323514327",
"=WEIBULL.DIST(2,5,1.5,TRUE)": "0.985212776817482",
New formula function AND (#701) and update doc for the NewSheet (#714)
2020-10-22 08:29:25 +08:00
// Information Functions
fn: ISBLANK, ISERR, ISERROR, ISEVEN, ISNA, ISNONTEXT, ISODD, NA
2020-05-31 15:13:52 +08:00
// ISBLANK
"=ISBLANK(A1)": "FALSE",
"=ISBLANK(A5)": "TRUE",
// ISERR
lint issue fixed and new formula function: ATAN, AVERAGE, AVERAGEA, CONCAT, CONCATENATE, COUNT, COUNTBLANK, MAX
2021-02-15 00:09:35 +08:00
"=ISERR(A1)": "FALSE",
"=ISERR(NA())": "FALSE",
"=ISERR(POWER(0,-1)))": "TRUE",
fn: ISBLANK, ISERR, ISERROR, ISEVEN, ISNA, ISNONTEXT, ISODD, NA
2020-05-31 15:13:52 +08:00
// ISERROR
"=ISERROR(A1)": "FALSE",
"=ISERROR(NA())": "TRUE",
// ISEVEN
"=ISEVEN(A1)": "FALSE",
"=ISEVEN(A2)": "TRUE",
// ISNA
"=ISNA(A1)": "FALSE",
"=ISNA(NA())": "TRUE",
// ISNONTEXT
"=ISNONTEXT(A1)": "FALSE",
"=ISNONTEXT(A5)": "TRUE",
`=ISNONTEXT("Excelize")`: "FALSE",
lint issue fixed and new formula function: ATAN, AVERAGE, AVERAGEA, CONCAT, CONCATENATE, COUNT, COUNTBLANK, MAX
2021-02-15 00:09:35 +08:00
"=ISNONTEXT(NA())": "TRUE",
fn: MEDIAN, ISNUMBER
2020-06-02 23:39:41 +08:00
// ISNUMBER
"=ISNUMBER(A1)": "TRUE",
"=ISNUMBER(D1)": "FALSE",
fn: ISBLANK, ISERR, ISERROR, ISEVEN, ISNA, ISNONTEXT, ISODD, NA
2020-05-31 15:13:52 +08:00
// ISODD
"=ISODD(A1)": "TRUE",
"=ISODD(A2)": "FALSE",
add ten formula functions: ENCODEURL, EXACT, FALSE, IFERROR, ISTEXT, LENB, NOT, REPT, SHEET, TRUE
2021-02-14 00:02:29 +08:00
// ISTEXT
"=ISTEXT(D1)": "TRUE",
"=ISTEXT(A1)": "FALSE",
#65 fn: N, PERCENTILE.INC and T typo fixed
2021-03-30 23:02:22 +08:00
// N
"=N(10)": "10",
"=N(\"10\")": "10",
"=N(\"x\")": "0",
"=N(TRUE)": "1",
"=N(FALSE)": "0",
add ten formula functions: ENCODEURL, EXACT, FALSE, IFERROR, ISTEXT, LENB, NOT, REPT, SHEET, TRUE
2021-02-14 00:02:29 +08:00
// SHEET
#65 fn: N, PERCENTILE.INC and T typo fixed
2021-03-30 23:02:22 +08:00
"=SHEET()": "1",
// T
"=T(\"text\")": "text",
"=T(N(10))": "",
New formula function AND (#701) and update doc for the NewSheet (#714)
2020-10-22 08:29:25 +08:00
// Logical Functions
Fix #701, init new formula function AND and OR, prevent formula lexer panic on retrieving the top token type
2020-10-17 00:57:12 +08:00
// AND
"=AND(0)": "FALSE",
"=AND(1)": "TRUE",
"=AND(1,0)": "FALSE",
"=AND(0,1)": "FALSE",
"=AND(1=1)": "TRUE",
"=AND(1<2)": "TRUE",
"=AND(1>2,2<3,2>0,3>1)": "FALSE",
"=AND(1=1),1=1": "TRUE",
add ten formula functions: ENCODEURL, EXACT, FALSE, IFERROR, ISTEXT, LENB, NOT, REPT, SHEET, TRUE
2021-02-14 00:02:29 +08:00
// FALSE
"=FALSE()": "FALSE",
// IFERROR
"=IFERROR(1/2,0)": "0.5",
"=IFERROR(ISERROR(),0)": "0",
"=IFERROR(1/0,0)": "0",
// NOT
"=NOT(FALSE())": "TRUE",
"=NOT(\"false\")": "TRUE",
"=NOT(\"true\")": "FALSE",
"=NOT(ISBLANK(B1))": "TRUE",
Fix #701, init new formula function AND and OR, prevent formula lexer panic on retrieving the top token type
2020-10-17 00:57:12 +08:00
// OR
"=OR(1)": "TRUE",
"=OR(0)": "FALSE",
"=OR(1=2,2=2)": "TRUE",
"=OR(1=2,2=3)": "FALSE",
add ten formula functions: ENCODEURL, EXACT, FALSE, IFERROR, ISTEXT, LENB, NOT, REPT, SHEET, TRUE
2021-02-14 00:02:29 +08:00
// TRUE
"=TRUE()": "TRUE",
This closes #1008, added new formula functions MATCH and XOR, related issue #65
2021-08-29 00:03:44 +08:00
// XOR
"=XOR(1>0,2>0)": "FALSE",
"=XOR(1>0,0>1)": "TRUE",
"=XOR(1>0,0>1,INT(0),INT(1),A1:A4,2)": "FALSE",
New formula function AND (#701) and update doc for the NewSheet (#714)
2020-10-22 08:29:25 +08:00
// Date and Time Functions
// DATE
"=DATE(2020,10,21)": "2020-10-21 00:00:00 +0000 UTC",
"=DATE(1900,1,1)": "1899-12-31 00:00:00 +0000 UTC",
#65 fn: DATEDIF
2021-03-19 23:23:05 +08:00
// DATEDIF
"=DATEDIF(43101,43101,\"D\")": "0",
"=DATEDIF(43101,43891,\"d\")": "790",
"=DATEDIF(43101,43891,\"Y\")": "2",
"=DATEDIF(42156,44242,\"y\")": "5",
"=DATEDIF(43101,43891,\"M\")": "26",
"=DATEDIF(42171,44242,\"m\")": "67",
"=DATEDIF(42156,44454,\"MD\")": "14",
"=DATEDIF(42171,44242,\"md\")": "30",
"=DATEDIF(43101,43891,\"YM\")": "2",
"=DATEDIF(42171,44242,\"ym\")": "7",
"=DATEDIF(43101,43891,\"YD\")": "59",
"=DATEDIF(36526,73110,\"YD\")": "60",
"=DATEDIF(42171,44242,\"yd\")": "244",
This closes #1002, new fn: DAY ref #65 Co-authored-by: Stani Michiels <git@rchtct.com> Co-authored-by: xuri <xuri.me@gmail.com>
2021-08-21 11:50:49 +08:00
// DAY
"=DAY(0)": "0",
"=DAY(INT(7))": "7",
"=DAY(\"35\")": "4",
"=DAY(42171)": "16",
"=DAY(\"2-28-1900\")": "28",
"=DAY(\"31-May-2015\")": "31",
"=DAY(\"01/03/2019 12:14:16\")": "3",
"=DAY(\"January 25, 2020 01 AM\")": "25",
"=DAY(\"January 25, 2020 01:03 AM\")": "25",
"=DAY(\"January 25, 2020 12:00:00 AM\")": "25",
"=DAY(\"1900-1-1\")": "1",
"=DAY(\"12-1-1900\")": "1",
"=DAY(\"3-January-1900\")": "3",
"=DAY(\"3-February-2000\")": "3",
"=DAY(\"3-February-2008\")": "3",
"=DAY(\"01/25/20\")": "25",
"=DAY(\"01/25/31\")": "25",
* This closes #1004, new fn: MONTH ref #65
2021-08-21 15:46:43 +08:00
// MONTH
"=MONTH(42171)": "6",
"=MONTH(\"31-May-2015\")": "5",
This closes #1006, new fn: MONTH ref #65 Co-authored-by: xuri <xuri.me@gmail.com>
2021-08-21 20:15:53 +08:00
// YEAR
"=YEAR(15)": "1900",
"=YEAR(\"15\")": "1900",
"=YEAR(2048)": "1905",
"=YEAR(42171)": "2015",
"=YEAR(\"29-May-2015\")": "2015",
"=YEAR(\"05/03/1984\")": "1984",
new formula func CLEAN and TRIM, change import path to v2 (#747)
2020-12-14 09:56:42 +08:00
// Text Functions
This improves compatibility for absolute XML path, Windows-style directory separator and inline namespace;
2021-02-27 00:03:46 +08:00
// CHAR
"=CHAR(65)": "A",
"=CHAR(97)": "a",
"=CHAR(63)": "?",
"=CHAR(51)": "3",
new formula func CLEAN and TRIM, change import path to v2 (#747)
2020-12-14 09:56:42 +08:00
// CLEAN
"=CLEAN(\"\u0009clean text\")": "clean text",
"=CLEAN(0)": "0",
handle default underline type on get rich text; #65 fn: CODE, COLUMN, FIND, FINDB
2021-02-24 00:37:44 +08:00
// CODE
"=CODE(\"Alpha\")": "65",
"=CODE(\"alpha\")": "97",
"=CODE(\"?\")": "63",
"=CODE(\"3\")": "51",
"=CODE(\"\")": "0",
lint issue fixed and new formula function: ATAN, AVERAGE, AVERAGEA, CONCAT, CONCATENATE, COUNT, COUNTBLANK, MAX
2021-02-15 00:09:35 +08:00
// CONCAT
"=CONCAT(TRUE(),1,FALSE(),\"0\",INT(2))": "TRUE1FALSE02",
// CONCATENATE
"=CONCATENATE(TRUE(),1,FALSE(),\"0\",INT(2))": "TRUE1FALSE02",
add ten formula functions: ENCODEURL, EXACT, FALSE, IFERROR, ISTEXT, LENB, NOT, REPT, SHEET, TRUE
2021-02-14 00:02:29 +08:00
// EXACT
"=EXACT(1,\"1\")": "TRUE",
"=EXACT(1,1)": "TRUE",
"=EXACT(\"A\",\"a\")": "FALSE",
related issue #65 fn: FIXED
2021-03-21 23:45:36 +08:00
// FIXED
"=FIXED(5123.591)": "5,123.591",
"=FIXED(5123.591,1)": "5,123.6",
"=FIXED(5123.591,0)": "5,124",
"=FIXED(5123.591,-1)": "5,120",
"=FIXED(5123.591,-2)": "5,100",
"=FIXED(5123.591,-3,TRUE)": "5000",
"=FIXED(5123.591,-5)": "0",
"=FIXED(-77262.23973,-5)": "-100,000",
handle default underline type on get rich text; #65 fn: CODE, COLUMN, FIND, FINDB
2021-02-24 00:37:44 +08:00
// FIND
"=FIND(\"T\",\"Original Text\")": "10",
"=FIND(\"t\",\"Original Text\")": "13",
"=FIND(\"i\",\"Original Text\")": "3",
"=FIND(\"i\",\"Original Text\",4)": "5",
"=FIND(\"\",\"Original Text\")": "1",
"=FIND(\"\",\"Original Text\",2)": "2",
// FINDB
"=FINDB(\"T\",\"Original Text\")": "10",
"=FINDB(\"t\",\"Original Text\")": "13",
"=FINDB(\"i\",\"Original Text\")": "3",
"=FINDB(\"i\",\"Original Text\",4)": "5",
"=FINDB(\"\",\"Original Text\")": "1",
"=FINDB(\"\",\"Original Text\",2)": "2",
check empty rich text run properties; new formula fn: LEFT, LEFTB, RIGHT, RIGHTB
2021-02-23 00:05:19 +08:00
// LEFT
"=LEFT(\"Original Text\")": "O",
"=LEFT(\"Original Text\",4)": "Orig",
"=LEFT(\"Original Text\",0)": "",
"=LEFT(\"Original Text\",13)": "Original Text",
"=LEFT(\"Original Text\",20)": "Original Text",
// LEFTB
"=LEFTB(\"Original Text\")": "O",
"=LEFTB(\"Original Text\",4)": "Orig",
"=LEFTB(\"Original Text\",0)": "",
"=LEFTB(\"Original Text\",13)": "Original Text",
"=LEFTB(\"Original Text\",20)": "Original Text",
new formula fn: IF, LEN; not equal operator support and faster numeric precision process
2021-01-27 13:51:47 +08:00
// LEN
"=LEN(\"\")": "0",
"=LEN(D1)": "5",
add ten formula functions: ENCODEURL, EXACT, FALSE, IFERROR, ISTEXT, LENB, NOT, REPT, SHEET, TRUE
2021-02-14 00:02:29 +08:00
// LENB
"=LENB(\"\")": "0",
"=LENB(D1)": "5",
This closes #752, fix incorrectly merged cells on duplicate row, and new formula function: LOWER, PROPER, UPPER
2020-12-22 08:47:46 +08:00
// LOWER
"=LOWER(\"test\")": "test",
"=LOWER(\"TEST\")": "test",
"=LOWER(\"Test\")": "test",
"=LOWER(\"TEST 123\")": "test 123",
This improves compatibility for absolute XML path, Windows-style directory separator and inline namespace;
2021-02-27 00:03:46 +08:00
// MID
"=MID(\"Original Text\",7,1)": "a",
"=MID(\"Original Text\",4,7)": "ginal T",
"=MID(\"255 years\",3,1)": "5",
"=MID(\"text\",3,6)": "xt",
"=MID(\"text\",6,0)": "",
// MIDB
"=MIDB(\"Original Text\",7,1)": "a",
"=MIDB(\"Original Text\",4,7)": "ginal T",
"=MIDB(\"255 years\",3,1)": "5",
"=MIDB(\"text\",3,6)": "xt",
"=MIDB(\"text\",6,0)": "",
This closes #752, fix incorrectly merged cells on duplicate row, and new formula function: LOWER, PROPER, UPPER
2020-12-22 08:47:46 +08:00
// PROPER
"=PROPER(\"this is a test sentence\")": "This Is A Test Sentence",
"=PROPER(\"THIS IS A TEST SENTENCE\")": "This Is A Test Sentence",
"=PROPER(\"123tEST teXT\")": "123Test Text",
"=PROPER(\"Mr. SMITH's address\")": "Mr. Smith'S Address",
This improves compatibility for absolute XML path, Windows-style directory separator and inline namespace;
2021-02-27 00:03:46 +08:00
// REPLACE
"=REPLACE(\"test string\",7,3,\"X\")": "test sXng",
"=REPLACE(\"second test string\",8,4,\"XXX\")": "second XXX string",
"=REPLACE(\"text\",5,0,\" and char\")": "text and char",
"=REPLACE(\"text\",1,20,\"char and \")": "char and ",
// REPLACEB
"=REPLACEB(\"test string\",7,3,\"X\")": "test sXng",
"=REPLACEB(\"second test string\",8,4,\"XXX\")": "second XXX string",
"=REPLACEB(\"text\",5,0,\" and char\")": "text and char",
"=REPLACEB(\"text\",1,20,\"char and \")": "char and ",
add ten formula functions: ENCODEURL, EXACT, FALSE, IFERROR, ISTEXT, LENB, NOT, REPT, SHEET, TRUE
2021-02-14 00:02:29 +08:00
// REPT
"=REPT(\"*\",0)": "",
"=REPT(\"*\",1)": "*",
"=REPT(\"**\",2)": "****",
check empty rich text run properties; new formula fn: LEFT, LEFTB, RIGHT, RIGHTB
2021-02-23 00:05:19 +08:00
// RIGHT
"=RIGHT(\"Original Text\")": "t",
"=RIGHT(\"Original Text\",4)": "Text",
"=RIGHT(\"Original Text\",0)": "",
"=RIGHT(\"Original Text\",13)": "Original Text",
"=RIGHT(\"Original Text\",20)": "Original Text",
// RIGHTB
"=RIGHTB(\"Original Text\")": "t",
"=RIGHTB(\"Original Text\",4)": "Text",
"=RIGHTB(\"Original Text\",0)": "",
"=RIGHTB(\"Original Text\",13)": "Original Text",
"=RIGHTB(\"Original Text\",20)": "Original Text",
#65 fn: LARGE, SMALL, SUBSTITUTE, refactor ARABIC
2021-03-02 22:34:09 +08:00
// SUBSTITUTE
"=SUBSTITUTE(\"abab\",\"a\",\"X\")": "XbXb",
"=SUBSTITUTE(\"abab\",\"a\",\"X\",2)": "abXb",
"=SUBSTITUTE(\"abab\",\"x\",\"X\",2)": "abab",
"=SUBSTITUTE(\"John is 5 years old\",\"John\",\"Jack\")": "Jack is 5 years old",
"=SUBSTITUTE(\"John is 5 years old\",\"5\",\"6\")": "John is 6 years old",
This improves compatibility for absolute XML path, Windows-style directory separator and inline namespace;
2021-02-27 00:03:46 +08:00
// TRIM
"=TRIM(\" trim text \")": "trim text",
"=TRIM(0)": "0",
// UNICHAR
"=UNICHAR(65)": "A",
"=UNICHAR(97)": "a",
"=UNICHAR(63)": "?",
"=UNICHAR(51)": "3",
// UNICODE
"=UNICODE(\"Alpha\")": "65",
"=UNICODE(\"alpha\")": "97",
"=UNICODE(\"?\")": "63",
"=UNICODE(\"3\")": "51",
This closes #752, fix incorrectly merged cells on duplicate row, and new formula function: LOWER, PROPER, UPPER
2020-12-22 08:47:46 +08:00
// UPPER
"=UPPER(\"test\")": "TEST",
"=UPPER(\"TEST\")": "TEST",
"=UPPER(\"Test\")": "TEST",
"=UPPER(\"TEST 123\")": "TEST 123",
new formula fn: IF, LEN; not equal operator support and faster numeric precision process
2021-01-27 13:51:47 +08:00
// Conditional Functions
// IF
"=IF(1=1)": "TRUE",
"=IF(1<>1)": "FALSE",
"=IF(5<0, \"negative\", \"positive\")": "positive",
"=IF(-2<0, \"negative\", \"positive\")": "negative",
This closes #858 (#859) * fixes https://github.com/360EntSecGroup-Skylar/excelize/issues/858 * fixes https://github.com/360EntSecGroup-Skylar/excelize/issues/858 Co-authored-by: dvelderp <peter.de.velder@gmail.com>
2021-06-08 19:02:34 +08:00
`=IF(1=1, "equal", "notequal")`: "equal",
`=IF(1<>1, "equal", "notequal")`: "notequal",
`=IF("A"="A", "equal", "notequal")`: "equal",
`=IF("A"<>"A", "equal", "notequal")`: "notequal",
This closes #987: support nested calc for if formula (#988)
2021-08-12 14:53:59 +08:00
`=IF(FALSE,0,ROUND(4/2,0))`: "2",
`=IF(TRUE,ROUND(4/2,0),0)`: "2",
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
// Excel Lookup and Reference Functions
// CHOOSE
"=CHOOSE(4,\"red\",\"blue\",\"green\",\"brown\")": "brown",
"=CHOOSE(1,\"red\",\"blue\",\"green\",\"brown\")": "red",
Nested formula function support cell references as arguments
2021-01-31 01:28:40 +08:00
"=SUM(CHOOSE(A2,A1,B1:B2,A1:A3,A1:A4))": "9",
handle default underline type on get rich text; #65 fn: CODE, COLUMN, FIND, FINDB
2021-02-24 00:37:44 +08:00
// COLUMN
"=COLUMN()": "3",
"=COLUMN(Sheet1!A1)": "1",
"=COLUMN(Sheet1!A1:B1:C1)": "1",
"=COLUMN(Sheet1!F1:G1)": "6",
"=COLUMN(H1)": "8",
This improves compatibility for absolute XML path, Windows-style directory separator and inline namespace;
2021-02-27 00:03:46 +08:00
// COLUMNS
"=COLUMNS(B1)": "1",
"=COLUMNS(1:1)": "16384",
"=COLUMNS(Sheet1!1:1)": "16384",
"=COLUMNS(B1:E5)": "4",
"=COLUMNS(Sheet1!E5:H7:B1)": "7",
"=COLUMNS(E5:H7:B1:C1:Z1:C1:B1)": "25",
"=COLUMNS(E5:B1)": "4",
"=COLUMNS(EM38:HZ81)": "92",
init new formula function: HLOOKUP
2021-02-09 00:12:53 +08:00
// HLOOKUP
binary search in range lookup and new formula function: LOOKUP
2021-02-13 00:07:52 +08:00
"=HLOOKUP(D2,D2:D8,1,FALSE)": "Jan",
"=HLOOKUP(F3,F3:F8,3,FALSE)": "34440",
"=HLOOKUP(INT(F3),F3:F8,3,FALSE)": "34440",
"=HLOOKUP(MUNIT(1),MUNIT(1),1,FALSE)": "1",
init new formula function: VLOOKUP
2021-02-04 23:57:07 +08:00
// VLOOKUP
binary search in range lookup and new formula function: LOOKUP
2021-02-13 00:07:52 +08:00
"=VLOOKUP(D2,D:D,1,FALSE)": "Jan",
"=VLOOKUP(D2,D1:D10,1)": "Jan",
"=VLOOKUP(D2,D1:D11,1)": "Feb",
"=VLOOKUP(D2,D1:D10,1,FALSE)": "Jan",
"=VLOOKUP(INT(36693),F2:F2,1,FALSE)": "36693",
"=VLOOKUP(INT(F2),F3:F9,1)": "32080",
"=VLOOKUP(INT(F2),F3:F9,1,TRUE)": "32080",
"=VLOOKUP(MUNIT(3),MUNIT(3),1)": "0",
"=VLOOKUP(A1,A3:B5,1)": "0",
"=VLOOKUP(MUNIT(1),MUNIT(1),1,FALSE)": "1",
// LOOKUP
"=LOOKUP(F8,F8:F9,F8:F9)": "32080",
"=LOOKUP(F8,F8:F9,D8:D9)": "Feb",
This closes #994, fix LOOKUP function for Array form
2021-08-19 22:12:37 +08:00
"=LOOKUP(E3,E2:E5,F2:F5)": "22100",
"=LOOKUP(E3,E2:F5)": "22100",
This closes #997, fix LOOKUP function to find nearest match (#1001)
2021-08-21 11:58:15 +08:00
"=LOOKUP(F3+1,F3:F4,F3:F4)": "22100",
"=LOOKUP(F4+1,F3:F4,F3:F4)": "53321",
This closes #994, fix LOOKUP function for Array form
2021-08-19 22:12:37 +08:00
"=LOOKUP(1,MUNIT(1))": "1",
binary search in range lookup and new formula function: LOOKUP
2021-02-13 00:07:52 +08:00
"=LOOKUP(1,MUNIT(1),MUNIT(1))": "1",
This improves compatibility for absolute XML path, Windows-style directory separator and inline namespace;
2021-02-27 00:03:46 +08:00
// ROW
"=ROW()": "1",
"=ROW(Sheet1!A1)": "1",
"=ROW(Sheet1!A1:B2:C3)": "1",
"=ROW(Sheet1!F5:G6)": "5",
"=ROW(A8)": "8",
// ROWS
"=ROWS(B1)": "1",
"=ROWS(B:B)": "1048576",
"=ROWS(Sheet1!B:B)": "1048576",
"=ROWS(B1:E5)": "5",
"=ROWS(Sheet1!E5:H7:B1)": "7",
"=ROWS(E5:H8:B2:C3:Z26:C3:B2)": "25",
"=ROWS(E5:B1)": "5",
"=ROWS(EM38:HZ81)": "44",
add ten formula functions: ENCODEURL, EXACT, FALSE, IFERROR, ISTEXT, LENB, NOT, REPT, SHEET, TRUE
2021-02-14 00:02:29 +08:00
// Web Functions
// ENCODEURL
"=ENCODEURL(\"https://xuri.me/excelize/en/?q=Save As\")": "https%3A%2F%2Fxuri.me%2Fexcelize%2Fen%2F%3Fq%3DSave%20As",
#65 fn: IPMT, PMT and PPMT
2021-04-09 00:29:47 +08:00
// Financial Functions
fixed the negative values series missing chart color, #65 fn: CUMIPMT and CUMPRINC
2021-04-11 00:03:25 +08:00
// CUMIPMT
"=CUMIPMT(0.05/12,60,50000,1,12,0)": "-2294.97753732664",
"=CUMIPMT(0.05/12,60,50000,13,24,0)": "-1833.1000665738893",
// CUMPRINC
"=CUMPRINC(0.05/12,60,50000,1,12,0)": "-9027.762649079885",
"=CUMPRINC(0.05/12,60,50000,13,24,0)": "-9489.640119832635",
#65 fn: DB, DDB, DOLLARDE, DOLLARFR, EFFECT, ISPMT and NOMINAL
2021-04-13 00:01:13 +08:00
// DB
"=DB(0,1000,5,1)": "0",
"=DB(10000,1000,5,1)": "3690",
"=DB(10000,1000,5,2)": "2328.39",
"=DB(10000,1000,5,1,6)": "1845",
"=DB(10000,1000,5,6,6)": "238.52712458788187",
// DDB
"=DDB(0,1000,5,1)": "0",
"=DDB(10000,1000,5,1)": "4000",
"=DDB(10000,1000,5,2)": "2400",
"=DDB(10000,1000,5,3)": "1440",
"=DDB(10000,1000,5,4)": "864",
"=DDB(10000,1000,5,5)": "296",
// DOLLARDE
"=DOLLARDE(1.01,16)": "1.0625",
// DOLLARFR
"=DOLLARFR(1.0625,16)": "1.01",
// EFFECT
"=EFFECT(0.1,4)": "0.103812890625",
"=EFFECT(0.025,2)": "0.02515625",
#65 fn: FV, FVSCHEDULE, NPER, NPV and PDURATION
2021-04-14 00:39:18 +08:00
// FV
"=FV(0.05/12,60,-1000)": "68006.08284084337",
"=FV(0.1/4,16,-2000,0,1)": "39729.46089416617",
"=FV(0,16,-2000)": "32000",
// FVSCHEDULE
"=FVSCHEDULE(10000,A1:A5)": "240000",
"=FVSCHEDULE(10000,0.5)": "15000",
#65 fn: IPMT, PMT and PPMT
2021-04-09 00:29:47 +08:00
// IPMT
"=IPMT(0.05/12,2,60,50000)": "-205.26988187971995",
"=IPMT(0.035/4,2,8,0,5000,1)": "5.257455237829077",
#65 fn: DB, DDB, DOLLARDE, DOLLARFR, EFFECT, ISPMT and NOMINAL
2021-04-13 00:01:13 +08:00
// ISPMT
"=ISPMT(0.05/12,1,60,50000)": "-204.8611111111111",
"=ISPMT(0.05/12,2,60,50000)": "-201.38888888888886",
"=ISPMT(0.05/12,2,1,50000)": "208.33333333333334",
// NOMINAL
"=NOMINAL(0.025,12)": "0.024718035238113",
#65 fn: FV, FVSCHEDULE, NPER, NPV and PDURATION
2021-04-14 00:39:18 +08:00
// NPER
"=NPER(0.04,-6000,50000)": "10.338035071507665",
"=NPER(0,-6000,50000)": "8.333333333333334",
"=NPER(0.06/4,-2000,60000,30000,1)": "52.794773709274764",
// NPV
"=NPV(0.02,-5000,\"\",800)": "-4133.025759323337",
// PDURATION
"=PDURATION(0.04,10000,15000)": "10.33803507150765",
#65 fn: IPMT, PMT and PPMT
2021-04-09 00:29:47 +08:00
// PMT
"=PMT(0,8,0,5000,1)": "-625",
"=PMT(0.035/4,8,0,5000,1)": "-600.8520271804658",
// PPMT
"=PPMT(0.05/12,2,60,50000)": "-738.2918003208238",
"=PPMT(0.035/4,2,8,0,5000,1)": "-606.1094824182949",
init formula calculation engine, ref #65 and #599
2020-05-03 18:44:43 +08:00
}
for formula, expected := range mathCalc {
binary search in range lookup and new formula function: LOOKUP
2021-02-13 00:07:52 +08:00
f := prepareCalcData(cellData)
init formula calculation engine, ref #65 and #599
2020-05-03 18:44:43 +08:00
assert.NoError(t, f.SetCellFormula("Sheet1", "C1", formula))
result, err := f.CalcCellValue("Sheet1", "C1")
init new formula function: VLOOKUP
2021-02-04 23:57:07 +08:00
assert.NoError(t, err, formula)
- fn: SUMSQ - resolve ineffectual assignment - handle exception with invalid formula - update range resolver
2020-05-09 00:32:36 +08:00
assert.Equal(t, expected, result, formula)
init formula calculation engine, ref #65 and #599
2020-05-03 18:44:43 +08:00
}
mathCalcError := map[string]string{
add ten formula functions: ENCODEURL, EXACT, FALSE, IFERROR, ISTEXT, LENB, NOT, REPT, SHEET, TRUE
2021-02-14 00:02:29 +08:00
"=1/0": "#DIV/0!",
#65 fn: DEC2BIN, DEC2HEX, DEC2OCT
2021-02-18 08:13:22 +08:00
// Engineering Functions
#65 fn: BESSELI and BESSELJ
2021-04-02 22:41:33 +08:00
// BESSELI
"=BESSELI()": "BESSELI requires 2 numeric arguments",
"=BESSELI(\"\",0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=BESSELI(0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
// BESSELJ
"=BESSELJ()": "BESSELJ requires 2 numeric arguments",
"=BESSELJ(\"\",0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=BESSELJ(0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
#65 fn: BESSELK and BESSELY
2021-05-09 14:20:17 +08:00
// BESSELK
"=BESSELK()": "BESSELK requires 2 numeric arguments",
"=BESSELK(\"\",0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=BESSELK(0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=BESSELK(-1,0)": "#NUM!",
"=BESSELK(1,-1)": "#NUM!",
// BESSELY
"=BESSELY()": "BESSELY requires 2 numeric arguments",
"=BESSELY(\"\",0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=BESSELY(0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=BESSELY(-1,0)": "#NUM!",
"=BESSELY(1,-1)": "#NUM!",
This closes #787, avoid duplicate rich text string items, new formula fn: BIN2DEC, BIN2HEX, BIN2OCT, HEX2BIN, HEX2DEC, HEX2OCT, OCT2BIN, OCT2DEC, OCT2HEX
2021-02-21 00:21:45 +08:00
// BIN2DEC
"=BIN2DEC()": "BIN2DEC requires 1 numeric argument",
"=BIN2DEC(\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
// BIN2HEX
"=BIN2HEX()": "BIN2HEX requires at least 1 argument",
"=BIN2HEX(1,1,1)": "BIN2HEX allows at most 2 arguments",
"=BIN2HEX(\"\",1)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=BIN2HEX(1,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=BIN2HEX(12345678901,10)": "#NUM!",
"=BIN2HEX(1,-1)": "#NUM!",
"=BIN2HEX(31,1)": "#NUM!",
// BIN2OCT
"=BIN2OCT()": "BIN2OCT requires at least 1 argument",
"=BIN2OCT(1,1,1)": "BIN2OCT allows at most 2 arguments",
"=BIN2OCT(\"\",1)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=BIN2OCT(1,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=BIN2OCT(-12345678901 ,10)": "#NUM!",
"=BIN2OCT(1,-1)": "#NUM!",
"=BIN2OCT(8,1)": "#NUM!",
ref: #756, set cell as blank when SetCellValue with nil #756, new formula fn: BITAND, BITLSHIFT, BITOR, BITRSHIFT, BITXOR
2021-02-19 00:03:51 +08:00
// BITAND
"=BITAND()": "BITAND requires 2 numeric arguments",
"=BITAND(-1,2)": "#NUM!",
"=BITAND(2^48,2)": "#NUM!",
"=BITAND(1,-1)": "#NUM!",
"=BITAND(\"\",-1)": "#NUM!",
"=BITAND(1,\"\")": "#NUM!",
"=BITAND(1,2^48)": "#NUM!",
// BITLSHIFT
"=BITLSHIFT()": "BITLSHIFT requires 2 numeric arguments",
"=BITLSHIFT(-1,2)": "#NUM!",
"=BITLSHIFT(2^48,2)": "#NUM!",
"=BITLSHIFT(1,-1)": "#NUM!",
"=BITLSHIFT(\"\",-1)": "#NUM!",
"=BITLSHIFT(1,\"\")": "#NUM!",
"=BITLSHIFT(1,2^48)": "#NUM!",
// BITOR
"=BITOR()": "BITOR requires 2 numeric arguments",
"=BITOR(-1,2)": "#NUM!",
"=BITOR(2^48,2)": "#NUM!",
"=BITOR(1,-1)": "#NUM!",
"=BITOR(\"\",-1)": "#NUM!",
"=BITOR(1,\"\")": "#NUM!",
"=BITOR(1,2^48)": "#NUM!",
// BITRSHIFT
"=BITRSHIFT()": "BITRSHIFT requires 2 numeric arguments",
"=BITRSHIFT(-1,2)": "#NUM!",
"=BITRSHIFT(2^48,2)": "#NUM!",
"=BITRSHIFT(1,-1)": "#NUM!",
"=BITRSHIFT(\"\",-1)": "#NUM!",
"=BITRSHIFT(1,\"\")": "#NUM!",
"=BITRSHIFT(1,2^48)": "#NUM!",
// BITXOR
"=BITXOR()": "BITXOR requires 2 numeric arguments",
"=BITXOR(-1,2)": "#NUM!",
"=BITXOR(2^48,2)": "#NUM!",
"=BITXOR(1,-1)": "#NUM!",
"=BITXOR(\"\",-1)": "#NUM!",
"=BITXOR(1,\"\")": "#NUM!",
"=BITXOR(1,2^48)": "#NUM!",
Fixed #813, streaming data writer result missing after call normal API #65 formula function: COMPLEX
2021-04-03 22:56:02 +08:00
// COMPLEX
"=COMPLEX()": "COMPLEX requires at least 2 arguments",
"=COMPLEX(10,-5,\"\")": "#VALUE!",
"=COMPLEX(\"\",0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=COMPLEX(0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=COMPLEX(10,-5,\"i\",0)": "COMPLEX allows at most 3 arguments",
#65 fn: DEC2BIN, DEC2HEX, DEC2OCT
2021-02-18 08:13:22 +08:00
// DEC2BIN
"=DEC2BIN()": "DEC2BIN requires at least 1 argument",
"=DEC2BIN(1,1,1)": "DEC2BIN allows at most 2 arguments",
"=DEC2BIN(\"\",1)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=DEC2BIN(1,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=DEC2BIN(-513,10)": "#NUM!",
"=DEC2BIN(1,-1)": "#NUM!",
"=DEC2BIN(2,1)": "#NUM!",
// DEC2HEX
"=DEC2HEX()": "DEC2HEX requires at least 1 argument",
"=DEC2HEX(1,1,1)": "DEC2HEX allows at most 2 arguments",
"=DEC2HEX(\"\",1)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=DEC2HEX(1,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=DEC2HEX(-549755813888,10)": "#NUM!",
"=DEC2HEX(1,-1)": "#NUM!",
"=DEC2HEX(31,1)": "#NUM!",
// DEC2OCT
"=DEC2OCT()": "DEC2OCT requires at least 1 argument",
"=DEC2OCT(1,1,1)": "DEC2OCT allows at most 2 arguments",
"=DEC2OCT(\"\",1)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=DEC2OCT(1,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=DEC2OCT(-536870912 ,10)": "#NUM!",
"=DEC2OCT(1,-1)": "#NUM!",
"=DEC2OCT(8,1)": "#NUM!",
This closes #787, avoid duplicate rich text string items, new formula fn: BIN2DEC, BIN2HEX, BIN2OCT, HEX2BIN, HEX2DEC, HEX2OCT, OCT2BIN, OCT2DEC, OCT2HEX
2021-02-21 00:21:45 +08:00
// HEX2BIN
"=HEX2BIN()": "HEX2BIN requires at least 1 argument",
"=HEX2BIN(1,1,1)": "HEX2BIN allows at most 2 arguments",
"=HEX2BIN(\"X\",1)": "strconv.ParseInt: parsing \"X\": invalid syntax",
"=HEX2BIN(1,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=HEX2BIN(-513,10)": "strconv.ParseInt: parsing \"-\": invalid syntax",
"=HEX2BIN(1,-1)": "#NUM!",
"=HEX2BIN(2,1)": "#NUM!",
// HEX2DEC
"=HEX2DEC()": "HEX2DEC requires 1 numeric argument",
"=HEX2DEC(\"X\")": "strconv.ParseInt: parsing \"X\": invalid syntax",
// HEX2OCT
"=HEX2OCT()": "HEX2OCT requires at least 1 argument",
"=HEX2OCT(1,1,1)": "HEX2OCT allows at most 2 arguments",
"=HEX2OCT(\"X\",1)": "strconv.ParseInt: parsing \"X\": invalid syntax",
"=HEX2OCT(1,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=HEX2OCT(-513,10)": "strconv.ParseInt: parsing \"-\": invalid syntax",
"=HEX2OCT(1,-1)": "#NUM!",
Go 1.15 and later required, #65 fn: IMABS, IMCOS, IMCOSH, IMCOT, IMCSC, IMCSCH, IMEXP, IMLN and IMLOG10
2021-04-04 15:29:43 +08:00
// IMABS
"=IMABS()": "IMABS requires 1 argument",
"=IMABS(\"\")": "strconv.ParseComplex: parsing \"\": invalid syntax",
Fixed #819, read empty after streaming data writing #65 fn: IMAGINARY, IMARGUMENT, IMCONJUGATE and IMDIV
2021-04-08 00:50:59 +08:00
// IMAGINARY
"=IMAGINARY()": "IMAGINARY requires 1 argument",
"=IMAGINARY(\"\")": "strconv.ParseComplex: parsing \"\": invalid syntax",
// IMARGUMENT
"=IMARGUMENT()": "IMARGUMENT requires 1 argument",
"=IMARGUMENT(\"\")": "strconv.ParseComplex: parsing \"\": invalid syntax",
// IMCONJUGATE
"=IMCONJUGATE()": "IMCONJUGATE requires 1 argument",
"=IMCONJUGATE(\"\")": "strconv.ParseComplex: parsing \"\": invalid syntax",
Go 1.15 and later required, #65 fn: IMABS, IMCOS, IMCOSH, IMCOT, IMCSC, IMCSCH, IMEXP, IMLN and IMLOG10
2021-04-04 15:29:43 +08:00
// IMCOS
"=IMCOS()": "IMCOS requires 1 argument",
"=IMCOS(\"\")": "strconv.ParseComplex: parsing \"\": invalid syntax",
// IMCOSH
"=IMCOSH()": "IMCOSH requires 1 argument",
"=IMCOSH(\"\")": "strconv.ParseComplex: parsing \"\": invalid syntax",
// IMCOT
"=IMCOT()": "IMCOT requires 1 argument",
"=IMCOT(\"\")": "strconv.ParseComplex: parsing \"\": invalid syntax",
// IMCSC
"=IMCSC()": "IMCSC requires 1 argument",
"=IMCSC(\"\")": "strconv.ParseComplex: parsing \"\": invalid syntax",
"=IMCSC(0)": "#NUM!",
// IMCSCH
"=IMCSCH()": "IMCSCH requires 1 argument",
"=IMCSCH(\"\")": "strconv.ParseComplex: parsing \"\": invalid syntax",
"=IMCSCH(0)": "#NUM!",
Fixed #819, read empty after streaming data writing #65 fn: IMAGINARY, IMARGUMENT, IMCONJUGATE and IMDIV
2021-04-08 00:50:59 +08:00
// IMDIV
"=IMDIV()": "IMDIV requires 2 arguments",
"=IMDIV(0,\"\")": "strconv.ParseComplex: parsing \"\": invalid syntax",
"=IMDIV(\"\",0)": "strconv.ParseComplex: parsing \"\": invalid syntax",
"=IMDIV(1,0)": "#NUM!",
Go 1.15 and later required, #65 fn: IMABS, IMCOS, IMCOSH, IMCOT, IMCSC, IMCSCH, IMEXP, IMLN and IMLOG10
2021-04-04 15:29:43 +08:00
// IMEXP
"=IMEXP()": "IMEXP requires 1 argument",
"=IMEXP(\"\")": "strconv.ParseComplex: parsing \"\": invalid syntax",
// IMLN
"=IMLN()": "IMLN requires 1 argument",
"=IMLN(\"\")": "strconv.ParseComplex: parsing \"\": invalid syntax",
"=IMLN(0)": "#NUM!",
// IMLOG10
"=IMLOG10()": "IMLOG10 requires 1 argument",
"=IMLOG10(\"\")": "strconv.ParseComplex: parsing \"\": invalid syntax",
"=IMLOG10(0)": "#NUM!",
#65 fn: IMLOG2, IMPOWER, IMPRODUCT, IMREAL, IMSEC, and IMSECH
2021-04-07 00:01:03 +08:00
// IMLOG2
"=IMLOG2()": "IMLOG2 requires 1 argument",
"=IMLOG2(\"\")": "strconv.ParseComplex: parsing \"\": invalid syntax",
"=IMLOG2(0)": "#NUM!",
// IMPOWER
"=IMPOWER()": "IMPOWER requires 2 arguments",
"=IMPOWER(0,\"\")": "strconv.ParseComplex: parsing \"\": invalid syntax",
"=IMPOWER(\"\",0)": "strconv.ParseComplex: parsing \"\": invalid syntax",
"=IMPOWER(0,0)": "#NUM!",
"=IMPOWER(0,-1)": "#NUM!",
// IMPRODUCT
"=IMPRODUCT(\"x\")": "strconv.ParseComplex: parsing \"x\": invalid syntax",
"=IMPRODUCT(A1:D1)": "strconv.ParseComplex: parsing \"Month\": invalid syntax",
// IMREAL
"=IMREAL()": "IMREAL requires 1 argument",
"=IMREAL(\"\")": "strconv.ParseComplex: parsing \"\": invalid syntax",
// IMSEC
"=IMSEC()": "IMSEC requires 1 argument",
"=IMSEC(\"\")": "strconv.ParseComplex: parsing \"\": invalid syntax",
// IMSECH
"=IMSECH()": "IMSECH requires 1 argument",
"=IMSECH(\"\")": "strconv.ParseComplex: parsing \"\": invalid syntax",
#65 fn: IMSIN, IMSINH, IMSQRT, IMSUB, IMSUM, IMTAN
2021-04-05 13:00:34 +08:00
// IMSIN
"=IMSIN()": "IMSIN requires 1 argument",
"=IMSIN(\"\")": "strconv.ParseComplex: parsing \"\": invalid syntax",
// IMSINH
"=IMSINH()": "IMSINH requires 1 argument",
"=IMSINH(\"\")": "strconv.ParseComplex: parsing \"\": invalid syntax",
// IMSQRT
"=IMSQRT()": "IMSQRT requires 1 argument",
"=IMSQRT(\"\")": "strconv.ParseComplex: parsing \"\": invalid syntax",
// IMSUB
"=IMSUB()": "IMSUB requires 2 arguments",
"=IMSUB(0,\"\")": "strconv.ParseComplex: parsing \"\": invalid syntax",
"=IMSUB(\"\",0)": "strconv.ParseComplex: parsing \"\": invalid syntax",
// IMSUM
"=IMSUM()": "IMSUM requires at least 1 argument",
"=IMSUM(\"\")": "strconv.ParseComplex: parsing \"\": invalid syntax",
// IMTAN
"=IMTAN()": "IMTAN requires 1 argument",
"=IMTAN(\"\")": "strconv.ParseComplex: parsing \"\": invalid syntax",
This closes #787, avoid duplicate rich text string items, new formula fn: BIN2DEC, BIN2HEX, BIN2OCT, HEX2BIN, HEX2DEC, HEX2OCT, OCT2BIN, OCT2DEC, OCT2HEX
2021-02-21 00:21:45 +08:00
// OCT2BIN
"=OCT2BIN()": "OCT2BIN requires at least 1 argument",
"=OCT2BIN(1,1,1)": "OCT2BIN allows at most 2 arguments",
"=OCT2BIN(\"\",1)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=OCT2BIN(1,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=OCT2BIN(-536870912 ,10)": "#NUM!",
"=OCT2BIN(1,-1)": "#NUM!",
// OCT2DEC
"=OCT2DEC()": "OCT2DEC requires 1 numeric argument",
"=OCT2DEC(\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
// OCT2HEX
"=OCT2HEX()": "OCT2HEX requires at least 1 argument",
"=OCT2HEX(1,1,1)": "OCT2HEX allows at most 2 arguments",
"=OCT2HEX(\"\",1)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=OCT2HEX(1,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=OCT2HEX(-536870912 ,10)": "#NUM!",
"=OCT2HEX(1,-1)": "#NUM!",
// Math and Trigonometric Functions
fn: ABS, GCD, LCM, POWER, PRODUCT, SIGN, SQRT, SUM, QUOTIENT
2020-05-04 13:40:04 +08:00
// ABS
updated test and go.mod
2020-05-11 00:01:22 +08:00
"=ABS()": "ABS requires 1 numeric argument",
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=ABS("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
init new formula function: VLOOKUP
2021-02-04 23:57:07 +08:00
"=ABS(~)": `invalid column name "~"`,
fn: ACOS, ACOSH, ACOT, ACOTH, ARABIC, ASIN, ASINH, ATANH, ATAN2, BASE
2020-05-04 18:18:05 +08:00
// ACOS
Nested formula function support cell references as arguments
2021-01-31 01:28:40 +08:00
"=ACOS()": "ACOS requires 1 numeric argument",
`=ACOS("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
"=ACOS(ACOS(0))": "#NUM!",
fn: ACOS, ACOSH, ACOT, ACOTH, ARABIC, ASIN, ASINH, ATANH, ATAN2, BASE
2020-05-04 18:18:05 +08:00
// ACOSH
updated test and go.mod
2020-05-11 00:01:22 +08:00
"=ACOSH()": "ACOSH requires 1 numeric argument",
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=ACOSH("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
fn: CEILING, CEILING.MATH
2020-05-04 21:22:11 +08:00
// _xlfn.ACOT
updated test and go.mod
2020-05-11 00:01:22 +08:00
"=_xlfn.ACOT()": "ACOT requires 1 numeric argument",
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=_xlfn.ACOT("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
fn: CEILING, CEILING.MATH
2020-05-04 21:22:11 +08:00
// _xlfn.ACOTH
Nested formula function support cell references as arguments
2021-01-31 01:28:40 +08:00
"=_xlfn.ACOTH()": "ACOTH requires 1 numeric argument",
`=_xlfn.ACOTH("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
"=_xlfn.ACOTH(_xlfn.ACOTH(2))": "#NUM!",
fn: CEILING, CEILING.MATH
2020-05-04 21:22:11 +08:00
// _xlfn.ARABIC
#65 fn: CSCH, DECIMAL, DEGREES, EVEN, EXP, FACT, FACTDOUBLE, FLOOR, FLOOR.MATH, FLOOR.PRECISE, INT, ISO.CEILING, LN, LOG, LOG10, MDETERM
2020-05-06 00:01:31 +08:00
"=_xlfn.ARABIC()": "ARABIC requires 1 numeric argument",
#65 fn: LARGE, SMALL, SUBSTITUTE, refactor ARABIC
2021-03-02 22:34:09 +08:00
"=_xlfn.ARABIC(\"" + strings.Repeat("I", 256) + "\")": "#VALUE!",
fn: ACOS, ACOSH, ACOT, ACOTH, ARABIC, ASIN, ASINH, ATANH, ATAN2, BASE
2020-05-04 18:18:05 +08:00
// ASIN
updated test and go.mod
2020-05-11 00:01:22 +08:00
"=ASIN()": "ASIN requires 1 numeric argument",
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=ASIN("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
fn: ACOS, ACOSH, ACOT, ACOTH, ARABIC, ASIN, ASINH, ATANH, ATAN2, BASE
2020-05-04 18:18:05 +08:00
// ASINH
updated test and go.mod
2020-05-11 00:01:22 +08:00
"=ASINH()": "ASINH requires 1 numeric argument",
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=ASINH("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
fn: ACOS, ACOSH, ACOT, ACOTH, ARABIC, ASIN, ASINH, ATANH, ATAN2, BASE
2020-05-04 18:18:05 +08:00
// ATAN
updated test and go.mod
2020-05-11 00:01:22 +08:00
"=ATAN()": "ATAN requires 1 numeric argument",
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=ATAN("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
fn: ACOS, ACOSH, ACOT, ACOTH, ARABIC, ASIN, ASINH, ATANH, ATAN2, BASE
2020-05-04 18:18:05 +08:00
// ATANH
updated test and go.mod
2020-05-11 00:01:22 +08:00
"=ATANH()": "ATANH requires 1 numeric argument",
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=ATANH("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
fn: ACOS, ACOSH, ACOT, ACOTH, ARABIC, ASIN, ASINH, ATANH, ATAN2, BASE
2020-05-04 18:18:05 +08:00
// ATAN2
updated test and go.mod
2020-05-11 00:01:22 +08:00
"=ATAN2()": "ATAN2 requires 2 numeric arguments",
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=ATAN2("X",0)`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
`=ATAN2(0,"X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
fn: ACOS, ACOSH, ACOT, ACOTH, ARABIC, ASIN, ASINH, ATANH, ATAN2, BASE
2020-05-04 18:18:05 +08:00
// BASE
"=BASE()": "BASE requires at least 2 arguments",
"=BASE(1,2,3,4)": "BASE allows at most 3 arguments",
- formula engine: reduce cyclomatic complexity - styles: allow empty and default cell formats, #628
2020-05-10 16:56:08 +08:00
"=BASE(1,1)": "radix must be an integer >= 2 and <= 36",
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=BASE("X",2)`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
Fix hyperbolic cotangent calculation incorrect and unit test
2021-01-31 13:15:10 +08:00
`=BASE(1,"X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=BASE(1,2,"X")`: "strconv.Atoi: parsing \"X\": invalid syntax",
fn: CEILING, CEILING.MATH
2020-05-04 21:22:11 +08:00
// CEILING
"=CEILING()": "CEILING requires at least 1 argument",
"=CEILING(1,2,3)": "CEILING allows at most 2 arguments",
"=CEILING(1,-1)": "negative sig to CEILING invalid",
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=CEILING("X",0)`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
`=CEILING(0,"X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
fn: CEILING, CEILING.MATH
2020-05-04 21:22:11 +08:00
// _xlfn.CEILING.MATH
"=_xlfn.CEILING.MATH()": "CEILING.MATH requires at least 1 argument",
"=_xlfn.CEILING.MATH(1,2,3,4)": "CEILING.MATH allows at most 3 arguments",
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=_xlfn.CEILING.MATH("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
`=_xlfn.CEILING.MATH(1,"X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
`=_xlfn.CEILING.MATH(1,2,"X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
#65 fn: CEILING.PRECISE, COMBIN, COMBINA, COS, COSH, COT, COTH, CSC
2020-05-05 17:27:19 +08:00
// _xlfn.CEILING.PRECISE
"=_xlfn.CEILING.PRECISE()": "CEILING.PRECISE requires at least 1 argument",
"=_xlfn.CEILING.PRECISE(1,2,3)": "CEILING.PRECISE allows at most 2 arguments",
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=_xlfn.CEILING.PRECISE("X",2)`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
Fix hyperbolic cotangent calculation incorrect and unit test
2021-01-31 13:15:10 +08:00
`=_xlfn.CEILING.PRECISE(1,"X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
#65 fn: CEILING.PRECISE, COMBIN, COMBINA, COS, COSH, COT, COTH, CSC
2020-05-05 17:27:19 +08:00
// COMBIN
updated test and go.mod
2020-05-11 00:01:22 +08:00
"=COMBIN()": "COMBIN requires 2 argument",
"=COMBIN(-1,1)": "COMBIN requires number >= number_chosen",
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=COMBIN("X",1)`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
`=COMBIN(-1,"X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
#65 fn: CEILING.PRECISE, COMBIN, COMBINA, COS, COSH, COT, COTH, CSC
2020-05-05 17:27:19 +08:00
// _xlfn.COMBINA
updated test and go.mod
2020-05-11 00:01:22 +08:00
"=_xlfn.COMBINA()": "COMBINA requires 2 argument",
"=_xlfn.COMBINA(-1,1)": "COMBINA requires number > number_chosen",
"=_xlfn.COMBINA(-1,-1)": "COMBIN requires number >= number_chosen",
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=_xlfn.COMBINA("X",1)`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
`=_xlfn.COMBINA(-1,"X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
#65 fn: CEILING.PRECISE, COMBIN, COMBINA, COS, COSH, COT, COTH, CSC
2020-05-05 17:27:19 +08:00
// COS
updated test and go.mod
2020-05-11 00:01:22 +08:00
"=COS()": "COS requires 1 numeric argument",
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=COS("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
#65 fn: CEILING.PRECISE, COMBIN, COMBINA, COS, COSH, COT, COTH, CSC
2020-05-05 17:27:19 +08:00
// COSH
updated test and go.mod
2020-05-11 00:01:22 +08:00
"=COSH()": "COSH requires 1 numeric argument",
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=COSH("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
#65 fn: CEILING.PRECISE, COMBIN, COMBINA, COS, COSH, COT, COTH, CSC
2020-05-05 17:27:19 +08:00
// _xlfn.COT
updated test and go.mod
2020-05-11 00:01:22 +08:00
"=COT()": "COT requires 1 numeric argument",
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=COT("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
updated test and go.mod
2020-05-11 00:01:22 +08:00
"=COT(0)": "#DIV/0!",
#65 fn: CEILING.PRECISE, COMBIN, COMBINA, COS, COSH, COT, COTH, CSC
2020-05-05 17:27:19 +08:00
// _xlfn.COTH
updated test and go.mod
2020-05-11 00:01:22 +08:00
"=COTH()": "COTH requires 1 numeric argument",
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=COTH("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
updated test and go.mod
2020-05-11 00:01:22 +08:00
"=COTH(0)": "#DIV/0!",
#65 fn: CEILING.PRECISE, COMBIN, COMBINA, COS, COSH, COT, COTH, CSC
2020-05-05 17:27:19 +08:00
// _xlfn.CSC
updated test and go.mod
2020-05-11 00:01:22 +08:00
"=_xlfn.CSC()": "CSC requires 1 numeric argument",
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=_xlfn.CSC("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
updated test and go.mod
2020-05-11 00:01:22 +08:00
"=_xlfn.CSC(0)": "#DIV/0!",
#65 fn: CSCH, DECIMAL, DEGREES, EVEN, EXP, FACT, FACTDOUBLE, FLOOR, FLOOR.MATH, FLOOR.PRECISE, INT, ISO.CEILING, LN, LOG, LOG10, MDETERM
2020-05-06 00:01:31 +08:00
// _xlfn.CSCH
updated test and go.mod
2020-05-11 00:01:22 +08:00
"=_xlfn.CSCH()": "CSCH requires 1 numeric argument",
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=_xlfn.CSCH("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
updated test and go.mod
2020-05-11 00:01:22 +08:00
"=_xlfn.CSCH(0)": "#DIV/0!",
#65 fn: CSCH, DECIMAL, DEGREES, EVEN, EXP, FACT, FACTDOUBLE, FLOOR, FLOOR.MATH, FLOOR.PRECISE, INT, ISO.CEILING, LN, LOG, LOG10, MDETERM
2020-05-06 00:01:31 +08:00
// _xlfn.DECIMAL
"=_xlfn.DECIMAL()": "DECIMAL requires 2 numeric arguments",
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=_xlfn.DECIMAL("X", 2)`: "strconv.ParseInt: parsing \"X\": invalid syntax",
`=_xlfn.DECIMAL(2000, "X")`: "strconv.Atoi: parsing \"X\": invalid syntax",
#65 fn: CSCH, DECIMAL, DEGREES, EVEN, EXP, FACT, FACTDOUBLE, FLOOR, FLOOR.MATH, FLOOR.PRECISE, INT, ISO.CEILING, LN, LOG, LOG10, MDETERM
2020-05-06 00:01:31 +08:00
// DEGREES
updated test and go.mod
2020-05-11 00:01:22 +08:00
"=DEGREES()": "DEGREES requires 1 numeric argument",
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=DEGREES("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
updated test and go.mod
2020-05-11 00:01:22 +08:00
"=DEGREES(0)": "#DIV/0!",
#65 fn: CSCH, DECIMAL, DEGREES, EVEN, EXP, FACT, FACTDOUBLE, FLOOR, FLOOR.MATH, FLOOR.PRECISE, INT, ISO.CEILING, LN, LOG, LOG10, MDETERM
2020-05-06 00:01:31 +08:00
// EVEN
updated test and go.mod
2020-05-11 00:01:22 +08:00
"=EVEN()": "EVEN requires 1 numeric argument",
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=EVEN("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
#65 fn: CSCH, DECIMAL, DEGREES, EVEN, EXP, FACT, FACTDOUBLE, FLOOR, FLOOR.MATH, FLOOR.PRECISE, INT, ISO.CEILING, LN, LOG, LOG10, MDETERM
2020-05-06 00:01:31 +08:00
// EXP
updated test and go.mod
2020-05-11 00:01:22 +08:00
"=EXP()": "EXP requires 1 numeric argument",
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=EXP("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
#65 fn: CSCH, DECIMAL, DEGREES, EVEN, EXP, FACT, FACTDOUBLE, FLOOR, FLOOR.MATH, FLOOR.PRECISE, INT, ISO.CEILING, LN, LOG, LOG10, MDETERM
2020-05-06 00:01:31 +08:00
// FACT
updated test and go.mod
2020-05-11 00:01:22 +08:00
"=FACT()": "FACT requires 1 numeric argument",
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=FACT("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
updated test and go.mod
2020-05-11 00:01:22 +08:00
"=FACT(-1)": "#NUM!",
#65 fn: CSCH, DECIMAL, DEGREES, EVEN, EXP, FACT, FACTDOUBLE, FLOOR, FLOOR.MATH, FLOOR.PRECISE, INT, ISO.CEILING, LN, LOG, LOG10, MDETERM
2020-05-06 00:01:31 +08:00
// FACTDOUBLE
updated test and go.mod
2020-05-11 00:01:22 +08:00
"=FACTDOUBLE()": "FACTDOUBLE requires 1 numeric argument",
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=FACTDOUBLE("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
updated test and go.mod
2020-05-11 00:01:22 +08:00
"=FACTDOUBLE(-1)": "#NUM!",
#65 fn: CSCH, DECIMAL, DEGREES, EVEN, EXP, FACT, FACTDOUBLE, FLOOR, FLOOR.MATH, FLOOR.PRECISE, INT, ISO.CEILING, LN, LOG, LOG10, MDETERM
2020-05-06 00:01:31 +08:00
// FLOOR
updated test and go.mod
2020-05-11 00:01:22 +08:00
"=FLOOR()": "FLOOR requires 2 numeric arguments",
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=FLOOR("X",-1)`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
`=FLOOR(1,"X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
"=FLOOR(1,-1)": "invalid arguments to FLOOR",
#65 fn: CSCH, DECIMAL, DEGREES, EVEN, EXP, FACT, FACTDOUBLE, FLOOR, FLOOR.MATH, FLOOR.PRECISE, INT, ISO.CEILING, LN, LOG, LOG10, MDETERM
2020-05-06 00:01:31 +08:00
// _xlfn.FLOOR.MATH
"=_xlfn.FLOOR.MATH()": "FLOOR.MATH requires at least 1 argument",
"=_xlfn.FLOOR.MATH(1,2,3,4)": "FLOOR.MATH allows at most 3 arguments",
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=_xlfn.FLOOR.MATH("X",2,3)`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
`=_xlfn.FLOOR.MATH(1,"X",3)`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
`=_xlfn.FLOOR.MATH(1,2,"X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
#65 fn: CSCH, DECIMAL, DEGREES, EVEN, EXP, FACT, FACTDOUBLE, FLOOR, FLOOR.MATH, FLOOR.PRECISE, INT, ISO.CEILING, LN, LOG, LOG10, MDETERM
2020-05-06 00:01:31 +08:00
// _xlfn.FLOOR.PRECISE
"=_xlfn.FLOOR.PRECISE()": "FLOOR.PRECISE requires at least 1 argument",
"=_xlfn.FLOOR.PRECISE(1,2,3)": "FLOOR.PRECISE allows at most 2 arguments",
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=_xlfn.FLOOR.PRECISE("X",2)`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
`=_xlfn.FLOOR.PRECISE(1,"X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
fn: ABS, GCD, LCM, POWER, PRODUCT, SIGN, SQRT, SUM, QUOTIENT
2020-05-04 13:40:04 +08:00
// GCD
"=GCD()": "GCD requires at least 1 argument",
lint issue fixed and new formula function: ATAN, AVERAGE, AVERAGEA, CONCAT, CONCATENATE, COUNT, COUNTBLANK, MAX
2021-02-15 00:09:35 +08:00
"=GCD(\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
fn: ABS, GCD, LCM, POWER, PRODUCT, SIGN, SQRT, SUM, QUOTIENT
2020-05-04 13:40:04 +08:00
"=GCD(-1)": "GCD only accepts positive arguments",
"=GCD(1,-1)": "GCD only accepts positive arguments",
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=GCD("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
#65 fn: CSCH, DECIMAL, DEGREES, EVEN, EXP, FACT, FACTDOUBLE, FLOOR, FLOOR.MATH, FLOOR.PRECISE, INT, ISO.CEILING, LN, LOG, LOG10, MDETERM
2020-05-06 00:01:31 +08:00
// INT
updated test and go.mod
2020-05-11 00:01:22 +08:00
"=INT()": "INT requires 1 numeric argument",
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=INT("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
#65 fn: CSCH, DECIMAL, DEGREES, EVEN, EXP, FACT, FACTDOUBLE, FLOOR, FLOOR.MATH, FLOOR.PRECISE, INT, ISO.CEILING, LN, LOG, LOG10, MDETERM
2020-05-06 00:01:31 +08:00
// ISO.CEILING
"=ISO.CEILING()": "ISO.CEILING requires at least 1 argument",
"=ISO.CEILING(1,2,3)": "ISO.CEILING allows at most 2 arguments",
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=ISO.CEILING("X",2)`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
`=ISO.CEILING(1,"X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
fn: ABS, GCD, LCM, POWER, PRODUCT, SIGN, SQRT, SUM, QUOTIENT
2020-05-04 13:40:04 +08:00
// LCM
"=LCM()": "LCM requires at least 1 argument",
"=LCM(-1)": "LCM only accepts positive arguments",
"=LCM(1,-1)": "LCM only accepts positive arguments",
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=LCM("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
#65 fn: CSCH, DECIMAL, DEGREES, EVEN, EXP, FACT, FACTDOUBLE, FLOOR, FLOOR.MATH, FLOOR.PRECISE, INT, ISO.CEILING, LN, LOG, LOG10, MDETERM
2020-05-06 00:01:31 +08:00
// LN
updated test and go.mod
2020-05-11 00:01:22 +08:00
"=LN()": "LN requires 1 numeric argument",
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=LN("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
#65 fn: CSCH, DECIMAL, DEGREES, EVEN, EXP, FACT, FACTDOUBLE, FLOOR, FLOOR.MATH, FLOOR.PRECISE, INT, ISO.CEILING, LN, LOG, LOG10, MDETERM
2020-05-06 00:01:31 +08:00
// LOG
"=LOG()": "LOG requires at least 1 argument",
"=LOG(1,2,3)": "LOG allows at most 2 arguments",
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=LOG("X",1)`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
`=LOG(1,"X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
"=LOG(0,0)": "#DIV/0!",
"=LOG(1,0)": "#DIV/0!",
#65 fn: CSCH, DECIMAL, DEGREES, EVEN, EXP, FACT, FACTDOUBLE, FLOOR, FLOOR.MATH, FLOOR.PRECISE, INT, ISO.CEILING, LN, LOG, LOG10, MDETERM
2020-05-06 00:01:31 +08:00
"=LOG(1,1)": "#DIV/0!",
// LOG10
updated test and go.mod
2020-05-11 00:01:22 +08:00
"=LOG10()": "LOG10 requires 1 numeric argument",
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=LOG10("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
init new formula function: HLOOKUP
2021-02-09 00:12:53 +08:00
// MDETERM
"MDETERM()": "MDETERM requires at least 1 argument",
#65 fn: MOD, MROUND, MULTINOMIAL, MUNIT, ODD, PI, RADIANS, RAND, RANDBETWEEN, ROMAN
2020-05-07 00:15:54 +08:00
// MOD
updated test and go.mod
2020-05-11 00:01:22 +08:00
"=MOD()": "MOD requires 2 numeric arguments",
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
"=MOD(6,0)": "MOD divide by zero",
`=MOD("X",0)`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
`=MOD(6,"X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
#65 fn: MOD, MROUND, MULTINOMIAL, MUNIT, ODD, PI, RADIANS, RAND, RANDBETWEEN, ROMAN
2020-05-07 00:15:54 +08:00
// MROUND
updated test and go.mod
2020-05-11 00:01:22 +08:00
"=MROUND()": "MROUND requires 2 numeric arguments",
"=MROUND(1,0)": "#NUM!",
"=MROUND(1,-1)": "#NUM!",
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=MROUND("X",0)`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
`=MROUND(1,"X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
updated test and go.mod
2020-05-11 00:01:22 +08:00
// MULTINOMIAL
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=MULTINOMIAL("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
#65 fn: MOD, MROUND, MULTINOMIAL, MUNIT, ODD, PI, RADIANS, RAND, RANDBETWEEN, ROMAN
2020-05-07 00:15:54 +08:00
// _xlfn.MUNIT
binary search in range lookup and new formula function: LOOKUP
2021-02-13 00:07:52 +08:00
"=_xlfn.MUNIT()": "MUNIT requires 1 numeric argument",
`=_xlfn.MUNIT("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
"=_xlfn.MUNIT(-1)": "",
#65 fn: MOD, MROUND, MULTINOMIAL, MUNIT, ODD, PI, RADIANS, RAND, RANDBETWEEN, ROMAN
2020-05-07 00:15:54 +08:00
// ODD
updated test and go.mod
2020-05-11 00:01:22 +08:00
"=ODD()": "ODD requires 1 numeric argument",
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=ODD("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
#65 fn: MOD, MROUND, MULTINOMIAL, MUNIT, ODD, PI, RADIANS, RAND, RANDBETWEEN, ROMAN
2020-05-07 00:15:54 +08:00
// PI
"=PI(1)": "PI accepts no arguments",
init formula calculation engine, ref #65 and #599
2020-05-03 18:44:43 +08:00
// POWER
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=POWER("X",1)`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
`=POWER(1,"X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
updated test and go.mod
2020-05-11 00:01:22 +08:00
"=POWER(0,0)": "#NUM!",
"=POWER(0,-1)": "#DIV/0!",
"=POWER(1)": "POWER requires 2 numeric arguments",
// PRODUCT
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=PRODUCT("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
#65 fn: MOD, MROUND, MULTINOMIAL, MUNIT, ODD, PI, RADIANS, RAND, RANDBETWEEN, ROMAN
2020-05-07 00:15:54 +08:00
// QUOTIENT
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=QUOTIENT("X",1)`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
`=QUOTIENT(1,"X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
updated test and go.mod
2020-05-11 00:01:22 +08:00
"=QUOTIENT(1,0)": "#DIV/0!",
"=QUOTIENT(1)": "QUOTIENT requires 2 numeric arguments",
#65 fn: MOD, MROUND, MULTINOMIAL, MUNIT, ODD, PI, RADIANS, RAND, RANDBETWEEN, ROMAN
2020-05-07 00:15:54 +08:00
// RADIANS
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=RADIANS("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
updated test and go.mod
2020-05-11 00:01:22 +08:00
"=RADIANS()": "RADIANS requires 1 numeric argument",
#65 fn: MOD, MROUND, MULTINOMIAL, MUNIT, ODD, PI, RADIANS, RAND, RANDBETWEEN, ROMAN
2020-05-07 00:15:54 +08:00
// RAND
"=RAND(1)": "RAND accepts no arguments",
// RANDBETWEEN
update formula functions test
2021-02-01 00:07:51 +08:00
`=RANDBETWEEN("X",1)`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
`=RANDBETWEEN(1,"X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
updated test and go.mod
2020-05-11 00:01:22 +08:00
"=RANDBETWEEN()": "RANDBETWEEN requires 2 numeric arguments",
"=RANDBETWEEN(2,1)": "#NUM!",
#65 fn: MOD, MROUND, MULTINOMIAL, MUNIT, ODD, PI, RADIANS, RAND, RANDBETWEEN, ROMAN
2020-05-07 00:15:54 +08:00
// ROMAN
"=ROMAN()": "ROMAN requires at least 1 argument",
"=ROMAN(1,2,3)": "ROMAN allows at most 2 arguments",
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=ROMAN("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
`=ROMAN("X",1)`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
#65, fn: ROUND, ROUNDDOWN, ROUNDUP, SEC, SECH, SIN, SINH, SQRTPI, TAN, TANH, TRUNC
2020-05-08 00:31:17 +08:00
// ROUND
updated test and go.mod
2020-05-11 00:01:22 +08:00
"=ROUND()": "ROUND requires 2 numeric arguments",
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=ROUND("X",1)`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
`=ROUND(1,"X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
#65, fn: ROUND, ROUNDDOWN, ROUNDUP, SEC, SECH, SIN, SINH, SQRTPI, TAN, TANH, TRUNC
2020-05-08 00:31:17 +08:00
// ROUNDDOWN
updated test and go.mod
2020-05-11 00:01:22 +08:00
"=ROUNDDOWN()": "ROUNDDOWN requires 2 numeric arguments",
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=ROUNDDOWN("X",1)`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
`=ROUNDDOWN(1,"X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
#65, fn: ROUND, ROUNDDOWN, ROUNDUP, SEC, SECH, SIN, SINH, SQRTPI, TAN, TANH, TRUNC
2020-05-08 00:31:17 +08:00
// ROUNDUP
updated test and go.mod
2020-05-11 00:01:22 +08:00
"=ROUNDUP()": "ROUNDUP requires 2 numeric arguments",
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=ROUNDUP("X",1)`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
`=ROUNDUP(1,"X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
#65, fn: ROUND, ROUNDDOWN, ROUNDUP, SEC, SECH, SIN, SINH, SQRTPI, TAN, TANH, TRUNC
2020-05-08 00:31:17 +08:00
// SEC
updated test and go.mod
2020-05-11 00:01:22 +08:00
"=_xlfn.SEC()": "SEC requires 1 numeric argument",
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=_xlfn.SEC("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
#65, fn: ROUND, ROUNDDOWN, ROUNDUP, SEC, SECH, SIN, SINH, SQRTPI, TAN, TANH, TRUNC
2020-05-08 00:31:17 +08:00
// _xlfn.SECH
updated test and go.mod
2020-05-11 00:01:22 +08:00
"=_xlfn.SECH()": "SECH requires 1 numeric argument",
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=_xlfn.SECH("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
fn: ABS, GCD, LCM, POWER, PRODUCT, SIGN, SQRT, SUM, QUOTIENT
2020-05-04 13:40:04 +08:00
// SIGN
updated test and go.mod
2020-05-11 00:01:22 +08:00
"=SIGN()": "SIGN requires 1 numeric argument",
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=SIGN("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
#65, fn: ROUND, ROUNDDOWN, ROUNDUP, SEC, SECH, SIN, SINH, SQRTPI, TAN, TANH, TRUNC
2020-05-08 00:31:17 +08:00
// SIN
updated test and go.mod
2020-05-11 00:01:22 +08:00
"=SIN()": "SIN requires 1 numeric argument",
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=SIN("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
#65, fn: ROUND, ROUNDDOWN, ROUNDUP, SEC, SECH, SIN, SINH, SQRTPI, TAN, TANH, TRUNC
2020-05-08 00:31:17 +08:00
// SINH
updated test and go.mod
2020-05-11 00:01:22 +08:00
"=SINH()": "SINH requires 1 numeric argument",
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=SINH("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
init formula calculation engine, ref #65 and #599
2020-05-03 18:44:43 +08:00
// SQRT
updated test and go.mod
2020-05-11 00:01:22 +08:00
"=SQRT()": "SQRT requires 1 numeric argument",
update formula functions test
2021-02-01 00:07:51 +08:00
`=SQRT("")`: "strconv.ParseFloat: parsing \"\": invalid syntax",
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=SQRT("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
updated test and go.mod
2020-05-11 00:01:22 +08:00
"=SQRT(-1)": "#NUM!",
#65, fn: ROUND, ROUNDDOWN, ROUNDUP, SEC, SECH, SIN, SINH, SQRTPI, TAN, TANH, TRUNC
2020-05-08 00:31:17 +08:00
// SQRTPI
updated test and go.mod
2020-05-11 00:01:22 +08:00
"=SQRTPI()": "SQRTPI requires 1 numeric argument",
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=SQRTPI("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
#65 fn: KURT, STDEV, STDEVA
2021-02-17 00:51:06 +08:00
// STDEV
"=STDEV()": "STDEV requires at least 1 argument",
"=STDEV(E2:E9)": "#DIV/0!",
#65, new fn: POISSON.DIST, POISSON, SKEW, and STDEV.S
2021-03-26 00:17:29 +08:00
// STDEV.S
"=STDEV.S()": "STDEV.S requires at least 1 argument",
#65 fn: KURT, STDEV, STDEVA
2021-02-17 00:51:06 +08:00
// STDEVA
"=STDEVA()": "STDEVA requires at least 1 argument",
"=STDEVA(E2:E9)": "#DIV/0!",
#65, new fn: POISSON.DIST, POISSON, SKEW, and STDEV.S
2021-03-26 00:17:29 +08:00
// POISSON.DIST
"=POISSON.DIST()": "POISSON.DIST requires 3 arguments",
// POISSON
"=POISSON()": "POISSON requires 3 arguments",
"=POISSON(\"\",0,FALSE)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=POISSON(0,\"\",FALSE)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=POISSON(0,0,\"\")": "strconv.ParseBool: parsing \"\": invalid syntax",
"=POISSON(0,-1,TRUE)": "#N/A",
- fn: SUMSQ - resolve ineffectual assignment - handle exception with invalid formula - update range resolver
2020-05-09 00:32:36 +08:00
// SUM
This closes #652, new SetColWidth API, support set column width in stream writing mode, and export error message
2021-05-10 00:09:24 +08:00
"=SUM((": ErrInvalidFormula.Error(),
"=SUM(-)": ErrInvalidFormula.Error(),
"=SUM(1+)": ErrInvalidFormula.Error(),
"=SUM(1-)": ErrInvalidFormula.Error(),
"=SUM(1*)": ErrInvalidFormula.Error(),
"=SUM(1/)": ErrInvalidFormula.Error(),
fn: SUMIF
2020-05-30 23:21:02 +08:00
// SUMIF
"=SUMIF()": "SUMIF requires at least 2 argument",
updated test and go.mod
2020-05-11 00:01:22 +08:00
// SUMSQ
init new formula function: HLOOKUP
2021-02-09 00:12:53 +08:00
`=SUMSQ("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
"=SUMSQ(C1:D2)": "strconv.ParseFloat: parsing \"Month\": invalid syntax",
#65, fn: ROUND, ROUNDDOWN, ROUNDUP, SEC, SECH, SIN, SINH, SQRTPI, TAN, TANH, TRUNC
2020-05-08 00:31:17 +08:00
// TAN
updated test and go.mod
2020-05-11 00:01:22 +08:00
"=TAN()": "TAN requires 1 numeric argument",
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=TAN("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
#65, fn: ROUND, ROUNDDOWN, ROUNDUP, SEC, SECH, SIN, SINH, SQRTPI, TAN, TANH, TRUNC
2020-05-08 00:31:17 +08:00
// TANH
updated test and go.mod
2020-05-11 00:01:22 +08:00
"=TANH()": "TANH requires 1 numeric argument",
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=TANH("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
#65, fn: ROUND, ROUNDDOWN, ROUNDUP, SEC, SECH, SIN, SINH, SQRTPI, TAN, TANH, TRUNC
2020-05-08 00:31:17 +08:00
// TRUNC
updated test and go.mod
2020-05-11 00:01:22 +08:00
"=TRUNC()": "TRUNC requires at least 1 argument",
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=TRUNC("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
`=TRUNC(1,"X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax",
New formula function AND (#701) and update doc for the NewSheet (#714)
2020-10-22 08:29:25 +08:00
// Statistical Functions
lint issue fixed and new formula function: ATAN, AVERAGE, AVERAGEA, CONCAT, CONCATENATE, COUNT, COUNTBLANK, MAX
2021-02-15 00:09:35 +08:00
// AVERAGE
"=AVERAGE(H1)": "AVERAGE divide by zero",
// AVERAGE
"=AVERAGEA(H1)": "AVERAGEA divide by zero",
// COUNTBLANK
"=COUNTBLANK()": "COUNTBLANK requires 1 argument",
"=COUNTBLANK(1,2)": "COUNTBLANK requires 1 argument",
This closes #785, support to change tab color; new formula function: FISHER, FISHERINV, GAMMA, GAMMALN, MIN, MINA, PERMUT
2021-02-16 00:02:14 +08:00
// FISHER
"=FISHER()": "FISHER requires 1 numeric argument",
"=FISHER(2)": "#N/A",
"=FISHER(INT(-2)))": "#N/A",
"=FISHER(F1)": "FISHER requires 1 numeric argument",
// FISHERINV
"=FISHERINV()": "FISHERINV requires 1 numeric argument",
"=FISHERINV(F1)": "FISHERINV requires 1 numeric argument",
// GAMMA
"=GAMMA()": "GAMMA requires 1 numeric argument",
"=GAMMA(F1)": "GAMMA requires 1 numeric argument",
"=GAMMA(0)": "#N/A",
"=GAMMA(INT(0))": "#N/A",
// GAMMALN
"=GAMMALN()": "GAMMALN requires 1 numeric argument",
"=GAMMALN(F1)": "GAMMALN requires 1 numeric argument",
"=GAMMALN(0)": "#N/A",
"=GAMMALN(INT(0))": "#N/A",
This closes #809, and add new fn: HARMEAN
2021-03-25 00:05:02 +08:00
// HARMEAN
"=HARMEAN()": "HARMEAN requires at least 1 argument",
"=HARMEAN(-1)": "#N/A",
"=HARMEAN(0)": "#N/A",
#65 fn: KURT, STDEV, STDEVA
2021-02-17 00:51:06 +08:00
// KURT
"=KURT()": "KURT requires at least 1 argument",
"=KURT(F1,INT(1))": "#DIV/0!",
#64 fn: NORM.DIST, NORMDIST, NORM.INV, NORMINV, NORM.S.DIST, NORMSDIST, NORM.S.INV, and NORMSINV
2021-03-24 08:24:59 +08:00
// NORM.DIST
"=NORM.DIST()": "NORM.DIST requires 4 arguments",
// NORMDIST
"=NORMDIST()": "NORMDIST requires 4 arguments",
"=NORMDIST(\"\",0,0,FALSE)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=NORMDIST(0,\"\",0,FALSE)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=NORMDIST(0,0,\"\",FALSE)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=NORMDIST(0,0,0,\"\")": "strconv.ParseBool: parsing \"\": invalid syntax",
"=NORMDIST(0,0,-1,TRUE)": "#N/A",
// NORM.INV
"=NORM.INV()": "NORM.INV requires 3 arguments",
// NORMINV
"=NORMINV()": "NORMINV requires 3 arguments",
"=NORMINV(\"\",0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=NORMINV(0,\"\",0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=NORMINV(0,0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=NORMINV(0,0,-1)": "#N/A",
"=NORMINV(-1,0,0)": "#N/A",
"=NORMINV(0,0,0)": "#NUM!",
// NORM.S.DIST
"=NORM.S.DIST()": "NORM.S.DIST requires 2 numeric arguments",
// NORMSDIST
"=NORMSDIST()": "NORMSDIST requires 1 numeric argument",
// NORM.S.INV
"=NORM.S.INV()": "NORM.S.INV requires 1 numeric argument",
// NORMSINV
"=NORMSINV()": "NORMSINV requires 1 numeric argument",
#65 fn: LARGE, SMALL, SUBSTITUTE, refactor ARABIC
2021-03-02 22:34:09 +08:00
// LARGE
"=LARGE()": "LARGE requires 2 arguments",
"=LARGE(A1:A5,0)": "k should be > 0",
"=LARGE(A1:A5,6)": "k should be <= length of array",
"=LARGE(A1:A5,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
lint issue fixed and new formula function: ATAN, AVERAGE, AVERAGEA, CONCAT, CONCATENATE, COUNT, COUNTBLANK, MAX
2021-02-15 00:09:35 +08:00
// MAX
"=MAX()": "MAX requires at least 1 argument",
"=MAX(NA())": "#N/A",
// MAXA
"=MAXA()": "MAXA requires at least 1 argument",
"=MAXA(NA())": "#N/A",
fn: MEDIAN, ISNUMBER
2020-06-02 23:39:41 +08:00
// MEDIAN
init new formula function: HLOOKUP
2021-02-09 00:12:53 +08:00
"=MEDIAN()": "MEDIAN requires at least 1 argument",
lint issue fixed and new formula function: ATAN, AVERAGE, AVERAGEA, CONCAT, CONCATENATE, COUNT, COUNTBLANK, MAX
2021-02-15 00:09:35 +08:00
"=MEDIAN(\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
init new formula function: HLOOKUP
2021-02-09 00:12:53 +08:00
"=MEDIAN(D1:D2)": "strconv.ParseFloat: parsing \"Month\": invalid syntax",
This closes #785, support to change tab color; new formula function: FISHER, FISHERINV, GAMMA, GAMMALN, MIN, MINA, PERMUT
2021-02-16 00:02:14 +08:00
// MIN
"=MIN()": "MIN requires at least 1 argument",
"=MIN(NA())": "#N/A",
// MINA
"=MINA()": "MINA requires at least 1 argument",
"=MINA(NA())": "#N/A",
#65 fn: N, PERCENTILE.INC and T typo fixed
2021-03-30 23:02:22 +08:00
// PERCENTILE.INC
"=PERCENTILE.INC()": "PERCENTILE.INC requires 2 arguments",
#65 fn: PERCENTILE and PERMUTATIONA
2021-03-27 00:08:55 +08:00
// PERCENTILE
"=PERCENTILE()": "PERCENTILE requires 2 arguments",
"=PERCENTILE(0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=PERCENTILE(0,-1)": "#N/A",
"=PERCENTILE(NA(),1)": "#N/A",
This closes #785, support to change tab color; new formula function: FISHER, FISHERINV, GAMMA, GAMMALN, MIN, MINA, PERMUT
2021-02-16 00:02:14 +08:00
// PERMUT
"=PERMUT()": "PERMUT requires 2 numeric arguments",
"=PERMUT(\"\",0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=PERMUT(0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=PERMUT(6,8)": "#N/A",
#65 fn: PERCENTILE and PERMUTATIONA
2021-03-27 00:08:55 +08:00
// PERMUTATIONA
"=PERMUTATIONA()": "PERMUTATIONA requires 2 numeric arguments",
"=PERMUTATIONA(\"\",0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=PERMUTATIONA(0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=PERMUTATIONA(-1,0)": "#N/A",
"=PERMUTATIONA(0,-1)": "#N/A",
#65 fn: QUARTILE and QUARTILE.INC
2021-03-31 22:01:02 +08:00
// QUARTILE
"=QUARTILE()": "QUARTILE requires 2 arguments",
"=QUARTILE(A1:A4,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=QUARTILE(A1:A4,-1)": "#NUM!",
"=QUARTILE(A1:A4,5)": "#NUM!",
// QUARTILE.INC
"=QUARTILE.INC()": "QUARTILE.INC requires 2 arguments",
#65, new fn: POISSON.DIST, POISSON, SKEW, and STDEV.S
2021-03-26 00:17:29 +08:00
// SKEW
"=SKEW()": "SKEW requires at least 1 argument",
"=SKEW(\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=SKEW(0)": "#DIV/0!",
#65 fn: LARGE, SMALL, SUBSTITUTE, refactor ARABIC
2021-03-02 22:34:09 +08:00
// SMALL
"=SMALL()": "SMALL requires 2 arguments",
"=SMALL(A1:A5,0)": "k should be > 0",
"=SMALL(A1:A5,6)": "k should be <= length of array",
"=SMALL(A1:A5,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
#65 fn: VAR.P and VARP and fix Yoda conditions issue
2021-04-01 21:52:43 +08:00
// VARP
"=VARP()": "VARP requires at least 1 argument",
"=VARP(\"\")": "#DIV/0!",
// VAR.P
"=VAR.P()": "VAR.P requires at least 1 argument",
"=VAR.P(\"\")": "#DIV/0!",
new formula functions: WEIBULL and WEIBULL.DIST, ref #65
2021-09-14 22:23:12 +08:00
// WEIBULL
"=WEIBULL()": "WEIBULL requires 4 arguments",
"=WEIBULL(\"\",1,1,FALSE)": "#VALUE!",
"=WEIBULL(1,0,1,FALSE)": "#N/A",
"=WEIBULL(1,1,-1,FALSE)": "#N/A",
// WEIBULL.DIST
"=WEIBULL.DIST()": "WEIBULL.DIST requires 4 arguments",
"=WEIBULL.DIST(\"\",1,1,FALSE)": "#VALUE!",
"=WEIBULL.DIST(1,0,1,FALSE)": "#N/A",
"=WEIBULL.DIST(1,1,-1,FALSE)": "#N/A",
new formula functions: Z.TEST and ZTEST, ref #65
2021-09-13 22:40:38 +08:00
// Z.TEST
new formula functions: WEIBULL and WEIBULL.DIST, ref #65
2021-09-14 22:23:12 +08:00
"=Z.TEST(A1)": "Z.TEST requires at least 2 arguments",
"=Z.TEST(A1,0,0,0)": "Z.TEST accepts at most 3 arguments",
"=Z.TEST(H1,0)": "#N/A",
"=Z.TEST(A1,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=Z.TEST(A1,1)": "#DIV/0!",
"=Z.TEST(A1,1,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
new formula functions: Z.TEST and ZTEST, ref #65
2021-09-13 22:40:38 +08:00
// ZTEST
new formula functions: WEIBULL and WEIBULL.DIST, ref #65
2021-09-14 22:23:12 +08:00
"=ZTEST(A1)": "ZTEST requires at least 2 arguments",
"=ZTEST(A1,0,0,0)": "ZTEST accepts at most 3 arguments",
"=ZTEST(H1,0)": "#N/A",
"=ZTEST(A1,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=ZTEST(A1,1)": "#DIV/0!",
"=ZTEST(A1,1,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
New formula function AND (#701) and update doc for the NewSheet (#714)
2020-10-22 08:29:25 +08:00
// Information Functions
fn: ISBLANK, ISERR, ISERROR, ISEVEN, ISNA, ISNONTEXT, ISODD, NA
2020-05-31 15:13:52 +08:00
// ISBLANK
"=ISBLANK(A1,A2)": "ISBLANK requires 1 argument",
// ISERR
"=ISERR()": "ISERR requires 1 argument",
// ISERROR
"=ISERROR()": "ISERROR requires 1 argument",
// ISEVEN
- Resolve #711, update docs for the GetSheetIndex - Update unit test
2020-10-12 00:05:27 +08:00
"=ISEVEN()": "ISEVEN requires 1 argument",
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=ISEVEN("text")`: "strconv.Atoi: parsing \"text\": invalid syntax",
fn: ISBLANK, ISERR, ISERROR, ISEVEN, ISNA, ISNONTEXT, ISODD, NA
2020-05-31 15:13:52 +08:00
// ISNA
"=ISNA()": "ISNA requires 1 argument",
// ISNONTEXT
"=ISNONTEXT()": "ISNONTEXT requires 1 argument",
fn: MEDIAN, ISNUMBER
2020-06-02 23:39:41 +08:00
// ISNUMBER
"=ISNUMBER()": "ISNUMBER requires 1 argument",
fn: ISBLANK, ISERR, ISERROR, ISEVEN, ISNA, ISNONTEXT, ISODD, NA
2020-05-31 15:13:52 +08:00
// ISODD
- Resolve #711, update docs for the GetSheetIndex - Update unit test
2020-10-12 00:05:27 +08:00
"=ISODD()": "ISODD requires 1 argument",
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=ISODD("text")`: "strconv.Atoi: parsing \"text\": invalid syntax",
add ten formula functions: ENCODEURL, EXACT, FALSE, IFERROR, ISTEXT, LENB, NOT, REPT, SHEET, TRUE
2021-02-14 00:02:29 +08:00
// ISTEXT
"=ISTEXT()": "ISTEXT requires 1 argument",
#65 fn: N, PERCENTILE.INC and T typo fixed
2021-03-30 23:02:22 +08:00
// N
"=N()": "N requires 1 argument",
"=N(NA())": "#N/A",
fn: ISBLANK, ISERR, ISERROR, ISEVEN, ISNA, ISNONTEXT, ISODD, NA
2020-05-31 15:13:52 +08:00
// NA
lint issue fixed and new formula function: ATAN, AVERAGE, AVERAGEA, CONCAT, CONCATENATE, COUNT, COUNTBLANK, MAX
2021-02-15 00:09:35 +08:00
"=NA()": "#N/A",
fn: ISBLANK, ISERR, ISERROR, ISEVEN, ISNA, ISNONTEXT, ISODD, NA
2020-05-31 15:13:52 +08:00
"=NA(1)": "NA accepts no arguments",
add ten formula functions: ENCODEURL, EXACT, FALSE, IFERROR, ISTEXT, LENB, NOT, REPT, SHEET, TRUE
2021-02-14 00:02:29 +08:00
// SHEET
"=SHEET(1)": "SHEET accepts no arguments",
#65 fn: N, PERCENTILE.INC and T typo fixed
2021-03-30 23:02:22 +08:00
// T
"=T()": "T requires 1 argument",
"=T(NA())": "#N/A",
New formula function AND (#701) and update doc for the NewSheet (#714)
2020-10-22 08:29:25 +08:00
// Logical Functions
Fix #701, init new formula function AND and OR, prevent formula lexer panic on retrieving the top token type
2020-10-17 00:57:12 +08:00
// AND
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=AND("text")`: "strconv.ParseFloat: parsing \"text\": invalid syntax",
Fix #701, init new formula function AND and OR, prevent formula lexer panic on retrieving the top token type
2020-10-17 00:57:12 +08:00
`=AND(A1:B1)`: "#VALUE!",
"=AND()": "AND requires at least 1 argument",
"=AND(1" + strings.Repeat(",1", 30) + ")": "AND accepts at most 30 arguments",
add ten formula functions: ENCODEURL, EXACT, FALSE, IFERROR, ISTEXT, LENB, NOT, REPT, SHEET, TRUE
2021-02-14 00:02:29 +08:00
// FALSE
"=FALSE(A1)": "FALSE takes no arguments",
// IFERROR
"=IFERROR()": "IFERROR requires 2 arguments",
// NOT
"=NOT()": "NOT requires 1 argument",
"=NOT(NOT())": "NOT requires 1 argument",
"=NOT(\"\")": "NOT expects 1 boolean or numeric argument",
Fix #701, init new formula function AND and OR, prevent formula lexer panic on retrieving the top token type
2020-10-17 00:57:12 +08:00
// OR
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
`=OR("text")`: "strconv.ParseFloat: parsing \"text\": invalid syntax",
Fix #701, init new formula function AND and OR, prevent formula lexer panic on retrieving the top token type
2020-10-17 00:57:12 +08:00
`=OR(A1:B1)`: "#VALUE!",
"=OR()": "OR requires at least 1 argument",
"=OR(1" + strings.Repeat(",1", 30) + ")": "OR accepts at most 30 arguments",
add ten formula functions: ENCODEURL, EXACT, FALSE, IFERROR, ISTEXT, LENB, NOT, REPT, SHEET, TRUE
2021-02-14 00:02:29 +08:00
// TRUE
"=TRUE(A1)": "TRUE takes no arguments",
This closes #1008, added new formula functions MATCH and XOR, related issue #65
2021-08-29 00:03:44 +08:00
// XOR
"=XOR()": "XOR requires at least 1 argument",
"=XOR(\"text\")": "#VALUE!",
"=XOR(XOR(\"text\"))": "#VALUE!",
New formula function AND (#701) and update doc for the NewSheet (#714)
2020-10-22 08:29:25 +08:00
// Date and Time Functions
// DATE
"=DATE()": "DATE requires 3 number arguments",
`=DATE("text",10,21)`: "DATE requires 3 number arguments",
`=DATE(2020,"text",21)`: "DATE requires 3 number arguments",
`=DATE(2020,10,"text")`: "DATE requires 3 number arguments",
#65 fn: DATEDIF
2021-03-19 23:23:05 +08:00
// DATEDIF
"=DATEDIF()": "DATEDIF requires 3 number arguments",
"=DATEDIF(\"\",\"\",\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=DATEDIF(43891,43101,\"Y\")": "start_date > end_date",
"=DATEDIF(43101,43891,\"x\")": "DATEDIF has invalid unit",
This closes #1002, new fn: DAY ref #65 Co-authored-by: Stani Michiels <git@rchtct.com> Co-authored-by: xuri <xuri.me@gmail.com>
2021-08-21 11:50:49 +08:00
// DAY
"=DAY()": "DAY requires exactly 1 argument",
"=DAY(-1)": "DAY only accepts positive argument",
"=DAY(0,0)": "DAY requires exactly 1 argument",
"=DAY(\"text\")": "#VALUE!",
"=DAY(\"January 25, 2020 9223372036854775808 AM\")": "#VALUE!",
"=DAY(\"January 25, 2020 9223372036854775808:00 AM\")": "#VALUE!",
"=DAY(\"January 25, 2020 00:9223372036854775808 AM\")": "#VALUE!",
"=DAY(\"January 25, 2020 9223372036854775808:00.0 AM\")": "#VALUE!",
"=DAY(\"January 25, 2020 0:1" + strings.Repeat("0", 309) + ".0 AM\")": "#VALUE!",
"=DAY(\"January 25, 2020 9223372036854775808:00:00 AM\")": "#VALUE!",
"=DAY(\"January 25, 2020 0:9223372036854775808:0 AM\")": "#VALUE!",
"=DAY(\"January 25, 2020 0:0:1" + strings.Repeat("0", 309) + " AM\")": "#VALUE!",
"=DAY(\"January 25, 2020 0:61:0 AM\")": "#VALUE!",
"=DAY(\"January 25, 2020 0:00:60 AM\")": "#VALUE!",
"=DAY(\"January 25, 2020 24:00:00\")": "#VALUE!",
"=DAY(\"January 25, 2020 00:00:10001\")": "#VALUE!",
"=DAY(\"9223372036854775808/25/2020\")": "#VALUE!",
"=DAY(\"01/9223372036854775808/2020\")": "#VALUE!",
"=DAY(\"01/25/9223372036854775808\")": "#VALUE!",
"=DAY(\"01/25/10000\")": "#VALUE!",
"=DAY(\"01/25/100\")": "#VALUE!",
"=DAY(\"January 9223372036854775808, 2020\")": "#VALUE!",
"=DAY(\"January 25, 9223372036854775808\")": "#VALUE!",
"=DAY(\"January 25, 10000\")": "#VALUE!",
"=DAY(\"January 25, 100\")": "#VALUE!",
"=DAY(\"9223372036854775808-25-2020\")": "#VALUE!",
"=DAY(\"01-9223372036854775808-2020\")": "#VALUE!",
"=DAY(\"01-25-9223372036854775808\")": "#VALUE!",
"=DAY(\"1900-0-0\")": "#VALUE!",
"=DAY(\"14-25-1900\")": "#VALUE!",
"=DAY(\"3-January-9223372036854775808\")": "#VALUE!",
"=DAY(\"9223372036854775808-January-1900\")": "#VALUE!",
"=DAY(\"0-January-1900\")": "#VALUE!",
* This closes #1004, new fn: MONTH ref #65
2021-08-21 15:46:43 +08:00
// MONTH
"=MONTH()": "MONTH requires exactly 1 argument",
This closes #1006, new fn: MONTH ref #65 Co-authored-by: xuri <xuri.me@gmail.com>
2021-08-21 20:15:53 +08:00
"=MONTH(0,0)": "MONTH requires exactly 1 argument",
* This closes #1004, new fn: MONTH ref #65
2021-08-21 15:46:43 +08:00
"=MONTH(-1)": "MONTH only accepts positive argument",
"=MONTH(\"text\")": "#VALUE!",
"=MONTH(\"January 25, 100\")": "#VALUE!",
This closes #1006, new fn: MONTH ref #65 Co-authored-by: xuri <xuri.me@gmail.com>
2021-08-21 20:15:53 +08:00
// YEAR
"=YEAR()": "YEAR requires exactly 1 argument",
"=YEAR(0,0)": "YEAR requires exactly 1 argument",
"=YEAR(-1)": "YEAR only accepts positive argument",
"=YEAR(\"text\")": "#VALUE!",
"=YEAR(\"January 25, 100\")": "#VALUE!",
#65 fn: NOW and TODAY, and update dependencies
2021-03-14 22:29:18 +08:00
// NOW
"=NOW(A1)": "NOW accepts no arguments",
// TODAY
"=TODAY(A1)": "TODAY accepts no arguments",
new formula func CLEAN and TRIM, change import path to v2 (#747)
2020-12-14 09:56:42 +08:00
// Text Functions
This improves compatibility for absolute XML path, Windows-style directory separator and inline namespace;
2021-02-27 00:03:46 +08:00
// CHAR
"=CHAR()": "CHAR requires 1 argument",
"=CHAR(-1)": "#VALUE!",
"=CHAR(256)": "#VALUE!",
"=CHAR(\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
new formula func CLEAN and TRIM, change import path to v2 (#747)
2020-12-14 09:56:42 +08:00
// CLEAN
"=CLEAN()": "CLEAN requires 1 argument",
"=CLEAN(1,2)": "CLEAN requires 1 argument",
handle default underline type on get rich text; #65 fn: CODE, COLUMN, FIND, FINDB
2021-02-24 00:37:44 +08:00
// CODE
"=CODE()": "CODE requires 1 argument",
"=CODE(1,2)": "CODE requires 1 argument",
lint issue fixed and new formula function: ATAN, AVERAGE, AVERAGEA, CONCAT, CONCATENATE, COUNT, COUNTBLANK, MAX
2021-02-15 00:09:35 +08:00
// CONCAT
"=CONCAT(MUNIT(2))": "CONCAT requires arguments to be strings",
// CONCATENATE
"=CONCATENATE(MUNIT(2))": "CONCATENATE requires arguments to be strings",
add ten formula functions: ENCODEURL, EXACT, FALSE, IFERROR, ISTEXT, LENB, NOT, REPT, SHEET, TRUE
2021-02-14 00:02:29 +08:00
// EXACT
"=EXACT()": "EXACT requires 2 arguments",
"=EXACT(1,2,3)": "EXACT requires 2 arguments",
related issue #65 fn: FIXED
2021-03-21 23:45:36 +08:00
// FIXED
"=FIXED()": "FIXED requires at least 1 argument",
"=FIXED(0,1,2,3)": "FIXED allows at most 3 arguments",
"=FIXED(\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=FIXED(0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=FIXED(0,0,\"\")": "strconv.ParseBool: parsing \"\": invalid syntax",
handle default underline type on get rich text; #65 fn: CODE, COLUMN, FIND, FINDB
2021-02-24 00:37:44 +08:00
// FIND
"=FIND()": "FIND requires at least 2 arguments",
"=FIND(1,2,3,4)": "FIND allows at most 3 arguments",
"=FIND(\"x\",\"\")": "#VALUE!",
"=FIND(\"x\",\"x\",-1)": "#VALUE!",
"=FIND(\"x\",\"x\",\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
// FINDB
"=FINDB()": "FINDB requires at least 2 arguments",
"=FINDB(1,2,3,4)": "FINDB allows at most 3 arguments",
"=FINDB(\"x\",\"\")": "#VALUE!",
"=FINDB(\"x\",\"x\",-1)": "#VALUE!",
"=FINDB(\"x\",\"x\",\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
check empty rich text run properties; new formula fn: LEFT, LEFTB, RIGHT, RIGHTB
2021-02-23 00:05:19 +08:00
// LEFT
"=LEFT()": "LEFT requires at least 1 argument",
"=LEFT(\"\",2,3)": "LEFT allows at most 2 arguments",
"=LEFT(\"\",\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=LEFT(\"\",-1)": "#VALUE!",
// LEFTB
"=LEFTB()": "LEFTB requires at least 1 argument",
"=LEFTB(\"\",2,3)": "LEFTB allows at most 2 arguments",
"=LEFTB(\"\",\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=LEFTB(\"\",-1)": "#VALUE!",
new formula fn: IF, LEN; not equal operator support and faster numeric precision process
2021-01-27 13:51:47 +08:00
// LEN
"=LEN()": "LEN requires 1 string argument",
add ten formula functions: ENCODEURL, EXACT, FALSE, IFERROR, ISTEXT, LENB, NOT, REPT, SHEET, TRUE
2021-02-14 00:02:29 +08:00
// LENB
"=LENB()": "LENB requires 1 string argument",
This closes #752, fix incorrectly merged cells on duplicate row, and new formula function: LOWER, PROPER, UPPER
2020-12-22 08:47:46 +08:00
// LOWER
"=LOWER()": "LOWER requires 1 argument",
"=LOWER(1,2)": "LOWER requires 1 argument",
This improves compatibility for absolute XML path, Windows-style directory separator and inline namespace;
2021-02-27 00:03:46 +08:00
// MID
"=MID()": "MID requires 3 arguments",
"=MID(\"\",-1,1)": "#VALUE!",
"=MID(\"\",\"\",1)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=MID(\"\",1,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
// MIDB
"=MIDB()": "MIDB requires 3 arguments",
"=MIDB(\"\",-1,1)": "#VALUE!",
"=MIDB(\"\",\"\",1)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=MIDB(\"\",1,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
This closes #752, fix incorrectly merged cells on duplicate row, and new formula function: LOWER, PROPER, UPPER
2020-12-22 08:47:46 +08:00
// PROPER
"=PROPER()": "PROPER requires 1 argument",
"=PROPER(1,2)": "PROPER requires 1 argument",
This improves compatibility for absolute XML path, Windows-style directory separator and inline namespace;
2021-02-27 00:03:46 +08:00
// REPLACE
"=REPLACE()": "REPLACE requires 4 arguments",
"=REPLACE(\"text\",0,4,\"string\")": "#VALUE!",
"=REPLACE(\"text\",\"\",0,\"string\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=REPLACE(\"text\",1,\"\",\"string\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
// REPLACEB
"=REPLACEB()": "REPLACEB requires 4 arguments",
"=REPLACEB(\"text\",0,4,\"string\")": "#VALUE!",
"=REPLACEB(\"text\",\"\",0,\"string\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=REPLACEB(\"text\",1,\"\",\"string\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
add ten formula functions: ENCODEURL, EXACT, FALSE, IFERROR, ISTEXT, LENB, NOT, REPT, SHEET, TRUE
2021-02-14 00:02:29 +08:00
// REPT
"=REPT()": "REPT requires 2 arguments",
"=REPT(INT(0),2)": "REPT requires first argument to be a string",
"=REPT(\"*\",\"*\")": "REPT requires second argument to be a number",
"=REPT(\"*\",-1)": "REPT requires second argument to be >= 0",
check empty rich text run properties; new formula fn: LEFT, LEFTB, RIGHT, RIGHTB
2021-02-23 00:05:19 +08:00
// RIGHT
"=RIGHT()": "RIGHT requires at least 1 argument",
"=RIGHT(\"\",2,3)": "RIGHT allows at most 2 arguments",
"=RIGHT(\"\",\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=RIGHT(\"\",-1)": "#VALUE!",
// RIGHTB
"=RIGHTB()": "RIGHTB requires at least 1 argument",
"=RIGHTB(\"\",2,3)": "RIGHTB allows at most 2 arguments",
"=RIGHTB(\"\",\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=RIGHTB(\"\",-1)": "#VALUE!",
#65 fn: LARGE, SMALL, SUBSTITUTE, refactor ARABIC
2021-03-02 22:34:09 +08:00
// SUBSTITUTE
"=SUBSTITUTE()": "SUBSTITUTE requires 3 or 4 arguments",
"=SUBSTITUTE(\"\",\"\",\"\",\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=SUBSTITUTE(\"\",\"\",\"\",0)": "instance_num should be > 0",
This improves compatibility for absolute XML path, Windows-style directory separator and inline namespace;
2021-02-27 00:03:46 +08:00
// TRIM
"=TRIM()": "TRIM requires 1 argument",
"=TRIM(1,2)": "TRIM requires 1 argument",
// UNICHAR
"=UNICHAR()": "UNICHAR requires 1 argument",
"=UNICHAR(\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=UNICHAR(55296)": "#VALUE!",
"=UNICHAR(0)": "#VALUE!",
// UNICODE
"=UNICODE()": "UNICODE requires 1 argument",
"=UNICODE(\"\")": "#VALUE!",
// UPPER
"=UPPER()": "UPPER requires 1 argument",
"=UPPER(1,2)": "UPPER requires 1 argument",
new formula fn: IF, LEN; not equal operator support and faster numeric precision process
2021-01-27 13:51:47 +08:00
// Conditional Functions
// IF
"=IF()": "IF requires at least 1 argument",
"=IF(0,1,2,3)": "IF accepts at most 3 arguments",
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
"=IF(D1,1,2)": "strconv.ParseBool: parsing \"Month\": invalid syntax",
// Excel Lookup and Reference Functions
// CHOOSE
"=CHOOSE()": "CHOOSE requires 2 arguments",
"=CHOOSE(\"index_num\",0)": "CHOOSE requires first argument of type number",
"=CHOOSE(2,0)": "index_num should be <= to the number of values",
handle default underline type on get rich text; #65 fn: CODE, COLUMN, FIND, FINDB
2021-02-24 00:37:44 +08:00
// COLUMN
"=COLUMN(1,2)": "COLUMN requires at most 1 argument",
"=COLUMN(\"\")": "invalid reference",
"=COLUMN(Sheet1)": "invalid column name \"Sheet1\"",
"=COLUMN(Sheet1!A1!B1)": "invalid column name \"Sheet1\"",
This improves compatibility for absolute XML path, Windows-style directory separator and inline namespace;
2021-02-27 00:03:46 +08:00
// COLUMNS
"=COLUMNS()": "COLUMNS requires 1 argument",
"=COLUMNS(1)": "invalid reference",
"=COLUMNS(\"\")": "invalid reference",
"=COLUMNS(Sheet1)": "invalid column name \"Sheet1\"",
"=COLUMNS(Sheet1!A1!B1)": "invalid column name \"Sheet1\"",
"=COLUMNS(Sheet1!Sheet1)": "invalid column name \"Sheet1\"",
init new formula function: HLOOKUP
2021-02-09 00:12:53 +08:00
// HLOOKUP
"=HLOOKUP()": "HLOOKUP requires at least 3 arguments",
"=HLOOKUP(D2,D1,1,FALSE)": "HLOOKUP requires second argument of table array",
"=HLOOKUP(D2,D:D,FALSE,FALSE)": "HLOOKUP requires numeric row argument",
"=HLOOKUP(D2,D:D,1,FALSE,FALSE)": "HLOOKUP requires at most 4 arguments",
"=HLOOKUP(D2,D:D,1,2)": "strconv.ParseBool: parsing \"2\": invalid syntax",
"=HLOOKUP(D2,D10:D10,1,FALSE)": "HLOOKUP no result found",
"=HLOOKUP(D2,D2:D3,4,FALSE)": "HLOOKUP has invalid row index",
"=HLOOKUP(D2,C:C,1,FALSE)": "HLOOKUP no result found",
"=HLOOKUP(ISNUMBER(1),F3:F9,1)": "HLOOKUP no result found",
"=HLOOKUP(INT(1),E2:E9,1)": "HLOOKUP no result found",
"=HLOOKUP(MUNIT(2),MUNIT(3),1)": "HLOOKUP no result found",
"=HLOOKUP(A1:B2,B2:B3,1)": "HLOOKUP no result found",
This closes #1008, added new formula functions MATCH and XOR, related issue #65
2021-08-29 00:03:44 +08:00
// MATCH
"=MATCH()": "MATCH requires 1 or 2 arguments",
"=MATCH(0,A1:A1,0,0)": "MATCH requires 1 or 2 arguments",
"=MATCH(0,A1:A1,\"x\")": "MATCH requires numeric match_type argument",
"=MATCH(0,A1)": "MATCH arguments lookup_array should be one-dimensional array",
"=MATCH(0,A1:B1)": "MATCH arguments lookup_array should be one-dimensional array",
init new formula function: VLOOKUP
2021-02-04 23:57:07 +08:00
// VLOOKUP
"=VLOOKUP()": "VLOOKUP requires at least 3 arguments",
"=VLOOKUP(D2,D1,1,FALSE)": "VLOOKUP requires second argument of table array",
"=VLOOKUP(D2,D:D,FALSE,FALSE)": "VLOOKUP requires numeric col argument",
"=VLOOKUP(D2,D:D,1,FALSE,FALSE)": "VLOOKUP requires at most 4 arguments",
"=VLOOKUP(D2,D:D,1,2)": "strconv.ParseBool: parsing \"2\": invalid syntax",
"=VLOOKUP(D2,D10:D10,1,FALSE)": "VLOOKUP no result found",
"=VLOOKUP(D2,D:D,2,FALSE)": "VLOOKUP has invalid column index",
"=VLOOKUP(D2,C:C,1,FALSE)": "VLOOKUP no result found",
"=VLOOKUP(ISNUMBER(1),F3:F9,1)": "VLOOKUP no result found",
"=VLOOKUP(INT(1),E2:E9,1)": "VLOOKUP no result found",
"=VLOOKUP(MUNIT(2),MUNIT(3),1)": "VLOOKUP no result found",
binary search in range lookup and new formula function: LOOKUP
2021-02-13 00:07:52 +08:00
"=VLOOKUP(1,G1:H2,1,FALSE)": "VLOOKUP no result found",
// LOOKUP
"=LOOKUP()": "LOOKUP requires at least 2 arguments",
"=LOOKUP(D2,D1,D2)": "LOOKUP requires second argument of table array",
"=LOOKUP(D2,D1,D2,FALSE)": "LOOKUP requires at most 3 arguments",
This closes #994, fix LOOKUP function for Array form
2021-08-19 22:12:37 +08:00
"=LOOKUP(1,MUNIT(0))": "LOOKUP requires not empty range as second argument",
binary search in range lookup and new formula function: LOOKUP
2021-02-13 00:07:52 +08:00
"=LOOKUP(D1,MUNIT(1),MUNIT(1))": "LOOKUP no result found",
This improves compatibility for absolute XML path, Windows-style directory separator and inline namespace;
2021-02-27 00:03:46 +08:00
// ROW
"=ROW(1,2)": "ROW requires at most 1 argument",
"=ROW(\"\")": "invalid reference",
"=ROW(Sheet1)": "invalid column name \"Sheet1\"",
"=ROW(Sheet1!A1!B1)": "invalid column name \"Sheet1\"",
// ROWS
"=ROWS()": "ROWS requires 1 argument",
"=ROWS(1)": "invalid reference",
"=ROWS(\"\")": "invalid reference",
"=ROWS(Sheet1)": "invalid column name \"Sheet1\"",
"=ROWS(Sheet1!A1!B1)": "invalid column name \"Sheet1\"",
"=ROWS(Sheet1!Sheet1)": "invalid column name \"Sheet1\"",
add ten formula functions: ENCODEURL, EXACT, FALSE, IFERROR, ISTEXT, LENB, NOT, REPT, SHEET, TRUE
2021-02-14 00:02:29 +08:00
// Web Functions
// ENCODEURL
"=ENCODEURL()": "ENCODEURL requires 1 argument",
#65 fn: IPMT, PMT and PPMT
2021-04-09 00:29:47 +08:00
// Financial Functions
fixed the negative values series missing chart color, #65 fn: CUMIPMT and CUMPRINC
2021-04-11 00:03:25 +08:00
// CUMIPMT
"=CUMIPMT()": "CUMIPMT requires 6 arguments",
"=CUMIPMT(0,0,0,0,0,2)": "#N/A",
"=CUMIPMT(0,0,0,-1,0,0)": "#N/A",
"=CUMIPMT(0,0,0,1,0,0)": "#N/A",
"=CUMIPMT(\"\",0,0,0,0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=CUMIPMT(0,\"\",0,0,0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=CUMIPMT(0,0,\"\",0,0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=CUMIPMT(0,0,0,\"\",0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=CUMIPMT(0,0,0,0,\"\",0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=CUMIPMT(0,0,0,0,0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
// CUMPRINC
"=CUMPRINC()": "CUMPRINC requires 6 arguments",
"=CUMPRINC(0,0,0,0,0,2)": "#N/A",
"=CUMPRINC(0,0,0,-1,0,0)": "#N/A",
"=CUMPRINC(0,0,0,1,0,0)": "#N/A",
"=CUMPRINC(\"\",0,0,0,0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=CUMPRINC(0,\"\",0,0,0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=CUMPRINC(0,0,\"\",0,0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=CUMPRINC(0,0,0,\"\",0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=CUMPRINC(0,0,0,0,\"\",0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=CUMPRINC(0,0,0,0,0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
#65 fn: DB, DDB, DOLLARDE, DOLLARFR, EFFECT, ISPMT and NOMINAL
2021-04-13 00:01:13 +08:00
// DB
"=DB()": "DB requires at least 4 arguments",
"=DB(0,0,0,0,0,0)": "DB allows at most 5 arguments",
"=DB(-1,0,0,0)": "#N/A",
"=DB(\"\",0,0,0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=DB(0,\"\",0,0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=DB(0,0,\"\",0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=DB(0,0,0,\"\",0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=DB(0,0,0,0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
// DDB
"=DDB()": "DDB requires at least 4 arguments",
"=DDB(0,0,0,0,0,0)": "DDB allows at most 5 arguments",
"=DDB(-1,0,0,0)": "#N/A",
"=DDB(\"\",0,0,0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=DDB(0,\"\",0,0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=DDB(0,0,\"\",0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=DDB(0,0,0,\"\",0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=DDB(0,0,0,0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
// DOLLARDE
"=DOLLARDE()": "DOLLARDE requires 2 arguments",
"=DOLLARDE(\"\",0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=DOLLARDE(0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=DOLLARDE(0,-1)": "#NUM!",
"=DOLLARDE(0,0)": "#DIV/0!",
// DOLLARFR
"=DOLLARFR()": "DOLLARFR requires 2 arguments",
"=DOLLARFR(\"\",0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=DOLLARFR(0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=DOLLARFR(0,-1)": "#NUM!",
"=DOLLARFR(0,0)": "#DIV/0!",
// EFFECT
"=EFFECT()": "EFFECT requires 2 arguments",
"=EFFECT(\"\",0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=EFFECT(0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=EFFECT(0,0)": "#NUM!",
"=EFFECT(1,0)": "#NUM!",
#65 fn: FV, FVSCHEDULE, NPER, NPV and PDURATION
2021-04-14 00:39:18 +08:00
// FV
"=FV()": "FV requires at least 3 arguments",
"=FV(0,0,0,0,0,0,0)": "FV allows at most 5 arguments",
"=FV(0,0,0,0,2)": "#N/A",
"=FV(\"\",0,0,0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=FV(0,\"\",0,0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=FV(0,0,\"\",0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=FV(0,0,0,\"\",0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=FV(0,0,0,0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
// FVSCHEDULE
"=FVSCHEDULE()": "FVSCHEDULE requires 2 arguments",
"=FVSCHEDULE(\"\",0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=FVSCHEDULE(0,\"x\")": "strconv.ParseFloat: parsing \"x\": invalid syntax",
#65 fn: IPMT, PMT and PPMT
2021-04-09 00:29:47 +08:00
// IPMT
"=IPMT()": "IPMT requires at least 4 arguments",
"=IPMT(0,0,0,0,0,0,0)": "IPMT allows at most 6 arguments",
"=IPMT(0,0,0,0,0,2)": "#N/A",
"=IPMT(0,-1,0,0,0,0)": "#N/A",
"=IPMT(0,1,0,0,0,0)": "#N/A",
"=IPMT(\"\",0,0,0,0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=IPMT(0,\"\",0,0,0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=IPMT(0,0,\"\",0,0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=IPMT(0,0,0,\"\",0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=IPMT(0,0,0,0,\"\",0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=IPMT(0,0,0,0,0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
#65 fn: DB, DDB, DOLLARDE, DOLLARFR, EFFECT, ISPMT and NOMINAL
2021-04-13 00:01:13 +08:00
// ISPMT
"=ISPMT()": "ISPMT requires 4 arguments",
"=ISPMT(\"\",0,0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=ISPMT(0,\"\",0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=ISPMT(0,0,\"\",0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=ISPMT(0,0,0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
// NOMINAL
"=NOMINAL()": "NOMINAL requires 2 arguments",
"=NOMINAL(\"\",0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=NOMINAL(0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=NOMINAL(0,0)": "#NUM!",
"=NOMINAL(1,0)": "#NUM!",
#65 fn: FV, FVSCHEDULE, NPER, NPV and PDURATION
2021-04-14 00:39:18 +08:00
// NPER
"=NPER()": "NPER requires at least 3 arguments",
"=NPER(0,0,0,0,0,0)": "NPER allows at most 5 arguments",
"=NPER(0,0,0)": "#NUM!",
"=NPER(0,0,0,0,2)": "#N/A",
"=NPER(\"\",0,0,0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=NPER(0,\"\",0,0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=NPER(0,0,\"\",0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=NPER(0,0,0,\"\",0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=NPER(0,0,0,0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
// NPV
"=NPV()": "NPV requires at least 2 arguments",
"=NPV(\"\",0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
// PDURATION
"=PDURATION()": "PDURATION requires 3 arguments",
"=PDURATION(\"\",0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=PDURATION(0,\"\",0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=PDURATION(0,0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=PDURATION(0,0,0)": "#NUM!",
#65 fn: IPMT, PMT and PPMT
2021-04-09 00:29:47 +08:00
// PMT
"=PMT()": "PMT requires at least 3 arguments",
"=PMT(0,0,0,0,0,0)": "PMT allows at most 5 arguments",
"=PMT(0,0,0,0,2)": "#N/A",
"=PMT(\"\",0,0,0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=PMT(0,\"\",0,0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=PMT(0,0,\"\",0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=PMT(0,0,0,\"\",0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=PMT(0,0,0,0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
// PPMT
"=PPMT()": "PPMT requires at least 4 arguments",
"=PPMT(0,0,0,0,0,0,0)": "PPMT allows at most 6 arguments",
"=PPMT(0,0,0,0,0,2)": "#N/A",
"=PPMT(0,-1,0,0,0,0)": "#N/A",
"=PPMT(0,1,0,0,0,0)": "#N/A",
"=PPMT(\"\",0,0,0,0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=PPMT(0,\"\",0,0,0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=PPMT(0,0,\"\",0,0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=PPMT(0,0,0,\"\",0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=PPMT(0,0,0,0,\"\",0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=PPMT(0,0,0,0,0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
init formula calculation engine, ref #65 and #599
2020-05-03 18:44:43 +08:00
}
for formula, expected := range mathCalcError {
binary search in range lookup and new formula function: LOOKUP
2021-02-13 00:07:52 +08:00
f := prepareCalcData(cellData)
init formula calculation engine, ref #65 and #599
2020-05-03 18:44:43 +08:00
assert.NoError(t, f.SetCellFormula("Sheet1", "C1", formula))
result, err := f.CalcCellValue("Sheet1", "C1")
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
assert.EqualError(t, err, expected, formula)
- fn: SUMSQ - resolve ineffectual assignment - handle exception with invalid formula - update range resolver
2020-05-09 00:32:36 +08:00
assert.Equal(t, "", result, formula)
init formula calculation engine, ref #65 and #599
2020-05-03 18:44:43 +08:00
}
referenceCalc := map[string]string{
#65 fn: CSCH, DECIMAL, DEGREES, EVEN, EXP, FACT, FACTDOUBLE, FLOOR, FLOOR.MATH, FLOOR.PRECISE, INT, ISO.CEILING, LN, LOG, LOG10, MDETERM
2020-05-06 00:01:31 +08:00
// MDETERM
"=MDETERM(A1:B2)": "-3",
fn: ABS, GCD, LCM, POWER, PRODUCT, SIGN, SQRT, SUM, QUOTIENT
2020-05-04 13:40:04 +08:00
// PRODUCT
"=PRODUCT(Sheet1!A1:Sheet1!A1:A2,A2)": "4",
#65 fn: IMLOG2, IMPOWER, IMPRODUCT, IMREAL, IMSEC, and IMSECH
2021-04-07 00:01:03 +08:00
// IMPRODUCT
"=IMPRODUCT(Sheet1!A1:Sheet1!A1:A2,A2)": "4",
fn: ABS, GCD, LCM, POWER, PRODUCT, SIGN, SQRT, SUM, QUOTIENT
2020-05-04 13:40:04 +08:00
// SUM
Fixed #727, rounding numeric with precision for formula calculation
2020-11-19 21:38:35 +08:00
"=A1/A3": "0.333333333333333",
init formula calculation engine, ref #65 and #599
2020-05-03 18:44:43 +08:00
"=SUM(A1:A2)": "3",
"=SUM(Sheet1!A1,A2)": "3",
"=(-2-SUM(-4+A2))*5": "0",
"=SUM(Sheet1!A1:Sheet1!A1:A2,A2)": "5",
"=SUM(A1,A2,A3)*SUM(2,3)": "30",
Fixed #727, rounding numeric with precision for formula calculation
2020-11-19 21:38:35 +08:00
"=1+SUM(SUM(A1+A2/A3)*(2-3),2)": "1.333333333333334",
"=A1/A2/SUM(A1:A2:B1)": "0.041666666666667",
- fn: SUMSQ - resolve ineffectual assignment - handle exception with invalid formula - update range resolver
2020-05-09 00:32:36 +08:00
"=A1/A2/SUM(A1:A2:B1)*A3": "0.125",
#65 fn: KURT, STDEV, STDEVA
2021-02-17 00:51:06 +08:00
"=SUM(B1:D1)": "4",
"=SUM(\"X\")": "0",
init formula calculation engine, ref #65 and #599
2020-05-03 18:44:43 +08:00
}
for formula, expected := range referenceCalc {
binary search in range lookup and new formula function: LOOKUP
2021-02-13 00:07:52 +08:00
f := prepareCalcData(cellData)
init formula calculation engine, ref #65 and #599
2020-05-03 18:44:43 +08:00
assert.NoError(t, f.SetCellFormula("Sheet1", "C1", formula))
result, err := f.CalcCellValue("Sheet1", "C1")
assert.NoError(t, err)
- fn: SUMSQ - resolve ineffectual assignment - handle exception with invalid formula - update range resolver
2020-05-09 00:32:36 +08:00
assert.Equal(t, expected, result, formula)
init formula calculation engine, ref #65 and #599
2020-05-03 18:44:43 +08:00
}
referenceCalcError := map[string]string{
#65 fn: CSCH, DECIMAL, DEGREES, EVEN, EXP, FACT, FACTDOUBLE, FLOOR, FLOOR.MATH, FLOOR.PRECISE, INT, ISO.CEILING, LN, LOG, LOG10, MDETERM
2020-05-06 00:01:31 +08:00
// MDETERM
"=MDETERM(A1:B3)": "#VALUE!",
// SUM
init formula calculation engine, ref #65 and #599
2020-05-03 18:44:43 +08:00
"=1+SUM(SUM(A1+A2/A4)*(2-3),2)": "#DIV/0!",
}
for formula, expected := range referenceCalcError {
binary search in range lookup and new formula function: LOOKUP
2021-02-13 00:07:52 +08:00
f := prepareCalcData(cellData)
init formula calculation engine, ref #65 and #599
2020-05-03 18:44:43 +08:00
assert.NoError(t, f.SetCellFormula("Sheet1", "C1", formula))
result, err := f.CalcCellValue("Sheet1", "C1")
assert.EqualError(t, err, expected)
- fn: SUMSQ - resolve ineffectual assignment - handle exception with invalid formula - update range resolver
2020-05-09 00:32:36 +08:00
assert.Equal(t, "", result, formula)
init formula calculation engine, ref #65 and #599
2020-05-03 18:44:43 +08:00
}
updated test and go.mod
2020-05-11 00:01:22 +08:00
volatileFuncs := []string{
#65 fn: NOW and TODAY, and update dependencies
2021-03-14 22:29:18 +08:00
"=NOW()",
updated test and go.mod
2020-05-11 00:01:22 +08:00
"=RAND()",
"=RANDBETWEEN(1,2)",
#65 fn: NOW and TODAY, and update dependencies
2021-03-14 22:29:18 +08:00
"=TODAY()",
updated test and go.mod
2020-05-11 00:01:22 +08:00
}
for _, formula := range volatileFuncs {
binary search in range lookup and new formula function: LOOKUP
2021-02-13 00:07:52 +08:00
f := prepareCalcData(cellData)
updated test and go.mod
2020-05-11 00:01:22 +08:00
assert.NoError(t, f.SetCellFormula("Sheet1", "C1", formula))
_, err := f.CalcCellValue("Sheet1", "C1")
assert.NoError(t, err)
}
init formula calculation engine, ref #65 and #599
2020-05-03 18:44:43 +08:00
// Test get calculated cell value on not formula cell.
binary search in range lookup and new formula function: LOOKUP
2021-02-13 00:07:52 +08:00
f := prepareCalcData(cellData)
init formula calculation engine, ref #65 and #599
2020-05-03 18:44:43 +08:00
result, err := f.CalcCellValue("Sheet1", "A1")
assert.NoError(t, err)
assert.Equal(t, "", result)
// Test get calculated cell value on not exists worksheet.
binary search in range lookup and new formula function: LOOKUP
2021-02-13 00:07:52 +08:00
f = prepareCalcData(cellData)
init formula calculation engine, ref #65 and #599
2020-05-03 18:44:43 +08:00
_, err = f.CalcCellValue("SheetN", "A1")
assert.EqualError(t, err, "sheet SheetN is not exist")
// Test get calculated cell value with not support formula.
binary search in range lookup and new formula function: LOOKUP
2021-02-13 00:07:52 +08:00
f = prepareCalcData(cellData)
init formula calculation engine, ref #65 and #599
2020-05-03 18:44:43 +08:00
assert.NoError(t, f.SetCellFormula("Sheet1", "A1", "=UNSUPPORT(A1)"))
_, err = f.CalcCellValue("Sheet1", "A1")
assert.EqualError(t, err, "not support UNSUPPORT function")
fn: SUMIF
2020-05-30 23:21:02 +08:00
assert.NoError(t, f.SaveAs(filepath.Join("test", "TestCalcCellValue.xlsx")))
Fix issue 665 (#666)
2020-07-14 23:05:43 +08:00
}
Fix #724, standardize variable naming and update unit tests
2020-11-10 23:48:09 +08:00
func TestCalculate(t *testing.T) {
err := `strconv.ParseFloat: parsing "string": invalid syntax`
opd := NewStack()
opd.Push(efp.Token{TValue: "string"})
opt := efp.Token{TValue: "-", TType: efp.TokenTypeOperatorPrefix}
assert.EqualError(t, calculate(opd, opt), err)
opd.Push(efp.Token{TValue: "string"})
opd.Push(efp.Token{TValue: "string"})
opt = efp.Token{TValue: "-", TType: efp.TokenTypeOperatorInfix}
assert.EqualError(t, calculate(opd, opt), err)
}
binary search in range lookup and new formula function: LOOKUP
2021-02-13 00:07:52 +08:00
func TestCalcWithDefinedName(t *testing.T) {
Fix issue 665 (#666)
2020-07-14 23:05:43 +08:00
cellData := [][]interface{}{
{"A1 value", "B1 value", nil},
}
binary search in range lookup and new formula function: LOOKUP
2021-02-13 00:07:52 +08:00
f := prepareCalcData(cellData)
assert.NoError(t, f.SetDefinedName(&DefinedName{Name: "defined_name1", RefersTo: "Sheet1!A1", Scope: "Workbook"}))
assert.NoError(t, f.SetDefinedName(&DefinedName{Name: "defined_name1", RefersTo: "Sheet1!B1", Scope: "Sheet1"}))
fixes #856 (#857)
2021-06-07 18:49:20 +08:00
Fix issue 665 (#666)
2020-07-14 23:05:43 +08:00
assert.NoError(t, f.SetCellFormula("Sheet1", "C1", "=defined_name1"))
result, err := f.CalcCellValue("Sheet1", "C1")
assert.NoError(t, err)
// DefinedName with scope WorkSheet takes precedence over DefinedName with scope Workbook, so we should get B1 value
assert.Equal(t, "B1 value", result, "=defined_name1")
fixes #856 (#857)
2021-06-07 18:49:20 +08:00
assert.NoError(t, f.SetCellFormula("Sheet1", "C1", "=CONCATENATE(\"<\",defined_name1,\">\")"))
result, err = f.CalcCellValue("Sheet1", "C1")
assert.NoError(t, err)
assert.Equal(t, "<B1 value>", result, "=defined_name1")
init formula calculation engine, ref #65 and #599
2020-05-03 18:44:43 +08:00
}
- Resolve #711, update docs for the GetSheetIndex - Update unit test
2020-10-12 00:05:27 +08:00
binary search in range lookup and new formula function: LOOKUP
2021-02-13 00:07:52 +08:00
func TestCalcArithmeticOperations(t *testing.T) {
This closes #998 - Support text comparison in the formula, also ref #65 - `GetCellValue`, `GetRows`, `GetCols`, `Rows` and `Cols` support to specify read cell with raw value, ref #621 - Add missing properties for the cell formula - Update the unit test for the `CalcCellValue`
2021-09-05 11:59:50 +08:00
opdStack := NewStack()
for _, test := range [][]string{{"1", "text", "FALSE"}, {"text", "1", "TRUE"}} {
assert.NoError(t, calcL(test[0], test[1], opdStack))
assert.Equal(t, test[2], opdStack.Peek().(efp.Token).TValue)
opdStack.Empty()
assert.NoError(t, calcLe(test[0], test[1], opdStack))
assert.Equal(t, test[2], opdStack.Peek().(efp.Token).TValue)
opdStack.Empty()
}
for _, test := range [][]string{{"1", "text", "TRUE"}, {"text", "1", "FALSE"}} {
assert.NoError(t, calcG(test[0], test[1], opdStack))
assert.Equal(t, test[2], opdStack.Peek().(efp.Token).TValue)
opdStack.Empty()
assert.NoError(t, calcGe(test[0], test[1], opdStack))
assert.Equal(t, test[2], opdStack.Peek().(efp.Token).TValue)
opdStack.Empty()
}
Fix #701, init new formula function AND and OR, prevent formula lexer panic on retrieving the top token type
2020-10-17 00:57:12 +08:00
err := `strconv.ParseFloat: parsing "text": invalid syntax`
assert.EqualError(t, calcPow("1", "text", nil), err)
assert.EqualError(t, calcPow("text", "1", nil), err)
assert.EqualError(t, calcAdd("1", "text", nil), err)
assert.EqualError(t, calcAdd("text", "1", nil), err)
assert.EqualError(t, calcAdd("1", "text", nil), err)
assert.EqualError(t, calcAdd("text", "1", nil), err)
assert.EqualError(t, calcSubtract("1", "text", nil), err)
assert.EqualError(t, calcSubtract("text", "1", nil), err)
assert.EqualError(t, calcMultiply("1", "text", nil), err)
assert.EqualError(t, calcMultiply("text", "1", nil), err)
assert.EqualError(t, calcDiv("1", "text", nil), err)
assert.EqualError(t, calcDiv("text", "1", nil), err)
}
binary search in range lookup and new formula function: LOOKUP
2021-02-13 00:07:52 +08:00
func TestCalcISBLANK(t *testing.T) {
Fix #701, init new formula function AND and OR, prevent formula lexer panic on retrieving the top token type
2020-10-17 00:57:12 +08:00
argsList := list.New()
argsList.PushBack(formulaArg{
Type: ArgUnknown,
})
fn := formulaFuncs{}
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
result := fn.ISBLANK(argsList)
assert.Equal(t, result.String, "TRUE")
assert.Empty(t, result.Error)
Fix #701, init new formula function AND and OR, prevent formula lexer panic on retrieving the top token type
2020-10-17 00:57:12 +08:00
}
binary search in range lookup and new formula function: LOOKUP
2021-02-13 00:07:52 +08:00
func TestCalcAND(t *testing.T) {
Fix #701, init new formula function AND and OR, prevent formula lexer panic on retrieving the top token type
2020-10-17 00:57:12 +08:00
argsList := list.New()
argsList.PushBack(formulaArg{
Type: ArgUnknown,
})
fn := formulaFuncs{}
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
result := fn.AND(argsList)
Fix hyperbolic cotangent calculation incorrect and unit test
2021-01-31 13:15:10 +08:00
assert.Equal(t, result.String, "")
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
assert.Empty(t, result.Error)
Fix #701, init new formula function AND and OR, prevent formula lexer panic on retrieving the top token type
2020-10-17 00:57:12 +08:00
}
binary search in range lookup and new formula function: LOOKUP
2021-02-13 00:07:52 +08:00
func TestCalcOR(t *testing.T) {
Fix #701, init new formula function AND and OR, prevent formula lexer panic on retrieving the top token type
2020-10-17 00:57:12 +08:00
argsList := list.New()
argsList.PushBack(formulaArg{
Type: ArgUnknown,
})
fn := formulaFuncs{}
refactor formula calculation framework, add new function CHOOSE, and update dependencies module
2021-01-30 00:11:01 +08:00
result := fn.OR(argsList)
assert.Equal(t, result.String, "FALSE")
assert.Empty(t, result.Error)
Fix #701, init new formula function AND and OR, prevent formula lexer panic on retrieving the top token type
2020-10-17 00:57:12 +08:00
}
binary search in range lookup and new formula function: LOOKUP
2021-02-13 00:07:52 +08:00
func TestCalcDet(t *testing.T) {
- Resolve #711, update docs for the GetSheetIndex - Update unit test
2020-10-12 00:05:27 +08:00
assert.Equal(t, det([][]float64{
{1, 2, 3, 4},
{2, 3, 4, 5},
{3, 4, 5, 6},
{4, 5, 6, 7},
}), float64(0))
}
init new formula function: VLOOKUP
2021-02-04 23:57:07 +08:00
binary search in range lookup and new formula function: LOOKUP
2021-02-13 00:07:52 +08:00
func TestCalcToBool(t *testing.T) {
b := newBoolFormulaArg(true).ToBool()
assert.Equal(t, b.Boolean, true)
assert.Equal(t, b.Number, 1.0)
}
lint issue fixed and new formula function: ATAN, AVERAGE, AVERAGEA, CONCAT, CONCATENATE, COUNT, COUNTBLANK, MAX
2021-02-15 00:09:35 +08:00
func TestCalcToList(t *testing.T) {
assert.Equal(t, []formulaArg(nil), newEmptyFormulaArg().ToList())
formulaList := []formulaArg{newEmptyFormulaArg()}
assert.Equal(t, formulaList, newListFormulaArg(formulaList).ToList())
}
binary search in range lookup and new formula function: LOOKUP
2021-02-13 00:07:52 +08:00
func TestCalcCompareFormulaArg(t *testing.T) {
init new formula function: VLOOKUP
2021-02-04 23:57:07 +08:00
assert.Equal(t, compareFormulaArg(newEmptyFormulaArg(), newEmptyFormulaArg(), false, false), criteriaEq)
lhs := newListFormulaArg([]formulaArg{newEmptyFormulaArg()})
rhs := newListFormulaArg([]formulaArg{newEmptyFormulaArg(), newEmptyFormulaArg()})
assert.Equal(t, compareFormulaArg(lhs, rhs, false, false), criteriaL)
assert.Equal(t, compareFormulaArg(rhs, lhs, false, false), criteriaG)
lhs = newListFormulaArg([]formulaArg{newBoolFormulaArg(true)})
rhs = newListFormulaArg([]formulaArg{newBoolFormulaArg(true)})
assert.Equal(t, compareFormulaArg(lhs, rhs, false, false), criteriaEq)
assert.Equal(t, compareFormulaArg(formulaArg{Type: ArgUnknown}, formulaArg{Type: ArgUnknown}, false, false), criteriaErr)
}
binary search in range lookup and new formula function: LOOKUP
2021-02-13 00:07:52 +08:00
func TestCalcMatchPattern(t *testing.T) {
init new formula function: VLOOKUP
2021-02-04 23:57:07 +08:00
assert.True(t, matchPattern("", ""))
assert.True(t, matchPattern("file/*", "file/abc/bcd/def"))
assert.True(t, matchPattern("*", ""))
assert.False(t, matchPattern("file/?", "file/abc/bcd/def"))
}
binary search in range lookup and new formula function: LOOKUP
2021-02-13 00:07:52 +08:00
func TestCalcVLOOKUP(t *testing.T) {
cellData := [][]interface{}{
{nil, nil, nil, nil, nil, nil},
{nil, "Score", "Grade", nil, nil, nil},
{nil, 0, "F", nil, "Score", 85},
{nil, 60, "D", nil, "Grade"},
{nil, 70, "C", nil, nil, nil},
{nil, 80, "b", nil, nil, nil},
{nil, 90, "A", nil, nil, nil},
{nil, 85, "B", nil, nil, nil},
{nil, nil, nil, nil, nil, nil},
}
f := prepareCalcData(cellData)
calc := map[string]string{
"=VLOOKUP(F3,B3:C8,2)": "b",
"=VLOOKUP(F3,B3:C8,2,TRUE)": "b",
"=VLOOKUP(F3,B3:C8,2,FALSE)": "B",
}
for formula, expected := range calc {
assert.NoError(t, f.SetCellFormula("Sheet1", "F4", formula))
result, err := f.CalcCellValue("Sheet1", "F4")
assert.NoError(t, err, formula)
assert.Equal(t, expected, result, formula)
}
calcError := map[string]string{
"=VLOOKUP(INT(1),C3:C3,1,FALSE)": "VLOOKUP no result found",
}
for formula, expected := range calcError {
assert.NoError(t, f.SetCellFormula("Sheet1", "F4", formula))
result, err := f.CalcCellValue("Sheet1", "F4")
assert.EqualError(t, err, expected, formula)
assert.Equal(t, "", result, formula)
}
}
#65 fn: KURT, STDEV, STDEVA
2021-02-17 00:51:06 +08:00
func TestCalcBoolean(t *testing.T) {
lint issue fixed and new formula function: ATAN, AVERAGE, AVERAGEA, CONCAT, CONCATENATE, COUNT, COUNTBLANK, MAX
2021-02-15 00:09:35 +08:00
cellData := [][]interface{}{
This closes #785, support to change tab color; new formula function: FISHER, FISHERINV, GAMMA, GAMMALN, MIN, MINA, PERMUT
2021-02-16 00:02:14 +08:00
{0.5, "TRUE", -0.5, "FALSE"},
lint issue fixed and new formula function: ATAN, AVERAGE, AVERAGEA, CONCAT, CONCATENATE, COUNT, COUNTBLANK, MAX
2021-02-15 00:09:35 +08:00
}
f := prepareCalcData(cellData)
formulaList := map[string]string{
#65 fn: KURT, STDEV, STDEVA
2021-02-17 00:51:06 +08:00
"=AVERAGEA(A1:C1)": "0.333333333333333",
"=MAX(0.5,B1)": "0.5",
"=MAX(A1:B1)": "0.5",
"=MAXA(A1:B1)": "1",
"=MAXA(0.5,B1)": "1",
"=MIN(-0.5,D1)": "-0.5",
"=MIN(C1:D1)": "-0.5",
"=MINA(C1:D1)": "-0.5",
"=MINA(-0.5,D1)": "-0.5",
"=STDEV(A1:C1)": "0.707106781186548",
"=STDEV(A1,B1,C1)": "0.707106781186548",
"=STDEVA(A1:C1,B1)": "0.707106781186548",
lint issue fixed and new formula function: ATAN, AVERAGE, AVERAGEA, CONCAT, CONCATENATE, COUNT, COUNTBLANK, MAX
2021-02-15 00:09:35 +08:00
}
for formula, expected := range formulaList {
assert.NoError(t, f.SetCellFormula("Sheet1", "B10", formula))
result, err := f.CalcCellValue("Sheet1", "B10")
assert.NoError(t, err, formula)
assert.Equal(t, expected, result, formula)
}
}
binary search in range lookup and new formula function: LOOKUP
2021-02-13 00:07:52 +08:00
func TestCalcHLOOKUP(t *testing.T) {
cellData := [][]interface{}{
{"Example Result Table"},
{nil, "A", "B", "C", "E", "F"},
{"Math", .58, .9, .67, .76, .8},
{"French", .61, .71, .59, .59, .76},
{"Physics", .75, .45, .39, .52, .69},
{"Biology", .39, .55, .77, .61, .45},
{},
{"Individual Student Score"},
{"Student:", "Biology Score:"},
{"E"},
}
f := prepareCalcData(cellData)
formulaList := map[string]string{
"=HLOOKUP(A10,A2:F6,5,FALSE)": "0.61",
"=HLOOKUP(D3,D3:D3,1,TRUE)": "0.67",
"=HLOOKUP(F3,D3:F3,1,TRUE)": "0.8",
"=HLOOKUP(A5,A2:F2,1,TRUE)": "F",
"=HLOOKUP(\"D\",A2:F2,1,TRUE)": "C",
}
for formula, expected := range formulaList {
assert.NoError(t, f.SetCellFormula("Sheet1", "B10", formula))
result, err := f.CalcCellValue("Sheet1", "B10")
assert.NoError(t, err, formula)
assert.Equal(t, expected, result, formula)
}
calcError := map[string]string{
"=HLOOKUP(INT(1),A3:A3,1,FALSE)": "HLOOKUP no result found",
}
for formula, expected := range calcError {
assert.NoError(t, f.SetCellFormula("Sheet1", "B10", formula))
result, err := f.CalcCellValue("Sheet1", "B10")
assert.EqualError(t, err, expected, formula)
assert.Equal(t, "", result, formula)
}
}
#65 fn: IRR nad MIRR
2021-04-16 22:45:45 +08:00
func TestCalcIRR(t *testing.T) {
cellData := [][]interface{}{{-1}, {0.2}, {0.24}, {0.288}, {0.3456}, {0.4147}}
f := prepareCalcData(cellData)
formulaList := map[string]string{
"=IRR(A1:A4)": "-0.136189509034157",
"=IRR(A1:A6)": "0.130575760006905",
"=IRR(A1:A4,-0.1)": "-0.136189514994621",
}
for formula, expected := range formulaList {
assert.NoError(t, f.SetCellFormula("Sheet1", "B1", formula))
result, err := f.CalcCellValue("Sheet1", "B1")
assert.NoError(t, err, formula)
assert.Equal(t, expected, result, formula)
}
calcError := map[string]string{
"=IRR()": "IRR requires at least 1 argument",
"=IRR(0,0,0)": "IRR allows at most 2 arguments",
"=IRR(0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=IRR(A2:A3)": "#NUM!",
}
for formula, expected := range calcError {
assert.NoError(t, f.SetCellFormula("Sheet1", "B1", formula))
result, err := f.CalcCellValue("Sheet1", "B1")
assert.EqualError(t, err, expected, formula)
assert.Equal(t, "", result, formula)
}
}
func TestCalcMIRR(t *testing.T) {
cellData := [][]interface{}{{-100}, {18}, {22.5}, {28}, {35.5}, {45}}
f := prepareCalcData(cellData)
formulaList := map[string]string{
"=MIRR(A1:A5,0.055,0.05)": "0.025376365108071",
"=MIRR(A1:A6,0.055,0.05)": "0.1000268752662",
}
for formula, expected := range formulaList {
assert.NoError(t, f.SetCellFormula("Sheet1", "B1", formula))
result, err := f.CalcCellValue("Sheet1", "B1")
assert.NoError(t, err, formula)
assert.Equal(t, expected, result, formula)
}
calcError := map[string]string{
"=MIRR()": "MIRR requires 3 arguments",
"=MIRR(A1:A5,\"\",0)": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=MIRR(A1:A5,0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax",
"=MIRR(B1:B5,0,0)": "#DIV/0!",
}
for formula, expected := range calcError {
assert.NoError(t, f.SetCellFormula("Sheet1", "B1", formula))
result, err := f.CalcCellValue("Sheet1", "B1")
assert.EqualError(t, err, expected, formula)
assert.Equal(t, "", result, formula)
}
}
This closes #1002, new fn: DAY ref #65 Co-authored-by: Stani Michiels <git@rchtct.com> Co-authored-by: xuri <xuri.me@gmail.com>
2021-08-21 11:50:49 +08:00
This closes #1008, added new formula functions MATCH and XOR, related issue #65
2021-08-29 00:03:44 +08:00
func TestCalcMATCH(t *testing.T) {
f := NewFile()
for cell, row := range map[string][]interface{}{
"A1": {"cccc", 7, 4, 16},
"A2": {"dddd", 2, 6, 11},
"A3": {"aaaa", 4, 7, 10},
"A4": {"bbbb", 1, 10, 7},
"A5": {"eeee", 8, 11, 6},
"A6": {nil, 11, 16, 4},
} {
assert.NoError(t, f.SetSheetRow("Sheet1", cell, &row))
}
formulaList := map[string]string{
"=MATCH(\"aaaa\",A1:A6,0)": "3",
"=MATCH(\"*b\",A1:A5,0)": "4",
"=MATCH(\"?eee\",A1:A5,0)": "5",
"=MATCH(\"?*?e\",A1:A5,0)": "5",
"=MATCH(\"aaaa\",A1:A6,1)": "3",
"=MATCH(10,B1:B6)": "5",
"=MATCH(8,C1:C6,1)": "3",
"=MATCH(6,B1:B6,-1)": "1",
"=MATCH(10,D1:D6,-1)": "3",
}
for formula, expected := range formulaList {
assert.NoError(t, f.SetCellFormula("Sheet1", "E1", formula))
result, err := f.CalcCellValue("Sheet1", "E1")
assert.NoError(t, err, formula)
assert.Equal(t, expected, result, formula)
}
calcError := map[string]string{
"=MATCH(3,C1:C6,1)": "#N/A",
"=MATCH(5,C1:C6,-1)": "#N/A",
}
for formula, expected := range calcError {
assert.NoError(t, f.SetCellFormula("Sheet1", "E1", formula))
result, err := f.CalcCellValue("Sheet1", "E1")
assert.EqualError(t, err, expected, formula)
assert.Equal(t, "", result, formula)
}
assert.Equal(t, newErrorFormulaArg(formulaErrorNA, formulaErrorNA), calcMatch(2, nil, []formulaArg{}))
}
new formula functions: Z.TEST and ZTEST, ref #65
2021-09-13 22:40:38 +08:00
func TestCalcZTEST(t *testing.T) {
f := NewFile()
assert.NoError(t, f.SetSheetRow("Sheet1", "A1", &[]int{4, 5, 2, 5, 8, 9, 3, 2, 3, 8, 9, 5}))
formulaList := map[string]string{
"=Z.TEST(A1:L1,5)": "0.371103278558538",
"=Z.TEST(A1:L1,6)": "0.838129187019751",
"=Z.TEST(A1:L1,5,1)": "0.193238115385616",
"=ZTEST(A1:L1,5)": "0.371103278558538",
"=ZTEST(A1:L1,6)": "0.838129187019751",
"=ZTEST(A1:L1,5,1)": "0.193238115385616",
}
for formula, expected := range formulaList {
assert.NoError(t, f.SetCellFormula("Sheet1", "M1", formula))
result, err := f.CalcCellValue("Sheet1", "M1")
assert.NoError(t, err, formula)
assert.Equal(t, expected, result, formula)
}
}
This closes #1002, new fn: DAY ref #65 Co-authored-by: Stani Michiels <git@rchtct.com> Co-authored-by: xuri <xuri.me@gmail.com>
2021-08-21 11:50:49 +08:00
func TestStrToDate(t *testing.T) {
_, _, _, _, err := strToDate("")
assert.Equal(t, formulaErrorVALUE, err.Error)
}