{
  "_schema_version": 3,
  "generatedAt": "2026-04-28T04:19:06.524Z",
  "baseUrl": "sheets.wiki",
  "functions": [
    {
      "name": "ABS",
      "slug": "ABS",
      "category": "math",
      "engineStatus": {},
      "engines": [],
      "syntax": "ABS(value)",
      "description": "Returns the absolute value of a number."
    },
    {
      "name": "ACCRINT",
      "slug": "ACCRINT",
      "category": "financial",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0003"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0003"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0003"
        }
      },
      "engines": [],
      "syntax": "ACCRINT(issue, first_payment, settlement, rate, redemption, frequency, [day_count_convention])",
      "description": "Calculates the accrued interest of a security that has periodic payments."
    },
    {
      "name": "ACCRINTM",
      "slug": "ACCRINTM",
      "category": "financial",
      "engineStatus": {},
      "engines": [],
      "syntax": "ACCRINTM(issue, maturity, rate, [redemption], [day_count_convention])",
      "description": "Calculates the accrued interest of a security that pays interest at maturity."
    },
    {
      "name": "ACOS",
      "slug": "ACOS",
      "category": "math",
      "engineStatus": {},
      "engines": [],
      "syntax": "ACOS(value)",
      "description": "The ACOS function returns the inverse cosine of a value in radians."
    },
    {
      "name": "ACOSH",
      "slug": "ACOSH",
      "category": "math",
      "engineStatus": {
        "libreoffice": {
          "status": "partial",
          "via": "DV-0008"
        }
      },
      "engines": [],
      "syntax": "ACOSH(value)",
      "description": "The ACOSH function returns the inverse hyperbolic cosine of a number."
    },
    {
      "name": "ACOT",
      "slug": "ACOT",
      "category": "math",
      "engineStatus": {},
      "engines": [],
      "syntax": "ACOT(value)",
      "description": "The ACOT function returns the inverse cotangent of a value in radians."
    },
    {
      "name": "ACOTH",
      "slug": "ACOTH",
      "category": "math",
      "engineStatus": {
        "libreoffice": {
          "status": "missing",
          "via": "DV-0004"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0004"
        }
      },
      "engines": [],
      "syntax": "ACOTH(value)",
      "description": "The ACOTH function returns the inverse hyperbolic cotangent of a value in radians."
    },
    {
      "name": "ADD",
      "slug": "ADD",
      "category": "operator",
      "engineStatus": {
        "excel": {
          "status": "missing",
          "via": "DV-0002"
        },
        "formulas": {
          "status": "missing",
          "via": "DV-0002"
        },
        "hyperformula": {
          "status": "missing",
          "via": "DV-0002"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0002"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0002"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0002"
        },
        "lattice": {
          "status": "partial",
          "via": "DV-0018"
        }
      },
      "engines": [],
      "syntax": "ADD(value1, value2)",
      "description": "Returns the sum of two numbers."
    },
    {
      "name": "ADDRESS",
      "slug": "ADDRESS",
      "category": "lookup",
      "engineStatus": {
        "ironcalc": {
          "status": "missing",
          "via": "DV-0005"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0005"
        }
      },
      "engines": [],
      "syntax": "ADDRESS(row, column, [absolute_relative_mode], [use_a1_notation], [sheet])",
      "description": "Returns a cell reference as a string."
    },
    {
      "name": "AI",
      "slug": "AI",
      "category": "google",
      "engineStatus": {
        "gsheets": {
          "status": "available"
        }
      },
      "engines": [
        "gsheets"
      ],
      "coverage": "out-of-scope",
      "syntax": "AI(“prompt”,[optional range])",
      "description": "The AI function queries Gemini given a prompt and context from a Google Sheet."
    },
    {
      "name": "AMORLINC",
      "slug": "AMORLINC",
      "category": "financial",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0003"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0003"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0003"
        }
      },
      "engines": [],
      "syntax": "AMORLINC(cost, purchase_date, first_period_end, salvage, period, rate, [basis])",
      "description": "The AMORLINC function returns the depreciation for an accounting period, or the prorated depreciation if the asset was purchased in the middle of a period."
    },
    {
      "name": "AND",
      "slug": "AND",
      "category": "logical",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0006"
        }
      },
      "engines": [],
      "syntax": "AND(logical_expression1, [logical_expression2, ...])",
      "description": "The AND function returns true if all of the provided arguments are logically true, and false if any of the provided arguments are logically false."
    },
    {
      "name": "ARABIC",
      "slug": "ARABIC",
      "category": "text",
      "engineStatus": {
        "libreoffice": {
          "status": "missing",
          "via": "DV-0004"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0004"
        }
      },
      "engines": [],
      "syntax": "ARABIC(roman_numeral)",
      "description": "Computes the value of a Roman numeral."
    },
    {
      "name": "ARRAYFORMULA",
      "slug": "ARRAYFORMULA",
      "category": "google",
      "engineStatus": {
        "excel": {
          "status": "partial",
          "via": "DV-0019"
        },
        "formulas": {
          "status": "missing",
          "via": "DV-0029"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0029"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0029"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0029"
        }
      },
      "engines": [],
      "syntax": "ARRAYFORMULA(array_formula)",
      "description": "The primary array-enabling function. Enables the use of non-array functions with arrays."
    },
    {
      "name": "ARRAY_CONSTRAIN",
      "slug": "ARRAY_CONSTRAIN",
      "category": "array",
      "engineStatus": {
        "excel": {
          "status": "missing",
          "via": "DV-0032"
        }
      },
      "engines": [],
      "syntax": "ARRAY_CONSTRAIN(input_range, num_rows, num_cols)",
      "description": "Constrains an array result to a specified size."
    },
    {
      "name": "ARRAY_LITERAL",
      "slug": "ARRAY_LITERAL",
      "category": "uncategorized",
      "engineStatus": {
        "gsheets": {
          "status": "available"
        }
      },
      "engines": [
        "gsheets"
      ],
      "coverage": "pending-assay",
      "syntax": "ARRAY_LITERAL(row1, [row2, ...])",
      "description": "Constructs a 2D [[Array|array]] by stacking rows vertically. `ARRAY_LITERAL` is the functional equivalent of the `{}` [[Array#array-literals|array literal]] syntax, where each argument corresponds to a row — typically produced by [[ARRAY_ROW]]."
    },
    {
      "name": "ARRAY_ROW",
      "slug": "ARRAY_ROW",
      "category": "uncategorized",
      "engineStatus": {
        "gsheets": {
          "status": "available"
        }
      },
      "engines": [
        "gsheets"
      ],
      "coverage": "pending-assay",
      "syntax": "ARRAY_ROW(value1, [value2, ...])",
      "description": "Constructs a horizontal [[Array#vectors|vector]] (a single row). `ARRAY_ROW` is the functional equivalent of comma separation within an [[Array#array-literals|array literal]] `{}`."
    },
    {
      "name": "ASC",
      "slug": "ASC",
      "category": "text",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0003"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0003"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0003"
        }
      },
      "engines": [],
      "syntax": "=ASC(text)",
      "description": "The ASC function converts full-width ASCII and Katakana characters to their half-width counterparts."
    },
    {
      "name": "ASIN",
      "slug": "ASIN",
      "category": "math",
      "engineStatus": {},
      "engines": [],
      "syntax": "ASIN(value)",
      "description": "The ASIN function returns the inverse sine of a value in radians."
    },
    {
      "name": "ASINH",
      "slug": "ASINH",
      "category": "math",
      "engineStatus": {},
      "engines": [],
      "syntax": "ASINH(value)",
      "description": "The ASINH function returns the inverse hyperbolic sine of a number."
    },
    {
      "name": "ATAN",
      "slug": "ATAN",
      "category": "math",
      "engineStatus": {},
      "engines": [],
      "syntax": "ATAN(value)",
      "description": "The ATAN function returns the inverse tangent of a value in radians."
    },
    {
      "name": "ATAN2",
      "slug": "ATAN2",
      "category": "math",
      "engineStatus": {},
      "engines": [],
      "syntax": "ATAN2(x,y)",
      "description": "The ATAN2 function returns the angle between the x-axis and a line segment from the origin (0,0) to the specified coordinate pair (`x`,`y`), in radians."
    },
    {
      "name": "ATANH",
      "slug": "ATANH",
      "category": "math",
      "engineStatus": {
        "libreoffice": {
          "status": "partial",
          "via": "DV-0008"
        }
      },
      "engines": [],
      "syntax": "ATANH(value)",
      "description": "The ATANH function returns the inverse hyperbolic tangent of a number."
    },
    {
      "name": "AVEDEV",
      "slug": "AVEDEV",
      "category": "statistical",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        }
      },
      "engines": [],
      "syntax": "AVEDEV(value1, [value2, ...])",
      "description": "Calculates the average of the magnitudes of deviations of data from a dataset's mean."
    },
    {
      "name": "AVERAGE.WEIGHTED",
      "slug": "AVERAGE.WEIGHTED",
      "category": "statistical",
      "engineStatus": {
        "excel": {
          "status": "missing",
          "via": "DV-0002"
        },
        "formulas": {
          "status": "missing",
          "via": "DV-0002"
        },
        "hyperformula": {
          "status": "missing",
          "via": "DV-0002"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0002"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0002"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0002"
        },
        "lattice": {
          "status": "partial",
          "via": "DV-0018"
        }
      },
      "engines": [],
      "syntax": "AVERAGE.WEIGHTED(values, weights, [additional values], [additional weights])",
      "description": "The AVERAGE."
    },
    {
      "name": "AVERAGE",
      "slug": "AVERAGE",
      "category": "statistical",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0006"
        },
        "lattice": {
          "status": "partial",
          "via": "DV-0055"
        }
      },
      "engines": [],
      "syntax": "AVERAGE(column)",
      "description": "The AVERAGE function returns the numerical average value in a dataset, ignoring text."
    },
    {
      "name": "AVERAGEA",
      "slug": "AVERAGEA",
      "category": "statistical",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        },
        "excel": {
          "status": "partial",
          "via": "DV-0219"
        },
        "formulas": {
          "status": "partial",
          "via": "DV-0219"
        },
        "gsheets": {
          "status": "partial",
          "via": "DV-0219"
        },
        "hyperformula": {
          "status": "partial",
          "via": "DV-0219"
        },
        "ironcalc": {
          "status": "partial",
          "via": "DV-0219"
        }
      },
      "engines": [],
      "syntax": "AVERAGEA(value1, [value2, ...])",
      "description": "Returns the numerical average value in a dataset."
    },
    {
      "name": "AVERAGEIF",
      "slug": "AVERAGEIF",
      "category": "statistical",
      "engineStatus": {},
      "engines": [],
      "syntax": "AVERAGEIF(criteria_column, criterion, average_column)",
      "description": "Returns the average of a range depending on criteria."
    },
    {
      "name": "AVERAGEIFS",
      "slug": "AVERAGEIFS",
      "category": "statistical",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0006"
        }
      },
      "engines": [],
      "syntax": "AVERAGEIFS(average_column, criteria_column1, criterion1, criteria_column2, criterion 2)",
      "description": "Returns the average of a range depending on multiple criteria."
    },
    {
      "name": "BAHTTEXT",
      "slug": "BAHTTEXT",
      "category": "text",
      "engineStatus": {
        "excel": {
          "status": "available"
        },
        "gsheets": {
          "status": "available"
        }
      },
      "engines": [
        "excel",
        "gsheets"
      ],
      "coverage": "pending-assay",
      "syntax": "BAHTTEXT(value)",
      "description": "Converts a number to Thai text with the suffix [Baht](en.wikipedia.org/wiki/Thai_baht) for integer values and Satang for decimal values."
    },
    {
      "name": "BASE",
      "slug": "BASE",
      "category": "math",
      "engineStatus": {
        "formulas": {
          "status": "missing",
          "via": "DV-0025"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0025"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0025"
        }
      },
      "engines": [],
      "syntax": "BASE(value, base, [min_length])",
      "description": "The BASE function converts a decimal number into a text representation in another base."
    },
    {
      "name": "BETA.DIST",
      "slug": "BETA.DIST",
      "category": "statistical",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0017"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0017"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0017"
        }
      },
      "engines": [],
      "syntax": "BETA.DIST(value, alpha, beta, lower_bound, upper_bound)",
      "description": "The BETA."
    },
    {
      "name": "BETA.INV",
      "slug": "BETA.INV",
      "category": "statistical",
      "engineStatus": {},
      "engines": [],
      "syntax": "BETA.INV(probability, alpha, beta, lower_bound, upper_bound)",
      "description": "The BETA."
    },
    {
      "name": "BETADIST",
      "slug": "BETADIST",
      "category": "statistical",
      "engineStatus": {},
      "engines": [],
      "syntax": "BETA.DIST(value, alpha, beta, lower_bound, upper_bound)",
      "description": "The BETA."
    },
    {
      "name": "BETAINV",
      "slug": "BETAINV",
      "category": "statistical",
      "engineStatus": {},
      "engines": [],
      "syntax": "BETA.INV(probability, alpha, beta, lower_bound, upper_bound)",
      "description": "The BETA."
    },
    {
      "name": "BIN2DEC",
      "slug": "BIN2DEC",
      "category": "engineering",
      "engineStatus": {
        "libreoffice": {
          "status": "partial",
          "via": "DV-0008"
        }
      },
      "engines": [],
      "syntax": "BIN2DEC(signed_binary_number)",
      "description": "The BIN2DEC function converts a signed binary number to decimal format."
    },
    {
      "name": "BIN2HEX",
      "slug": "BIN2HEX",
      "category": "engineering",
      "engineStatus": {
        "libreoffice": {
          "status": "partial",
          "via": "DV-0008"
        }
      },
      "engines": [],
      "syntax": "BIN2HEX(signed_binary_number, [significant_digits])",
      "description": "The BIN2HEX function converts a signed binary number to signed hexadecimal format."
    },
    {
      "name": "BIN2OCT",
      "slug": "BIN2OCT",
      "category": "engineering",
      "engineStatus": {
        "libreoffice": {
          "status": "partial",
          "via": "DV-0008"
        }
      },
      "engines": [],
      "syntax": "BIN2OCT(signed_binary_number, [significant_digits])",
      "description": "The BIN2OCT function converts a signed binary number to signed octal format."
    },
    {
      "name": "BINOM.DIST.RANGE",
      "slug": "BINOM.DIST.RANGE",
      "category": "statistical",
      "engineStatus": {
        "excel": {
          "status": "available"
        },
        "gsheets": {
          "status": "available"
        }
      },
      "engines": [
        "excel",
        "gsheets"
      ],
      "coverage": "pending-assay",
      "syntax": "BINOM.DIST.RANGE(num_trials, prob_success, num_successes, max_num_successes)",
      "description": "Returns the probability of drawing a specific number of successes or range of successes given a probability and number of tries."
    },
    {
      "name": "BINOM.DIST",
      "slug": "BINOM.DIST",
      "category": "statistical",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0017"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0017"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0017"
        },
        "lattice": {
          "status": "partial",
          "via": "DV-0224"
        }
      },
      "engines": [],
      "syntax": "BINOMDIST(num_successes, num_trials, prob_success, cumulative)",
      "description": "Calculates the probability of drawing a certain number of successes (or a maximum number of successes) in a certain number of tries given a population of a certain size containing a certain number of successes, with replacement of draws."
    },
    {
      "name": "BINOM.INV",
      "slug": "BINOM.INV",
      "category": "statistical",
      "engineStatus": {
        "libreoffice": {
          "status": "missing",
          "via": "DV-0004"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0004"
        }
      },
      "engines": [],
      "syntax": "CRITBINOM(num_trials, prob_success, target_prob)",
      "description": "Calculates the smallest value for which the cumulative binomial distribution is greater than or equal to a specified criteria."
    },
    {
      "name": "BINOMDIST",
      "slug": "BINOMDIST",
      "category": "statistical",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0003"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0003"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0003"
        }
      },
      "engines": [],
      "syntax": "BINOMDIST(num_successes, num_trials, prob_success, cumulative)",
      "description": "Calculates the probability of drawing a certain number of successes (or a maximum number of successes) in a certain number of tries given a population of a certain size containing a certain number of successes, with replacement of draws."
    },
    {
      "name": "BITAND",
      "slug": "BITAND",
      "category": "engineering",
      "engineStatus": {
        "libreoffice": {
          "status": "missing",
          "via": "DV-0007"
        },
        "hyperformula": {
          "status": "partial",
          "via": "DV-0097"
        },
        "pycel": {
          "status": "partial",
          "via": "DV-0097"
        }
      },
      "engines": [],
      "syntax": "BITAND(value1,value2)",
      "description": "The BITAND function returns the bitwise boolean AND of two numbers."
    },
    {
      "name": "BITLSHIFT",
      "slug": "BITLSHIFT",
      "category": "engineering",
      "engineStatus": {
        "libreoffice": {
          "status": "missing",
          "via": "DV-0007"
        },
        "lattice": {
          "status": "partial",
          "via": "DV-0052"
        }
      },
      "engines": [],
      "syntax": "BITLSHIFT(value,shift_amount)",
      "description": "The BITLSHIFT function shifts the bits of the input a certain number of places to the left."
    },
    {
      "name": "BITOR",
      "slug": "BITOR",
      "category": "engineering",
      "engineStatus": {
        "libreoffice": {
          "status": "missing",
          "via": "DV-0007"
        }
      },
      "engines": [],
      "syntax": "BITOR(value1, value2)",
      "description": "The BITOR function returns the bitwise Boolean OR of 2 numbers."
    },
    {
      "name": "BITRSHIFT",
      "slug": "BITRSHIFT",
      "category": "engineering",
      "engineStatus": {
        "libreoffice": {
          "status": "missing",
          "via": "DV-0007"
        },
        "lattice": {
          "status": "partial",
          "via": "DV-0052"
        }
      },
      "engines": [],
      "syntax": "BITRSHIFT(value, shift_amount)",
      "description": "The BITRSHIFT function shifts the bits of the input a certain number of places to the right."
    },
    {
      "name": "BITXOR",
      "slug": "BITXOR",
      "category": "engineering",
      "engineStatus": {
        "libreoffice": {
          "status": "missing",
          "via": "DV-0007"
        }
      },
      "engines": [],
      "syntax": "BITXOR(value1, value2)",
      "description": "The BITXOR function is a bitwise XOR (exclusive or) of 2 numbers that returns a bit of “1” if 2 bits are different, and a bit of “0” otherwise."
    },
    {
      "name": "BYCOL",
      "slug": "BYCOL",
      "category": "array",
      "engineStatus": {},
      "engines": [],
      "syntax": "BYCOL(array_or_range,LAMBDA)",
      "description": "This function groups an array by columns by application of a `LAMBDA` function to each column."
    },
    {
      "name": "BYROW",
      "slug": "BYROW",
      "category": "array",
      "engineStatus": {},
      "engines": [],
      "syntax": "BYROW(array_or_range,LAMBDA)",
      "description": "This function groups an array by rows by application of a `LAMBDA` function to each row."
    },
    {
      "name": "CEILING.MATH",
      "slug": "CEILING.MATH",
      "category": "math",
      "engineStatus": {
        "libreoffice": {
          "status": "missing",
          "via": "DV-0007"
        }
      },
      "engines": [],
      "syntax": "CEILING.MATH(number, [significance], [mode])",
      "description": "The CEILING."
    },
    {
      "name": "CEILING.PRECISE",
      "slug": "CEILING.PRECISE",
      "category": "math",
      "engineStatus": {
        "libreoffice": {
          "status": "missing",
          "via": "DV-0007"
        },
        "formulas": {
          "status": "partial",
          "via": "DV-0067"
        }
      },
      "engines": [],
      "syntax": "CEILING.PRECISE(number, [significance])",
      "description": "The CEILING."
    },
    {
      "name": "CEILING",
      "slug": "CEILING",
      "category": "math",
      "engineStatus": {
        "libreoffice": {
          "status": "partial",
          "via": "DV-0008"
        }
      },
      "engines": [],
      "syntax": "CEILING(value, [factor])",
      "description": "The CEILING function rounds a number up to the nearest integer multiple of specified significance."
    },
    {
      "name": "CELL",
      "slug": "CELL",
      "category": "info",
      "engineStatus": {
        "formulas": {
          "status": "missing",
          "via": "DV-0033"
        },
        "hyperformula": {
          "status": "missing",
          "via": "DV-0033"
        },
        "lattice": {
          "status": "missing",
          "via": "DV-0033"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0033"
        }
      },
      "engines": [],
      "syntax": "CELL(info_type, reference)",
      "description": "Returns the requested information about the specified cell."
    },
    {
      "name": "CHAR",
      "slug": "CHAR",
      "category": "text",
      "engineStatus": {
        "ironcalc": {
          "status": "missing",
          "via": "DV-0005"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0005"
        }
      },
      "engines": [],
      "syntax": "CHAR(table_number)",
      "description": "Convert a number into a character according to the current Unicode table."
    },
    {
      "name": "CHIDIST",
      "slug": "CHIDIST",
      "category": "statistical",
      "engineStatus": {},
      "engines": [],
      "syntax": "CHIDIST(x, degrees_freedom)",
      "description": "Calculates the right-tailed chi-squared distribution, often used in hypothesis testing."
    },
    {
      "name": "CHIINV",
      "slug": "CHIINV",
      "category": "statistical",
      "engineStatus": {},
      "engines": [],
      "syntax": "CHIINV(probability, degrees_freedom)",
      "description": "Calculates the inverse of the right-tailed chi-squared distribution."
    },
    {
      "name": "CHISQ.DIST.RT",
      "slug": "CHISQ.DIST.RT",
      "category": "statistical",
      "engineStatus": {},
      "engines": [],
      "syntax": "CHISQ.DIST.RT(x, degrees_freedom)",
      "description": "Calculates the right-tailed chi-squared distribution, which is commonly used in hypothesis testing."
    },
    {
      "name": "CHISQ.DIST",
      "slug": "CHISQ.DIST",
      "category": "statistical",
      "engineStatus": {},
      "engines": [],
      "syntax": "CHISQ.DIST(x, degrees_freedom, cumulative)",
      "description": "Calculates the left-tailed chi-squared distribution, often used in hypothesis testing."
    },
    {
      "name": "CHISQ.INV.RT",
      "slug": "CHISQ.INV.RT",
      "category": "statistical",
      "engineStatus": {},
      "engines": [],
      "syntax": "CHISQ.INV.RT(probability, degrees_freedom)",
      "description": "Calculates the inverse of the right-tailed chi-squared distribution."
    },
    {
      "name": "CHISQ.INV",
      "slug": "CHISQ.INV",
      "category": "statistical",
      "engineStatus": {},
      "engines": [],
      "syntax": "CHISQ.INV(probability, degrees_freedom)",
      "description": "Calculates the inverse of the left-tailed chi-squared distribution."
    },
    {
      "name": "CHISQ.TEST",
      "slug": "CHISQ.TEST",
      "category": "statistical",
      "engineStatus": {
        "libreoffice": {
          "status": "missing",
          "via": "DV-0004"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0004"
        }
      },
      "engines": [],
      "syntax": "CHITEST(observed_range, expected_range)",
      "description": "Returns the probability associated with a Pearson’s chi-squared test on the two ranges of data."
    },
    {
      "name": "CHITEST",
      "slug": "CHITEST",
      "category": "statistical",
      "engineStatus": {},
      "engines": [],
      "syntax": "CHITEST(observed_range, expected_range)",
      "description": "Returns the probability associated with a Pearson’s chi-squared test on the two ranges of data."
    },
    {
      "name": "CHOOSE",
      "slug": "CHOOSE",
      "category": "lookup",
      "engineStatus": {},
      "engines": [],
      "syntax": "CHOOSE(index, choice1, [choice2, ...])",
      "description": "Returns an element from a list of choices based on index."
    },
    {
      "name": "CHOOSECOLS",
      "slug": "CHOOSECOLS",
      "category": "array",
      "engineStatus": {},
      "engines": [],
      "syntax": "CHOOSECOLS(array, col_num1, [col_num2])",
      "description": "This function creates a new array from the selected columns in the existing range."
    },
    {
      "name": "CHOOSEROWS",
      "slug": "CHOOSEROWS",
      "category": "array",
      "engineStatus": {},
      "engines": [],
      "syntax": "CHOOSEROWS(array, row_num1, [row_num2])",
      "description": "This function creates a new array from the selected rows in the existing range."
    },
    {
      "name": "CLEAN",
      "slug": "CLEAN",
      "category": "text",
      "engineStatus": {
        "ironcalc": {
          "status": "missing",
          "via": "DV-0005"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0005"
        },
        "excel": {
          "status": "partial",
          "via": "DV-0031"
        },
        "formulas": {
          "status": "partial",
          "via": "DV-0031"
        },
        "gsheets": {
          "status": "partial",
          "via": "DV-0031"
        },
        "libreoffice": {
          "status": "partial",
          "via": "DV-0031"
        }
      },
      "engines": [],
      "syntax": "CLEAN(text)",
      "description": "Returns the text with the non-printable ASCII characters removed."
    },
    {
      "name": "CODE",
      "slug": "CODE",
      "category": "text",
      "engineStatus": {
        "ironcalc": {
          "status": "missing",
          "via": "DV-0005"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0005"
        },
        "excel": {
          "status": "partial",
          "via": "DV-0227"
        },
        "formulas": {
          "status": "partial",
          "via": "DV-0227"
        },
        "gsheets": {
          "status": "partial",
          "via": "DV-0227"
        },
        "hyperformula": {
          "status": "partial",
          "via": "DV-0227"
        },
        "lattice": {
          "status": "partial",
          "via": "DV-0227"
        }
      },
      "engines": [],
      "syntax": "CODE(string)",
      "description": "Returns the numeric Unicode map value of the first character in the string provided."
    },
    {
      "name": "COINFLIP",
      "slug": "COINFLIP",
      "category": "math",
      "engineStatus": {
        "gsheets": {
          "status": "available"
        }
      },
      "engines": [
        "gsheets"
      ],
      "coverage": "out-of-scope",
      "syntax": "COINFLIP()",
      "description": "Returns `TRUE` or `FALSE` at random. `COINFLIP` is [[Volatile]]."
    },
    {
      "name": "COLUMN",
      "slug": "COLUMN",
      "category": "lookup",
      "engineStatus": {
        "hyperformula": {
          "status": "partial",
          "via": "DV-0249"
        },
        "lattice": {
          "status": "partial",
          "via": "DV-0075"
        }
      },
      "engines": [],
      "syntax": "COLUMN([cell_reference])",
      "description": "Returns the column number of a specified cell, with `A=1`."
    },
    {
      "name": "COLUMNS",
      "slug": "COLUMNS",
      "category": "lookup",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        },
        "formulas": {
          "status": "partial",
          "via": "DV-0039"
        },
        "ironcalc": {
          "status": "partial",
          "via": "DV-0039"
        }
      },
      "engines": [],
      "syntax": "COLUMNS(range)",
      "description": "Returns the number of columns in a specified array or range."
    },
    {
      "name": "COMBIN",
      "slug": "COMBIN",
      "category": "math",
      "engineStatus": {
        "libreoffice": {
          "status": "partial",
          "via": "DV-0008"
        },
        "formulas": {
          "status": "missing",
          "via": "DV-0035"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0035"
        }
      },
      "engines": [],
      "syntax": "COMBIN(n, k)",
      "description": "The COMBIN function returns the number of ways to choose some number of objects from a pool of a given size of objects."
    },
    {
      "name": "COMBINA",
      "slug": "COMBINA",
      "category": "math",
      "engineStatus": {
        "formulas": {
          "status": "missing",
          "via": "DV-0025"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0025"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0025"
        }
      },
      "engines": [],
      "syntax": "COMBINA(n, k)",
      "description": "The COMBINA function returns the number of ways to choose some number of objects from a pool of a given size of objects, including ways to choose the same object multiple times (also known as choosing with replacement)."
    },
    {
      "name": "COMPLEX",
      "slug": "COMPLEX",
      "category": "engineering",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        },
        "lattice": {
          "status": "partial",
          "via": "DV-0103"
        }
      },
      "engines": [],
      "syntax": "COMPLEX(real_part, imaginary_part, [suffix])",
      "description": "The COMPLEX function creates a complex number, given real and imaginary coefficients."
    },
    {
      "name": "CONCAT",
      "slug": "CONCAT",
      "category": "operator",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0015"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0015"
        },
        "gsheets": {
          "status": "partial",
          "via": "DV-0023"
        }
      },
      "engines": [],
      "syntax": "CONCAT(value1, value2)",
      "description": "Returns the concatenation of two values."
    },
    {
      "name": "CONCATENATE",
      "slug": "CONCATENATE",
      "category": "text",
      "engineStatus": {},
      "engines": [],
      "syntax": "CONCATENATE(string1, [string2, ...])",
      "description": "Appends strings to one another."
    },
    {
      "name": "CONFIDENCE.NORM",
      "slug": "CONFIDENCE.NORM",
      "category": "statistical",
      "engineStatus": {},
      "engines": [],
      "syntax": "CONFIDENCE.NORM(alpha, standard_deviation, pop_size)",
      "description": "Calculates the width of half the confidence interval for a normal distribution."
    },
    {
      "name": "CONFIDENCE.T",
      "slug": "CONFIDENCE.T",
      "category": "statistical",
      "engineStatus": {},
      "engines": [],
      "syntax": "CONFIDENCE.T(alpha, standard_deviation, size)",
      "description": "The CONFIDENCE."
    },
    {
      "name": "CONFIDENCE",
      "slug": "CONFIDENCE",
      "category": "statistical",
      "engineStatus": {},
      "engines": [],
      "syntax": "CONFIDENCE.NORM(alpha, standard_deviation, pop_size)",
      "description": "Calculates the width of half the confidence interval for a normal distribution."
    },
    {
      "name": "CONVERT",
      "slug": "CONVERT",
      "category": "parser",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0016"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0016"
        },
        "formulas": {
          "status": "partial",
          "via": "DV-0206"
        },
        "lattice": {
          "status": "partial",
          "via": "DV-0205"
        }
      },
      "engines": [],
      "syntax": "CONVERT(value, start_unit, end_unit)",
      "description": "Converts a numeric value to a different unit of measure."
    },
    {
      "name": "CORREL",
      "slug": "CORREL",
      "category": "statistical",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        }
      },
      "engines": [],
      "syntax": "CORREL(data_y, data_x)",
      "description": "Calculates r, the Pearson product-moment correlation coefficient of a dataset."
    },
    {
      "name": "COS",
      "slug": "COS",
      "category": "math",
      "engineStatus": {},
      "engines": [],
      "syntax": "COS(angle)",
      "description": "The COS function returns the cosine of an angle provided in radians."
    },
    {
      "name": "COSH",
      "slug": "COSH",
      "category": "math",
      "engineStatus": {},
      "engines": [],
      "syntax": "COSH(value)",
      "description": "The COSH function returns the hyperbolic cosine of any real number."
    },
    {
      "name": "COT",
      "slug": "COT",
      "category": "math",
      "engineStatus": {},
      "engines": [],
      "syntax": "COT(angle)",
      "description": "The COT function returns the cotangent of an angle provided in radians."
    },
    {
      "name": "COTH",
      "slug": "COTH",
      "category": "math",
      "engineStatus": {},
      "engines": [],
      "syntax": "COTH(value)",
      "description": "The COTH function returns the hyperbolic cotangent of any real number."
    },
    {
      "name": "COUNT",
      "slug": "COUNT",
      "category": "statistical",
      "engineStatus": {
        "libreoffice": {
          "status": "partial",
          "via": "DV-0226"
        }
      },
      "engines": [],
      "syntax": "COUNT(column)",
      "description": "Returns the number of numeric values in a dataset."
    },
    {
      "name": "COUNTA",
      "slug": "COUNTA",
      "category": "statistical",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        },
        "formulas": {
          "status": "partial",
          "via": "DV-0037"
        }
      },
      "engines": [],
      "syntax": "COUNTA(value1, [value2, ...])",
      "description": "Returns the number of values in a dataset."
    },
    {
      "name": "COUNTBLANK",
      "slug": "COUNTBLANK",
      "category": "math",
      "engineStatus": {},
      "engines": [],
      "syntax": "COUNTBLANK(column)",
      "description": "Returns the number of empty cells in a given range."
    },
    {
      "name": "COUNTIF",
      "slug": "COUNTIF",
      "category": "math",
      "engineStatus": {},
      "engines": [],
      "syntax": "COUNTIF(criteria_column, criterion)",
      "description": "Returns a conditional count across a range."
    },
    {
      "name": "COUNTIFS",
      "slug": "COUNTIFS",
      "category": "math",
      "engineStatus": {},
      "engines": [],
      "syntax": "COUNTIFS(criteria_column1, criterion1, criteria_column2, criterion2)",
      "description": "Returns the count of a range depending on multiple criteria."
    },
    {
      "name": "COUNTUNIQUE",
      "slug": "COUNTUNIQUE",
      "category": "math",
      "engineStatus": {
        "excel": {
          "status": "missing",
          "via": "DV-0049"
        },
        "formulas": {
          "status": "missing",
          "via": "DV-0049"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0049"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0049"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0049"
        }
      },
      "engines": [],
      "syntax": "COUNTUNIQUE(column)",
      "description": "Counts the number of unique values in a list of specified values and ranges."
    },
    {
      "name": "COUNTUNIQUEIFS",
      "slug": "COUNTUNIQUEIFS",
      "category": "math",
      "engineStatus": {
        "gsheets": {
          "status": "available"
        }
      },
      "engines": [
        "gsheets"
      ],
      "coverage": "pending-assay",
      "syntax": "COUNTUNIQUEIFS(column, criteria_column1, criterion1, creteria_column2, criterion2)",
      "description": "Returns the unique count of a range depending on multiple criteria."
    },
    {
      "name": "COUPDAYBS",
      "slug": "COUPDAYBS",
      "category": "financial",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0003"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0003"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0003"
        }
      },
      "engines": [],
      "syntax": "COUPDAYBS(settlement, maturity, frequency, [day_count_convention])",
      "description": "Calculates the number of days from the first coupon, or interest payment, until settlement."
    },
    {
      "name": "COUPDAYS",
      "slug": "COUPDAYS",
      "category": "financial",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0003"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0003"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0003"
        }
      },
      "engines": [],
      "syntax": "COUPDAYS(settlement, maturity, frequency, [day_count_convention])",
      "description": "Calculates the number of days in the coupon, or interest payment, period that contains the specified settlement date."
    },
    {
      "name": "COUPDAYSNC",
      "slug": "COUPDAYSNC",
      "category": "financial",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0003"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0003"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0003"
        }
      },
      "engines": [],
      "syntax": "COUPDAYSNC(settlement, maturity, frequency, [day_count_convention])",
      "description": "Calculates the number of days from the settlement date until the next coupon, or interest payment."
    },
    {
      "name": "COUPNCD",
      "slug": "COUPNCD",
      "category": "financial",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0003"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0003"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0003"
        }
      },
      "engines": [],
      "syntax": "COUPNCD(settlement, maturity, frequency, [day_count_convention])",
      "description": "Calculates next coupon, or interest payment, date after the settlement date."
    },
    {
      "name": "COUPNUM",
      "slug": "COUPNUM",
      "category": "financial",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0003"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0003"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0003"
        }
      },
      "engines": [],
      "syntax": "COUPNUM(settlement, maturity, frequency, [day_count_convention])",
      "description": "Calculates the number of coupons, or interest payments, between the settlement date and the maturity date of the investment."
    },
    {
      "name": "COUPPCD",
      "slug": "COUPPCD",
      "category": "financial",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0003"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0003"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0003"
        }
      },
      "engines": [],
      "syntax": "COUPPCD(settlement, maturity, frequency, [day_count_convention])",
      "description": "Calculates last coupon, or interest payment, date before the settlement date."
    },
    {
      "name": "COVAR",
      "slug": "COVAR",
      "category": "statistical",
      "engineStatus": {},
      "engines": [],
      "syntax": "COVAR(data_y, data_x)",
      "description": "Calculates the covariance of a dataset."
    },
    {
      "name": "COVARIANCE.P",
      "slug": "COVARIANCE.P",
      "category": "statistical",
      "engineStatus": {},
      "engines": [],
      "syntax": "COVAR(data_y, data_x)",
      "description": "Calculates the covariance of a dataset."
    },
    {
      "name": "COVARIANCE.S",
      "slug": "COVARIANCE.S",
      "category": "statistical",
      "engineStatus": {
        "libreoffice": {
          "status": "missing",
          "via": "DV-0004"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0004"
        }
      },
      "engines": [],
      "syntax": "COVARIANCE.S(data_y, data_x)",
      "description": "The COVARIANCE."
    },
    {
      "name": "CRITBINOM",
      "slug": "CRITBINOM",
      "category": "statistical",
      "engineStatus": {
        "ironcalc": {
          "status": "missing",
          "via": "DV-0005"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0005"
        }
      },
      "engines": [],
      "syntax": "CRITBINOM(num_trials, prob_success, target_prob)",
      "description": "Calculates the smallest value for which the cumulative binomial distribution is greater than or equal to a specified criteria."
    },
    {
      "name": "CSC",
      "slug": "CSC",
      "category": "math",
      "engineStatus": {
        "libreoffice": {
          "status": "missing",
          "via": "DV-0004"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0004"
        }
      },
      "engines": [],
      "syntax": "CSC(angle)",
      "description": "The CSC function returns the cosecant of an angle provided in radians."
    },
    {
      "name": "CSCH",
      "slug": "CSCH",
      "category": "math",
      "engineStatus": {},
      "engines": [],
      "syntax": "CSCH(value)",
      "description": "The CSCH function returns the hyperbolic cosecant of any real number."
    },
    {
      "name": "CUMIPMT",
      "slug": "CUMIPMT",
      "category": "financial",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        },
        "libreoffice": {
          "status": "partial",
          "via": "DV-0008"
        }
      },
      "engines": [],
      "syntax": "CUMIPMT(rate, number_of_periods, present_value, first_period, last_period, end_or_beginning)",
      "description": "Calculates the cumulative interest over a range of payment periods for an investment based on constant-amount periodic payments and a constant interest rate."
    },
    {
      "name": "CUMPRINC",
      "slug": "CUMPRINC",
      "category": "financial",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        },
        "libreoffice": {
          "status": "partial",
          "via": "DV-0008"
        },
        "excel": {
          "status": "partial",
          "via": "DV-0119"
        },
        "formulas": {
          "status": "partial",
          "via": "DV-0119"
        },
        "hyperformula": {
          "status": "partial",
          "via": "DV-0119"
        },
        "ironcalc": {
          "status": "partial",
          "via": "DV-0119"
        },
        "lattice": {
          "status": "partial",
          "via": "DV-0119"
        }
      },
      "engines": [],
      "syntax": "CUMPRINC(rate, number_of_periods, present_value, first_period, last_period, end_or_beginning)",
      "description": "Calculates the cumulative principal paid over a range of payment periods for an investment based on constant-amount periodic payments and a constant interest rate."
    },
    {
      "name": "CURSORPARK",
      "slug": "CURSORPARK",
      "category": "uncategorized",
      "engineStatus": {
        "gsheets": {
          "status": "available"
        }
      },
      "engines": [
        "gsheets"
      ],
      "coverage": "out-of-scope",
      "syntax": "CURSORPARK()",
      "description": "Generates a [cursor park](knowyourmeme.com/memes/cursor-park), a $5 \\times 8$ [[Array|array]] of [emojis](en.wikipedia.org/wiki/Emoji)."
    },
    {
      "name": "DATE",
      "slug": "DATE",
      "category": "date",
      "engineStatus": {
        "lattice": {
          "status": "partial",
          "via": "DV-0018"
        }
      },
      "engines": [],
      "syntax": "DATE(year, month, day)",
      "description": "Converts a year, month, and day into a date."
    },
    {
      "name": "DATEDIF",
      "slug": "DATEDIF",
      "category": "date",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        },
        "hyperformula": {
          "status": "partial",
          "via": "DV-0012"
        }
      },
      "engines": [],
      "syntax": "DATEDIF(start_date, end_date, unit)",
      "description": "Calculates the number of days, months, or years between two dates."
    },
    {
      "name": "DATEVALUE",
      "slug": "DATEVALUE",
      "category": "date",
      "engineStatus": {
        "hyperformula": {
          "status": "partial",
          "via": "DV-0093"
        },
        "ironcalc": {
          "status": "partial",
          "via": "DV-0093"
        }
      },
      "engines": [],
      "syntax": "DATEVALUE(date_string)",
      "description": "Converts a provided date string in a known format to a date value."
    },
    {
      "name": "DAVERAGE",
      "slug": "DAVERAGE",
      "category": "database",
      "engineStatus": {
        "formulas": {
          "status": "missing",
          "via": "DV-0011"
        },
        "hyperformula": {
          "status": "missing",
          "via": "DV-0011"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0011"
        }
      },
      "engines": [],
      "syntax": "DAVERAGE(database, field, criteria)",
      "description": "Returns the average of a set of values selected from a database table-like array or range using a SQL-like query."
    },
    {
      "name": "DAY",
      "slug": "DAY",
      "category": "date",
      "engineStatus": {
        "hyperformula": {
          "status": "partial",
          "via": "DV-0014"
        },
        "pycel": {
          "status": "partial",
          "via": "DV-0014"
        }
      },
      "engines": [],
      "syntax": "DAY(date)",
      "description": "Returns the day of the month that a specific date falls on, in numeric format."
    },
    {
      "name": "DAYS",
      "slug": "DAYS",
      "category": "date",
      "engineStatus": {
        "libreoffice": {
          "status": "missing",
          "via": "DV-0004"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0004"
        },
        "hyperformula": {
          "status": "partial",
          "via": "DV-0012"
        }
      },
      "engines": [],
      "syntax": "DAYS(end_date,start_date)",
      "description": "The DAYS function returns the number of days between two dates."
    },
    {
      "name": "DAYS360",
      "slug": "DAYS360",
      "category": "date",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        },
        "hyperformula": {
          "status": "partial",
          "via": "DV-0012"
        }
      },
      "engines": [],
      "syntax": "DAYS360(start_date, end_date, [method])",
      "description": "Returns the difference between two days based on the 360-day year used in some financial interest calculations."
    },
    {
      "name": "DB",
      "slug": "DB",
      "category": "financial",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        }
      },
      "engines": [],
      "syntax": "DB(cost, salvage, life, period, [month])",
      "description": "The DB function calculates the depreciation of an asset for a specified period using the arithmetic declining balance method."
    },
    {
      "name": "DCOUNT",
      "slug": "DCOUNT",
      "category": "database",
      "engineStatus": {
        "formulas": {
          "status": "missing",
          "via": "DV-0011"
        },
        "hyperformula": {
          "status": "missing",
          "via": "DV-0011"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0011"
        }
      },
      "engines": [],
      "syntax": "DCOUNT(database, field, criteria)",
      "description": "Counts numeric values selected from a database table-like array or range using a SQL-like query."
    },
    {
      "name": "DCOUNTA",
      "slug": "DCOUNTA",
      "category": "database",
      "engineStatus": {
        "formulas": {
          "status": "missing",
          "via": "DV-0011"
        },
        "hyperformula": {
          "status": "missing",
          "via": "DV-0011"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0011"
        }
      },
      "engines": [],
      "syntax": "DCOUNTA(database, field, criteria)",
      "description": "Counts values, including text, selected from a database table-like array or range using a SQL-like query."
    },
    {
      "name": "DDB",
      "slug": "DDB",
      "category": "financial",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        },
        "gsheets": {
          "status": "partial",
          "via": "DV-0123"
        },
        "formulas": {
          "status": "partial",
          "via": "DV-0122"
        }
      },
      "engines": [],
      "syntax": "DDB(cost, salvage, life, period, [factor])",
      "description": "The DDB function calculates the depreciation of an asset for a specified period using the double-declining balance method."
    },
    {
      "name": "DEC2BIN",
      "slug": "DEC2BIN",
      "category": "engineering",
      "engineStatus": {
        "libreoffice": {
          "status": "partial",
          "via": "DV-0008"
        }
      },
      "engines": [],
      "syntax": "DEC2BIN(decimal_number, [significant_digits])",
      "description": "The DEC2BIN function converts a decimal number to signed binary format."
    },
    {
      "name": "DEC2HEX",
      "slug": "DEC2HEX",
      "category": "engineering",
      "engineStatus": {
        "libreoffice": {
          "status": "partial",
          "via": "DV-0008"
        }
      },
      "engines": [],
      "syntax": "DEC2HEX(decimal_number, [significant_digits])",
      "description": "The DEC2HEX function converts a decimal number to signed hexadecimal format."
    },
    {
      "name": "DEC2OCT",
      "slug": "DEC2OCT",
      "category": "engineering",
      "engineStatus": {
        "libreoffice": {
          "status": "partial",
          "via": "DV-0008"
        }
      },
      "engines": [],
      "syntax": "DEC2OCT(decimal_number, [significant_digits])",
      "description": "The DEC2OCT function converts a decimal number to signed octal format."
    },
    {
      "name": "DECIMAL",
      "slug": "DECIMAL",
      "category": "math",
      "engineStatus": {
        "libreoffice": {
          "status": "missing",
          "via": "DV-0004"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0004"
        }
      },
      "engines": [],
      "syntax": "DECIMAL(value, base)",
      "description": "The DECIMAL function converts the text representation of a number in another base, to base 10 (decimal)."
    },
    {
      "name": "DEGREES",
      "slug": "DEGREES",
      "category": "math",
      "engineStatus": {},
      "engines": [],
      "syntax": "DEGREES(angle)",
      "description": "The DEGREES function converts an angle value in radians to degrees."
    },
    {
      "name": "DELTA",
      "slug": "DELTA",
      "category": "engineering",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        }
      },
      "engines": [],
      "syntax": "DELTA(number1, [number2])",
      "description": "Compare two numeric values, returning 1 if they're equal."
    },
    {
      "name": "DETECTLANGUAGE",
      "slug": "DETECTLANGUAGE",
      "category": "google",
      "engineStatus": {
        "excel": {
          "status": "missing",
          "via": "DV-0009"
        },
        "formulas": {
          "status": "missing",
          "via": "DV-0010"
        },
        "hyperformula": {
          "status": "missing",
          "via": "DV-0010"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0010"
        },
        "lattice": {
          "status": "missing",
          "via": "DV-0010"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0010"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0010"
        }
      },
      "engines": [],
      "syntax": "DETECTLANGUAGE(text_or_range)",
      "description": "Identifies the language used in text within the specified range."
    },
    {
      "name": "DEVSQ",
      "slug": "DEVSQ",
      "category": "statistical",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        }
      },
      "engines": [],
      "syntax": "DEVSQ(value1, [value2, ...])",
      "description": "Calculates the sum of squares of deviations based on a sample."
    },
    {
      "name": "DGET",
      "slug": "DGET",
      "category": "database",
      "engineStatus": {
        "libreoffice": {
          "status": "partial",
          "via": "DV-0008"
        },
        "formulas": {
          "status": "missing",
          "via": "DV-0011"
        },
        "hyperformula": {
          "status": "missing",
          "via": "DV-0011"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0011"
        }
      },
      "engines": [],
      "syntax": "DGET(database, field, criteria)",
      "description": "Returns a single value from a database table-like array or range using a SQL-like query."
    },
    {
      "name": "DISC",
      "slug": "DISC",
      "category": "financial",
      "engineStatus": {},
      "engines": [],
      "syntax": "DISC(settlement, maturity, price, redemption, [day_count_convention])",
      "description": "Calculates the discount rate of a security based on price."
    },
    {
      "name": "DIVIDE",
      "slug": "DIVIDE",
      "category": "operator",
      "engineStatus": {
        "excel": {
          "status": "missing",
          "via": "DV-0002"
        },
        "formulas": {
          "status": "missing",
          "via": "DV-0002"
        },
        "hyperformula": {
          "status": "missing",
          "via": "DV-0002"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0002"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0002"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0002"
        }
      },
      "engines": [],
      "syntax": "DIVIDE(dividend, divisor)",
      "description": "Returns one number divided by another."
    },
    {
      "name": "DMAX",
      "slug": "DMAX",
      "category": "database",
      "engineStatus": {
        "formulas": {
          "status": "missing",
          "via": "DV-0011"
        },
        "hyperformula": {
          "status": "missing",
          "via": "DV-0011"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0011"
        }
      },
      "engines": [],
      "syntax": "DMAX(database, field, criteria)",
      "description": "Returns the maximum value selected from a database table-like array or range using a SQL-like query."
    },
    {
      "name": "DMIN",
      "slug": "DMIN",
      "category": "database",
      "engineStatus": {
        "formulas": {
          "status": "missing",
          "via": "DV-0011"
        },
        "hyperformula": {
          "status": "missing",
          "via": "DV-0011"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0011"
        }
      },
      "engines": [],
      "syntax": "DMIN(database, field, criteria)",
      "description": "Returns the minimum value selected from a database table-like array or range using a SQL-like query."
    },
    {
      "name": "DOLLAR",
      "slug": "DOLLAR",
      "category": "text",
      "engineStatus": {
        "formulas": {
          "status": "missing",
          "via": "DV-0050"
        },
        "hyperformula": {
          "status": "missing",
          "via": "DV-0050"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0050"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0050"
        }
      },
      "engines": [],
      "syntax": "DOLLAR(number, [number_of_places])",
      "description": "Formats a number into the locale-specific currency format."
    },
    {
      "name": "DOLLARDE",
      "slug": "DOLLARDE",
      "category": "financial",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        }
      },
      "engines": [],
      "syntax": "DOLLARDE(fractional_price, unit)",
      "description": "Converts a price quotation given as a decimal fraction into a decimal value."
    },
    {
      "name": "DOLLARFR",
      "slug": "DOLLARFR",
      "category": "financial",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        }
      },
      "engines": [],
      "syntax": "DOLLARFR(decimal_price, unit)",
      "description": "Converts a price quotation given as a decimal value into a decimal fraction."
    },
    {
      "name": "DPRODUCT",
      "slug": "DPRODUCT",
      "category": "database",
      "engineStatus": {
        "formulas": {
          "status": "missing",
          "via": "DV-0011"
        },
        "hyperformula": {
          "status": "missing",
          "via": "DV-0011"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0011"
        }
      },
      "engines": [],
      "syntax": "DPRODUCT(database, field, criteria)",
      "description": "Returns the product of values selected from a database table-like array or range using a SQL-like query."
    },
    {
      "name": "DSTDEV",
      "slug": "DSTDEV",
      "category": "database",
      "engineStatus": {},
      "engines": [],
      "syntax": "DSTDEV(database, field, criteria)",
      "description": "Returns the standard deviation of a population sample selected from a database table-like array or range using a SQL-like query."
    },
    {
      "name": "DSTDEVP",
      "slug": "DSTDEVP",
      "category": "database",
      "engineStatus": {
        "formulas": {
          "status": "missing",
          "via": "DV-0011"
        },
        "hyperformula": {
          "status": "missing",
          "via": "DV-0011"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0011"
        }
      },
      "engines": [],
      "syntax": "DSTDEVP(database, field, criteria)",
      "description": "Returns the standard deviation of an entire population selected from a database table-like array or range using a SQL-like query."
    },
    {
      "name": "DSUM",
      "slug": "DSUM",
      "category": "database",
      "engineStatus": {
        "formulas": {
          "status": "missing",
          "via": "DV-0011"
        },
        "hyperformula": {
          "status": "missing",
          "via": "DV-0011"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0011"
        }
      },
      "engines": [],
      "syntax": "DSUM(database, field, criteria)",
      "description": "Returns the sum of values selected from a database table-like array or range using a SQL-like query."
    },
    {
      "name": "DUCKHUNT",
      "slug": "DUCKHUNT",
      "category": "uncategorized",
      "engineStatus": {
        "gsheets": {
          "status": "available"
        }
      },
      "engines": [
        "gsheets"
      ],
      "coverage": "out-of-scope",
      "syntax": "DUCKHUNT()",
      "description": "Returns `🦆`, the duck emoji (`U+1F986`)."
    },
    {
      "name": "DURATION",
      "slug": "DURATION",
      "category": "financial",
      "engineStatus": {},
      "engines": [],
      "syntax": "DURATION(settlement, maturity, rate, yield, frequency, [day_count_convention])",
      "description": "Calculates the number of compounding periods required for an investment of a specified present value appreciating at a given rate to reach a target value."
    },
    {
      "name": "DVAR",
      "slug": "DVAR",
      "category": "database",
      "engineStatus": {
        "formulas": {
          "status": "missing",
          "via": "DV-0011"
        },
        "hyperformula": {
          "status": "missing",
          "via": "DV-0011"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0011"
        }
      },
      "engines": [],
      "syntax": "DVAR(database, field, criteria)",
      "description": "Returns the variance of a population sample selected from a database table-like array or range using a SQL-like query."
    },
    {
      "name": "DVARP",
      "slug": "DVARP",
      "category": "database",
      "engineStatus": {
        "formulas": {
          "status": "missing",
          "via": "DV-0011"
        },
        "hyperformula": {
          "status": "missing",
          "via": "DV-0011"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0011"
        }
      },
      "engines": [],
      "syntax": "DVARP(database, field, criteria)",
      "description": "Returns the variance of an entire population selected from a database table-like array or range using a SQL-like query."
    },
    {
      "name": "EDATE",
      "slug": "EDATE",
      "category": "date",
      "engineStatus": {
        "hyperformula": {
          "status": "partial",
          "via": "DV-0014"
        },
        "pycel": {
          "status": "partial",
          "via": "DV-0014"
        }
      },
      "engines": [],
      "syntax": "EDATE(start_date, months)",
      "description": "Returns a date a specified number of months before or after another date."
    },
    {
      "name": "EFFECT",
      "slug": "EFFECT",
      "category": "financial",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        },
        "libreoffice": {
          "status": "partial",
          "via": "DV-0127"
        },
        "excel": {
          "status": "partial",
          "via": "DV-0124"
        },
        "formulas": {
          "status": "partial",
          "via": "DV-0124"
        },
        "gsheets": {
          "status": "partial",
          "via": "DV-0124"
        },
        "lattice": {
          "status": "partial",
          "via": "DV-0124"
        },
        "ironcalc": {
          "status": "partial",
          "via": "DV-0125"
        },
        "hyperformula": {
          "status": "partial",
          "via": "DV-0126"
        }
      },
      "engines": [],
      "syntax": "EFFECT(nominal_rate, periods_per_year)",
      "description": "Calculates the annual effective interest rate given the nominal rate and number of compounding periods per year."
    },
    {
      "name": "ENCODEURL",
      "slug": "ENCODEURL",
      "category": "web",
      "engineStatus": {
        "excel": {
          "status": "missing",
          "via": "DV-0038"
        },
        "formulas": {
          "status": "missing",
          "via": "DV-0038"
        },
        "hyperformula": {
          "status": "missing",
          "via": "DV-0038"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0038"
        },
        "lattice": {
          "status": "missing",
          "via": "DV-0038"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0038"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0038"
        }
      },
      "engines": [],
      "syntax": "ENCODEURL(text)",
      "description": "Encodes text so it can be used in the query string of a URL."
    },
    {
      "name": "EOMONTH",
      "slug": "EOMONTH",
      "category": "date",
      "engineStatus": {
        "hyperformula": {
          "status": "partial",
          "via": "DV-0014"
        },
        "pycel": {
          "status": "partial",
          "via": "DV-0014"
        }
      },
      "engines": [],
      "syntax": "EOMONTH(start_date, months)",
      "description": "Returns a date representing the last day of a month which falls a specified number of months before or after another date."
    },
    {
      "name": "EPOCHTODATE",
      "slug": "EPOCHTODATE",
      "category": "date",
      "engineStatus": {
        "excel": {
          "status": "missing",
          "via": "DV-0009"
        },
        "formulas": {
          "status": "missing",
          "via": "DV-0010"
        },
        "hyperformula": {
          "status": "missing",
          "via": "DV-0010"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0010"
        },
        "lattice": {
          "status": "missing",
          "via": "DV-0010"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0010"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0010"
        }
      },
      "engines": [],
      "syntax": "EPOCHTODATE(timestamp, [unit])",
      "description": "Converts a Unix epoch timestamp in seconds, milliseconds, or microseconds to a datetime in Universal Time Coordinated(UTC)."
    },
    {
      "name": "EQ",
      "slug": "EQ",
      "category": "operator",
      "engineStatus": {
        "excel": {
          "status": "missing",
          "via": "DV-0002"
        },
        "formulas": {
          "status": "missing",
          "via": "DV-0002"
        },
        "hyperformula": {
          "status": "missing",
          "via": "DV-0002"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0002"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0002"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0002"
        }
      },
      "engines": [],
      "syntax": "EQ(value1, value2)",
      "description": "Returns \"TRUE\" if two specified values are equal and \"FALSE\" otherwise."
    },
    {
      "name": "ERF.PRECISE",
      "slug": "ERF.PRECISE",
      "category": "engineering",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0017"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0017"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0017"
        }
      },
      "engines": [],
      "syntax": "ERF(lower_bound, [upper_bound])",
      "description": "The ERF function returns the integral of the Gauss error function over an interval of values."
    },
    {
      "name": "ERF",
      "slug": "ERF",
      "category": "engineering",
      "engineStatus": {},
      "engines": [],
      "syntax": "ERF(lower_bound, [upper_bound])",
      "description": "The ERF function returns the integral of the Gauss error function over an interval of values."
    },
    {
      "name": "ERFC.PRECISE",
      "slug": "ERFC.PRECISE",
      "category": "math",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0017"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0017"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0017"
        }
      },
      "engines": [],
      "syntax": "ERFC(z)",
      "description": "The ERFC function returns the complementary Gauss error function of a value."
    },
    {
      "name": "ERFC",
      "slug": "ERFC",
      "category": "math",
      "engineStatus": {},
      "engines": [],
      "syntax": "ERFC(z)",
      "description": "The ERFC function returns the complementary Gauss error function of a value."
    },
    {
      "name": "ERROR.TYPE",
      "slug": "ERROR.TYPE",
      "category": "info",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0016"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0016"
        },
        "lattice": {
          "status": "partial",
          "via": "DV-0062"
        }
      },
      "engines": [],
      "syntax": "ERROR.TYPE(reference)",
      "description": "Returns a number corresponding to the error value in a different cell."
    },
    {
      "name": "EVEN",
      "slug": "EVEN",
      "category": "math",
      "engineStatus": {},
      "engines": [],
      "syntax": "EVEN(value)",
      "description": "Rounds a number up to the nearest even integer."
    },
    {
      "name": "EXACT",
      "slug": "EXACT",
      "category": "text",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        }
      },
      "engines": [],
      "syntax": "EXACT(string1, string2)",
      "description": "Tests whether two strings are identical."
    },
    {
      "name": "EXP",
      "slug": "EXP",
      "category": "math",
      "engineStatus": {
        "ironcalc": {
          "status": "partial",
          "via": "DV-0200"
        },
        "hyperformula": {
          "status": "partial",
          "via": "DV-0201"
        },
        "libreoffice": {
          "status": "partial",
          "via": "DV-0202"
        }
      },
      "engines": [],
      "syntax": "EXP(exponent)",
      "description": "Returns Euler's number, e (~2."
    },
    {
      "name": "EXPON.DIST",
      "slug": "EXPON.DIST",
      "category": "statistical",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0017"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0017"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0017"
        }
      },
      "engines": [],
      "syntax": "EXPON.DIST(x, lambda, cumulative)",
      "description": "Returns the value of the exponential distribution function with a specified lambda at a specified value."
    },
    {
      "name": "EXPONDIST",
      "slug": "EXPONDIST",
      "category": "statistical",
      "engineStatus": {},
      "engines": [],
      "syntax": "EXPON.DIST(x, lambda, cumulative)",
      "description": "Returns the value of the exponential distribution function with a specified lambda at a specified value."
    },
    {
      "name": "F.DIST.RT",
      "slug": "F.DIST.RT",
      "category": "statistical",
      "engineStatus": {},
      "engines": [],
      "syntax": "F.DIST.RT(x, degrees_freedom1, degrees_freedom2)",
      "description": "The F."
    },
    {
      "name": "F.DIST",
      "slug": "F.DIST",
      "category": "statistical",
      "engineStatus": {},
      "engines": [],
      "syntax": "F.DIST(x, degrees_freedom1, degrees_freedom2, cumulative)",
      "description": "Calculates the left-tailed F probability distribution (degree of diversity) for two data sets with given input x."
    },
    {
      "name": "F.INV.RT",
      "slug": "F.INV.RT",
      "category": "statistical",
      "engineStatus": {},
      "engines": [],
      "syntax": "F.INV.RT(probability, degrees_freedom1, degrees_freedom2)",
      "description": "The F."
    },
    {
      "name": "F.INV",
      "slug": "F.INV",
      "category": "statistical",
      "engineStatus": {},
      "engines": [],
      "syntax": "F.INV(probability, degrees_freedom1, degrees_freedom2)",
      "description": "Calculates the inverse of the left-tailed F probability distribution."
    },
    {
      "name": "F.TEST",
      "slug": "F.TEST",
      "category": "statistical",
      "engineStatus": {},
      "engines": [],
      "syntax": "FTEST(range1, range2)",
      "description": "Returns the probability associated with an F-test for equality of variances."
    },
    {
      "name": "FACT",
      "slug": "FACT",
      "category": "math",
      "engineStatus": {
        "libreoffice": {
          "status": "partial",
          "via": "DV-0008"
        }
      },
      "engines": [],
      "syntax": "FACT(value)",
      "description": "The FACT function returns the factorial of a number."
    },
    {
      "name": "FACTDOUBLE",
      "slug": "FACTDOUBLE",
      "category": "math",
      "engineStatus": {
        "libreoffice": {
          "status": "partial",
          "via": "DV-0008"
        },
        "pycel": {
          "status": "partial",
          "via": "DV-0192"
        },
        "gsheets": {
          "status": "partial",
          "via": "DV-0192"
        },
        "hyperformula": {
          "status": "partial",
          "via": "DV-0192"
        },
        "lattice": {
          "status": "partial",
          "via": "DV-0192"
        }
      },
      "engines": [],
      "syntax": "FACTDOUBLE(value)",
      "description": "Returns the \"double factorial\" of a number."
    },
    {
      "name": "FALSE",
      "slug": "FALSE",
      "category": "logical",
      "engineStatus": {},
      "engines": [],
      "syntax": "FALSE()",
      "description": "Returns the logical value `FALSE`."
    },
    {
      "name": "FDIST",
      "slug": "FDIST",
      "category": "statistical",
      "engineStatus": {},
      "engines": [],
      "syntax": "F.DIST.RT(x, degrees_freedom1, degrees_freedom2)",
      "description": "The F."
    },
    {
      "name": "FILTER",
      "slug": "FILTER",
      "category": "filter",
      "engineStatus": {
        "lattice": {
          "status": "partial",
          "via": "DV-0018"
        },
        "gsheets": {
          "status": "partial",
          "via": "DV-0023"
        },
        "excel": {
          "status": "partial",
          "via": "DV-0213"
        }
      },
      "engines": [],
      "syntax": "FILTER(range, condition1, [condition2, ...])",
      "description": "Returns a filtered version of the source range, returning only rows or columns that meet the specified conditions."
    },
    {
      "name": "FIND",
      "slug": "FIND",
      "category": "text",
      "engineStatus": {},
      "engines": [],
      "syntax": "FIND(search_for, text_to_search, [starting_at])",
      "description": "Returns the position at which a string is first found within text, case-sensitive."
    },
    {
      "name": "FINDB",
      "slug": "FINDB",
      "category": "text",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0003"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0003"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0003"
        }
      },
      "engines": [],
      "syntax": "FINDB(search_for, text_to_search, [starting_at])",
      "description": "Returns the byte position at which a string is first found within text."
    },
    {
      "name": "FINV",
      "slug": "FINV",
      "category": "statistical",
      "engineStatus": {},
      "engines": [],
      "syntax": "F.INV.RT(probability, degrees_freedom1, degrees_freedom2)",
      "description": "The F."
    },
    {
      "name": "FISHER",
      "slug": "FISHER",
      "category": "statistical",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        }
      },
      "engines": [],
      "syntax": "FISHER(value)",
      "description": "Returns the Fisher transformation of a specified value."
    },
    {
      "name": "FISHERINV",
      "slug": "FISHERINV",
      "category": "statistical",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        }
      },
      "engines": [],
      "syntax": "FISHERINV(value)",
      "description": "Returns the inverse Fisher transformation of a specified value."
    },
    {
      "name": "FIXED",
      "slug": "FIXED",
      "category": "text",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0003"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0003"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0003"
        }
      },
      "engines": [],
      "syntax": "FIXED(number, [number_of_places], [suppress_separator])",
      "description": "Formats a number with a fixed number of decimal places."
    },
    {
      "name": "FLATTEN",
      "slug": "FLATTEN",
      "category": "array",
      "engineStatus": {
        "lattice": {
          "status": "partial",
          "via": "DV-0018"
        },
        "excel": {
          "status": "missing",
          "via": "DV-0032"
        }
      },
      "engines": [],
      "syntax": "=FLATTEN(range1, [range2, …])",
      "description": "Flattens all the values from one or more ranges into a single column."
    },
    {
      "name": "FLOOR.MATH",
      "slug": "FLOOR.MATH",
      "category": "math",
      "engineStatus": {
        "libreoffice": {
          "status": "missing",
          "via": "DV-0007"
        }
      },
      "engines": [],
      "syntax": "FLOOR.MATH(number, [significance], [mode])",
      "description": "The FLOOR."
    },
    {
      "name": "FLOOR.PRECISE",
      "slug": "FLOOR.PRECISE",
      "category": "math",
      "engineStatus": {
        "libreoffice": {
          "status": "missing",
          "via": "DV-0007"
        },
        "formulas": {
          "status": "partial",
          "via": "DV-0186"
        }
      },
      "engines": [],
      "syntax": "FLOOR.PRECISE(number, [significance])",
      "description": "The FLOOR."
    },
    {
      "name": "FLOOR",
      "slug": "FLOOR",
      "category": "math",
      "engineStatus": {
        "libreoffice": {
          "status": "partial",
          "via": "DV-0008"
        }
      },
      "engines": [],
      "syntax": "FLOOR(value, [factor])",
      "description": "The FLOOR function rounds a number down to the nearest integer multiple of specified significance."
    },
    {
      "name": "FORECAST.LINEAR",
      "slug": "FORECAST.LINEAR",
      "category": "statistical",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0013"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0013"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0013"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0013"
        }
      },
      "engines": [],
      "syntax": "FORECAST(x, data_y, data_x)",
      "description": "Calculates the expected y-value for a specified x based on a linear regression of a dataset."
    },
    {
      "name": "FORECAST",
      "slug": "FORECAST",
      "category": "statistical",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0215"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0215"
        }
      },
      "engines": [],
      "syntax": "FORECAST(x, data_y, data_x)",
      "description": "Calculates the expected y-value for a specified x based on a linear regression of a dataset."
    },
    {
      "name": "FORMULATEXT",
      "slug": "FORMULATEXT",
      "category": "lookup",
      "engineStatus": {},
      "engines": [],
      "syntax": "FORMULATEXT(cell)",
      "description": "The FORMULATEXT function returns a formula as a string."
    },
    {
      "name": "FREQUENCY",
      "slug": "FREQUENCY",
      "category": "array",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0003"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0003"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0003"
        },
        "libreoffice": {
          "status": "partial",
          "via": "DV-0084"
        }
      },
      "engines": [],
      "syntax": "FREQUENCY(data, classes)",
      "description": "Calculates the frequency distribution of a one-column array into specified classes."
    },
    {
      "name": "FTEST",
      "slug": "FTEST",
      "category": "statistical",
      "engineStatus": {},
      "engines": [],
      "syntax": "FTEST(range1, range2)",
      "description": "Returns the probability associated with an F-test for equality of variances."
    },
    {
      "name": "FV",
      "slug": "FV",
      "category": "financial",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        },
        "excel": {
          "status": "partial",
          "via": "DV-0131"
        },
        "formulas": {
          "status": "partial",
          "via": "DV-0132"
        },
        "gsheets": {
          "status": "partial",
          "via": "DV-0132"
        },
        "lattice": {
          "status": "partial",
          "via": "DV-0132"
        },
        "hyperformula": {
          "status": "partial",
          "via": "DV-0133"
        },
        "libreoffice": {
          "status": "partial",
          "via": "DV-0134"
        }
      },
      "engines": [],
      "syntax": "FV(rate, number_of_periods, payment_amount, [present_value], [end_or_beginning])",
      "description": "The FV function calculates the future value of an annuity investment based on constant-amount periodic payments and a constant interest rate."
    },
    {
      "name": "FVSCHEDULE",
      "slug": "FVSCHEDULE",
      "category": "financial",
      "engineStatus": {
        "ironcalc": {
          "status": "missing",
          "via": "DV-0005"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0005"
        },
        "excel": {
          "status": "partial",
          "via": "DV-0135"
        },
        "gsheets": {
          "status": "partial",
          "via": "DV-0135"
        },
        "hyperformula": {
          "status": "partial",
          "via": "DV-0135"
        },
        "lattice": {
          "status": "partial",
          "via": "DV-0135"
        },
        "libreoffice": {
          "status": "partial",
          "via": "DV-0135"
        },
        "formulas": {
          "status": "partial",
          "via": "DV-0137"
        }
      },
      "engines": [],
      "syntax": "FVSCHEDULE(principal, rate_schedule)",
      "description": "The FVSCHEDULE function calculates the future value of some principal based on a specified series of potentially varying interest rates."
    },
    {
      "name": "GAMMA.DIST",
      "slug": "GAMMA.DIST",
      "category": "statistical",
      "engineStatus": {},
      "engines": [],
      "syntax": "GAMMA.DIST(x, alpha, beta, cumulative)",
      "description": "The GAMMA."
    },
    {
      "name": "GAMMA.INV",
      "slug": "GAMMA.INV",
      "category": "statistical",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0017"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0017"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0017"
        }
      },
      "engines": [],
      "syntax": "GAMMA.INV(probability, alpha, beta)",
      "description": "The GAMMA."
    },
    {
      "name": "GAMMA",
      "slug": "GAMMA",
      "category": "statistical",
      "engineStatus": {
        "libreoffice": {
          "status": "missing",
          "via": "DV-0007"
        },
        "gsheets": {
          "status": "partial",
          "via": "DV-0225"
        },
        "lattice": {
          "status": "partial",
          "via": "DV-0225"
        }
      },
      "engines": [],
      "syntax": "GAMMA(number)",
      "description": "The GAMMA function returns the Gamma function evaluated at the specified value."
    },
    {
      "name": "GAMMADIST",
      "slug": "GAMMADIST",
      "category": "statistical",
      "engineStatus": {},
      "engines": [],
      "syntax": "GAMMA.DIST(x, alpha, beta, cumulative)",
      "description": "The GAMMA."
    },
    {
      "name": "GAMMAINV",
      "slug": "GAMMAINV",
      "category": "statistical",
      "engineStatus": {},
      "engines": [],
      "syntax": "GAMMA.INV(probability, alpha, beta)",
      "description": "The GAMMA."
    },
    {
      "name": "GAMMALN.PRECISE",
      "slug": "GAMMALN.PRECISE",
      "category": "math",
      "engineStatus": {
        "libreoffice": {
          "status": "missing",
          "via": "DV-0004"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0004"
        },
        "ironcalc": {
          "status": "partial",
          "via": "DV-0068"
        },
        "hyperformula": {
          "status": "partial",
          "via": "DV-0069"
        }
      },
      "engines": [],
      "syntax": "GAMMALN(value)",
      "description": "Returns the logarithm of a specified Gamma function, base e (Euler's number)."
    },
    {
      "name": "GAMMALN",
      "slug": "GAMMALN",
      "category": "math",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        },
        "libreoffice": {
          "status": "partial",
          "via": "DV-0008"
        },
        "ironcalc": {
          "status": "partial",
          "via": "DV-0068"
        },
        "hyperformula": {
          "status": "partial",
          "via": "DV-0069"
        }
      },
      "engines": [],
      "syntax": "GAMMALN(value)",
      "description": "Returns the logarithm of a specified Gamma function, base e (Euler's number)."
    },
    {
      "name": "GAUSS",
      "slug": "GAUSS",
      "category": "statistical",
      "engineStatus": {
        "libreoffice": {
          "status": "missing",
          "via": "DV-0004"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0004"
        }
      },
      "engines": [],
      "syntax": "GAUSS(z)",
      "description": "The GAUSS function returns the probability that a random variable, drawn from a normal distribution, will be between the mean and *z* standard deviations above (or below) the mean."
    },
    {
      "name": "GCD",
      "slug": "GCD",
      "category": "math",
      "engineStatus": {},
      "engines": [],
      "syntax": "GCD(value1, [value2, ...])",
      "description": "Returns the greatest common divisor of one or more integers."
    },
    {
      "name": "GEOMEAN",
      "slug": "GEOMEAN",
      "category": "statistical",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        },
        "gsheets": {
          "status": "partial",
          "via": "DV-0221"
        },
        "ironcalc": {
          "status": "partial",
          "via": "DV-0222"
        },
        "libreoffice": {
          "status": "partial",
          "via": "DV-0222"
        }
      },
      "engines": [],
      "syntax": "GEOMEAN(value1, [value2, ...])",
      "description": "Calculates the geometric mean of a dataset."
    },
    {
      "name": "GESTEP",
      "slug": "GESTEP",
      "category": "engineering",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0016"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0016"
        }
      },
      "engines": [],
      "syntax": "GESTEP(value,[step])",
      "description": "The GESTEP function returns 1 if the rate is strictly greater than or equal to the provided step value, or 0 otherwise."
    },
    {
      "name": "GETPIVOTDATA",
      "slug": "GETPIVOTDATA",
      "category": "lookup",
      "engineStatus": {},
      "engines": [],
      "syntax": "GETPIVOTDATA(value_name, any_pivot_table_cell, [original_column, ...], [pivot_item, ...])",
      "description": "Extracts an aggregated value from a pivot table that corresponds to the specified row and column headings."
    },
    {
      "name": "GOOGLEFINANCE",
      "slug": "GOOGLEFINANCE",
      "category": "google",
      "engineStatus": {
        "excel": {
          "status": "missing",
          "via": "DV-0009"
        },
        "formulas": {
          "status": "missing",
          "via": "DV-0010"
        },
        "hyperformula": {
          "status": "missing",
          "via": "DV-0010"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0010"
        },
        "lattice": {
          "status": "missing",
          "via": "DV-0010"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0010"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0010"
        }
      },
      "engines": [],
      "syntax": "GOOGLEFINANCE(ticker, [attribute], [start_date], [end_date|num_days], [interval])",
      "description": "Fetches current or historical securities information from Google Finance."
    },
    {
      "name": "GOOGLETRANSLATE",
      "slug": "GOOGLETRANSLATE",
      "category": "google",
      "engineStatus": {
        "excel": {
          "status": "missing",
          "via": "DV-0009"
        },
        "formulas": {
          "status": "missing",
          "via": "DV-0010"
        },
        "hyperformula": {
          "status": "missing",
          "via": "DV-0010"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0010"
        },
        "lattice": {
          "status": "missing",
          "via": "DV-0010"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0010"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0010"
        }
      },
      "engines": [],
      "syntax": "GOOGLETRANSLATE(text, [source_language, target_language])",
      "description": "Translates text from one language into another."
    },
    {
      "name": "GROWTH",
      "slug": "GROWTH",
      "category": "array",
      "engineStatus": {},
      "engines": [],
      "syntax": "GROWTH(known_data_y, [known_data_x], [new_data_x], [b])",
      "description": "Given partial data about an exponential growth trend, fits an ideal exponential growth trend and/or predicts further values."
    },
    {
      "name": "GT",
      "slug": "GT",
      "category": "operator",
      "engineStatus": {
        "excel": {
          "status": "missing",
          "via": "DV-0002"
        },
        "formulas": {
          "status": "missing",
          "via": "DV-0002"
        },
        "hyperformula": {
          "status": "missing",
          "via": "DV-0002"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0002"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0002"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0002"
        }
      },
      "engines": [],
      "syntax": "GT(value1, value2)",
      "description": "Returns `TRUE` if the first argument is strictly greater than the second, and `FALSE` otherwise."
    },
    {
      "name": "GTE",
      "slug": "GTE",
      "category": "operator",
      "engineStatus": {
        "excel": {
          "status": "missing",
          "via": "DV-0002"
        },
        "formulas": {
          "status": "missing",
          "via": "DV-0002"
        },
        "hyperformula": {
          "status": "missing",
          "via": "DV-0002"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0002"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0002"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0002"
        }
      },
      "engines": [],
      "syntax": "GTE(value1, value2)",
      "description": "Returns `TRUE` if the first argument is greater than or equal to the second, and `FALSE` otherwise."
    },
    {
      "name": "HARMEAN",
      "slug": "HARMEAN",
      "category": "statistical",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        },
        "libreoffice": {
          "status": "partial",
          "via": "DV-0008"
        }
      },
      "engines": [],
      "syntax": "HARMEAN(value1, [value2, ...])",
      "description": "Calculates the harmonic mean of a dataset."
    },
    {
      "name": "HEX2BIN",
      "slug": "HEX2BIN",
      "category": "engineering",
      "engineStatus": {
        "libreoffice": {
          "status": "partial",
          "via": "DV-0008"
        }
      },
      "engines": [],
      "syntax": "HEX2BIN(signed_hexadecimal_number, [significant_digits])",
      "description": "The HEX2BIN function converts a signed hexadecimal number to signed binary format."
    },
    {
      "name": "HEX2DEC",
      "slug": "HEX2DEC",
      "category": "engineering",
      "engineStatus": {
        "libreoffice": {
          "status": "partial",
          "via": "DV-0008"
        }
      },
      "engines": [],
      "syntax": "HEX2DEC(signed_hexadecimal_number)",
      "description": "The HEX2DEC function converts a signed hexadecimal number to decimal format."
    },
    {
      "name": "HEX2OCT",
      "slug": "HEX2OCT",
      "category": "engineering",
      "engineStatus": {
        "libreoffice": {
          "status": "partial",
          "via": "DV-0008"
        }
      },
      "engines": [],
      "syntax": "HEX2OCT(signed_hexadecimal_number, [significant_digits])",
      "description": "The HEX2OCT function converts a signed hexadecimal number to signed octal format."
    },
    {
      "name": "HLOOKUP",
      "slug": "HLOOKUP",
      "category": "lookup",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0006"
        }
      },
      "engines": [],
      "syntax": "HLOOKUP(search_key, range, index, [is_sorted])",
      "description": "Horizontal lookup."
    },
    {
      "name": "HOUR",
      "slug": "HOUR",
      "category": "date",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        },
        "ironcalc": {
          "status": "partial",
          "via": "DV-0028"
        }
      },
      "engines": [],
      "syntax": "HOUR(time)",
      "description": "Returns the hour component of a specific time, in numeric format."
    },
    {
      "name": "HSTACK",
      "slug": "HSTACK",
      "category": "array",
      "engineStatus": {
        "excel": {
          "status": "partial",
          "via": "DV-0096"
        },
        "lattice": {
          "status": "partial",
          "via": "DV-0096"
        }
      },
      "engines": [],
      "syntax": "HSTACK(range1; [range2, …])",
      "description": "This function appends arrays horizontally and in sequence to return a larger array."
    },
    {
      "name": "HYPERLINK",
      "slug": "HYPERLINK",
      "category": "web",
      "engineStatus": {},
      "engines": [],
      "syntax": "HYPERLINK(url, [link_label])",
      "description": "Creates a hyperlink inside a cell."
    },
    {
      "name": "HYPGEOM.DIST",
      "slug": "HYPGEOM.DIST",
      "category": "statistical",
      "engineStatus": {},
      "engines": [],
      "syntax": "HYPGEOMDIST(num_successes, num_draws, successes_in_pop, pop_size)",
      "description": "Calculates the probability of drawing a certain number of successes in a certain number of tries given a population of a certain size containing a certain number of successes, without replacement of draws."
    },
    {
      "name": "HYPGEOMDIST",
      "slug": "HYPGEOMDIST",
      "category": "statistical",
      "engineStatus": {},
      "engines": [],
      "syntax": "HYPGEOMDIST(num_successes, num_draws, successes_in_pop, pop_size)",
      "description": "Calculates the probability of drawing a certain number of successes in a certain number of tries given a population of a certain size containing a certain number of successes, without replacement of draws."
    },
    {
      "name": "IF",
      "slug": "IF",
      "category": "logical",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0006"
        },
        "lattice": {
          "status": "partial",
          "via": "DV-0116"
        }
      },
      "engines": [],
      "syntax": "IF(logical_expression, value_if_true, value_if_false)",
      "description": "Returns one value if a logical expression is `TRUE` and another if it is `FALSE`."
    },
    {
      "name": "IFERROR",
      "slug": "IFERROR",
      "category": "logical",
      "engineStatus": {},
      "engines": [],
      "syntax": "IFERROR(value, [value_if_error])",
      "description": "Returns the first argument if it is not an error value, otherwise returns the second argument if present, or a blank if the second argument is absent."
    },
    {
      "name": "IFNA",
      "slug": "IFNA",
      "category": "logical",
      "engineStatus": {
        "libreoffice": {
          "status": "missing",
          "via": "DV-0007"
        }
      },
      "engines": [],
      "syntax": "IFNA(value, value_if_na)",
      "description": "The IFNA function evaluates a value."
    },
    {
      "name": "IFS",
      "slug": "IFS",
      "category": "logical",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0015"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0015"
        }
      },
      "engines": [],
      "syntax": "IFS(condition1, value1, [condition2, value2, …])",
      "description": "Evaluates multiple conditions and returns a value that corresponds to the first true condition."
    },
    {
      "name": "IMABS",
      "slug": "IMABS",
      "category": "engineering",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        }
      },
      "engines": [],
      "syntax": "IMABS(number)",
      "description": "Returns the absolute value of a complex number."
    },
    {
      "name": "IMAGE",
      "slug": "IMAGE",
      "category": "google",
      "engineStatus": {
        "gsheets": {
          "status": "missing",
          "via": "DV-0020"
        }
      },
      "engines": [],
      "syntax": "IMAGE(url, [mode], [height], [width])",
      "description": "Inserts an image into a cell."
    },
    {
      "name": "IMAGINARY",
      "slug": "IMAGINARY",
      "category": "engineering",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        }
      },
      "engines": [],
      "syntax": "IMAGINARY(complex_number)",
      "description": "Returns the imaginary coefficient of a complex number."
    },
    {
      "name": "IMARGUMENT",
      "slug": "IMARGUMENT",
      "category": "engineering",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        }
      },
      "engines": [],
      "syntax": "=IMARGUMENT(number)",
      "description": "The IMARGUMENT function returns the angle (also known as the argument, or theta) of the given complex number in radians."
    },
    {
      "name": "IMCONJUGATE",
      "slug": "IMCONJUGATE",
      "category": "engineering",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        },
        "lattice": {
          "status": "partial",
          "via": "DV-0054"
        }
      },
      "engines": [],
      "syntax": "IMCONJUGATE(number)",
      "description": "Returns the complex conjugate of a number."
    },
    {
      "name": "IMCOS",
      "slug": "IMCOS",
      "category": "engineering",
      "engineStatus": {},
      "engines": [],
      "syntax": "IMCOS(number)",
      "description": "The IMCOS function returns the cosine of the given complex number."
    },
    {
      "name": "IMCOSH",
      "slug": "IMCOSH",
      "category": "engineering",
      "engineStatus": {},
      "engines": [],
      "syntax": "IMCOSH(number)",
      "description": "The IMCOSH function returns the hyperbolic cosine of the given complex number."
    },
    {
      "name": "IMCOT",
      "slug": "IMCOT",
      "category": "engineering",
      "engineStatus": {},
      "engines": [],
      "syntax": "IMCOT(number)",
      "description": "The IMCOT function returns the cotangent of the given complex number."
    },
    {
      "name": "IMCOTH",
      "slug": "IMCOTH",
      "category": "engineering",
      "engineStatus": {},
      "engines": [],
      "syntax": "IMCOTH(number)",
      "description": "The IMCOTH function returns the hyperbolic cotangent of the given complex number."
    },
    {
      "name": "IMCSC",
      "slug": "IMCSC",
      "category": "engineering",
      "engineStatus": {},
      "engines": [],
      "syntax": "IMCSC(number)",
      "description": "The IMCSC function returns the cosecant of the given complex number."
    },
    {
      "name": "IMCSCH",
      "slug": "IMCSCH",
      "category": "engineering",
      "engineStatus": {},
      "engines": [],
      "syntax": "IMCSCH(number)",
      "description": "The IMCSCH function returns the hyperbolic cosecant of the given complex number."
    },
    {
      "name": "IMDIV",
      "slug": "IMDIV",
      "category": "engineering",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        },
        "lattice": {
          "status": "partial",
          "via": "DV-0036"
        },
        "formulas": {
          "status": "partial",
          "via": "DV-0045"
        }
      },
      "engines": [],
      "syntax": "IMDIV(dividend, divisor)",
      "description": "Returns one complex number divided by another."
    },
    {
      "name": "IMEXP",
      "slug": "IMEXP",
      "category": "engineering",
      "engineStatus": {},
      "engines": [],
      "syntax": "IMEXP(exponent)",
      "description": "The IMEXP function returns Euler's number, e (~2."
    },
    {
      "name": "IMLN",
      "slug": "IMLN",
      "category": "math",
      "engineStatus": {},
      "engines": [],
      "syntax": "IMLN(number)",
      "description": "The `IMLN` function returns the logarithm of a complex number, base e (Euler's number)."
    },
    {
      "name": "IMLOG",
      "slug": "IMLOG",
      "category": "engineering",
      "engineStatus": {},
      "engines": [],
      "syntax": "IMLOG(value, base)",
      "description": "The IMLOG function returns the logarithm of a complex number for a specified base."
    },
    {
      "name": "IMLOG10",
      "slug": "IMLOG10",
      "category": "engineering",
      "engineStatus": {},
      "engines": [],
      "syntax": "IMLOG10(value)",
      "description": "The IMLOG10 function returns the logarithm of a complex number with base 10."
    },
    {
      "name": "IMLOG2",
      "slug": "IMLOG2",
      "category": "engineering",
      "engineStatus": {},
      "engines": [],
      "syntax": "IMLOG2(value)",
      "description": "The IMLOG2 function returns the logarithm of a complex number with base 2."
    },
    {
      "name": "IMPORTDATA",
      "slug": "IMPORTDATA",
      "category": "web",
      "engineStatus": {
        "gsheets": {
          "status": "missing",
          "via": "DV-0020"
        }
      },
      "engines": [],
      "syntax": "IMPORTDATA(url)",
      "description": "Imports data at a given url in ."
    },
    {
      "name": "IMPORTFEED",
      "slug": "IMPORTFEED",
      "category": "web",
      "engineStatus": {
        "gsheets": {
          "status": "missing",
          "via": "DV-0020"
        }
      },
      "engines": [],
      "syntax": "IMPORTFEED(url, [query], [headers], [num_items])",
      "description": "Imports a RSS or ATOM feed."
    },
    {
      "name": "IMPORTHTML",
      "slug": "IMPORTHTML",
      "category": "web",
      "engineStatus": {
        "gsheets": {
          "status": "missing",
          "via": "DV-0020"
        }
      },
      "engines": [],
      "syntax": "IMPORTHTML(url, query, index)",
      "description": "Imports data from a table or list within an HTML page."
    },
    {
      "name": "IMPORTRANGE",
      "slug": "IMPORTRANGE",
      "category": "web",
      "engineStatus": {
        "gsheets": {
          "status": "missing",
          "via": "DV-0020"
        }
      },
      "engines": [],
      "syntax": "IMPORTRANGE(spreadsheet_url, range_string)",
      "description": "Imports a range of cells from a specified spreadsheet."
    },
    {
      "name": "IMPORTXML",
      "slug": "IMPORTXML",
      "category": "web",
      "engineStatus": {
        "gsheets": {
          "status": "missing",
          "via": "DV-0020"
        }
      },
      "engines": [],
      "syntax": "IMPORTXML(url, xpath_query, locale)",
      "description": "Imports data from any of various structured data types including XML, HTML, CSV, TSV, and RSS and ATOM XML feeds."
    },
    {
      "name": "IMPOWER",
      "slug": "IMPOWER",
      "category": "math",
      "engineStatus": {},
      "engines": [],
      "syntax": "IMPOWER(complex_base, exponent)",
      "description": "The `IMPOWER` function returns a complex number raised to a power."
    },
    {
      "name": "IMPRODUCT",
      "slug": "IMPRODUCT",
      "category": "engineering",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        },
        "formulas": {
          "status": "partial",
          "via": "DV-0037"
        },
        "lattice": {
          "status": "partial",
          "via": "DV-0113"
        }
      },
      "engines": [],
      "syntax": "IMPRODUCT(factor1, [factor2, ...])",
      "description": "Returns the result of multiplying a series of complex numbers together."
    },
    {
      "name": "IMREAL",
      "slug": "IMREAL",
      "category": "engineering",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        }
      },
      "engines": [],
      "syntax": "IMREAL(complex_number)",
      "description": "Returns the real coefficient of a complex number."
    },
    {
      "name": "IMSEC",
      "slug": "IMSEC",
      "category": "engineering",
      "engineStatus": {},
      "engines": [],
      "syntax": "IMSEC(number)",
      "description": "The IMSEC function returns the secant of the given complex number."
    },
    {
      "name": "IMSECH",
      "slug": "IMSECH",
      "category": "engineering",
      "engineStatus": {},
      "engines": [],
      "syntax": "IMSECH(number)",
      "description": "The IMSECH function returns the hyperbolic secant of the given complex number."
    },
    {
      "name": "IMSIN",
      "slug": "IMSIN",
      "category": "engineering",
      "engineStatus": {},
      "engines": [],
      "syntax": "IMSIN (number)",
      "description": "The IMSIN function returns the sine of the given complex number."
    },
    {
      "name": "IMSINH",
      "slug": "IMSINH",
      "category": "engineering",
      "engineStatus": {},
      "engines": [],
      "syntax": "IMSINH(number)",
      "description": "The IMSINH function returns the hyperbolic sine of the given complex number."
    },
    {
      "name": "IMSQRT",
      "slug": "IMSQRT",
      "category": "math",
      "engineStatus": {},
      "engines": [],
      "syntax": "IMSQRT(complex_number)",
      "description": "The `IMSQRT` function computes the square root of a complex number."
    },
    {
      "name": "IMSUB",
      "slug": "IMSUB",
      "category": "engineering",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        },
        "lattice": {
          "status": "partial",
          "via": "DV-0110"
        }
      },
      "engines": [],
      "syntax": "IMSUB(first_number, second_number)",
      "description": "Returns the difference between two complex numbers."
    },
    {
      "name": "IMSUM",
      "slug": "IMSUM",
      "category": "engineering",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        },
        "lattice": {
          "status": "partial",
          "via": "DV-0107"
        },
        "ironcalc": {
          "status": "partial",
          "via": "DV-0105"
        }
      },
      "engines": [],
      "syntax": "IMSUM(value1, [value2, ...])",
      "description": "Returns the sum of a series of complex numbers or cells or both."
    },
    {
      "name": "IMTAN",
      "slug": "IMTAN",
      "category": "engineering",
      "engineStatus": {},
      "engines": [],
      "syntax": "IMTAN(number)",
      "description": "The IMTAN function returns the tangent of the given complex number."
    },
    {
      "name": "IMTANH",
      "slug": "IMTANH",
      "category": "engineering",
      "engineStatus": {},
      "engines": [],
      "syntax": "IMTANH(number)",
      "description": "The IMTANH function returns the hyperbolic tangent of the given complex number."
    },
    {
      "name": "INDEX",
      "slug": "INDEX/index",
      "category": "lookup",
      "engineStatus": {},
      "engines": [],
      "syntax": "INDEX(reference, [row], [column])",
      "description": "Returns the content of a cell, specified by row and column offset."
    },
    {
      "name": "INDIRECT",
      "slug": "INDIRECT",
      "category": "lookup",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0048"
        },
        "ironcalc": {
          "status": "partial",
          "via": "DV-0030"
        },
        "pycel": {
          "status": "partial",
          "via": "DV-0034"
        },
        "formulas": {
          "status": "missing",
          "via": "DV-0048"
        },
        "lattice": {
          "status": "partial",
          "via": "DV-0062"
        },
        "excel": {
          "status": "missing",
          "via": "DV-0114"
        }
      },
      "engines": [],
      "syntax": "INDIRECT(cell_reference_as_string, [is_A1_notation])",
      "description": "Returns a cell reference specified by a string."
    },
    {
      "name": "INT",
      "slug": "INT",
      "category": "math",
      "engineStatus": {
        "hyperformula": {
          "status": "partial",
          "via": "DV-0193"
        }
      },
      "engines": [],
      "syntax": "INT(value)",
      "description": "Rounds a number down to the nearest integer that is less than or equal to it."
    },
    {
      "name": "INTERCEPT",
      "slug": "INTERCEPT",
      "category": "statistical",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0006"
        },
        "pycel": {
          "status": "partial",
          "via": "DV-0216"
        }
      },
      "engines": [],
      "syntax": "INTERCEPT(data_y, data_x)",
      "description": "Calculates the y-value at which the line resulting from linear regression of a dataset will intersect the y-axis (x=0)."
    },
    {
      "name": "INTRATE",
      "slug": "INTRATE",
      "category": "financial",
      "engineStatus": {},
      "engines": [],
      "syntax": "INTRATE(buy_date, sell_date, buy_price, sell_price, [day_count_convention])",
      "description": "Calculates the effective interest rate generated when an investment is purchased at one price and sold at another with no interest or dividends generated by the investment itself."
    },
    {
      "name": "IPMT",
      "slug": "IPMT",
      "category": "financial",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        },
        "libreoffice": {
          "status": "partial",
          "via": "DV-0141"
        },
        "formulas": {
          "status": "partial",
          "via": "DV-0045"
        },
        "excel": {
          "status": "partial",
          "via": "DV-0138"
        },
        "gsheets": {
          "status": "partial",
          "via": "DV-0138"
        },
        "lattice": {
          "status": "partial",
          "via": "DV-0138"
        },
        "ironcalc": {
          "status": "partial",
          "via": "DV-0139"
        },
        "hyperformula": {
          "status": "partial",
          "via": "DV-0142"
        }
      },
      "engines": [],
      "syntax": "IPMT(rate, period, number_of_periods, present_value, [future_value], [end_or_beginning])",
      "description": "The IPMT function calculates the payment on interest for an investment based on constant-amount periodic payments and a constant interest rate."
    },
    {
      "name": "IRR",
      "slug": "IRR",
      "category": "financial",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        },
        "libreoffice": {
          "status": "partial",
          "via": "DV-0058"
        }
      },
      "engines": [],
      "syntax": "IRR(cashflow_amounts, [rate_guess])",
      "description": "Calculates the internal rate of return on an investment based on a series of periodic cash flows."
    },
    {
      "name": "ISBETWEEN",
      "slug": "ISBETWEEN",
      "category": "operator",
      "engineStatus": {
        "excel": {
          "status": "missing",
          "via": "DV-0002"
        },
        "formulas": {
          "status": "missing",
          "via": "DV-0002"
        },
        "hyperformula": {
          "status": "missing",
          "via": "DV-0002"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0002"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0002"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0002"
        }
      },
      "engines": [],
      "syntax": "ISBETWEEN(value_to_compare, lower_value, upper_value, lower_value_is_inclusive, upper_value_is_inclusive)",
      "description": "Checks whether a provided number is between two other numbers either inclusively or exclusively."
    },
    {
      "name": "ISBLANK",
      "slug": "ISBLANK",
      "category": "info",
      "engineStatus": {},
      "engines": [],
      "syntax": "ISBLANK(value)",
      "description": "Checks whether a value is null."
    },
    {
      "name": "ISDATE",
      "slug": "ISDATE",
      "category": "info",
      "engineStatus": {
        "excel": {
          "status": "partial",
          "via": "DV-0019"
        },
        "formulas": {
          "status": "missing",
          "via": "DV-0024"
        },
        "hyperformula": {
          "status": "missing",
          "via": "DV-0024"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0024"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0024"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0024"
        }
      },
      "engines": [],
      "syntax": "ISDATE(value)",
      "description": "The ISDATE function returns whether a value is a date."
    },
    {
      "name": "ISEMAIL",
      "slug": "ISEMAIL",
      "category": "info",
      "engineStatus": {
        "excel": {
          "status": "missing",
          "via": "DV-0009"
        },
        "formulas": {
          "status": "missing",
          "via": "DV-0010"
        },
        "hyperformula": {
          "status": "missing",
          "via": "DV-0010"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0010"
        },
        "lattice": {
          "status": "missing",
          "via": "DV-0010"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0010"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0010"
        }
      },
      "engines": [],
      "syntax": "ISEMAIL(value)",
      "description": "This function checks if a value is a valid email address against certain 2-letter country or region codes and top-level domains including:."
    },
    {
      "name": "ISERR",
      "slug": "ISERR",
      "category": "info",
      "engineStatus": {},
      "engines": [],
      "syntax": "ISERR(value)",
      "description": "Checks whether a value is an error other than `#N/A`."
    },
    {
      "name": "ISERROR",
      "slug": "ISERROR",
      "category": "info",
      "engineStatus": {},
      "engines": [],
      "syntax": "ISERROR(value)",
      "description": "Checks whether a value is an error."
    },
    {
      "name": "ISEVEN",
      "slug": "ISEVEN",
      "category": "math",
      "engineStatus": {},
      "engines": [],
      "syntax": "ISEVEN(value)",
      "description": "Checks whether the provided value is even."
    },
    {
      "name": "ISFORMULA",
      "slug": "ISFORMULA",
      "category": "info",
      "engineStatus": {
        "libreoffice": {
          "status": "missing",
          "via": "DV-0004"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0004"
        },
        "lattice": {
          "status": "partial",
          "via": "DV-0018"
        }
      },
      "engines": [],
      "syntax": "ISFORMULA(cell)",
      "description": "Checks whether a formula is in the referenced cell."
    },
    {
      "name": "ISLOGICAL",
      "slug": "ISLOGICAL",
      "category": "info",
      "engineStatus": {
        "hyperformula": {
          "status": "partial",
          "via": "DV-0047"
        }
      },
      "engines": [],
      "syntax": "ISLOGICAL(value)",
      "description": "Checks whether a value is `TRUE` or `FALSE`."
    },
    {
      "name": "ISNA",
      "slug": "ISNA",
      "category": "info",
      "engineStatus": {},
      "engines": [],
      "syntax": "ISNA(value)",
      "description": "Checks whether a value is the error `#N/A`."
    },
    {
      "name": "ISNONTEXT",
      "slug": "ISNONTEXT",
      "category": "info",
      "engineStatus": {},
      "engines": [],
      "syntax": "ISNONTEXT(value)",
      "description": "Checks whether a value is non-textual."
    },
    {
      "name": "ISNUMBER",
      "slug": "ISNUMBER",
      "category": "info",
      "engineStatus": {
        "formulas": {
          "status": "partial",
          "via": "DV-0061"
        },
        "libreoffice": {
          "status": "partial",
          "via": "DV-0177"
        }
      },
      "engines": [],
      "syntax": "ISNUMBER(value)",
      "description": "Checks whether a value is a number."
    },
    {
      "name": "ISO.CEILING",
      "slug": "ISO.CEILING",
      "category": "math",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        },
        "formulas": {
          "status": "partial",
          "via": "DV-0067"
        }
      },
      "engines": [],
      "syntax": "CEILING.PRECISE(number, [significance])",
      "description": "The CEILING."
    },
    {
      "name": "ISODD",
      "slug": "ISODD",
      "category": "math",
      "engineStatus": {
        "hyperformula": {
          "status": "partial",
          "via": "DV-0047"
        }
      },
      "engines": [],
      "syntax": "ISODD(value)",
      "description": "Checks whether the provided value is odd."
    },
    {
      "name": "ISOWEEKNUM",
      "slug": "ISOWEEKNUM",
      "category": "date",
      "engineStatus": {
        "libreoffice": {
          "status": "missing",
          "via": "DV-0004"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0004"
        },
        "hyperformula": {
          "status": "partial",
          "via": "DV-0012"
        }
      },
      "engines": [],
      "syntax": "ISOWEEKNUM(date)",
      "description": "Returns the number of the ISO (International Organization for Standardization) week of the year where the provided date falls."
    },
    {
      "name": "ISPMT",
      "slug": "ISPMT",
      "category": "financial",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        }
      },
      "engines": [],
      "syntax": "ISPMT(rate, period, number_of_periods, present_value)",
      "description": "The ISPMT function calculates the interest paid during a particular period of an investment."
    },
    {
      "name": "ISREF",
      "slug": "ISREF",
      "category": "info",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        }
      },
      "engines": [],
      "syntax": "ISREF(value)",
      "description": "Checks whether a value is a valid cell reference."
    },
    {
      "name": "ISTEXT",
      "slug": "ISTEXT",
      "category": "info",
      "engineStatus": {},
      "engines": [],
      "syntax": "ISTEXT(value)",
      "description": "Checks whether a value is text."
    },
    {
      "name": "ISURL",
      "slug": "ISURL",
      "category": "web",
      "engineStatus": {
        "excel": {
          "status": "missing",
          "via": "DV-0038"
        },
        "formulas": {
          "status": "missing",
          "via": "DV-0038"
        },
        "hyperformula": {
          "status": "missing",
          "via": "DV-0038"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0038"
        },
        "lattice": {
          "status": "missing",
          "via": "DV-0038"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0038"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0038"
        }
      },
      "engines": [],
      "syntax": "ISURL(value)",
      "description": "Checks whether a value is a valid URL."
    },
    {
      "name": "JOIN",
      "slug": "JOIN",
      "category": "text",
      "engineStatus": {
        "excel": {
          "status": "partial",
          "via": "DV-0019"
        },
        "formulas": {
          "status": "missing",
          "via": "DV-0024"
        },
        "hyperformula": {
          "status": "missing",
          "via": "DV-0024"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0024"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0024"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0024"
        }
      },
      "engines": [],
      "syntax": "JOIN(delimiter, value_or_array1, [value_or_array2, ...])",
      "description": "Concatenates the elements of one or more one-dimensional arrays using a specified delimiter."
    },
    {
      "name": "KURT",
      "slug": "KURT",
      "category": "statistical",
      "engineStatus": {},
      "engines": [],
      "syntax": "KURT(value1, [value2, ...])",
      "description": "Calculates the kurtosis of a dataset, which describes the shape, and in particular the \"peakedness\" of that dataset."
    },
    {
      "name": "LAMBDA",
      "slug": "LAMBDA",
      "category": "logical",
      "engineStatus": {},
      "engines": [],
      "syntax": "LAMBDA(name, formula_expression)",
      "description": "Creates an anonymous function with a set of names and a formula_expression that uses them."
    },
    {
      "name": "LARGE",
      "slug": "LARGE",
      "category": "statistical",
      "engineStatus": {
        "libreoffice": {
          "status": "partial",
          "via": "DV-0008"
        }
      },
      "engines": [],
      "syntax": "LARGE(data, n)",
      "description": "Returns the nth largest element from a data set, where n is user-defined."
    },
    {
      "name": "LCM",
      "slug": "LCM",
      "category": "math",
      "engineStatus": {},
      "engines": [],
      "syntax": "LCM(value1, [value2, ...])",
      "description": "Returns the least common multiple of one or more integers."
    },
    {
      "name": "LEFT",
      "slug": "LEFT",
      "category": "text",
      "engineStatus": {},
      "engines": [],
      "syntax": "LEFT(string, [number_of_characters])",
      "description": "Returns a substring from the beginning of a specified string."
    },
    {
      "name": "LEFTB",
      "slug": "LEFTB",
      "category": "text",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0003"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0003"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0003"
        },
        "excel": {
          "status": "partial",
          "via": "DV-0031"
        },
        "formulas": {
          "status": "partial",
          "via": "DV-0031"
        },
        "gsheets": {
          "status": "partial",
          "via": "DV-0031"
        },
        "libreoffice": {
          "status": "partial",
          "via": "DV-0031"
        }
      },
      "engines": [],
      "syntax": "LEFTB(string, num_of_bytes)",
      "description": "The LEFTB function returns the left portion of a string up to a certain number of bytes."
    },
    {
      "name": "LEN",
      "slug": "LEN",
      "category": "text",
      "engineStatus": {
        "lattice": {
          "status": "partial",
          "via": "DV-0086"
        }
      },
      "engines": [],
      "syntax": "LEN(text)",
      "description": "Returns the length of a string."
    },
    {
      "name": "LENB",
      "slug": "LENB",
      "category": "text",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0003"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0003"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0003"
        }
      },
      "engines": [],
      "syntax": "LENB(string)",
      "description": "The LENB function returns the length of a string in bytes."
    },
    {
      "name": "LET",
      "slug": "LET",
      "category": "logical",
      "engineStatus": {},
      "engines": [],
      "syntax": "LET(name1, value_expression1, [name2, …], [value_expression2, …], formula_expression )",
      "description": "This function assigns a name with the value_expression results and returns the result of the formula_expression."
    },
    {
      "name": "LINEST",
      "slug": "LINEST",
      "category": "array",
      "engineStatus": {},
      "engines": [],
      "syntax": "LINEST(known_data_y, [known_data_x], [calculate_b], [verbose])",
      "description": "Given partial data about a linear trend, calculates various parameters about the ideal linear trend using the least-squares method."
    },
    {
      "name": "LN",
      "slug": "LN",
      "category": "math",
      "engineStatus": {
        "excel": {
          "status": "partial",
          "via": "DV-0203"
        },
        "gsheets": {
          "status": "partial",
          "via": "DV-0203"
        }
      },
      "engines": [],
      "syntax": "LN(value)",
      "description": "Returns the logarithm of a number, base e (Euler's number)."
    },
    {
      "name": "LOG",
      "slug": "LOG",
      "category": "math",
      "engineStatus": {},
      "engines": [],
      "syntax": "LOG(value, [base])",
      "description": "Returns the logarithm of a number given a base."
    },
    {
      "name": "LOG10",
      "slug": "LOG10",
      "category": "math",
      "engineStatus": {},
      "engines": [],
      "syntax": "LOG10(value)",
      "description": "Returns the logarithm of a number, base 10."
    },
    {
      "name": "LOGEST",
      "slug": "LOGEST",
      "category": "array",
      "engineStatus": {},
      "engines": [],
      "syntax": "LOGEST(known_data_y, [known_data_x], [b], [verbose])",
      "description": "Given partial data about an exponential growth curve, calculates various parameters about the best fit ideal exponential growth curve."
    },
    {
      "name": "LOGINV",
      "slug": "LOGINV",
      "category": "statistical",
      "engineStatus": {
        "ironcalc": {
          "status": "missing",
          "via": "DV-0005"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0005"
        }
      },
      "engines": [],
      "syntax": "LOGINV(x, mean, standard_deviation)",
      "description": "Returns the value of the inverse log-normal cumulative distribution with given mean and standard deviation at a specified value."
    },
    {
      "name": "LOGNORM.DIST",
      "slug": "LOGNORM.DIST",
      "category": "statistical",
      "engineStatus": {},
      "engines": [],
      "syntax": "LOGNORMDIST(x, mean, standard_deviation)",
      "description": "Returns the value of the log-normal cumulative distribution with given mean and standard deviation at a specified value."
    },
    {
      "name": "LOGNORM.INV",
      "slug": "LOGNORM.INV",
      "category": "statistical",
      "engineStatus": {
        "libreoffice": {
          "status": "missing",
          "via": "DV-0004"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0004"
        }
      },
      "engines": [],
      "syntax": "LOGINV(x, mean, standard_deviation)",
      "description": "Returns the value of the inverse log-normal cumulative distribution with given mean and standard deviation at a specified value."
    },
    {
      "name": "LOGNORMDIST",
      "slug": "LOGNORMDIST",
      "category": "statistical",
      "engineStatus": {
        "ironcalc": {
          "status": "missing",
          "via": "DV-0005"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0005"
        },
        "hyperformula": {
          "status": "partial",
          "via": "DV-0072"
        }
      },
      "engines": [],
      "syntax": "LOGNORMDIST(x, mean, standard_deviation)",
      "description": "Returns the value of the log-normal cumulative distribution with given mean and standard deviation at a specified value."
    },
    {
      "name": "LOOKUP",
      "slug": "LOOKUP",
      "category": "lookup",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0006"
        }
      },
      "engines": [],
      "syntax": "LOOKUP(search_key, search_range|search_result_array, [result_range])",
      "description": "Looks through a sorted row or column for a key and returns the value of the cell in a result range located in the same position as the search row or column."
    },
    {
      "name": "LOWER",
      "slug": "LOWER",
      "category": "text",
      "engineStatus": {},
      "engines": [],
      "syntax": "LOWER(text)",
      "description": "Converts a specified string to lowercase."
    },
    {
      "name": "LT",
      "slug": "LT",
      "category": "operator",
      "engineStatus": {
        "excel": {
          "status": "missing",
          "via": "DV-0002"
        },
        "formulas": {
          "status": "missing",
          "via": "DV-0002"
        },
        "hyperformula": {
          "status": "missing",
          "via": "DV-0002"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0002"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0002"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0002"
        }
      },
      "engines": [],
      "syntax": "LT(value1, value2)",
      "description": "Returns `TRUE` if the first argument is strictly less than the second, and `FALSE` otherwise."
    },
    {
      "name": "LTE",
      "slug": "LTE",
      "category": "operator",
      "engineStatus": {
        "excel": {
          "status": "missing",
          "via": "DV-0002"
        },
        "formulas": {
          "status": "missing",
          "via": "DV-0002"
        },
        "hyperformula": {
          "status": "missing",
          "via": "DV-0002"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0002"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0002"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0002"
        }
      },
      "engines": [],
      "syntax": "LTE(value1, value2)",
      "description": "Returns `TRUE` if the first argument is less than or equal to the second, and `FALSE` otherwise."
    },
    {
      "name": "MAKEARRAY",
      "slug": "MAKEARRAY",
      "category": "array",
      "engineStatus": {},
      "engines": [],
      "syntax": "MAKEARRAY(rows, columns, LAMBDA)",
      "description": "This function returns an array of specified dimensions with values calculated by application of a LAMBDA function."
    },
    {
      "name": "MAP",
      "slug": "MAP",
      "category": "array",
      "engineStatus": {},
      "engines": [],
      "syntax": "MAP(array1, [array2, ...], LAMBDA)",
      "description": "This function maps each value in the given arrays to a new value by application of a `LAMBDA` function to each value."
    },
    {
      "name": "MARGINOFERROR",
      "slug": "MARGINOFERROR",
      "category": "statistical",
      "engineStatus": {},
      "engines": [],
      "syntax": "MARGINOFERROR(range, confidence)",
      "description": "This function calculates the margin of error from a range of values and a confidence level."
    },
    {
      "name": "MATCH",
      "slug": "MATCH",
      "category": "lookup",
      "engineStatus": {},
      "engines": [],
      "syntax": "MATCH(search_key, range, [search_type])",
      "description": "Returns the relative position of an item in a range that matches a specified value."
    },
    {
      "name": "MAX",
      "slug": "MAX",
      "category": "statistical",
      "engineStatus": {},
      "engines": [],
      "syntax": "MAX(column)",
      "description": "Returns the maximum value in a numeric dataset."
    },
    {
      "name": "MAXA",
      "slug": "MAXA",
      "category": "statistical",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0016"
        },
        "hyperformula": {
          "status": "missing",
          "via": "DV-0016"
        }
      },
      "engines": [],
      "syntax": "MAXA(value1, [value2, ...])",
      "description": "Returns the maximum numeric value in a dataset."
    },
    {
      "name": "MAXIFS",
      "slug": "MAXIFS",
      "category": "statistical",
      "engineStatus": {
        "libreoffice": {
          "status": "missing",
          "via": "DV-0007"
        }
      },
      "engines": [],
      "syntax": "MAXIFS(column, criteria_column1, criterion1, criteria_column2, criterion2)",
      "description": "Returns the maximum value in a range of cells, filtered by a set of criteria."
    },
    {
      "name": "MDETERM",
      "slug": "MDETERM",
      "category": "array",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0003"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0003"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0003"
        }
      },
      "engines": [],
      "syntax": "MDETERM(square_matrix)",
      "description": "Returns the matrix determinant of a square matrix specified as an array or range."
    },
    {
      "name": "MDURATION",
      "slug": "MDURATION",
      "category": "financial",
      "engineStatus": {},
      "engines": [],
      "syntax": "MDURATION(settlement, maturity, rate, yield, frequency, [day_count_convention])",
      "description": "Calculates the modified Macaulay duration of a security paying periodic interest, such as a US Treasury Bond, based on expected yield."
    },
    {
      "name": "MEDIAN",
      "slug": "MEDIAN",
      "category": "statistical",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        }
      },
      "engines": [],
      "syntax": "MEDIAN(value1, [value2, ...])",
      "description": "Returns the median value in a numeric dataset."
    },
    {
      "name": "MID",
      "slug": "MID",
      "category": "text",
      "engineStatus": {
        "gsheets": {
          "status": "partial",
          "via": "DV-0071"
        },
        "excel": {
          "status": "partial",
          "via": "DV-0238"
        },
        "formulas": {
          "status": "partial",
          "via": "DV-0238"
        },
        "hyperformula": {
          "status": "partial",
          "via": "DV-0238"
        },
        "ironcalc": {
          "status": "partial",
          "via": "DV-0238"
        },
        "libreoffice": {
          "status": "partial",
          "via": "DV-0238"
        },
        "pycel": {
          "status": "partial",
          "via": "DV-0238"
        }
      },
      "engines": [],
      "syntax": "MID(string, starting_at, extract_length)",
      "description": "Returns a segment of a string."
    },
    {
      "name": "MIDB",
      "slug": "MIDB",
      "category": "text",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0003"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0003"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0003"
        }
      },
      "engines": [],
      "syntax": "MIDB(string, starting_at, extract_length_bytes)",
      "description": "The MIDB function returns a section of a string starting at a given character and up to a specified number of bytes."
    },
    {
      "name": "MIN",
      "slug": "MIN",
      "category": "statistical",
      "engineStatus": {},
      "engines": [],
      "syntax": "MIN(column)",
      "description": "Returns the minimum value in a numeric dataset."
    },
    {
      "name": "MINA",
      "slug": "MINA",
      "category": "statistical",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0016"
        },
        "hyperformula": {
          "status": "missing",
          "via": "DV-0016"
        }
      },
      "engines": [],
      "syntax": "MINA(value1, [value2, ...])",
      "description": "Returns the minimum numeric value in a dataset."
    },
    {
      "name": "MINIFS",
      "slug": "MINIFS",
      "category": "statistical",
      "engineStatus": {
        "libreoffice": {
          "status": "missing",
          "via": "DV-0007"
        }
      },
      "engines": [],
      "syntax": "MINIFS(column, criteria_column1, criterion1, creteria_column2, criterion2)",
      "description": "Returns the minimum value in a range of cells, filtered by a set of criteria."
    },
    {
      "name": "MINUS",
      "slug": "MINUS",
      "category": "operator",
      "engineStatus": {
        "excel": {
          "status": "missing",
          "via": "DV-0002"
        },
        "formulas": {
          "status": "missing",
          "via": "DV-0002"
        },
        "hyperformula": {
          "status": "missing",
          "via": "DV-0002"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0002"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0002"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0002"
        }
      },
      "engines": [],
      "syntax": "MINUS(value1, value2)",
      "description": "Returns the difference of two numbers."
    },
    {
      "name": "MINUTE",
      "slug": "MINUTE",
      "category": "date",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        },
        "ironcalc": {
          "status": "partial",
          "via": "DV-0028"
        }
      },
      "engines": [],
      "syntax": "MINUTE(time)",
      "description": "Returns the minute component of a specific time, in numeric format."
    },
    {
      "name": "MINVERSE",
      "slug": "MINVERSE",
      "category": "array",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0003"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0003"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0003"
        },
        "libreoffice": {
          "status": "partial",
          "via": "DV-0081"
        },
        "excel": {
          "status": "partial",
          "via": "DV-0080"
        },
        "gsheets": {
          "status": "partial",
          "via": "DV-0080"
        },
        "lattice": {
          "status": "partial",
          "via": "DV-0080"
        }
      },
      "engines": [],
      "syntax": "MINVERSE(square_matrix)",
      "description": "Returns the multiplicative inverse of a square matrix specified as an array or range."
    },
    {
      "name": "MIRR",
      "slug": "MIRR",
      "category": "financial",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        },
        "libreoffice": {
          "status": "partial",
          "via": "DV-0008"
        }
      },
      "engines": [],
      "syntax": "MIRR(cashflow_amounts, financing_rate, reinvestment_return_rate)",
      "description": "Calculates the modified internal rate of return on an investment based on a series of periodic cash flows and the difference between the interest rate paid on financing versus the return received on reinvested income."
    },
    {
      "name": "MMULT",
      "slug": "MMULT",
      "category": "array",
      "engineStatus": {
        "ironcalc": {
          "status": "missing",
          "via": "DV-0005"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0005"
        },
        "libreoffice": {
          "status": "partial",
          "via": "DV-0083"
        },
        "excel": {
          "status": "partial",
          "via": "DV-0083"
        },
        "formulas": {
          "status": "partial",
          "via": "DV-0083"
        },
        "gsheets": {
          "status": "partial",
          "via": "DV-0083"
        },
        "lattice": {
          "status": "partial",
          "via": "DV-0083"
        }
      },
      "engines": [],
      "syntax": "MMULT(matrix1, matrix2)",
      "description": "Calculates the matrix product of two matrices specified as arrays or ranges."
    },
    {
      "name": "MOD",
      "slug": "MOD",
      "category": "math",
      "engineStatus": {
        "hyperformula": {
          "status": "partial",
          "via": "DV-0194"
        }
      },
      "engines": [],
      "syntax": "MOD(dividend, divisor)",
      "description": "Returns the result of the modulo operator, the remainder after a division operation."
    },
    {
      "name": "MODE.MULT",
      "slug": "MODE.MULT",
      "category": "statistical",
      "engineStatus": {},
      "engines": [],
      "syntax": "MODE.MULT(value1, value2)",
      "description": "The MODE."
    },
    {
      "name": "MODE.SNGL",
      "slug": "MODE.SNGL",
      "category": "statistical",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0013"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0013"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0013"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0013"
        }
      },
      "engines": [],
      "syntax": "MODE(value1, [value2, ...])",
      "description": "Returns the most commonly occurring value in a dataset."
    },
    {
      "name": "MODE",
      "slug": "MODE",
      "category": "statistical",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0003"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0003"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0003"
        },
        "libreoffice": {
          "status": "partial",
          "via": "DV-0008"
        }
      },
      "engines": [],
      "syntax": "MODE(value1, [value2, ...])",
      "description": "Returns the most commonly occurring value in a dataset."
    },
    {
      "name": "MONTH",
      "slug": "MONTH",
      "category": "date",
      "engineStatus": {
        "hyperformula": {
          "status": "partial",
          "via": "DV-0014"
        },
        "pycel": {
          "status": "partial",
          "via": "DV-0014"
        }
      },
      "engines": [],
      "syntax": "MONTH(date)",
      "description": "Returns the month of the year a specific date falls in, in numeric format."
    },
    {
      "name": "MROUND",
      "slug": "MROUND",
      "category": "math",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        }
      },
      "engines": [],
      "syntax": "MROUND(value,factor)",
      "description": "Rounds one number to the nearest integer multiple of another."
    },
    {
      "name": "MULTINOMIAL",
      "slug": "MULTINOMIAL",
      "category": "math",
      "engineStatus": {
        "ironcalc": {
          "status": "missing",
          "via": "DV-0005"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0005"
        },
        "excel": {
          "status": "partial",
          "via": "DV-0189"
        }
      },
      "engines": [],
      "syntax": "MULTINOMIAL(value1, [value2, ...])",
      "description": "Returns the factorial of the sum of values divided by the product of the values' factorials."
    },
    {
      "name": "MULTIPLY",
      "slug": "MULTIPLY",
      "category": "operator",
      "engineStatus": {
        "excel": {
          "status": "missing",
          "via": "DV-0002"
        },
        "formulas": {
          "status": "missing",
          "via": "DV-0002"
        },
        "hyperformula": {
          "status": "missing",
          "via": "DV-0002"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0002"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0002"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0002"
        }
      },
      "engines": [],
      "syntax": "MULTIPLY(factor1, factor2)",
      "description": "Returns the product of two numbers."
    },
    {
      "name": "MUNIT",
      "slug": "MUNIT",
      "category": "math",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0013"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0013"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0013"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0013"
        },
        "formulas": {
          "status": "partial",
          "via": "DV-0070"
        }
      },
      "engines": [],
      "syntax": "MUNIT(dimension)",
      "description": "The MUNIT function returns a unit matrix of size dimension x dimension."
    },
    {
      "name": "N",
      "slug": "N",
      "category": "info",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0006"
        },
        "formulas": {
          "status": "partial",
          "via": "DV-0178"
        }
      },
      "engines": [],
      "syntax": "N(value)",
      "description": "Returns the argument provided as a number."
    },
    {
      "name": "NA",
      "slug": "NA",
      "category": "info",
      "engineStatus": {},
      "engines": [],
      "syntax": "NA()",
      "description": "Returns the \"value not available\" error, `#N/A`."
    },
    {
      "name": "NE",
      "slug": "NE",
      "category": "operator",
      "engineStatus": {
        "excel": {
          "status": "missing",
          "via": "DV-0002"
        },
        "formulas": {
          "status": "missing",
          "via": "DV-0002"
        },
        "hyperformula": {
          "status": "missing",
          "via": "DV-0002"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0002"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0002"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0002"
        }
      },
      "engines": [],
      "syntax": "NE(value1, value2)",
      "description": "Returns \"TRUE\" if two specified values are not equal and \"FALSE\" otherwise."
    },
    {
      "name": "NEGBINOM.DIST",
      "slug": "NEGBINOM.DIST",
      "category": "statistical",
      "engineStatus": {},
      "engines": [],
      "syntax": "NEGBINOMDIST(num_failures, num_successes, prob_success)",
      "description": "Calculates the probability of drawing a certain number of failures before a certain number of successes given a probability of success in independent trials."
    },
    {
      "name": "NEGBINOMDIST",
      "slug": "NEGBINOMDIST",
      "category": "statistical",
      "engineStatus": {},
      "engines": [],
      "syntax": "NEGBINOMDIST(num_failures, num_successes, prob_success)",
      "description": "Calculates the probability of drawing a certain number of failures before a certain number of successes given a probability of success in independent trials."
    },
    {
      "name": "NETWORKDAYS.INTL",
      "slug": "NETWORKDAYS.INTL",
      "category": "date",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        },
        "hyperformula": {
          "status": "partial",
          "via": "DV-0012"
        }
      },
      "engines": [],
      "syntax": "NETWORKDAYS.INTL(start_date, end_date, [weekend], [holidays])",
      "description": "Returns the number of net working days between two provided days excluding specified weekend days and holidays."
    },
    {
      "name": "NETWORKDAYS",
      "slug": "NETWORKDAYS",
      "category": "date",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        },
        "hyperformula": {
          "status": "partial",
          "via": "DV-0094"
        },
        "gsheets": {
          "status": "partial",
          "via": "DV-0094"
        },
        "ironcalc": {
          "status": "partial",
          "via": "DV-0094"
        },
        "libreoffice": {
          "status": "partial",
          "via": "DV-0094"
        }
      },
      "engines": [],
      "syntax": "NETWORKDAYS(start_date, end_date, [holidays])",
      "description": "Returns the number of net working days between two provided days."
    },
    {
      "name": "NOMINAL",
      "slug": "NOMINAL",
      "category": "financial",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        },
        "libreoffice": {
          "status": "partial",
          "via": "DV-0008"
        },
        "excel": {
          "status": "partial",
          "via": "DV-0143"
        },
        "formulas": {
          "status": "partial",
          "via": "DV-0143"
        },
        "gsheets": {
          "status": "partial",
          "via": "DV-0143"
        },
        "lattice": {
          "status": "partial",
          "via": "DV-0143"
        }
      },
      "engines": [],
      "syntax": "NOMINAL(effective_rate, periods_per_year)",
      "description": "Calculates the annual nominal interest rate given the effective rate and number of compounding periods per year."
    },
    {
      "name": "NORM.DIST",
      "slug": "NORM.DIST",
      "category": "statistical",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0017"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0017"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0017"
        }
      },
      "engines": [],
      "syntax": "NORMDIST(x, mean, standard_deviation, cumulative)",
      "description": "The NORMDIST function returns the value of the normal distribution function (or normal cumulative distribution function) for a specified value, mean, and standard deviation."
    },
    {
      "name": "NORM.INV",
      "slug": "NORM.INV",
      "category": "statistical",
      "engineStatus": {
        "libreoffice": {
          "status": "missing",
          "via": "DV-0004"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0004"
        },
        "hyperformula": {
          "status": "partial",
          "via": "DV-0042"
        }
      },
      "engines": [],
      "syntax": "NORMINV(x, mean, standard_deviation)",
      "description": "Returns the value of the inverse normal distribution function for a specified value, mean, and standard deviation."
    },
    {
      "name": "NORM.S.DIST",
      "slug": "NORM.S.DIST",
      "category": "statistical",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0017"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0017"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0017"
        },
        "gsheets": {
          "status": "partial",
          "via": "DV-0023"
        }
      },
      "engines": [],
      "syntax": "NORMSDIST(x)",
      "description": "Returns the value of the standard normal cumulative distribution function for a specified value."
    },
    {
      "name": "NORM.S.INV",
      "slug": "NORM.S.INV",
      "category": "statistical",
      "engineStatus": {
        "libreoffice": {
          "status": "missing",
          "via": "DV-0004"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0004"
        },
        "hyperformula": {
          "status": "partial",
          "via": "DV-0042"
        }
      },
      "engines": [],
      "syntax": "NORMSINV(x)",
      "description": "Returns the value of the inverse standard normal distribution function for a specified value."
    },
    {
      "name": "NORMDIST",
      "slug": "NORMDIST",
      "category": "statistical",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0003"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0003"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0003"
        }
      },
      "engines": [],
      "syntax": "NORMDIST(x, mean, standard_deviation, cumulative)",
      "description": "The NORMDIST function returns the value of the normal distribution function (or normal cumulative distribution function) for a specified value, mean, and standard deviation."
    },
    {
      "name": "NORMINV",
      "slug": "NORMINV",
      "category": "statistical",
      "engineStatus": {
        "ironcalc": {
          "status": "missing",
          "via": "DV-0005"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0005"
        },
        "hyperformula": {
          "status": "partial",
          "via": "DV-0042"
        }
      },
      "engines": [],
      "syntax": "NORMINV(x, mean, standard_deviation)",
      "description": "Returns the value of the inverse normal distribution function for a specified value, mean, and standard deviation."
    },
    {
      "name": "NORMSDIST",
      "slug": "NORMSDIST",
      "category": "statistical",
      "engineStatus": {
        "ironcalc": {
          "status": "missing",
          "via": "DV-0005"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0005"
        },
        "hyperformula": {
          "status": "partial",
          "via": "DV-0072"
        }
      },
      "engines": [],
      "syntax": "NORMSDIST(x)",
      "description": "Returns the value of the standard normal cumulative distribution function for a specified value."
    },
    {
      "name": "NORMSINV",
      "slug": "NORMSINV",
      "category": "statistical",
      "engineStatus": {
        "ironcalc": {
          "status": "missing",
          "via": "DV-0005"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0005"
        },
        "hyperformula": {
          "status": "partial",
          "via": "DV-0042"
        }
      },
      "engines": [],
      "syntax": "NORMSINV(x)",
      "description": "Returns the value of the inverse standard normal distribution function for a specified value."
    },
    {
      "name": "NOT",
      "slug": "NOT",
      "category": "logical",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0006"
        }
      },
      "engines": [],
      "syntax": "NOT(logical_expression)",
      "description": "Returns the opposite of a logical value - `NOT(TRUE)` returns `FALSE`; `NOT(FALSE)` returns `TRUE`."
    },
    {
      "name": "NOW",
      "slug": "NOW",
      "category": "date",
      "engineStatus": {
        "lattice": {
          "status": "partial",
          "via": "DV-0247"
        }
      },
      "engines": [],
      "syntax": "NOW()",
      "description": "Returns the current date and time as a date value."
    },
    {
      "name": "NPER",
      "slug": "NPER",
      "category": "financial",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        }
      },
      "engines": [],
      "syntax": "NPER(rate, payment_amount, present_value, [future_value, end_or_beginning])",
      "description": "The NPER function calculates the number of payment periods for an investment based on constant-amount periodic payments and a constant interest rate."
    },
    {
      "name": "NPV",
      "slug": "NPV",
      "category": "financial",
      "engineStatus": {
        "excel": {
          "status": "partial",
          "via": "DV-0144"
        },
        "formulas": {
          "status": "partial",
          "via": "DV-0144"
        },
        "gsheets": {
          "status": "partial",
          "via": "DV-0144"
        },
        "lattice": {
          "status": "partial",
          "via": "DV-0144"
        },
        "libreoffice": {
          "status": "partial",
          "via": "DV-0144"
        },
        "pycel": {
          "status": "partial",
          "via": "DV-0144"
        },
        "ironcalc": {
          "status": "partial",
          "via": "DV-0145"
        },
        "hyperformula": {
          "status": "partial",
          "via": "DV-0146"
        }
      },
      "engines": [],
      "syntax": "NPV(discount, cashflow1, [cashflow2, ...])",
      "description": "Calculates the net present value of an investment based on a series of periodic cash flows and a discount rate."
    },
    {
      "name": "OCT2BIN",
      "slug": "OCT2BIN",
      "category": "engineering",
      "engineStatus": {
        "libreoffice": {
          "status": "partial",
          "via": "DV-0008"
        }
      },
      "engines": [],
      "syntax": "OCT2BIN(signed_octal_number, [significant_digits])",
      "description": "The OCT2BIN function converts a signed octal number to signed binary format."
    },
    {
      "name": "OCT2DEC",
      "slug": "OCT2DEC",
      "category": "engineering",
      "engineStatus": {
        "libreoffice": {
          "status": "partial",
          "via": "DV-0008"
        }
      },
      "engines": [],
      "syntax": "OCT2DEC(signed_octal_number)",
      "description": "The OCT2DEC function converts a signed octal number to decimal format."
    },
    {
      "name": "OCT2HEX",
      "slug": "OCT2HEX",
      "category": "engineering",
      "engineStatus": {
        "libreoffice": {
          "status": "partial",
          "via": "DV-0008"
        }
      },
      "engines": [],
      "syntax": "OCT2HEX(signed_octal_number, [significant_digits])",
      "description": "The OCT2HEX function converts a signed octal number to signed hexadecimal format."
    },
    {
      "name": "ODD",
      "slug": "ODD",
      "category": "math",
      "engineStatus": {},
      "engines": [],
      "syntax": "ODD(value)",
      "description": "Rounds a number up to the nearest odd integer."
    },
    {
      "name": "OFFSET",
      "slug": "OFFSET",
      "category": "lookup",
      "engineStatus": {
        "formulas": {
          "status": "missing",
          "via": "DV-0021"
        },
        "ironcalc": {
          "status": "partial",
          "via": "DV-0030"
        },
        "pycel": {
          "status": "partial",
          "via": "DV-0040"
        }
      },
      "engines": [],
      "syntax": "OFFSET(cell_reference, offset_rows, offset_columns, [height], [width])",
      "description": "Returns a range reference shifted a specified number of rows and columns from a starting cell reference."
    },
    {
      "name": "OR",
      "slug": "OR",
      "category": "logical",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0006"
        }
      },
      "engines": [],
      "syntax": "OR(logical_expression1, [logical_expression2, ...])",
      "description": "The OR function returns true if any of the provided arguments are logically true, and false if all of the provided arguments are logically false."
    },
    {
      "name": "PDURATION",
      "slug": "PDURATION",
      "category": "financial",
      "engineStatus": {
        "libreoffice": {
          "status": "missing",
          "via": "DV-0004"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0004"
        },
        "excel": {
          "status": "partial",
          "via": "DV-0147"
        },
        "gsheets": {
          "status": "partial",
          "via": "DV-0147"
        },
        "lattice": {
          "status": "partial",
          "via": "DV-0147"
        },
        "ironcalc": {
          "status": "partial",
          "via": "DV-0148"
        },
        "hyperformula": {
          "status": "partial",
          "via": "DV-0149"
        },
        "formulas": {
          "status": "partial",
          "via": "DV-0150"
        }
      },
      "engines": [],
      "syntax": "PDURATION(rate, present_value, future_value)",
      "description": "The PDURATION function returns the number of periods for an investment to reach a specific value at a given rate."
    },
    {
      "name": "PEARSON",
      "slug": "PEARSON",
      "category": "statistical",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        }
      },
      "engines": [],
      "syntax": "PEARSON(data_y, data_x)",
      "description": "Calculates r, the Pearson product-moment correlation coefficient of a dataset."
    },
    {
      "name": "PERCENTIF",
      "slug": "PERCENTIF",
      "category": "math",
      "engineStatus": {
        "gsheets": {
          "status": "available"
        }
      },
      "engines": [
        "gsheets"
      ],
      "coverage": "pending-assay",
      "syntax": "PERCENTIF(range, criterion)",
      "description": "Returns the percentage of a range that meets a condition."
    },
    {
      "name": "PERCENTILE.EXC",
      "slug": "PERCENTILE.EXC",
      "category": "statistical",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0013"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0013"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0013"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0013"
        }
      },
      "engines": [],
      "syntax": "PERCENTILE.EXC(data, percentile)",
      "description": "The PERCENTILE."
    },
    {
      "name": "PERCENTILE.INC",
      "slug": "PERCENTILE.INC",
      "category": "statistical",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0013"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0013"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0013"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0013"
        }
      },
      "engines": [],
      "syntax": "PERCENTILE(data, percentile)",
      "description": "Returns the value at a given percentile of a dataset."
    },
    {
      "name": "PERCENTILE",
      "slug": "PERCENTILE",
      "category": "statistical",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0003"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0003"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0003"
        }
      },
      "engines": [],
      "syntax": "PERCENTILE(data, percentile)",
      "description": "Returns the value at a given percentile of a dataset."
    },
    {
      "name": "PERCENTRANK.EXC",
      "slug": "PERCENTRANK.EXC",
      "category": "statistical",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0013"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0013"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0013"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0013"
        }
      },
      "engines": [],
      "syntax": "PERCENTRANK.EXC(data, value, [significant_digits])",
      "description": "Returns the percentage rank (percentile) from 0 to 1 exclusive of a specified value in a dataset."
    },
    {
      "name": "PERCENTRANK.INC",
      "slug": "PERCENTRANK.INC",
      "category": "statistical",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0013"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0013"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0013"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0013"
        }
      },
      "engines": [],
      "syntax": "PERCENTRANK.INC(data, value, [significant_digits])",
      "description": "Returns the percentage rank (percentile) from 0 to 1 inclusive of a specified value in a dataset."
    },
    {
      "name": "PERCENTRANK",
      "slug": "PERCENTRANK",
      "category": "statistical",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0003"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0003"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0003"
        }
      },
      "engines": [],
      "syntax": "PERCENTRANK(data, value, [significant_digits])",
      "description": "Returns the percentage rank (percentile) of a specified value in a dataset."
    },
    {
      "name": "PERMUT",
      "slug": "PERMUT",
      "category": "statistical",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0003"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0003"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0003"
        },
        "libreoffice": {
          "status": "partial",
          "via": "DV-0008"
        }
      },
      "engines": [],
      "syntax": "PERMUT(n, k)",
      "description": "Returns the number of ways to choose some number of objects from a pool of a given size of objects, considering order."
    },
    {
      "name": "PERMUTATIONA",
      "slug": "PERMUTATIONA",
      "category": "statistical",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0013"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0013"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0013"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0013"
        },
        "gsheets": {
          "status": "partial",
          "via": "DV-0071"
        }
      },
      "engines": [],
      "syntax": "PERMUTATIONA(number, number_chosen)",
      "description": "The PERMUTATIONA function returns the number of permutations for selecting a group of objects (with replacement) from a total number of objects."
    },
    {
      "name": "PHI",
      "slug": "PHI",
      "category": "statistical",
      "engineStatus": {},
      "engines": [],
      "syntax": "PHI(x)",
      "description": "The PHI function returns the value of the density function for a normal distribution with mean 0 and standard deviation 1, calculated with the formula ![](//screenshot."
    },
    {
      "name": "PI",
      "slug": "PI",
      "category": "math",
      "engineStatus": {
        "ironcalc": {
          "status": "partial",
          "via": "DV-0064"
        },
        "hyperformula": {
          "status": "partial",
          "via": "DV-0065"
        },
        "libreoffice": {
          "status": "partial",
          "via": "DV-0066"
        }
      },
      "engines": [],
      "syntax": "PI()",
      "description": "The PI function returns the value of pi to 9 decimal places."
    },
    {
      "name": "PMT",
      "slug": "PMT",
      "category": "financial",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        },
        "hyperformula": {
          "status": "partial",
          "via": "DV-0046"
        },
        "excel": {
          "status": "partial",
          "via": "DV-0059"
        },
        "libreoffice": {
          "status": "partial",
          "via": "DV-0060"
        },
        "formulas": {
          "status": "partial",
          "via": "DV-0151"
        },
        "gsheets": {
          "status": "partial",
          "via": "DV-0151"
        },
        "lattice": {
          "status": "partial",
          "via": "DV-0151"
        }
      },
      "engines": [],
      "syntax": "PMT(rate, number_of_periods, present_value, [future_value, end_or_beginning])",
      "description": "The PMT function calculates the periodic payment for an annuity investment based on constant-amount periodic payments and a constant interest rate."
    },
    {
      "name": "POISSON.DIST",
      "slug": "POISSON.DIST",
      "category": "statistical",
      "engineStatus": {},
      "engines": [],
      "syntax": "POISSON.DIST(x, mean, cumulative)",
      "description": "Returns the value of the Poisson distribution function (or Poisson cumulative distribution function) for a specified value and mean."
    },
    {
      "name": "POISSON",
      "slug": "POISSON",
      "category": "statistical",
      "engineStatus": {},
      "engines": [],
      "syntax": "POISSON.DIST(x, mean, cumulative)",
      "description": "Returns the value of the Poisson distribution function (or Poisson cumulative distribution function) for a specified value and mean."
    },
    {
      "name": "POW",
      "slug": "POW",
      "category": "operator",
      "engineStatus": {
        "excel": {
          "status": "missing",
          "via": "DV-0026"
        },
        "formulas": {
          "status": "missing",
          "via": "DV-0026"
        },
        "hyperformula": {
          "status": "missing",
          "via": "DV-0026"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0026"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0026"
        },
        "gsheets": {
          "status": "partial",
          "via": "DV-0204"
        },
        "pycel": {
          "status": "partial",
          "via": "DV-0204"
        }
      },
      "engines": [],
      "syntax": "POW(base, exponent)",
      "description": "Returns a number raised to a power."
    },
    {
      "name": "POWER",
      "slug": "POWER",
      "category": "math",
      "engineStatus": {},
      "engines": [],
      "syntax": "POWER(base, exponent)",
      "description": "Returns a number raised to a power."
    },
    {
      "name": "PPMT",
      "slug": "PPMT",
      "category": "financial",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        },
        "libreoffice": {
          "status": "partial",
          "via": "DV-0060"
        },
        "formulas": {
          "status": "partial",
          "via": "DV-0045"
        },
        "hyperformula": {
          "status": "partial",
          "via": "DV-0046"
        },
        "excel": {
          "status": "partial",
          "via": "DV-0059"
        },
        "gsheets": {
          "status": "partial",
          "via": "DV-0152"
        },
        "lattice": {
          "status": "partial",
          "via": "DV-0153"
        },
        "ironcalc": {
          "status": "partial",
          "via": "DV-0154"
        }
      },
      "engines": [],
      "syntax": "PPMT(rate, period, number_of_periods, present_value, [future_value, end_or_beginning])",
      "description": "The PPMT function calculates the payment on the principal of an investment based on constant-amount periodic payments and a constant interest rate."
    },
    {
      "name": "PRICE",
      "slug": "PRICE",
      "category": "financial",
      "engineStatus": {},
      "engines": [],
      "syntax": "PRICE(settlement, maturity, rate, yield, redemption, frequency, [day_count_convention])",
      "description": "Calculates the price of a security paying periodic interest, such as a US Treasury Bond, based on expected yield."
    },
    {
      "name": "PRICEDISC",
      "slug": "PRICEDISC",
      "category": "financial",
      "engineStatus": {},
      "engines": [],
      "syntax": "PRICEDISC(settlement, maturity, discount, redemption, [day_count_convention])",
      "description": "Calculates the price of a discount (non-interest-bearing) security, based on expected yield."
    },
    {
      "name": "PRICEMAT",
      "slug": "PRICEMAT",
      "category": "financial",
      "engineStatus": {},
      "engines": [],
      "syntax": "PRICEMAT(settlement, maturity, issue, rate, yield, [day_count_convention])",
      "description": "Calculates the price of a security paying interest at maturity, based on expected yield."
    },
    {
      "name": "PROB",
      "slug": "PROB",
      "category": "statistical",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0003"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0003"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0003"
        },
        "excel": {
          "status": "partial",
          "via": "DV-0218"
        },
        "formulas": {
          "status": "partial",
          "via": "DV-0218"
        },
        "gsheets": {
          "status": "partial",
          "via": "DV-0218"
        },
        "lattice": {
          "status": "partial",
          "via": "DV-0218"
        }
      },
      "engines": [],
      "syntax": "PROB(data, probabilities, low_limit, [high_limit])",
      "description": "Given a set of values and corresponding probabilities, calculates the probability that a value chosen at random falls between two limits."
    },
    {
      "name": "PRODUCT",
      "slug": "PRODUCT",
      "category": "math",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        }
      },
      "engines": [],
      "syntax": "PRODUCT(factor1, [factor2, ...])",
      "description": "Returns the result of multiplying a series of numbers together."
    },
    {
      "name": "PROPER",
      "slug": "PROPER",
      "category": "text",
      "engineStatus": {
        "ironcalc": {
          "status": "missing",
          "via": "DV-0005"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0005"
        }
      },
      "engines": [],
      "syntax": "PROPER(text_to_capitalize)",
      "description": "Capitalizes each word in a specified string."
    },
    {
      "name": "PV",
      "slug": "PV",
      "category": "financial",
      "engineStatus": {
        "excel": {
          "status": "partial",
          "via": "DV-0159"
        },
        "formulas": {
          "status": "partial",
          "via": "DV-0159"
        },
        "gsheets": {
          "status": "partial",
          "via": "DV-0159"
        },
        "lattice": {
          "status": "partial",
          "via": "DV-0159"
        },
        "pycel": {
          "status": "partial",
          "via": "DV-0159"
        },
        "ironcalc": {
          "status": "partial",
          "via": "DV-0160"
        },
        "hyperformula": {
          "status": "partial",
          "via": "DV-0161"
        },
        "libreoffice": {
          "status": "partial",
          "via": "DV-0162"
        }
      },
      "engines": [],
      "syntax": "PV(rate, number_of_periods, payment_amount, [future_value], [end_or_beginning])",
      "description": "Calculates the present value of an annuity investment based on constant-amount periodic payments and a constant interest rate."
    },
    {
      "name": "QUARTILE.EXC",
      "slug": "QUARTILE.EXC",
      "category": "statistical",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0013"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0013"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0013"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0013"
        }
      },
      "engines": [],
      "syntax": "QUARTILE.EXC(data, quartile_number)",
      "description": "The QUARTILE."
    },
    {
      "name": "QUARTILE.INC",
      "slug": "QUARTILE.INC",
      "category": "statistical",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0013"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0013"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0013"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0013"
        }
      },
      "engines": [],
      "syntax": "QUARTILE(data, quartile_number)",
      "description": "Returns a value nearest to a specified quartile of a dataset."
    },
    {
      "name": "QUARTILE",
      "slug": "QUARTILE",
      "category": "statistical",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0003"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0003"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0003"
        },
        "libreoffice": {
          "status": "partial",
          "via": "DV-0008"
        }
      },
      "engines": [],
      "syntax": "QUARTILE(data, quartile_number)",
      "description": "Returns a value nearest to a specified quartile of a dataset."
    },
    {
      "name": "QUERY",
      "slug": "QUERY",
      "category": "google",
      "engineStatus": {
        "excel": {
          "status": "partial",
          "via": "DV-0019"
        },
        "gsheets": {
          "status": "partial",
          "via": "DV-0118"
        }
      },
      "engines": [],
      "syntax": "QUERY(data, query, [headers])",
      "description": "The QUERY function allows the user to make SQL-like queries using the Google Visualization API Query Language on arrays."
    },
    {
      "name": "QUOTIENT",
      "slug": "QUOTIENT",
      "category": "math",
      "engineStatus": {
        "formulas": {
          "status": "missing",
          "via": "DV-0035"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0035"
        }
      },
      "engines": [],
      "syntax": "QUOTIENT(dividend, divisor)",
      "description": "Returns one number divided by another, without the remainder."
    },
    {
      "name": "RADIANS",
      "slug": "RADIANS",
      "category": "math",
      "engineStatus": {
        "ironcalc": {
          "status": "partial",
          "via": "DV-0183"
        },
        "hyperformula": {
          "status": "partial",
          "via": "DV-0184"
        },
        "libreoffice": {
          "status": "partial",
          "via": "DV-0185"
        }
      },
      "engines": [],
      "syntax": "RADIANS(angle)",
      "description": "The RADIANS function converts an angle value in degrees to radians."
    },
    {
      "name": "RAND",
      "slug": "RAND",
      "category": "math",
      "engineStatus": {
        "hyperformula": {
          "status": "partial",
          "via": "DV-0245"
        }
      },
      "engines": [],
      "syntax": "RAND()",
      "description": "Returns a random number between 0 inclusive and 1 exclusive."
    },
    {
      "name": "RANDARRAY",
      "slug": "RANDARRAY",
      "category": "math",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0006"
        }
      },
      "engines": [],
      "syntax": "RANDARRAY(rows, columns)",
      "description": "The RANDARRAY function generates an array of random numbers between 0 and 1."
    },
    {
      "name": "RANDBETWEEN",
      "slug": "RANDBETWEEN",
      "category": "math",
      "engineStatus": {
        "lattice": {
          "status": "partial",
          "via": "DV-0246"
        }
      },
      "engines": [],
      "syntax": "RANDBETWEEN(low, high)",
      "description": "Returns a uniformly random integer between two values, inclusive."
    },
    {
      "name": "RANK.AVG",
      "slug": "RANK.AVG",
      "category": "statistical",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0017"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0017"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0017"
        }
      },
      "engines": [],
      "syntax": "RANK.AVG(value, data, [is_ascending])",
      "description": "Returns the rank of a specified value in a dataset."
    },
    {
      "name": "RANK.EQ",
      "slug": "RANK.EQ",
      "category": "statistical",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0017"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0017"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0017"
        }
      },
      "engines": [],
      "syntax": "RANK.EQ(value, data, [is_ascending])",
      "description": "Returns the rank of a specified value in a dataset."
    },
    {
      "name": "RANK",
      "slug": "RANK",
      "category": "statistical",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0003"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0003"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0003"
        }
      },
      "engines": [],
      "syntax": "RANK(value, data, [is_ascending])",
      "description": "Returns the rank of a specified value in a dataset."
    },
    {
      "name": "RATE",
      "slug": "RATE",
      "category": "financial",
      "engineStatus": {},
      "engines": [],
      "syntax": "RATE(number_of_periods, payment_per_period, present_value, [future_value, end_or_beginning, rate_guess])",
      "description": "Calculates the interest rate of an annuity investment based on constant-amount periodic payments and the assumption of a constant interest rate."
    },
    {
      "name": "RECEIVED",
      "slug": "RECEIVED",
      "category": "financial",
      "engineStatus": {},
      "engines": [],
      "syntax": "RECEIVED(settlement, maturity, investment, discount, [day_count_convention])",
      "description": "Calculates the amount received at maturity for an investment in fixed-income securities purchased on a given date."
    },
    {
      "name": "REDUCE",
      "slug": "REDUCE",
      "category": "array",
      "engineStatus": {},
      "engines": [],
      "syntax": "REDUCE(initial_value, array_or_range, LAMBDA)",
      "description": "This function reduces an array to an accumulated result by application of a `LAMBDA` function to each value."
    },
    {
      "name": "REGEXEXTRACT",
      "slug": "REGEXEXTRACT",
      "category": "text",
      "engineStatus": {
        "gsheets": {
          "status": "partial",
          "via": "DV-0023"
        },
        "lattice": {
          "status": "partial",
          "via": "DV-0208"
        }
      },
      "engines": [],
      "syntax": "REGEXEXTRACT(text, regular_expression)",
      "description": "Extracts the first matching substrings according to a regular expression."
    },
    {
      "name": "REGEXMATCH",
      "slug": "REGEXMATCH",
      "category": "text",
      "engineStatus": {
        "gsheets": {
          "status": "missing",
          "via": "DV-0020"
        }
      },
      "engines": [],
      "syntax": "REGEXMATCH(text, regular_expression)",
      "description": "Whether a piece of text matches a regular expression."
    },
    {
      "name": "REGEXREPLACE",
      "slug": "REGEXREPLACE",
      "category": "text",
      "engineStatus": {},
      "engines": [],
      "syntax": "REGEXREPLACE(text, regular_expression, replacement)",
      "description": "Replaces part of a text string with a different text string using regular expressions."
    },
    {
      "name": "REPLACE",
      "slug": "REPLACE",
      "category": "text",
      "engineStatus": {
        "ironcalc": {
          "status": "missing",
          "via": "DV-0027"
        }
      },
      "engines": [],
      "syntax": "REPLACE(text, position, length, new_text)",
      "description": "Replaces part of a text string with a different text string."
    },
    {
      "name": "REPLACEB",
      "slug": "REPLACEB",
      "category": "text",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0003"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0003"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0003"
        }
      },
      "engines": [],
      "syntax": "REPLACEB(text, position, num_bytes, new_text)",
      "description": "The REPLACEB function replaces part of a text string, based on a number of bytes, with a different text string."
    },
    {
      "name": "REPT",
      "slug": "REPT",
      "category": "text",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        }
      },
      "engines": [],
      "syntax": "REPT(text_to_repeat, number_of_repetitions)",
      "description": "Returns specified text repeated a number of times."
    },
    {
      "name": "RIGHT",
      "slug": "RIGHT",
      "category": "text",
      "engineStatus": {},
      "engines": [],
      "syntax": "RIGHT(string, [number_of_characters])",
      "description": "Returns a substring from the end of a specified string."
    },
    {
      "name": "RIGHTB",
      "slug": "RIGHTB",
      "category": "text",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0003"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0003"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0003"
        },
        "excel": {
          "status": "partial",
          "via": "DV-0031"
        },
        "formulas": {
          "status": "partial",
          "via": "DV-0031"
        },
        "gsheets": {
          "status": "partial",
          "via": "DV-0031"
        },
        "libreoffice": {
          "status": "partial",
          "via": "DV-0031"
        }
      },
      "engines": [],
      "syntax": "RIGHTB(string, num_of_bytes)",
      "description": "The RIGHTB function returns the right portion of a string up to a certain number of bytes."
    },
    {
      "name": "RITZCODERZ",
      "slug": "RITZCODERZ",
      "category": "uncategorized",
      "engineStatus": {
        "gsheets": {
          "status": "available"
        }
      },
      "engines": [
        "gsheets"
      ],
      "coverage": "out-of-scope",
      "syntax": "RITZCODERZ()",
      "description": "Returns a $38 \\times 3$ [[Array#jagged-arrays|jagged array]] containing the names of developers on the Google Sheets team."
    },
    {
      "name": "ROMAN",
      "slug": "ROMAN",
      "category": "text",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        }
      },
      "engines": [],
      "syntax": "ROMAN(number, [rule_relaxation])",
      "description": "Formats a number in Roman numerals."
    },
    {
      "name": "ROUND",
      "slug": "ROUND",
      "category": "math",
      "engineStatus": {
        "formulas": {
          "status": "partial",
          "via": "DV-0195"
        },
        "hyperformula": {
          "status": "partial",
          "via": "DV-0195"
        },
        "pycel": {
          "status": "partial",
          "via": "DV-0195"
        }
      },
      "engines": [],
      "syntax": "ROUND(value, [places])",
      "description": "The ROUND function rounds a number to a certain number of decimal places according to standard rules."
    },
    {
      "name": "ROUNDDOWN",
      "slug": "ROUNDDOWN",
      "category": "math",
      "engineStatus": {},
      "engines": [],
      "syntax": "ROUNDDOWN(value,[places])",
      "description": "The ROUNDDOWN function rounds a number to a certain number of decimal places, always rounding down to the next valid increment."
    },
    {
      "name": "ROUNDUP",
      "slug": "ROUNDUP",
      "category": "math",
      "engineStatus": {},
      "engines": [],
      "syntax": "ROUNDUP(value,[places])",
      "description": "Rounds a number to a certain number of decimal places, always rounding up to the next valid increment."
    },
    {
      "name": "ROW",
      "slug": "ROW",
      "category": "lookup",
      "engineStatus": {
        "hyperformula": {
          "status": "partial",
          "via": "DV-0249"
        },
        "lattice": {
          "status": "partial",
          "via": "DV-0075"
        }
      },
      "engines": [],
      "syntax": "ROW([cell_reference])",
      "description": "Returns the row number of a specified cell."
    },
    {
      "name": "ROWS",
      "slug": "ROWS",
      "category": "lookup",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        },
        "formulas": {
          "status": "partial",
          "via": "DV-0039"
        },
        "ironcalc": {
          "status": "partial",
          "via": "DV-0039"
        }
      },
      "engines": [],
      "syntax": "ROWS(column)",
      "description": "Returns the number of rows in a specified array or range."
    },
    {
      "name": "RRI",
      "slug": "RRI",
      "category": "financial",
      "engineStatus": {
        "libreoffice": {
          "status": "missing",
          "via": "DV-0004"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0004"
        },
        "excel": {
          "status": "partial",
          "via": "DV-0163"
        },
        "formulas": {
          "status": "partial",
          "via": "DV-0163"
        },
        "gsheets": {
          "status": "partial",
          "via": "DV-0163"
        },
        "lattice": {
          "status": "partial",
          "via": "DV-0163"
        },
        "ironcalc": {
          "status": "partial",
          "via": "DV-0164"
        },
        "hyperformula": {
          "status": "partial",
          "via": "DV-0165"
        }
      },
      "engines": [],
      "syntax": "RRI(number_of_periods, present_value, future_value)",
      "description": "The RRI function returns the interest rate needed for an investment to reach a specific value within a given number of periods."
    },
    {
      "name": "RSQ",
      "slug": "RSQ",
      "category": "statistical",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        }
      },
      "engines": [],
      "syntax": "RSQ(data_y, data_x)",
      "description": "Calculates the square of r, the Pearson product-moment correlation coefficient of a dataset."
    },
    {
      "name": "SCAN",
      "slug": "SCAN",
      "category": "array",
      "engineStatus": {},
      "engines": [],
      "syntax": "SCAN(initial_value, array_or_range, LAMBDA)",
      "description": "This function scans an array and produces intermediate values by application of a `LAMBDA` function to each value."
    },
    {
      "name": "SEARCH",
      "slug": "SEARCH",
      "category": "text",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        },
        "formulas": {
          "status": "partial",
          "via": "DV-0228"
        },
        "excel": {
          "status": "partial",
          "via": "DV-0229"
        },
        "gsheets": {
          "status": "partial",
          "via": "DV-0229"
        },
        "hyperformula": {
          "status": "partial",
          "via": "DV-0229"
        },
        "ironcalc": {
          "status": "partial",
          "via": "DV-0229"
        },
        "lattice": {
          "status": "partial",
          "via": "DV-0229"
        },
        "libreoffice": {
          "status": "partial",
          "via": "DV-0229"
        }
      },
      "engines": [],
      "syntax": "SEARCH(search_for, text_to_search, [starting_at])",
      "description": "Returns the position at which a string is first found within text, ignoring case."
    },
    {
      "name": "SEARCHB",
      "slug": "SEARCHB",
      "category": "text",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0003"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0003"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0003"
        },
        "excel": {
          "status": "partial",
          "via": "DV-0230"
        },
        "formulas": {
          "status": "partial",
          "via": "DV-0230"
        },
        "gsheets": {
          "status": "partial",
          "via": "DV-0230"
        },
        "lattice": {
          "status": "partial",
          "via": "DV-0230"
        },
        "libreoffice": {
          "status": "partial",
          "via": "DV-0230"
        }
      },
      "engines": [],
      "syntax": "SEARCHB(search_for, text_to_search, [starting_at])",
      "description": "Returns the byte position at which a string is first found within text. Supports wildcard and case-insensitive searching."
    },
    {
      "name": "SEC",
      "slug": "SEC",
      "category": "math",
      "engineStatus": {
        "libreoffice": {
          "status": "missing",
          "via": "DV-0004"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0004"
        }
      },
      "engines": [],
      "syntax": "SEC(angle)",
      "description": "The SEC function returns the secant of an angle measured in radians."
    },
    {
      "name": "SECH",
      "slug": "SECH",
      "category": "math",
      "engineStatus": {
        "libreoffice": {
          "status": "missing",
          "via": "DV-0004"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0004"
        }
      },
      "engines": [],
      "syntax": "SECH(value)",
      "description": "The SECH function returns the hyperbolic secant of an angle."
    },
    {
      "name": "SECOND",
      "slug": "SECOND",
      "category": "date",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        },
        "ironcalc": {
          "status": "partial",
          "via": "DV-0028"
        }
      },
      "engines": [],
      "syntax": "SECOND(time)",
      "description": "Returns the second component of a specific time, in numeric format."
    },
    {
      "name": "SEQUENCE",
      "slug": "SEQUENCE",
      "category": "math",
      "engineStatus": {},
      "engines": [],
      "syntax": "SEQUENCE(rows, columns, start, step)",
      "description": "The SEQUENCE function returns an array of sequential numbers, such as 1, 2, 3, 4."
    },
    {
      "name": "SERIESSUM",
      "slug": "SERIESSUM",
      "category": "math",
      "engineStatus": {
        "formulas": {
          "status": "missing",
          "via": "DV-0041"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0041"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0041"
        }
      },
      "engines": [],
      "syntax": "SERIESSUM(x, n, m, a)",
      "description": "Given parameters `x`, `n`, `m`, and `a`, returns the power series sum a1xn + a2x(n+m) + ."
    },
    {
      "name": "SIGN",
      "slug": "SIGN",
      "category": "math",
      "engineStatus": {},
      "engines": [],
      "syntax": "SIGN(value)",
      "description": "Given an input number, returns `-1` if it is negative, `1` if positive, and `0` if it is zero."
    },
    {
      "name": "SIN",
      "slug": "SIN",
      "category": "math",
      "engineStatus": {},
      "engines": [],
      "syntax": "SIN(angle)",
      "description": "The SIN function returns the sine of an angle provided in radians."
    },
    {
      "name": "SINGLE",
      "slug": "SINGLE",
      "category": "array",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0013"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0013"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0013"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0013"
        },
        "excel": {
          "status": "partial",
          "via": "DV-0019"
        }
      },
      "engines": [],
      "syntax": "SINGLE(array)",
      "description": "Constrains an [[Array|array]] to $1 \\times 1$. Returns the upper-leftmost [[Data type#scalar-types|scalar value]]."
    },
    {
      "name": "SINH",
      "slug": "SINH",
      "category": "math",
      "engineStatus": {},
      "engines": [],
      "syntax": "SINH(value)",
      "description": "The SINH function returns the hyperbolic sine of any real number."
    },
    {
      "name": "SKEW.P",
      "slug": "SKEW.P",
      "category": "statistical",
      "engineStatus": {
        "libreoffice": {
          "status": "missing",
          "via": "DV-0004"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0004"
        }
      },
      "engines": [],
      "syntax": "SKEW.P(value1, value2)",
      "description": "The SKEW."
    },
    {
      "name": "SKEW",
      "slug": "SKEW",
      "category": "statistical",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        }
      },
      "engines": [],
      "syntax": "SKEW(value1, [value2, ...])",
      "description": "Calculates the skewness of a dataset, which describes the symmetry of that dataset about the mean."
    },
    {
      "name": "SLN",
      "slug": "SLN",
      "category": "financial",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        }
      },
      "engines": [],
      "syntax": "SLN(cost, salvage, life)",
      "description": "The SLN function calculates the depreciation of an asset for one period using the straight-line method."
    },
    {
      "name": "SLOPE",
      "slug": "SLOPE",
      "category": "statistical",
      "engineStatus": {
        "pycel": {
          "status": "partial",
          "via": "DV-0217"
        }
      },
      "engines": [],
      "syntax": "SLOPE(data_y, data_x)",
      "description": "Calculates the slope of the line resulting from linear regression of a dataset."
    },
    {
      "name": "SMALL",
      "slug": "SMALL",
      "category": "statistical",
      "engineStatus": {
        "libreoffice": {
          "status": "partial",
          "via": "DV-0008"
        }
      },
      "engines": [],
      "syntax": "SMALL(data, n)",
      "description": "Returns the nth smallest element from a data set, where n is user-defined."
    },
    {
      "name": "SORT",
      "slug": "SORT",
      "category": "filter",
      "engineStatus": {},
      "engines": [],
      "syntax": "SORT(range, sort_column, is_ascending, [sort_column2, is_ascending2, ...])",
      "description": "Sorts the rows of a given array or range by the values in one or more columns."
    },
    {
      "name": "SORTN",
      "slug": "SORTN",
      "category": "filter",
      "engineStatus": {
        "gsheets": {
          "status": "partial",
          "via": "DV-0056"
        }
      },
      "engines": [],
      "syntax": "SORTN(range, [n], [display_ties_mode], [sort_column1, is_ascending1], ...)",
      "description": "Returns the first n items in a data set after performing a sort."
    },
    {
      "name": "SPARKLINE",
      "slug": "SPARKLINE",
      "category": "google",
      "engineStatus": {
        "excel": {
          "status": "missing",
          "via": "DV-0009"
        },
        "formulas": {
          "status": "missing",
          "via": "DV-0010"
        },
        "hyperformula": {
          "status": "missing",
          "via": "DV-0010"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0010"
        },
        "lattice": {
          "status": "missing",
          "via": "DV-0010"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0010"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0010"
        }
      },
      "engines": [],
      "syntax": "SPARKLINE(data, [options])",
      "description": "Creates a miniature chart contained within a single cell."
    },
    {
      "name": "SPLIT",
      "slug": "SPLIT",
      "category": "text",
      "engineStatus": {
        "hyperformula": {
          "status": "partial",
          "via": "DV-0231"
        },
        "excel": {
          "status": "partial",
          "via": "DV-0231"
        },
        "formulas": {
          "status": "missing",
          "via": "DV-0029"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0029"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0029"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0029"
        }
      },
      "engines": [],
      "syntax": "SPLIT(text, delimiter, [split_by_each], [remove_empty_text])",
      "description": "Divides text around a specified character or string, and puts each fragment into a separate cell in the row."
    },
    {
      "name": "SQRT",
      "slug": "SQRT",
      "category": "math",
      "engineStatus": {
        "libreoffice": {
          "status": "partial",
          "via": "DV-0198"
        },
        "ironcalc": {
          "status": "partial",
          "via": "DV-0196"
        },
        "hyperformula": {
          "status": "partial",
          "via": "DV-0197"
        }
      },
      "engines": [],
      "syntax": "SQRT(value)",
      "description": "Returns the positive square root of a positive number."
    },
    {
      "name": "SQRTPI",
      "slug": "SQRTPI",
      "category": "math",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        },
        "libreoffice": {
          "status": "partial",
          "via": "DV-0008"
        }
      },
      "engines": [],
      "syntax": "SQRTPI(value)",
      "description": "Returns the positive square root of the product of Pi and the given positive number."
    },
    {
      "name": "STANDARDIZE",
      "slug": "STANDARDIZE",
      "category": "statistical",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        },
        "libreoffice": {
          "status": "partial",
          "via": "DV-0223"
        }
      },
      "engines": [],
      "syntax": "STANDARDIZE(value, mean, standard_deviation)",
      "description": "Calculates the normalized equivalent of a random variable given mean and standard deviation of the distribution."
    },
    {
      "name": "STDEV.P",
      "slug": "STDEV.P",
      "category": "statistical",
      "engineStatus": {
        "libreoffice": {
          "status": "missing",
          "via": "DV-0004"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0004"
        }
      },
      "engines": [],
      "syntax": "STDEVP(column)",
      "description": "Calculates the standard deviation based on an entire population."
    },
    {
      "name": "STDEV.S",
      "slug": "STDEV.S",
      "category": "statistical",
      "engineStatus": {
        "libreoffice": {
          "status": "missing",
          "via": "DV-0004"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0004"
        }
      },
      "engines": [],
      "syntax": "STDEV(column)",
      "description": "The STDEV function calculates the standard deviation based on a sample."
    },
    {
      "name": "STDEV",
      "slug": "STDEV",
      "category": "statistical",
      "engineStatus": {
        "ironcalc": {
          "status": "missing",
          "via": "DV-0005"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0005"
        }
      },
      "engines": [],
      "syntax": "STDEV(column)",
      "description": "The STDEV function calculates the standard deviation based on a sample."
    },
    {
      "name": "STDEVA",
      "slug": "STDEVA",
      "category": "statistical",
      "engineStatus": {},
      "engines": [],
      "syntax": "STDEVA(value1, [value2, ...])",
      "description": "Calculates the standard deviation based on a sample, setting text to the value `0`."
    },
    {
      "name": "STDEVP",
      "slug": "STDEVP",
      "category": "statistical",
      "engineStatus": {
        "ironcalc": {
          "status": "missing",
          "via": "DV-0005"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0005"
        }
      },
      "engines": [],
      "syntax": "STDEVP(column)",
      "description": "Calculates the standard deviation based on an entire population."
    },
    {
      "name": "STDEVPA",
      "slug": "STDEVPA",
      "category": "statistical",
      "engineStatus": {},
      "engines": [],
      "syntax": "STDEVPA(value1, [value2, ...])",
      "description": "Calculates the standard deviation based on an entire population, setting text to the value `0`."
    },
    {
      "name": "STEYX",
      "slug": "STEYX",
      "category": "statistical",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        }
      },
      "engines": [],
      "syntax": "STEYX(data_y, data_x)",
      "description": "Calculates the standard error of the predicted y-value for each x in the regression of a dataset."
    },
    {
      "name": "SUBSTITUTE",
      "slug": "SUBSTITUTE",
      "category": "text",
      "engineStatus": {},
      "engines": [],
      "syntax": "SUBSTITUTE(text_to_search, search_for, replace_with, [occurrence_number])",
      "description": "Replaces existing text with new text in a string."
    },
    {
      "name": "SUBTOTAL",
      "slug": "SUBTOTAL",
      "category": "math",
      "engineStatus": {
        "formulas": {
          "status": "missing",
          "via": "DV-0021"
        }
      },
      "engines": [],
      "syntax": "SUBTOTAL(function_code, range1, [range2, ...])",
      "description": "Returns a subtotal for a vertical range of cells using a specified aggregation function."
    },
    {
      "name": "SUM",
      "slug": "SUM",
      "category": "math",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0006"
        },
        "lattice": {
          "status": "partial",
          "via": "DV-0242"
        },
        "ironcalc": {
          "status": "partial",
          "via": "DV-0248"
        }
      },
      "engines": [],
      "syntax": "SUM(value1, [value2, ...])",
      "description": "Returns the sum of a series of numbers and/or cells."
    },
    {
      "name": "SUMIF",
      "slug": "SUMIF",
      "category": "math",
      "engineStatus": {},
      "engines": [],
      "syntax": "SUMIF(criteria_column, criterion, sum_column)",
      "description": "Returns a conditional sum across a range."
    },
    {
      "name": "SUMIFS",
      "slug": "SUMIFS",
      "category": "math",
      "engineStatus": {},
      "engines": [],
      "syntax": "SUMIFS(sum_column, criteria_column1, criterion1, criteria_column2, criterion2)",
      "description": "Returns the sum of a range depending on multiple criteria."
    },
    {
      "name": "SUMPRODUCT",
      "slug": "SUMPRODUCT",
      "category": "array",
      "engineStatus": {
        "ironcalc": {
          "status": "missing",
          "via": "DV-0027"
        },
        "formulas": {
          "status": "partial",
          "via": "DV-0089"
        },
        "pycel": {
          "status": "partial",
          "via": "DV-0199"
        }
      },
      "engines": [],
      "syntax": "SUMPRODUCT(array1, [array2, ...])",
      "description": "The SUMPRODUCT function calculates the sum of the products of corresponding entries in 2 equally sized arrays or ranges."
    },
    {
      "name": "SUMSQ",
      "slug": "SUMSQ",
      "category": "math",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        }
      },
      "engines": [],
      "syntax": "SUMSQ(value1, [value2, ...])",
      "description": "Returns the sum of the squares of a series of numbers and/or cells."
    },
    {
      "name": "SUMX2MY2",
      "slug": "SUMX2MY2",
      "category": "array",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        }
      },
      "engines": [],
      "syntax": "SUMX2MY2(array_x, array_y)",
      "description": "Calculates the sum of the differences of the squares of values in two arrays."
    },
    {
      "name": "SUMX2PY2",
      "slug": "SUMX2PY2",
      "category": "array",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        }
      },
      "engines": [],
      "syntax": "SUMX2PY2(array_x, array_y)",
      "description": "Calculates the sum of the sums of the squares of values in two arrays."
    },
    {
      "name": "SUMXMY2",
      "slug": "SUMXMY2",
      "category": "array",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        }
      },
      "engines": [],
      "syntax": "SUMXMY2(array_x, array_y)",
      "description": "Calculates the sum of the squares of differences of values in two arrays."
    },
    {
      "name": "SWITCH",
      "slug": "SWITCH",
      "category": "logical",
      "engineStatus": {
        "libreoffice": {
          "status": "missing",
          "via": "DV-0004"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0004"
        }
      },
      "engines": [],
      "syntax": "SWITCH(expression, case1, value1, [case2, value2, ...], [default])",
      "description": "Tests an expression against a list of cases and returns the corresponding value of the first matching case, with an optional default value if nothing else is met."
    },
    {
      "name": "SYD",
      "slug": "SYD",
      "category": "financial",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        },
        "excel": {
          "status": "partial",
          "via": "DV-0170"
        },
        "formulas": {
          "status": "partial",
          "via": "DV-0170"
        },
        "gsheets": {
          "status": "partial",
          "via": "DV-0170"
        },
        "lattice": {
          "status": "partial",
          "via": "DV-0170"
        },
        "ironcalc": {
          "status": "partial",
          "via": "DV-0171"
        },
        "hyperformula": {
          "status": "partial",
          "via": "DV-0172"
        },
        "libreoffice": {
          "status": "partial",
          "via": "DV-0174"
        }
      },
      "engines": [],
      "syntax": "SYD(cost, salvage, life, period)",
      "description": "The SYD function calculates the depreciation of an asset for a specified period using the sum of years digits method."
    },
    {
      "name": "T.DIST.2T",
      "slug": "T.DIST.2T",
      "category": "statistical",
      "engineStatus": {},
      "engines": [],
      "syntax": "T.DIST.2T(x, degrees_freedom)",
      "description": "The T."
    },
    {
      "name": "T.DIST.RT",
      "slug": "T.DIST.RT",
      "category": "statistical",
      "engineStatus": {
        "libreoffice": {
          "status": "missing",
          "via": "DV-0004"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0004"
        }
      },
      "engines": [],
      "syntax": "T.DIST.2T(x, degrees_freedom)",
      "description": "Returns the right tailed Student distribution for a value x."
    },
    {
      "name": "T.DIST",
      "slug": "T.DIST",
      "category": "statistical",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0017"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0017"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0017"
        }
      },
      "engines": [],
      "syntax": "T.DIST(x, degrees_freedom, cumulative)",
      "description": "The T."
    },
    {
      "name": "T.INV.2T",
      "slug": "T.INV.2T",
      "category": "statistical",
      "engineStatus": {},
      "engines": [],
      "syntax": "T.INV.2T(probability, degrees_freedom)",
      "description": "The T."
    },
    {
      "name": "T.INV",
      "slug": "T.INV",
      "category": "statistical",
      "engineStatus": {
        "libreoffice": {
          "status": "missing",
          "via": "DV-0004"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0004"
        }
      },
      "engines": [],
      "syntax": "T.INV(probability, degrees_freedom)",
      "description": "Calculates the negative inverse of the one-tailed TDIST function."
    },
    {
      "name": "T.TEST",
      "slug": "T.TEST",
      "category": "statistical",
      "engineStatus": {},
      "engines": [],
      "syntax": "T.TEST(range1, range2, tails, type)",
      "description": "Returns the probability associated with t-test."
    },
    {
      "name": "T",
      "slug": "T",
      "category": "text",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0016"
        },
        "hyperformula": {
          "status": "missing",
          "via": "DV-0016"
        },
        "excel": {
          "status": "partial",
          "via": "DV-0031"
        },
        "formulas": {
          "status": "partial",
          "via": "DV-0031"
        },
        "gsheets": {
          "status": "partial",
          "via": "DV-0031"
        },
        "libreoffice": {
          "status": "partial",
          "via": "DV-0031"
        },
        "lattice": {
          "status": "partial",
          "via": "DV-0244"
        }
      },
      "engines": [],
      "syntax": "T(value)",
      "description": "Returns string arguments as text."
    },
    {
      "name": "TAN",
      "slug": "TAN",
      "category": "math",
      "engineStatus": {},
      "engines": [],
      "syntax": "TAN(angle)",
      "description": "The TAN function returns the tangent of an angle provided in radians."
    },
    {
      "name": "TANH",
      "slug": "TANH",
      "category": "math",
      "engineStatus": {},
      "engines": [],
      "syntax": "TANH(value)",
      "description": "The TANH function returns the hyperbolic tangent of any real number."
    },
    {
      "name": "TBILLEQ",
      "slug": "TBILLEQ",
      "category": "financial",
      "engineStatus": {},
      "engines": [],
      "syntax": "TBILLEQ(settlement, maturity, discount)",
      "description": "Calculates the equivalent annualized rate of return of a US Treasury Bill based on discount rate."
    },
    {
      "name": "TBILLPRICE",
      "slug": "TBILLPRICE",
      "category": "financial",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        }
      },
      "engines": [],
      "syntax": "TBILLPRICE(settlement, maturity, discount)",
      "description": "Calculates the price of a US Treasury Bill based on discount rate."
    },
    {
      "name": "TBILLYIELD",
      "slug": "TBILLYIELD",
      "category": "financial",
      "engineStatus": {},
      "engines": [],
      "syntax": "TBILLYIELD(settlement, maturity, price)",
      "description": "Calculates the yield of a US Treasury Bill based on price."
    },
    {
      "name": "TDIST",
      "slug": "TDIST",
      "category": "statistical",
      "engineStatus": {},
      "engines": [],
      "syntax": "TDIST(x, degrees_freedom, tails)",
      "description": "Calculates the probability for Student's t-distribution with a given input (x)."
    },
    {
      "name": "TEXT",
      "slug": "TEXT",
      "category": "text",
      "engineStatus": {
        "hyperformula": {
          "status": "partial",
          "via": "DV-0235"
        },
        "lattice": {
          "status": "partial",
          "via": "DV-0234"
        }
      },
      "engines": [],
      "syntax": "TEXT(number, format)",
      "description": "Converts a number into text according to a specified format."
    },
    {
      "name": "TEXTJOIN",
      "slug": "TEXTJOIN",
      "category": "text",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0017"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0017"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0017"
        }
      },
      "engines": [],
      "syntax": "TEXTJOIN(delimiter, ignore_empty, text1, [text2, ...])",
      "description": "Combines the text from multiple strings and/or arrays, with a specifiable delimiter separating the different texts."
    },
    {
      "name": "TIME",
      "slug": "TIME",
      "category": "date",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        }
      },
      "engines": [],
      "syntax": "TIME(hour, minute, second)",
      "description": "Converts an hour, minute, and second into a time."
    },
    {
      "name": "TIMEVALUE",
      "slug": "TIMEVALUE",
      "category": "date",
      "engineStatus": {},
      "engines": [],
      "syntax": "TIMEVALUE(time_string)",
      "description": "Returns the fraction of a 24-hour day the time represents."
    },
    {
      "name": "TINV",
      "slug": "TINV",
      "category": "statistical",
      "engineStatus": {},
      "engines": [],
      "syntax": "T.INV.2T(probability, degrees_freedom)",
      "description": "The T."
    },
    {
      "name": "TOCOL",
      "slug": "TOCOL",
      "category": "array",
      "engineStatus": {},
      "engines": [],
      "syntax": "TOCOL(array_or_range, [ignore], [scan_by_column])",
      "description": "This function transforms an array or range of cells into a single column."
    },
    {
      "name": "TODAY",
      "slug": "TODAY",
      "category": "date",
      "engineStatus": {
        "lattice": {
          "status": "partial",
          "via": "DV-0074"
        }
      },
      "engines": [],
      "syntax": "TODAY()",
      "description": "Returns the current date as a date value."
    },
    {
      "name": "TOROW",
      "slug": "TOROW",
      "category": "array",
      "engineStatus": {},
      "engines": [],
      "syntax": "TOROW(array_or_range, [ignore], [scan_by_column])",
      "description": "This function transforms an array or range of cells into a single row."
    },
    {
      "name": "TO_DATE",
      "slug": "TO_DATE",
      "category": "parser",
      "engineStatus": {
        "excel": {
          "status": "missing",
          "via": "DV-0009"
        },
        "formulas": {
          "status": "missing",
          "via": "DV-0010"
        },
        "hyperformula": {
          "status": "missing",
          "via": "DV-0010"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0010"
        },
        "lattice": {
          "status": "missing",
          "via": "DV-0010"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0010"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0010"
        }
      },
      "engines": [],
      "syntax": "TO_DATE(value)",
      "description": "Converts a provided number to a date."
    },
    {
      "name": "TO_DOLLARS",
      "slug": "TO_DOLLARS",
      "category": "parser",
      "engineStatus": {
        "excel": {
          "status": "missing",
          "via": "DV-0009"
        },
        "formulas": {
          "status": "missing",
          "via": "DV-0010"
        },
        "hyperformula": {
          "status": "missing",
          "via": "DV-0010"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0010"
        },
        "lattice": {
          "status": "missing",
          "via": "DV-0010"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0010"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0010"
        }
      },
      "engines": [],
      "syntax": "TO_DOLLARS(value)",
      "description": "Converts a provided number to a dollar value."
    },
    {
      "name": "TO_PERCENT",
      "slug": "TO_PERCENT",
      "category": "parser",
      "engineStatus": {
        "excel": {
          "status": "missing",
          "via": "DV-0009"
        },
        "formulas": {
          "status": "missing",
          "via": "DV-0010"
        },
        "hyperformula": {
          "status": "missing",
          "via": "DV-0010"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0010"
        },
        "lattice": {
          "status": "missing",
          "via": "DV-0010"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0010"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0010"
        }
      },
      "engines": [],
      "syntax": "TO_PERCENT(value)",
      "description": "Converts a provided number to a percentage."
    },
    {
      "name": "TO_PURE_NUMBER",
      "slug": "TO_PURE_NUMBER",
      "category": "parser",
      "engineStatus": {
        "excel": {
          "status": "missing",
          "via": "DV-0009"
        },
        "formulas": {
          "status": "missing",
          "via": "DV-0010"
        },
        "hyperformula": {
          "status": "missing",
          "via": "DV-0010"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0010"
        },
        "lattice": {
          "status": "missing",
          "via": "DV-0010"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0010"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0010"
        }
      },
      "engines": [],
      "syntax": "TO_PURE_NUMBER(value)",
      "description": "Converts a provided date/time, percentage, currency or other formatted numeric value to a pure number without formatting."
    },
    {
      "name": "TO_TEXT",
      "slug": "TO_TEXT",
      "category": "parser",
      "engineStatus": {
        "excel": {
          "status": "missing",
          "via": "DV-0009"
        },
        "formulas": {
          "status": "missing",
          "via": "DV-0010"
        },
        "hyperformula": {
          "status": "missing",
          "via": "DV-0010"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0010"
        },
        "lattice": {
          "status": "missing",
          "via": "DV-0010"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0010"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0010"
        }
      },
      "engines": [],
      "syntax": "TO_TEXT(value)",
      "description": "Converts a provided numeric value to a text value."
    },
    {
      "name": "TRANSPOSE",
      "slug": "TRANSPOSE",
      "category": "array",
      "engineStatus": {
        "ironcalc": {
          "status": "missing",
          "via": "DV-0005"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0005"
        },
        "libreoffice": {
          "status": "partial",
          "via": "DV-0022"
        }
      },
      "engines": [],
      "syntax": "TRANSPOSE(array_or_range)",
      "description": "Transposes the rows and columns of an array or range of cells."
    },
    {
      "name": "TREND",
      "slug": "TREND",
      "category": "array",
      "engineStatus": {},
      "engines": [],
      "syntax": "TREND(known_data_y, [known_data_x], [new_data_x], [b])",
      "description": "Given partial data about a linear trend, fits an ideal linear trend using the least squares method and/or predicts further values."
    },
    {
      "name": "TRIM",
      "slug": "TRIM",
      "category": "text",
      "engineStatus": {
        "pycel": {
          "status": "partial",
          "via": "DV-0239"
        }
      },
      "engines": [],
      "syntax": "TRIM(text)",
      "description": "Removes leading, trailing, and repeated spaces in text."
    },
    {
      "name": "TRIMMEAN",
      "slug": "TRIMMEAN",
      "category": "statistical",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0003"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0003"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0003"
        },
        "libreoffice": {
          "status": "partial",
          "via": "DV-0008"
        }
      },
      "engines": [],
      "syntax": "TRIMMEAN(data, exclude_proportion)",
      "description": "Calculates the mean of a dataset excluding some proportion of data from the high and low ends of the dataset."
    },
    {
      "name": "TRIXTERNS",
      "slug": "TRIXTERNS",
      "category": "uncategorized",
      "engineStatus": {
        "gsheets": {
          "status": "available"
        }
      },
      "engines": [
        "gsheets"
      ],
      "coverage": "out-of-scope",
      "syntax": "TRIXTERNS()",
      "description": "Returns a $43 \\times 1$ [[Array|array]] containing the names and years of each cohort of interns with the Google Sheets team."
    },
    {
      "name": "TRUE",
      "slug": "TRUE",
      "category": "logical",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0006"
        }
      },
      "engines": [],
      "syntax": "TRUE()",
      "description": "Returns the logical value `TRUE`."
    },
    {
      "name": "TRUNC",
      "slug": "TRUNC",
      "category": "math",
      "engineStatus": {},
      "engines": [],
      "syntax": "TRUNC(value, [places])",
      "description": "Truncates a number to a certain number of significant digits by omitting less significant digits."
    },
    {
      "name": "TTEST",
      "slug": "TTEST",
      "category": "statistical",
      "engineStatus": {},
      "engines": [],
      "syntax": "T.TEST(range1, range2, tails, type)",
      "description": "Returns the probability associated with t-test."
    },
    {
      "name": "TYPE",
      "slug": "TYPE",
      "category": "info",
      "engineStatus": {},
      "engines": [],
      "syntax": "TYPE(value)",
      "description": "Returns a number associated with the type of data passed into the function."
    },
    {
      "name": "UMINUS",
      "slug": "UMINUS",
      "category": "operator",
      "engineStatus": {
        "excel": {
          "status": "missing",
          "via": "DV-0002"
        },
        "formulas": {
          "status": "missing",
          "via": "DV-0002"
        },
        "hyperformula": {
          "status": "missing",
          "via": "DV-0002"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0002"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0002"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0002"
        }
      },
      "engines": [],
      "syntax": "UMINUS(value)",
      "description": "Returns a number with the sign reversed."
    },
    {
      "name": "UNARY_PERCENT",
      "slug": "UNARY_PERCENT",
      "category": "operator",
      "engineStatus": {
        "excel": {
          "status": "missing",
          "via": "DV-0002"
        },
        "formulas": {
          "status": "missing",
          "via": "DV-0002"
        },
        "hyperformula": {
          "status": "missing",
          "via": "DV-0002"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0002"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0002"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0002"
        }
      },
      "engines": [],
      "syntax": "UNARY_PERCENT(percentage)",
      "description": "Returns a value interpreted as a percentage; that is, `UNARY\\_PERCENT(100)` equals `1`."
    },
    {
      "name": "UNICHAR",
      "slug": "UNICHAR",
      "category": "text",
      "engineStatus": {
        "ironcalc": {
          "status": "missing",
          "via": "DV-0043"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0043"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0043"
        },
        "excel": {
          "status": "partial",
          "via": "DV-0236"
        },
        "formulas": {
          "status": "partial",
          "via": "DV-0236"
        },
        "gsheets": {
          "status": "partial",
          "via": "DV-0236"
        },
        "hyperformula": {
          "status": "partial",
          "via": "DV-0236"
        }
      },
      "engines": [],
      "syntax": "UNICHAR(number)",
      "description": "Returns the Unicode character for a number."
    },
    {
      "name": "UNICODE",
      "slug": "UNICODE",
      "category": "text",
      "engineStatus": {
        "libreoffice": {
          "status": "missing",
          "via": "DV-0004"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0004"
        }
      },
      "engines": [],
      "syntax": "UNICODE(text)",
      "description": "The `UNICODE` function returns the decimal Unicode value of the first character of the text."
    },
    {
      "name": "UNIQUE",
      "slug": "UNIQUE",
      "category": "operator",
      "engineStatus": {},
      "engines": [],
      "syntax": "UNIQUE(range, by_column, exactly_once)",
      "description": "Returns unique rows in the provided source range, discarding duplicates."
    },
    {
      "name": "UPLUS",
      "slug": "UPLUS",
      "category": "operator",
      "engineStatus": {
        "excel": {
          "status": "missing",
          "via": "DV-0002"
        },
        "formulas": {
          "status": "missing",
          "via": "DV-0002"
        },
        "hyperformula": {
          "status": "missing",
          "via": "DV-0002"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0002"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0002"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0002"
        }
      },
      "engines": [],
      "syntax": "UPLUS(value)",
      "description": "Returns a specified number, unchanged."
    },
    {
      "name": "UPPER",
      "slug": "UPPER",
      "category": "text",
      "engineStatus": {},
      "engines": [],
      "syntax": "UPPER(text)",
      "description": "Converts a specified string to uppercase."
    },
    {
      "name": "VALUE",
      "slug": "VALUE",
      "category": "text",
      "engineStatus": {
        "excel": {
          "status": "partial",
          "via": "DV-0237"
        },
        "formulas": {
          "status": "partial",
          "via": "DV-0237"
        },
        "hyperformula": {
          "status": "partial",
          "via": "DV-0237"
        },
        "ironcalc": {
          "status": "partial",
          "via": "DV-0237"
        },
        "lattice": {
          "status": "partial",
          "via": "DV-0237"
        },
        "libreoffice": {
          "status": "partial",
          "via": "DV-0237"
        },
        "pycel": {
          "status": "partial",
          "via": "DV-0237"
        }
      },
      "engines": [],
      "syntax": "VALUE(text)",
      "description": "Converts a string in any of the date, time or number formats that Google Sheets understands into a number."
    },
    {
      "name": "VAR.P",
      "slug": "VAR.P",
      "category": "statistical",
      "engineStatus": {
        "libreoffice": {
          "status": "missing",
          "via": "DV-0004"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0004"
        }
      },
      "engines": [],
      "syntax": "VARP(column)",
      "description": "Calculates the variance based on an entire population."
    },
    {
      "name": "VAR.S",
      "slug": "VAR.S",
      "category": "statistical",
      "engineStatus": {
        "libreoffice": {
          "status": "missing",
          "via": "DV-0004"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0004"
        }
      },
      "engines": [],
      "syntax": "VAR(column)",
      "description": "Calculates the variance based on a sample."
    },
    {
      "name": "VAR",
      "slug": "VAR",
      "category": "statistical",
      "engineStatus": {
        "ironcalc": {
          "status": "missing",
          "via": "DV-0005"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0005"
        }
      },
      "engines": [],
      "syntax": "VAR(column)",
      "description": "Calculates the variance based on a sample."
    },
    {
      "name": "VARA",
      "slug": "VARA",
      "category": "statistical",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        }
      },
      "engines": [],
      "syntax": "VARA(value1, [value2, ...])",
      "description": "Calculates the variance based on a sample, setting text to the value `0`."
    },
    {
      "name": "VARP",
      "slug": "VARP",
      "category": "statistical",
      "engineStatus": {
        "ironcalc": {
          "status": "missing",
          "via": "DV-0005"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0005"
        }
      },
      "engines": [],
      "syntax": "VARP(column)",
      "description": "Calculates the variance based on an entire population."
    },
    {
      "name": "VARPA",
      "slug": "VARPA",
      "category": "statistical",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        }
      },
      "engines": [],
      "syntax": "VARPA(value1, [value2, ...])",
      "description": "Calculates the variance based on an entire population, setting text to the value `0`."
    },
    {
      "name": "VDB",
      "slug": "VDB",
      "category": "financial",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0003"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0003"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0003"
        }
      },
      "engines": [],
      "syntax": "VDB(cost, salvage, life, start_period, end_period, [factor], [no_switch])",
      "description": "The VDB function returns the depreciation of an asset for a particular period (or partial period)."
    },
    {
      "name": "VLOOKUP",
      "slug": "VLOOKUP",
      "category": "lookup",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0006"
        }
      },
      "engines": [],
      "syntax": "VLOOKUP(search_key, range,index, is_sorted)",
      "description": "If you have known information on your spreadsheet, you can use `VLOOKUP` to search for related information by row."
    },
    {
      "name": "VSTACK",
      "slug": "VSTACK",
      "category": "array",
      "engineStatus": {},
      "engines": [],
      "syntax": "VSTACK(range1; [range2, …])",
      "description": "This function appends ranges vertically and in sequence to return a larger array."
    },
    {
      "name": "WEEKDAY",
      "slug": "WEEKDAY",
      "category": "date",
      "engineStatus": {
        "hyperformula": {
          "status": "partial",
          "via": "DV-0014"
        },
        "pycel": {
          "status": "partial",
          "via": "DV-0014"
        }
      },
      "engines": [],
      "syntax": "WEEKDAY(date, [type])",
      "description": "Returns a number representing the day of the week of the date provided."
    },
    {
      "name": "WEEKNUM",
      "slug": "WEEKNUM",
      "category": "date",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        },
        "hyperformula": {
          "status": "partial",
          "via": "DV-0012"
        }
      },
      "engines": [],
      "syntax": "WEEKNUM(date, [type])",
      "description": "Returns a number representing the week of the year where the provided date falls."
    },
    {
      "name": "WEIBULL.DIST",
      "slug": "WEIBULL.DIST",
      "category": "statistical",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0017"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0017"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0017"
        }
      },
      "engines": [],
      "syntax": "WEIBULL(x, shape, scale, cumulative)",
      "description": "Returns the value of the Weibull distribution function (or Weibull cumulative distribution function) for a specified shape and scale."
    },
    {
      "name": "WEIBULL",
      "slug": "WEIBULL",
      "category": "statistical",
      "engineStatus": {},
      "engines": [],
      "syntax": "WEIBULL(x, shape, scale, cumulative)",
      "description": "Returns the value of the Weibull distribution function (or Weibull cumulative distribution function) for a specified shape and scale."
    },
    {
      "name": "WHATTHEFOXSAY",
      "slug": "WHATTHEFOXSAY",
      "category": "math",
      "engineStatus": {
        "gsheets": {
          "status": "available"
        }
      },
      "engines": [
        "gsheets"
      ],
      "coverage": "out-of-scope",
      "syntax": "WHATTHEFOXSAY()",
      "description": "Returns one of eight lyrics from the song [The Fox](en.wikipedia.org/wiki/The_Fox_(What_Does_the_Fox_Say%3F)) at random. `WHATTHEFOXSAY` is [[Volatile]]."
    },
    {
      "name": "WORKDAY.INTL",
      "slug": "WORKDAY.INTL",
      "category": "date",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        },
        "hyperformula": {
          "status": "partial",
          "via": "DV-0012"
        }
      },
      "engines": [],
      "syntax": "WORKDAY.INTL(start_date, num_days, [weekend], [holidays])",
      "description": "Calculates the date after a specified number of workdays excluding specified weekend days and holidays."
    },
    {
      "name": "WORKDAY",
      "slug": "WORKDAY",
      "category": "date",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        },
        "hyperformula": {
          "status": "partial",
          "via": "DV-0095"
        },
        "gsheets": {
          "status": "partial",
          "via": "DV-0095"
        },
        "ironcalc": {
          "status": "partial",
          "via": "DV-0095"
        }
      },
      "engines": [],
      "syntax": "WORKDAY(start_date, num_days, [holidays])",
      "description": "Calculates the end date after a specified number of working days."
    },
    {
      "name": "WRAPCOLS",
      "slug": "WRAPCOLS",
      "category": "array",
      "engineStatus": {},
      "engines": [],
      "syntax": "WRAPCOLS(range, wrap_count, [pad_with])",
      "description": "This function wraps the provided row or column of cells by columns after a specified number of elements to form a new array."
    },
    {
      "name": "WRAPROWS",
      "slug": "WRAPROWS",
      "category": "array",
      "engineStatus": {},
      "engines": [],
      "syntax": "WRAPROWS(range, wrap_count, [pad_with])",
      "description": "This function wraps the provided row or column of cells by rows after a specified number of elements to form a new array."
    },
    {
      "name": "XIRR",
      "slug": "XIRR",
      "category": "financial",
      "engineStatus": {
        "libreoffice": {
          "status": "partial",
          "via": "DV-0008"
        },
        "hyperformula": {
          "status": "missing",
          "via": "DV-0016"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0016"
        }
      },
      "engines": [],
      "syntax": "XIRR(cashflow_amounts, cashflow_dates, [rate_guess])",
      "description": "Calculates the internal rate of return of an investment based on a specified series of potentially irregularly spaced cash flows."
    },
    {
      "name": "XLOOKUP",
      "slug": "XLOOKUP",
      "category": "lookup",
      "engineStatus": {
        "libreoffice": {
          "status": "missing",
          "via": "DV-0004"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0004"
        }
      },
      "engines": [],
      "syntax": "XLOOKUP(search_key,lookup_range,result_range,missing_value,match_mode)",
      "description": "The `XLOOKUP` function returns the values in the result range based on the position where a match was found in the lookup range."
    },
    {
      "name": "XMATCH",
      "slug": "XMATCH",
      "category": "uncategorized",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0013"
        },
        "ironcalc": {
          "status": "missing",
          "via": "DV-0013"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0013"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0013"
        }
      },
      "engines": [],
      "syntax": "XMATCH(search_key, lookup_range, [match_mode], [search_mode])",
      "description": "XMATCH returns the relative position of an item in an array or range that matches a specified value."
    },
    {
      "name": "XNPV",
      "slug": "XNPV",
      "category": "financial",
      "engineStatus": {
        "pycel": {
          "status": "missing",
          "via": "DV-0001"
        },
        "hyperformula": {
          "status": "partial",
          "via": "DV-0175"
        },
        "libreoffice": {
          "status": "partial",
          "via": "DV-0175"
        },
        "formulas": {
          "status": "partial",
          "via": "DV-0176"
        }
      },
      "engines": [],
      "syntax": "XNPV(discount, cashflow_amounts, cashflow_dates)",
      "description": "Calculates the net present value of an investment based on a specified series of potentially irregularly spaced cash flows and a discount rate."
    },
    {
      "name": "XOR",
      "slug": "XOR",
      "category": "logical",
      "engineStatus": {
        "hyperformula": {
          "status": "missing",
          "via": "DV-0015"
        },
        "libreoffice": {
          "status": "missing",
          "via": "DV-0015"
        },
        "pycel": {
          "status": "partial",
          "via": "DV-0179"
        }
      },
      "engines": [],
      "syntax": "XOR(logical_expression1, [logical_expression2, ...])",
      "description": "The XOR function returns TRUE if an odd number of the provided arguments are logically true, and FALSE otherwise."
    },
    {
      "name": "YEAR",
      "slug": "YEAR",
      "category": "date",
      "engineStatus": {
        "hyperformula": {
          "status": "partial",
          "via": "DV-0014"
        },
        "pycel": {
          "status": "partial",
          "via": "DV-0014"
        }
      },
      "engines": [],
      "syntax": "YEAR(date)",
      "description": "Returns the year specified by a given date."
    },
    {
      "name": "YEARFRAC",
      "slug": "YEARFRAC",
      "category": "date",
      "engineStatus": {
        "hyperformula": {
          "status": "partial",
          "via": "DV-0014"
        },
        "pycel": {
          "status": "partial",
          "via": "DV-0014"
        }
      },
      "engines": [],
      "syntax": "YEARFRAC(start_date, end_date, [day_count_convention])",
      "description": "Returns the number of years, including fractional years, between two dates using a specified day count convention."
    },
    {
      "name": "YIELD",
      "slug": "YIELD",
      "category": "financial",
      "engineStatus": {},
      "engines": [],
      "syntax": "YIELD(settlement, maturity, rate, price, redemption, frequency, [day_count_convention])",
      "description": "Calculates the annual yield of a security paying periodic interest, such as a US Treasury Bond, based on price."
    },
    {
      "name": "YIELDDISC",
      "slug": "YIELDDISC",
      "category": "financial",
      "engineStatus": {},
      "engines": [],
      "syntax": "YIELDDISC(settlement, maturity, price, redemption, [day_count_convention])",
      "description": "Calculates the annual yield of a discount (non-interest-bearing) security, based on price."
    },
    {
      "name": "YIELDMAT",
      "slug": "YIELDMAT",
      "category": "financial",
      "engineStatus": {},
      "engines": [],
      "syntax": "YIELDMAT(settlement, maturity, issue, rate, price, [day_count_convention])",
      "description": "The `YIELDMAT` function calculates the annual yield of a security paying interest at maturity, based on price."
    },
    {
      "name": "Z.TEST",
      "slug": "Z.TEST",
      "category": "statistical",
      "engineStatus": {
        "libreoffice": {
          "status": "missing",
          "via": "DV-0004"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0004"
        },
        "lattice": {
          "status": "partial",
          "via": "DV-0018"
        }
      },
      "engines": [],
      "syntax": "Z.TEST(data, value, [standard_deviation])",
      "description": "Returns the one-tailed P-value of a Z-test with standard distribution."
    },
    {
      "name": "ZTEST",
      "slug": "ZTEST",
      "category": "statistical",
      "engineStatus": {
        "ironcalc": {
          "status": "missing",
          "via": "DV-0005"
        },
        "pycel": {
          "status": "missing",
          "via": "DV-0005"
        }
      },
      "engines": [],
      "syntax": "Z.TEST(data, value, [standard_deviation])",
      "description": "Returns the one-tailed P-value of a Z-test with standard distribution."
    }
  ]
}