Formulas allow you to make simple and advanced calculations between different attributes within the same item in your folders.

This way, you can easily calculate anything from yearly budgets to financial records, various metrics, estimated costs, etc.

In Infinity, there are **11 types of formulas** that you can use:

- Date
- Financial
- Math
- Operator
- Engineering
- Text
- Statistical
- Logical
- Array
- Lookup
- Parser

Using formulas is first and foremost meant for the Table view, so to get started you’ll first want to create a new table.

Next, you’re going to have to add the corresponding attribute to your item.

Give your new formula attribute a name and then choose the function you need to use in the empty field below the name. Then, decide which attributes (columns) you need a calculation for.

When you’re done, click ‘Save’. The formula attribute will usually appear as a new column in your table.

Now, let’s say that we want to calculate a sum of e.g. our signups and logins from our Marketing Management board.

We would create a new formula attribute and then select SUM from the drop-down menu.

The syntax for this function is as follows: SUM(value1, [value2, ...])

In the brackets next to SUM add existing values (columns) from your table i.e. signups and logins. You can also enter other values that you have in mind. When you’re done, click ‘Save’.

You can edit the formula and change functions anytime you need to in the Edit section of your attribute.

{primary} NOTE: Formulas currently work with the following attributes:

text,date, andnumber.

Infinity supports **over 350 different functions** for formulas which you can apply to your items.

{primary} NOTE: When using a function with the word 'range' in it, make sure that you use ARGS2ARRAY function, as well.

**ABS**

**Syntax:** `ABS(value)`

**Explanation:** Returns the absolute value of a number.

**ACCRINT**

**Syntax:** `ACCRINT(issue, first_payment, settlement, rate, redemption, frequency, [day_count_convention])`

**Explanation:** Calculates the accrued interest of a security that has periodic payments.

**ACOS**

**Syntax:** `ACOS(value)`

**Explanation:** Returns the inverse cosine of a value, in radians.

**ACOSH**

**Syntax:** `ACOSH(value)`

**Explanation:** Returns the inverse hyperbolic cosine of a number.

**ACOT**

**Syntax:** `ACOT(value)`

**Explanation:** Returns the inverse cotangent of a value, in radians.

**ACOTH**

**Syntax:** `ACOTH(value)`

**Explanation:** Returns the inverse hyperbolic cotangent of a value, in radians. Must not be between -1 and 1, inclusive.

**ADD**

**Syntax:** `ADD(value1, value2)`

**Explanation:** Returns the sum of two numbers. Equivalent to the `+`

operator.

**AGGREGATE**

**Syntax:** `AGGREGATE(function, options, ref1, [ref2],...)`

**Explanation:** Returns an aggregate in a list or database.

**AND**

**Syntax:** `AND(logical_expression1, [logical_expression2, ...])`

**Explanation:** Returns true if all of the provided arguments are logically true, and false if any of the provided arguments are logically false.

**ARABIC**

**Syntax:** `ARABIC("roman_numeral")`

**Explanation:** Computes the value of a Roman numeral.

**ARGS2ARRAY**

**Syntax:** `ARGS2ARRAY(value1,value2,value3...)`

**Explanation:** Creates an array from all the given values.

**ASIN**

**Syntax:** `ASIN(value)`

**Explanation:** Returns the inverse sine of a value, in radians.

**ASINH**

**Syntax:** `ASINH(value)`

**Explanation:** Returns the inverse hyperbolic sine of a number.

**ATAN**

**Syntax:** `ATAN(value)`

**Explanation:** Returns the inverse tangent of a value, in radians.

**ATAN2**

**Syntax:** `ATAN2(x, y)`

**Explanation:** Returns the angle between the x-axis and a line segment from the origin (0,0) to specified coordinate pair (`x`

,`y`

), in radians.

**ATANH**

**Syntax:** `ATANH(value)`

**Explanation:** Returns the inverse hyperbolic tangent of a number.

**AVEDEV**

**Syntax:** `AVEDEV(value1, [value2, ...])`

**Explanation:** Calculates the average of the magnitudes of deviations of data from a dataset's mean.

**AVERAGE**

**Syntax:** `AVERAGE(value1, [value2, ...])`

**Explanation:** Returns the numerical average value in a dataset, ignoring text.

**AVERAGEA**

**Syntax:** `AVERAGEA(value1, [value2, ...])`

**Explanation:** Returns the numerical average value in a dataset.

**AVERAGEIF**

**Syntax:** `AVERAGEIF(criteria_range, criterion, [average_range])`

**Explanation:** Returns the average of a range depending on criteria.

**AVERAGEIFS**

**Syntax:** `AVERAGEIFS(average_range, criteria_range1, criterion1, [criteria_range2, criterion2, ...])`

**Explanation:** Returns the average of a range depending on multiple criteria.

**BASE**

**Syntax:** `BASE(value, base, [min_length])`

**Explanation:** Converts a number into a text representation in another base, for example, base 2 for binary.

**BESSELI**

**Syntax:** `BESSELI(x, n)`

**Explanation:** Returns the modified Bessel function In(x).

**BESSELJ**

**Syntax:** `BESSELJ(x, n)`

**Explanation:** Returns the Bessel function Jn(x).

**BESSELK**

**Syntax:** `BESSELK(x, n)`

**Explanation:** Returns the modified Bessel function Kn(x).

**BESSELY**

**Syntax:** `BESSELY(x, n)`

**Explanation:** Returns the Bessel function Yn(x).

**BETA.DIST**

**Syntax:** `BETA.DIST(value, alpha, beta, cumulative, lower_bound, upper_bound)`

**Explanation:** Returns the probability of a given value as defined by the beta distribution function.

**BETA.INV**

**Syntax:** `BETA.INV(probability, alpha, beta, lower_bound, upper_bound)`

**Explanation:** Returns the value of the inverse beta distribution function for a given probability.

**BETADIST**

**Syntax:** `BETADIST(value, alpha, beta, cumulative, lower_bound, upper_bound)`

**Explanation:** Returns the probability of a given value as defined by the beta distribution function.

**BETAINV**

**Syntax:** `BETAINV(probability, alpha, beta, lower_bound, upper_bound)`

**Explanation:** Returns the value of the inverse beta distribution function for a given probability.

**BIN2DEC**

**Syntax:** `BIN2DEC(signed_binary_number)`

**Explanation:** Converts a signed binary number to decimal format.

**BIN2HEX**

**Syntax:** `BIN2HEX(signed_binary_number, [significant_digits])`

**Explanation:** Converts a signed binary number to signed hexadecimal format.

**BIN2OCT**

**Syntax:** `BIN2OCT(signed_binary_number, [significant_digits])`

**Explanation:** Converts a signed binary number to signed octal format.

**BINOM.DIST**

**Syntax:** `BINOM.DIST(num_successes, num_trials, prob_success, cumulative)`

**Explanation:** 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.

**BINOM.DIST.RANGE**

**Syntax:** `BINOM.DIST.RANGE(trials, probability_s, number_s, [number_s2])`

**Explanation:** Returns the probability of a trial result using a binomial distribution.

**BINOM.INV**

**Syntax:** `BINOM.INV(num_trials, prob_success, target_prob)`

**Explanation:** Returns the smallest value for which the cumulative binomial distribution is greater than or equal to a criterion value.

**BINOMDIST**

**Syntax:** `BINOMDIST(num_successes, num_trials, prob_success, cumulative)`

**Explanation:** 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.

**BITAND**

**Syntax:** `BITAND(value1, value2)`

**Explanation:** Bitwise boolean AND of two numbers.

**BITLSHIFT**

**Syntax:** `BITLSHIFT(value, shift_amount)`

**Explanation:** Shifts the bits of the input a certain number of places to the left.

**BITOR**

**Syntax:** `BITOR(value1, value2)`

**Explanation:** Bitwise boolean OR of 2 numbers.

**BITRSHIFT**

**Syntax:** `BITRSHIFT(value, shift_amount)`

**Explanation:** Shifts the bits of the input a certain number of places to the right.

**BITXOR**

**Syntax:** `BITXOR(value1, value2)`

**Explanation:** Bitwise XOR (exclusive OR) of 2 numbers.

**CEILING**

**Syntax:** `CEILING(value, [factor])`

**Explanation:** Rounds a number up to the nearest integer multiple of specified significance.

**CEILINGMATH**

**Syntax:** `CEILINGMATH(number, [significance], [mode])`

**Explanation:** Rounds a number up to the nearest integer multiple of specified significance, with negative numbers rounding toward or away from 0 depending on the mode.

**CEILINGPRECISE**

**Syntax:** `CEILINGPRECISE(number, [significance])`

**Explanation:** Rounds a number up to the nearest integer multiple of specified significance. If the number is positive or negative, it is rounded up.

**CHAR**

**Syntax:** `CHAR(table_number)`

**Explanation:** Convert a number into a character according to the current Unicode table.

**CHISQ.DIST**

**Syntax:** `CHISQ.DIST(x, degrees_freedom, cumulative)`

**Explanation:** Calculates the left-tailed chi-squared distribution, often used in hypothesis testing.

**CHISQ.DIST.RT**

**Syntax:** `CHISQ.DIST.RT(x, degrees_freedom)`

**Explanation:** Calculates the right-tailed chi-squared distribution, which is commonly used in hypothesis testing.

**CHISQ.INV**

**Syntax:** `CHISQ.INV(probability, degrees_freedom)`

**Explanation:** Calculates the inverse of the left-tailed chi-squared distribution.

**CHISQ.INV.RT**

**Syntax:** `CHISQ.INV.RT(probability, degrees_freedom)`

**Explanation:** Calculates the inverse of the right-tailed chi-squared distribution.

**CHOOSE**

**Syntax:** `CHOOSE(index, choice1, [choice2, ...])`

**Explanation:** Returns an element from a list of choices based on index.

**CLEAN**

**Syntax:** `CLEAN(text)`

**Explanation:** Returns the text with the non-printable ASCII characters removed.

**CODE**

**Syntax:** `CODE(string)`

**Explanation:** Returns the numeric Unicode map value of the first character in the string provided.

**COMBIN**

**Syntax:** `COMBIN(n, k)`

**Explanation:** Returns the number of ways to choose some number of objects from a pool of a given size of objects.

**COMBINA**

**Syntax:** `COMBINA(n, k)`

**Explanation:** Returns the number of ways to choose some number of objects from a pool of a given size of objects, including ways that choose the same object multiple times.

**COMPLEX**

**Syntax:** `COMPLEX(real_part, imaginary_part, [suffix])`

**Explanation:** Creates a complex number given real and imaginary coefficients.

**CONCATENATE**

**Syntax:** `CONCATENATE(string1, [string2, ...])`

**Explanation:** Appends strings to one another.

**CONFIDENCE**

**Syntax:** `CONFIDENCE(alpha, standard_deviation, pop_size)`

**Explanation:** Calculates the width of half the confidence interval for a normal distribution.

**CONFIDENCE.NORM**

**Syntax:** `CONFIDENCE.NORM(alpha, standard_deviation, pop_size)`

**Explanation:** Calculates the width of half the confidence interval for a normal distribution.

**CONFIDENCE.T**

**Syntax:** `CONFIDENCE.T(alpha, standard_deviation, size)`

**Explanation:** Calculates the width of half the confidence interval for a Student’s t-distribution.

**CONVERT**

**Syntax:** `CONVERT(value, start_unit, end_unit)`

**Explanation:** Converts a numeric value to a different unit of measure.

**CORREL**

**Syntax:** `CORREL(data_y, data_x)`

**Explanation:** Calculates r, the Pearson product-moment correlation coefficient of a dataset.

**COS**

**Syntax:** `COS(angle)`

**Explanation:** Returns the cosine of an angle provided in radians.

**COSH**

**Syntax:** `COSH(value)`

**Explanation:** Returns the hyperbolic cosine of any real number.

**COT**

**Syntax:** `COT(angle)`

**Explanation:** Returns the cotangent of an angle provided in radians.

**COTH**

**Syntax:** `COTH(value)`

**Explanation:** Returns the hyperbolic cotangent of any real number.

**COUNT**

**Syntax:** `COUNT(value1, [value2, ...])`

**Explanation:** Returns a count of the number of numeric values in a dataset.

**COUNTA**

**Syntax:** `COUNTA(value1, [value2, ...])`

**Explanation:** Returns a count of the number of values in a dataset.

**COUNTBLANK**

**Syntax:** `COUNTBLANK(range)`

**Explanation:** Returns the number of empty values in a given range.

**COUNTIF**

**Syntax:** `COUNTIF(range, criterion)`

**Explanation:** Returns a conditional count across a range.

**COUNTIFS**

**Syntax:** `COUNTIFS(criteria_range1, criterion1, [criteria_range2, criterion2, ...])`

**Explanation:** Returns the count of a range depending on multiple criteria.

**COUNTIN**

**Syntax:** `COUNTIN(values_array,value)`

**Explanation:** Returns the number of chosen values in the given array.

**COUNTUNIQUE**

**Syntax:** `COUNTUNIQUE(value1, [value2, ...])`

**Explanation:** Counts the number of unique values in a list of specified values and ranges.

**COVARIANCE.P**

**Syntax:** `COVARIANCE.P(data_y, data_x)`

**Explanation:** Calculates the covariance of a dataset.

**COVARIANCE.S**

**Syntax:** `COVARIANCE.S(data_y, data_x)`

**Explanation:** Calculates the covariance of a dataset, where the dataset is a sample of the total population.

**CSC**

**Syntax:** `CSC(angle)`

**Explanation:** Returns the cosecant of an angle provided in radians.

**CSCH**

**Syntax:** `CSCH(value)`

**Explanation:** The CSCH function returns the hyperbolic cosecant of any real number.

**CUMIPMT**

**Syntax:** `CUMIPMT(rate, number_of_periods, present_value, first_period, last_period, end_or_beginning)`

**Explanation:** Calculates the cumulative interest over a range of payment periods for an investment based on constant-amount periodic payments and a constant interest rate.

**CUMPRINC**

**Syntax:** `CUMPRINC(rate, number_of_periods, present_value, first_period, last_period, end_or_beginning)`

**Explanation:** 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.

**DATE**

**Syntax:** `DATE(year, month, day)`

**Explanation:** Converts a year, month, and day into a date.

**DATEVALUE**

**Syntax:** `DATEVALUE(date_string)`

**Explanation:** Converts a provided date string in a known format to a date value.

**DAY**

**Syntax:** `DAY(date)`

**Explanation:** Returns the day of the month that a specific date falls on, in numeric format.

**DAYS**

**Syntax:** `DAYS(end_date,start_date)`

**Explanation:** The DAYS function returns the number of days between two dates.

**DAYS360**

**Syntax:** `DAYS360(start_date, end_date, [method])`

**Explanation:** Returns the difference between two days based on the 360-day year used in some financial interest calculations.

**DB**

**Syntax:** `DB(cost, salvage, life, period, [month])`

**Explanation:** Calculates the depreciation of an asset for a specified period using the arithmetic declining balance method.

**DDB**

**Syntax:** `DDB(cost, salvage, life, period, [factor])`

**Explanation:** Calculates the depreciation of an asset for a specified period using the double-declining balance method.

**DEC2BIN**

**Syntax:** `DEC2BIN(decimal_number, [significant_digits])`

**Explanation:** Converts a decimal number to signed binary format.

**DEC2HEX**

**Syntax:** `DEC2HEX(decimal_number, [significant_digits])`

**Explanation:** Converts a decimal number to signed hexadecimal format.

**DEC2OCT**

**Syntax:** `DEC2OCT(decimal_number, [significant_digits])`

**Explanation:** Converts a decimal number to signed octal format.

**DECIMAL**

**Syntax:** `DECIMAL(value, base)`

**Explanation:** Converts the text representation of a number in another base, to base 10 (decimal).

**DEGREES**

**Syntax:** `DEGREES(angle)`

**Explanation:** Converts an angle value in radians to degrees.

**DELTA**

**Syntax:** `DELTA(number1, [number2])`

**Explanation:** Converts an angle value in radians to degrees.

**DEVSQ**

**Syntax:** `DEVSQ(value1, value2)`

**Explanation:** Calculates the sum of squares of deviations based on a sample.

**DIVIDE**

**Syntax:** `DIVIDE(dividend, divisor)`

**Explanation:** Returns one number divided by another. Equivalent to the `/`

operator.

**DOLLARDE**

**Syntax:** `DOLLARDE(fractional_price, unit)`

**Explanation:** Converts a price quotation given as a decimal fraction into a decimal value.

**DOLLARFR**

**Syntax:** `DOLLARFR(decimal_price, unit)`

**Explanation:** Converts a price quotation given as a decimal value into a decimal fraction.

**E**

**Syntax:** `No syntax - just E`

**Explanation:** /

**EDATE**

**Syntax:** `EDATE(start_date, months)`

**Explanation:** Returns a date a specified number of months before or after another date.

**EFFECT**

**Syntax:** `EFFECT(nominal_rate, periods_per_year)`

**Explanation:** Calculates the annual effective interest rate given the nominal rate and number of compounding periods per year.

**EOMONTH**

**Syntax:** `EOMONTH(start_date, months)`

**Explanation:** Returns a date representing the last day of a month which falls a specified number of months before or after another date.

**EQ**

**Syntax:** `EQ(value1, value2)`

**Explanation:** Returns "TRUE" if two specified values are equal and "FALSE" otherwise. Equivalent to the "=" operator.

**ERF**

**Syntax:** `ERF(lower_bound, [upper_bound])`

**Explanation:** Returns "TRUE" if two specified values are equal and "FALSE" otherwise. Equivalent to the "=" operator.

**ERFC**

**Syntax:** `ERFC(z)`

**Explanation:** The ERFC function returns the complementary Gauss error function of a value.

**EVEN**

**Syntax:** `EVEN(value)`

**Explanation:** Rounds a number up to the nearest even integer.

**EXACT**

**Syntax:** `EXACT(string1, string2)`

**Explanation:** Tests whether two strings are identical.

**EXP**

**Syntax:** `EXP(exponent)`

**Explanation:** Returns Euler's number, e (~2.718) raised to a power.

**EXPON.DIST**

**Syntax:** `EXPON.DIST(x, lambda, cumulative)`

**Explanation:** Returns the value of the exponential distribution function with a specified lambda at a specified value

**EXPONDIST**

**Syntax:** `EXPONDIST(x, lambda, cumulative)`

**Explanation:** Returns the value of the exponential distribution function with a specified lambda at a specified value

**F.DIST**

**Syntax:** `F.DIST(x, degrees_freedom1, degrees_freedom2, cumulative)`

**Explanation:** Calculates the left-tailed F probability distribution (degree of diversity) for two data sets with given input x. Alternately called Fisher-Snedecor distribution or Snedecor's F distribution.

**F.DIST.RT**

**Syntax:** `F.DIST.RT(x, degrees_freedom1, degrees_freedom2)`

**Explanation:** The F.DIST.RT function calculates the right-tailed F probability distribution (degree of diversity) for two data sets with given input x. Alternately called Fisher-Snedecor distribution or Snedecor's F distribution.

**F.INV**

**Syntax:** `F.INV(probability, degrees_freedom1, degrees_freedom2)`

**Explanation:** Calculates the inverse of the left-tailed F probability distribution. Also called the Fisher-Snedecor distribution or Snedecor’s F distribution.

**F.INV.RT**

**Syntax:** `F.INV.RT(probability, degrees_freedom1, degrees_freedom2)`

**Explanation:** The F.INV.RT function calculates the inverse of the right-tailed F probability distribution. Also called the Fisher-Snedecor distribution or Snedecor’s F distribution.

**FACT**

**Syntax:** `FACT(value)`

**Explanation:** The FACT function returns the factorial of a number.

**FACTDOUBLE**

**Syntax:** `FACTDOUBLE(value)`

-Explanation: Returns the "double factorial" of a number.

**FALSE**

**Syntax:** `FALSE()`

**Explanation:** Returns the logical value `FALSE`

.

**FDIST**

**Syntax:** `FDIST (x, degrees_freedom1, degrees_freedom2)`

**Explanation:** The FDIST function calculates the right-tailed F probability distribution (degree of diversity) for two data sets with given input x. Alternately called Fisher-Snedecor distribution or Snedecor's F distribution.

**FDISTRT**

**Syntax:** `FDISTRT(x, degrees_freedom1, degrees_freedom2)`

**Explanation:** The FDISTRT function calculates the right-tailed F probability distribution (degree of diversity) for two data sets with given input x. Alternately called Fisher-Snedecor distribution or Snedecor's F distribution.

**FIND**

**Syntax:** `FIND(search_for, text_to_search, [starting_at])`

**Explanation:** Returns the position at which a string is first found within text, case-sensitive.

**FINV**

**Syntax:** `FINV(probability, degrees_freedom1, degrees_freedom2)`

**Explanation:** The FINV function calculates the inverse of the right-tailed F probability distribution. Also called the Fisher-Snedecor distribution or Snedecor’s F distribution.

**FINVRT**

**Syntax:** `FINVRT(probability, degrees_freedom1, degrees_freedom2)`

**Explanation:** The FINVRT function calculates the inverse of the right-tailed F probability distribution. Also called the Fisher-Snedecor distribution or Snedecor’s F distribution.

**FISHER**

**Syntax:** `FISHER(value)`

**Explanation:** Returns the Fisher transformation of a specified value.

**FISHERINV**

**Syntax:** `FISHERINV(value)`

**Explanation:** Returns the inverse Fisher transformation of a specified value.

**FLOOR**

**Syntax:** `FLOOR(value, [factor])`

**Explanation:** The FLOOR function rounds a number down to the nearest integer multiple of specified significance.

**FORECAST**

**Syntax:** `FORECAST(x, data_y, data_x)`

**Explanation:** Calculates the expected y-value for a specified x based on a linear regression of a dataset.

**FREQUENCY**

**Syntax:** `FREQUENCY(data, classes)`

**Explanation:** Calculates the frequency distribution of a one-column array into specified classes.

**FV**

**Syntax:** `FV(rate, number_of_periods, payment_amount, [present_value], [end_or_beginning])`

**Explanation:** The FV function calculates the future value of an annuity investment based on constant-amount periodic payments and a constant interest rate.

**FVSCHEDULE**

**Syntax:** `FVSCHEDULE(principal, rate_schedule)`

**Explanation:** The FVSCHEDULE function calculates the future value of some principal based on a specified series of potentially varying interest rates.

**GAMMA**

**Syntax:** `GAMMA(number)`

**Explanation:The** GAMMA function returns the Gamma function evaluated at the specified value.

**GAMMA.DIST**

**Syntax:** `GAMMA.DIST(x, alpha, beta, cumulative)`

**Explanation:** The GAMMA.DIST function calculates the gamma distribution, a 2-parameter continuous probability distribution.

**GAMMA.INV**

**Syntax:** `GAMMA.INV(probability, alpha, beta)`

**Explanation:** The GAMMA.INV function returns the value of the inverse gamma cumulative distribution function for the specified probability, alpha, and beta parameters.

**GAMMALN**

**Syntax:** `GAMMALN(value)`

**Explanation:** Returns the logarithm of a specified Gamma function, base e (Euler's number).

**GAMMALN.PRECISE**

**Syntax:** `GAMMALN.PRECISE(value)`

**Explanation:** Returns the logarithm of a specified Gamma function, base e (Euler's number).

**GAUSS**

**Syntax:** `GAUSS(z)`

**Explanation:** 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. A normal distribution is also commonly known as a Gaussian distribution, from which this function gets its name.

**GCD**

**Syntax:** `GCD(value1, value2)`

**Explanation:** Returns the greatest common divisor of one or more integers.

**GEOMEAN**

**Syntax:** `GEOMEAN(value1, value2)`

**Explanation:** Calculates the geometric mean of a dataset.

**GESTEP**

**Syntax:** `GESTEP(value, [step])`

**Explanation:** The GESTEP function returns 1 if the rate is strictly greater than or equal to the provided step value, or 0 otherwise. If no step value is provided, then the default value of 0 is used.

**GROWTH**

**Syntax:** `GROWTH(known_data_y, [known_data_x], [new_data_x], [b])`

**Explanation:** Given partial data about an exponential growth trend, fits an ideal exponential growth trend and/or predicts further values.

**GTE**

**Syntax:** `GTE(value1, value2)`

**Explanation:** Returns `TRUE`

if the first argument is greater than or equal to the second, and `FALSE`

otherwise. Equivalent to the `>=`

operator

**HARMEAN**

**Syntax:** `HARMEAN(value1, value2)`

**Explanation:** Calculates the harmonic mean of a dataset.

**HEX2BIN**

**Syntax:** `HEX2BIN(signed_hexadecimal_number, [significant_digits])`

**Explanation:** The HEX2BIN function converts a signed hexadecimal number to signed binary format.

**HEX2DEC**

**Syntax:** `HEX2DEC(signed_hexadecimal_number)`

**Explanation:** The HEX2DEC function converts a signed hexadecimal number to decimal format.

**HEX2OCT**

**Syntax:** `HEX2OCT(signed_hexadecimal_number, significant_digits)`

**Explanation:** The HEX2OCT function converts a signed hexadecimal number to signed octal format.

**HOUR**

**Syntax:** `HOUR(time)`

**Explanation:** Returns the hour component of a specific time, in numeric format.

**HTML2TEXT**

**Syntax:** `HTML2TEXT(html_string)`

**Explanation:** Converts an HTML string to text

**HYPGEOM.DIST**

**Syntax:** `HYPGEOM.DIST(number_of_successes_drawn, population_size, number_of_successes_in_population, number_of_items_drawn_from_a_population)`

**Explanation:** The hypergeometric distribution is a discrete probability distribution that describes the probability of {\displaystyle k}k successes (random draws for which the object drawn has a specified feature) in {\displaystyle n}n draws, without replacement, from a finite population of size {\displaystyle N}N that contains exactly {\displaystyle K}K objects with that feature, wherein each draw is either a success or a failure. In contrast, the binomial distribution describes the probability of {\displaystyle k}k successes in {\displaystyle n}n draws with replacement.

**HYPGEOMDIST**

**Syntax:** `HYPGEOMDIST(number_of_successes_drawn, population_size, number_of_successes_in_population, number_of_items_drawn_from_a_population)`

**Explanation:** The hypergeometric distribution is a discrete probability distribution that describes the probability of {\displaystyle k}k successes (random draws for which the object drawn has a specified feature) in {\displaystyle n}n draws, without replacement, from a finite population of size {\displaystyle N}N that contains exactly {\displaystyle K}K objects with that feature, wherein each draw is either a success or a failure. In contrast, the binomial distribution describes the probability of {\displaystyle k}k successes in {\displaystyle n}n draws with replacement.

**IF**

**Syntax:** `IF(logical_expression, value_if_true, value_if_false)`

**Explanation:** Returns one value if a logical expression is `TRUE`

and another if it is `FALSE`

.

**IMABS**

**Syntax:** `IMABS(number)`

**Explanation:** Returns the absolute value of a complex number.

**IMAGINARY**

**Syntax:** `IMAGINARY(complex_number)`

**Explanation:** Returns the imaginary coefficient of a complex number.

**IMARGUMENT**

**Syntax:** `IMARGUMENT(number)`

**Explanation:** The IMARGUMENT function returns the angle (also known as the argument, or theta) of the given complex number in radians. This is the angle θ such that, for any complex number in Cartesian form x + yi, x + yi = reiθ where r is the magnitude of the number.

**IMCONJUGATE**

**Syntax:** `IMCONJUGATE(number)`

**Explanation:** Returns the complex conjugate of a number.

**IMCOS**

**Syntax:** `IMCOS(number)`

**Explanation:** The IMCOS function returns the cosine of the given complex number. For example, a given complex number "x+yi" returns "cos(x+yi).

**IMCOSH**

**Syntax:** `IMCOSH(complex_number)`

**Explanation:** The IMCOSH function returns the cosine of the given complex number. For example, a given complex number "x+yi" returns "cos(x+yi).

**IMCOT**

**Syntax:** `IMCOT(number)`

**Explanation:** The IMCOT function returns the cotangent of the given complex number. For example, a given complex number "x+yi" returns "cot(x+yi)."

**IMCSC**

**Syntax:** `IMCSC(number)`

**Explanation:** The IMCSC function returns the cosecant of the given complex number. For example, a given complex number "x+yi" returns "csc(x+yi)."

**IMCSCH**

**Syntax:** `IMCSCH(number)`

**Explanation:** The IMCSCH function returns the hyperbolic cosecant of the given complex number. For example, a given complex number "x+yi" returns "csch(x+yi)."

**IMDIV**

**Syntax:** `IMDIV(dividend, divisor)`

**Explanation:** Returns one complex number divided by another.

**IMEXP**

**Syntax:** `IMEXP(exponent)`

**Explanation:** The IMEXP function returns Euler's number, e (~2.718) raised to a complex power.

**IMLN**

**Syntax:** `IMLN(complex_value)`

**Explanation:** The IMLN function returns the logarithm of a complex number, base e (Euler's number).

**IMLOG10**

**Syntax:** `IMLOG10(value)`

**Explanation:** The IMLOG10 function returns the logarithm of a complex number with base 10.

**IMLOG2**

**Syntax:** `IMLOG2(value)`

**Explanation:** The IMLOG2 function returns the logarithm of a complex number with base 2.

**IMPOWER**

**Syntax:** `IMPOWER(complex_base, exponent)`

**Explanation:** The IMPOWER function returns a complex number raised to a power.

**IMPRODUCT**

**Syntax:** `IMPRODUCT(factor1, [factor2, ...])`

**Explanation:** Returns the result of multiplying a series of complex numbers together.

**IMREAL**

**Syntax:** `IMREAL(complex_number)`

**Explanation:** Returns the real coefficient of a complex number.

**IMSEC**

**Syntax:** `IMSEC(number)`

**Explanation:** The IMSEC function returns the secant of the given complex number. For example, a given complex number "x+yi" returns "sec(x+yi)."

**IMSECH**

**Syntax:** `IMSECH(number)`

**Explanation:** The IMSECH function returns the hyperbolic secant of the given complex number. For example, a given complex number "x+yi" returns "sech(x+yi).

**IMSIN**

**Syntax:** `IMSIN (number)`

**Explanation:** The IMSIN function returns the sine of the given complex number. For example, a given complex number "x+yi" returns "sin(x+yi).

**IMSINH**

**Syntax:** `IMSINH(number)`

**Explanation:** The IMSINH function returns the hyperbolic sine of the given complex number. For example, a given complex number "x+yi" returns "sinh(x+yi).

**IMSQRT**

**Syntax:** `IMSQRT(complex_number)`

**Explanation:** The IMSQRT function computes the square root of a complex number.

**IMSUB**

**Syntax:** `IMSUB(first_number, second_number)`

**Explanation:** Returns the difference between two complex numbers.

**IMSUM**

**Syntax:** `IMSUM(value1, [value2, ...])`

**Explanation:** Returns the sum of a series of complex numbers.

**IMTAN**

**Syntax:** `IMTAN(number)`

**Explanation:** The IMTAN function returns the tangent of the given complex number. For example, a given complex number "x+yi" returns "tan(x+yi)."

**INT**

**Syntax:** `INT(value)`

**Explanation:** Rounds a number down to the nearest integer that is less than or equal to it.

**INTERCEPT**

**Syntax:** `INTERCEPT(data_y, data_x)`

**Explanation:** Calculates the y-value at which the line resulting from linear regression of a dataset will intersect the y-axis (x=0).

**IRR**

**Syntax:** `IRR(cashflow_amounts, [rate_guess])`

**Explanation:** Calculates the internal rate of return on an investment based on a series of periodic cash flows.

**ISBINARY**

**Syntax:** `ISBINARY(number)`

**Explanation:** Returns "true" if the number is binary and "false" if the number is not binary.

**ISBLANK**

**Syntax:** `ISBLANK(value)`

**Explanation:** Checks whether the referenced attribute value is empty.

**ISEVEN**

**Syntax:** `ISEVEN(value)`

**Explanation:** Checks whether the provided value is even.

**ISLOGICAL**

**Syntax:** `ISLOGICAL(value)`

**Explanation:** Checks whether a value is `TRUE`

or `FALSE`

.

**ISNONTEXT**

**Syntax:** `ISNONTEXT(value)`

**Explanation:** Checks whether a value is non-textual.

**ISNUMBER**

**Syntax:** `ISNUMBER(value)`

**Explanation:** Checks whether a value is a number.

**ISODD**

**Syntax:** `ISODD(value)`

**Explanation:** Checks whether the provided value is odd.

**ISOWEEKNUM**

**Syntax:** `ISOWEEKNUM(date)`

**Explanation:** Returns the number of the ISO (International Organization for Standardization) week of the year where the provided date falls.

**ISPMT**

**Syntax:** `ISPMT(rate, period, number_of_periods, present_value)`

**Explanation:** The ISPMT function calculates the interest paid during a particular period of an investment.

**ISTEXT**

**Syntax:** `ISTEXT(value)`

**Explanation:** Checks whether a value is text.

**JOIN**

**Syntax:** `JOIN(delimiter, value_or_array1, [value_or_array2, ...])`

**Explanation:** Concatenates the elements of one or more one-dimensional arrays using a specified delimiter.

**KURT**

**Syntax:** `KURT(value1, value2)`

**Explanation:** Calculates the kurtosis of a dataset, which describes the shape, and in particular the "peakedness" of that dataset.

**LARGE**

**Syntax:** `LARGE(data, n)`

**Explanation:** Returns the nth largest element from a data set, where n is user-defined.

**LCM**

**Syntax:** `LCM(value1, value2)`

**Explanation:** Returns the least common multiple of one or more integers.

**LEFT**

**Syntax:** `LEFT(string, [number_of_characters])`

**Explanation:** Returns a substring from the beginning of a specified string.

**LEN**

**Syntax:** `LEN(text)`

**Explanation:** Returns the length of a string.

**LINEST**

**Syntax:** `LINEST(known_data_y, [known_data_x], [calculate_b], [verbose])`

**Explanation:** Given partial data about a linear trend, calculates various parameters about the ideal linear trend using the least-squares method.

**LN**

**Syntax:** `LN(value)`

**Explanation:** Returns the logarithm of a number, base e (Euler's number).

**LOG**

**Syntax:** `LOG(value, base)`

**Explanation:** Returns the logarithm of a number given a base.

**LOG10**

**Syntax:** `LOG10(value)`

**Explanation:** Returns the logarithm of a number, base 10.

**LOGEST**

**Syntax:** `LOGEST(known_data_y, [known_data_x], [b], [verbose])`

**Explanation:** Given partial data about an exponential growth curve, calculates various parameters about the best fit ideal exponential growth curve.

**LOGNORM.DIST**

**Syntax:** `LOGNORM.DIST(x, mean, standard_deviation)`

**Explanation:** Returns the value of the log-normal cumulative distribution with given mean and standard deviation at a specified value.

**LOGNORM.INV**

**Syntax:** `LOGNORM.INV(x, mean, standard_deviation)`

**Explanation:** Returns the value of the inverse log-normal cumulative distribution with given mean and standard deviation at a specified value.

**LOGNORMDIST**

**Syntax:** `LOGNORMDIST(x, mean, standard_deviation)`

**Explanation:** Returns the value of the log-normal cumulative distribution with given mean and standard deviation at a specified value

**LOGNORMINV**

**Syntax:** `LOGNORMINV(probability, mean, standard_dev)`

**Explanation:** Returns the inverse of the lognormal cumulative distribution function of x, where ln(x) is normally distributed with parameters Mean and Standard_dev. If p = LOGNORM.DIST(x,...) then LOGNORM.INV(p,...) = x.

**LOWER**

**Syntax:** `LOWER(text)`

**Explanation:** Converts a specified string to lowercase.

**LT**

**Syntax:** `LT(value1, value2)`

**Explanation:** Returns `TRUE`

if the first argument is strictly less than the second, and `FALSE`

otherwise. Equivalent to the `<`

operator.

**LTE**

**Syntax:** `LTE(value1, value2)`

**Explanation:** Returns `TRUE`

if the first argument is less than or equal to the second, and `FALSE`

otherwise. Equivalent to the `<=`

operator.

**MAX**

**Syntax:** `MAX(value1, [value2, ...])`

**Explanation:** Returns the maximum value in a numeric dataset.

**MAXA**

**Syntax:** `MAXA(value1, value2)`

**Explanation:** Returns the maximum numeric value in a dataset.

**MEDIAN**

**Syntax:** `MEDIAN(value1, [value2, ...])`

**Explanation:** Returns the median value in a numeric dataset.

**MID**

**Syntax:** `MID(string, starting_at, extract_length)`

**Explanation:** Returns a segment of a string.

**MIN**

**Syntax:** `MIN(value1, [value2, ...])`

**Explanation:** Returns the minimum value in a numeric dataset.

**MINA**

**Syntax:** `MINA(value1, value2)`

**Explanation:** Returns the minimum numeric value in a dataset

**MINUS**

**Syntax:** `MINUS(value1, value2)`

**Explanation:** Returns the difference of two numbers. Equivalent to the `-`

operator.

**MINUTE**

**Syntax:** `MINUTE(time)`

**Explanation:** Returns the minute component of a specific time, in numeric format.

**MIRR**

**Syntax:** `MIRR(cashflow_amounts, financing_rate, reinvestment_return_rate)`

**Explanation:** 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.

**MOD**

**Syntax:** `MOD(dividend, divisor)`

**Explanation:** Returns the result of the modulo operator, the remainder after a division operation.

**MODE.MULT**

**Syntax:** `MODE.MULT(value1, value2)`

**Explanation:** Returns the most commonly occurring values in a dataset.

**MODE.SNGL**

**Syntax:** `MODE.SNGL(value1, [value2, ...])`

**Explanation:** Returns the most frequently occurring, or repetitive, value in an array or range of data.

**MODEMULT**

**Syntax:** `MODEMULT((number1,[number2],...)`

**Explanation:** Returns a vertical array of the most frequently occurring, or repetitive values in an array or range of data.

**MODESNGL**

**Syntax:** `MODESNGL(number1,[number2],...)`

**Explanation:** Returns the most frequently occurring, or repetitive, value in an array or range of data.

**MONTH**

**Syntax:** `MONTH(date)`

**Explanation:** Returns the month of the year a specific date falls in, in numeric format.

**MROUND**

**Syntax:** `MROUND(value, factor)`

**Explanation:** Rounds one number to the nearest integer multiple of another.

**MULTINOMIAL**

**Syntax:** `MULTINOMIAL(value1, value2)`

**Explanation:** Returns the factorial of the sum of values divided by the product of the values' factorials.

**MULTIPLY**

**Syntax:** `MULTIPLY(factor1, factor2)`

**Explanation:** Returns the product of two numbers. Equivalent to the `*`

operator.

**NE**

**Syntax:** `NE(value1, value2)`

**Explanation:** Returns `TRUE`

if two specified values are not equal and `FALSE`

otherwise. Equivalent to the `<>`

operator.

**NEGBINOM.DIST**

**Syntax:** `NEGBINOM.DIST(num_failures, num_successes, prob_success)`

**Explanation:** Calculates the probability of drawing a certain number of failures before a certain number of successes given a probability of success in independent trials.

**NEGBINOMDIST**

**Syntax:** `NEGBINOMDIST(num_failures, num_successes, prob_success)`

**Explanation:** Calculates the probability of drawing a certain number of failures before a certain number of successes given a probability of success in independent trials.

**NETWORKDAYS**

**Syntax:** `NETWORKDAYS(start_date, end_date, [holidays])`

**Explanation:** Returns the number of net working days between two provided days.

**NOMINAL**

**Syntax:** `NOMINAL(effective_rate, periods_per_year)`

**Explanation:** Calculates the annual nominal interest rate given the effective rate and number of compounding periods per year.

**NORM.DIST**

**Syntax:** `NORM.DIST(x, mean, standard_deviation, cumulative)`

**Explanation:** Returns the value of the normal distribution function (or normal cumulative distribution function) for a specified value, mean, and standard deviation.

**NORM.INV**

**Syntax:** `NORM.INV(x, mean, standard_deviation)`

**Explanation:** Returns the value of the inverse normal distribution function for a specified value, mean, and standard deviation.

**NORM.S.DIST**

**Syntax:** `NORM.S.DIST(x)`

Explanation: Returns the value of the standard normal cumulative distribution function for a specified value.

**NORM.S.INV**

**Syntax:** `NORM.S.INV(x)`

**Explanation:** Returns the value of the inverse standard normal distribution function for a specified value.

**NORMDIST**

**Syntax:** `NORMDIST(x, mean, standard_deviation, cumulative)`

**Explanation:** Returns the value of the normal distribution function (or normal cumulative distribution function) for a specified value, mean, and standard deviation.

**NORMINV**

**Syntax:** `NORMINV(x, mean, standard_deviation)`

**Explanation:** Returns the value of the inverse normal distribution function for a specified value, mean, and standard deviation

**NORMSDIST**

**Syntax:** `NORMSDIST(x)`

**Explanation:** Returns the value of the standard normal cumulative distribution function for a specified value.

**NORMSINV**

**Syntax:** `NORMSINV(x)`

**Explanation:** Returns the value of the inverse standard normal distribution function for a specified value.

**NOT**

**Syntax:** `NOT(logical_expression)`

**Explanation:** Returns the opposite of a logical value - `NOT(TRUE)`

returns `FALSE`

; `NOT(FALSE)`

returns `TRUE`

.

**NOW**

**Syntax:** `NOW()`

**Explanation:** Returns the current date and time as a date value.

**NPER**

**Syntax:** `NPER(rate, payment_amount, present_value, [future_value], [end_or_beginning])`

**Explanation:** Calculates the number of payment periods for an investment based on constant-amount periodic payments and a constant interest rate.

**NPV**

**Syntax:** `NPV(array)`

**Explanation:** Returns true or false if the value is a type of number.

**NUMBERS**

**Syntax:** `NUMBERS(values)`

**Explanation:** Creates an array of all the given values which are numbers.

**OCT2BIN**

**Syntax:** `OCT2BIN(signed_octal_number, [significant_digits])`

**Explanation:** Converts a signed octal number to signed binary format.

**OCT2DEC**

**Syntax:** `OCT2DEC(signed_octal_number)`

**Explanation:** The OCT2DEC function converts a signed octal number to decimal format.

**OCT2HEX**

**Syntax:** `OCT2HEX(signed_octal_number, [significant_digits])`

**Explanation:** Converts a signed octal number to signed hexadecimal format.

**ODD**

- ODD(value)

**Explanation:**Rounds a number up to the nearest odd integer.

**OR**

**Syntax:** `OR(logical_expression1, [logical_expression2, ...])`

**Explanation:** Returns true if any of the provided arguments are logically true, and false if all of the provided arguments are logically false.

**PDURATION**

**Syntax:** `PDURATION(rate, present_value, future_value)`

**Explanation:** Returns the number of periods for an investment to reach a specific value at a given rate.

**PEARSON**

**Syntax:** `PEARSON(data_y, data_x)`

**Explanation:** Calculates r, the Pearson product-moment correlation coefficient of a dataset.

**PERCENTILEEXC**

**Syntax:** `PERCENTILEEXC(array,k)`

**Explanation:** Returns the k-th percentile of values in a range, where k is in the range 0..1, exclusive.

**PERCENTILEINC**

**Syntax:** `PERCENTILEINC(array,k)`

**Explanation:** Returns the k-th percentile of values in a range, where k is in the range 0..1, inclusive.

**PERCENTRANKEXC**

**Syntax:** `PERCENTRANKEXC(array,x,[significance])`

**Explanation:** Returns the rank of a value in a data set as a percentage (0..1, exclusive) of the data set.

**PERMUT**

**Syntax:** `PERMUT(n, k)`

**Explanation:** Returns the number of ways to choose some number of objects from a pool of a given size of objects, considering order.

**PERMUTATIONA**

**Syntax:** `PERMUTATIONA(number, number_chosen)`

**Explanation:** Returns the number of ways to choose some number of objects from a pool of a given size of objects, considering order.

**PHI**

**Syntax:** `PHI(x)`

**Explanation:** The PHI function returns the value of the normal distribution with mean 0 and standard deviation 1.

**PI**

**Syntax:** `PI()`

**Explanation:** Returns the value of Pi to 14 decimal places.

**PMT**

**Syntax:** `PMT(rate, number_of_periods, present_value, [future_value], [end_or_beginning])`

**Explanation:** Calculates the periodic payment for an annuity investment based on constant-amount periodic payments and a constant interest rate.

**POISSON.DIST**

**Syntax:** `POISSON.DIST(x, mean, [cumulative])`

**Explanation:** Returns the value of the Poisson distribution function (or Poisson cumulative distribution function) for a specified value and mean.

**POISSONDIST**

**Syntax:** `POISSONDIST(x, mean, [cumulative])`

**Explanation:** Returns the value of the Poisson distribution function (or Poisson cumulative distribution function) for a specified value and mean.

**POW**

**Syntax:** `POW(base, exponent)`

**Explanation:** Returns a number raised to a power.

**POWER**

**Syntax:** `POWER(base, exponent)`

**Explanation:** Returns a number raised to a power

**PPMT**

**Syntax:** `PPMT(rate, period, number_of_periods, present_value, [future_value], [end_or_beginning])`

**Explanation:** Calculates the payment on the principal of an investment based on constant-amount periodic payments and a constant interest rate.

**PRECENTRANKINC**

**Syntax:** `PERCENTRANK.INC(array,x,[significance])`

**Explanation:** Returns the rank of a value in a data set as a percentage (0..1, inclusive) of the data set.

**PROB**

**Syntax:** `PROB(data, probabilities, low_limit, [high_limit])`

**Explanation:** Given a set of values and corresponding probabilities, calculates the probability that a value chosen at random falls between two limits.

**PRODUCT**

**Syntax:** `PRODUCT(factor1, [factor2, ...])`

**Explanation:** Returns the result of multiplying a series of numbers together.

**PROPER**

**Syntax:** `PROPER(text_to_capitalize)`

**Explanation:** Capitalizes each word in a specified string.

**PV**

**Syntax:** `PV(rate, number_of_periods, payment_amount, [future_value], [end_or_beginning])`

**Explanation:** Calculates the present value of an annuity investment based on constant-amount periodic payments and a constant interest rate.

**QUARTILE.EXC**

**Syntax:** `QUARTILE.EXC(array, quart)`

**Explanation:** Returns the quartile of the data set, based on percentile values from 0..1, exclusive.

**QUARTILE.INC**

**Syntax:** `QUARTILE.INC(array,quart)`

**Explanation:** Returns the quartile of a data set, based on percentile values from 0..1, inclusive.

**QUARTILEEXC**

**Syntax:** `QUARTILEEXC(array, quart)`

**Explanation:** Returns the quartile of the data set, based on percentile values from 0..1, exclusive.

**QUARTILEINC**

**Syntax:** `QUARTILEINC(array,quart)`

**Explanation:** Returns the quartile of a data set, based on percentile values from 0..1, inclusive.

**QUOTIENT**

**Syntax:** `QUOTIENT(dividend, divisor)`

**Explanation:** Returns one number divided by another.

**RADIANS**

**Syntax:** `RADIANS(angle)`

**Explanation:** Converts an angle value in degrees to radians.

**RAND**

**Syntax:** `RAND()`

**Explanation:** Returns a random number between 0 inclusive and 1 exclusive.

**RANDBETWEEN**

**Syntax:** `RANDBETWEEN(low, high)`

**Explanation:** Returns a uniformly random integer between two values, inclusive.

**RANK.AVG**

**Syntax:** `RANK.AVG(number,ref,[order]`

**Explanation:** Returns the rank of a number in a list of numbers: its size relative to other values in the list; if more than one value has the same rank, the average rank is returned.

**RANK.EQ**
**Syntax:** RANK.EQ(value, data, [is_ascending])
**Explanation:** Returns the rank of a specified value in a dataset. If there is more than one entry of the same value in the dataset, the top rank of the entries will be returned.

**RANKEQ**

**Syntax:** `RANKEQ([Units Sold]1,[Units Sold]:[Units Sold], 1)`

**Explanation:** Returns the rank of a number relative to other numbers in a range.

**RATE**

**Syntax:** `RATE(nper, pmt, pv, [fv], [type], [guess])`

**Explanation:** Returns the interest rate per period of an annuity. RATE is calculated by iteration and can have zero or more solutions. If the successive results of RATE do not converge to within 0.0000001 after 20 iterations, RATE returns the #NUM! error value.

**REGEXEXTRACT**

**Syntax:** `REGEXEXTRACT(text, regular_expression)`

**Explanation:** Extracts matching substrings according to a regular expression.

**REGEXMATCH**

**Syntax:** `REGEXMATCH(text, regular_expression)`

**Explanation:** Whether a piece of text matches a regular expression.

**REGEXREPLACE**

**Syntax:** `REGEXREPLACE(text, regular_expression, replacement)`

**Explanation:** Replaces part of a text string with a different text string using regular expressions.

**REPLACE**

**Syntax:** `REPLACE(text, position, length, new_text)`

**Explanation:** Replaces part of a text string with a different text string.

**REPT**

**Syntax:** `REPT(text_to_repeat, number_of_repetitions)`

**Explanation:** Returns specified text repeated a number of times.

**RIGHT**

**Syntax:** `RIGHT(string, [number_of_characters])`

**Explanation:** Returns a substring from the end of a specified string.

**ROMAN**

**Syntax:** `ROMAN(number, [rule_relaxation])`

**Explanation:** Formats a number in Roman numerals.

**ROUND**

**Syntax:** `ROUND(value, [places])`

**Explanation:** The ROUND function rounds a number to a certain number of decimal places according to standard rules.

**ROUNDDOWN**

**Syntax:** `ROUNDDOWN(value,[places])`

**Explanation:** The ROUNDDOWN function rounds a number to a certain number of decimal places, always rounding down to the next valid increment.

**ROUNDUP**

**Syntax:** `ROUNDUP(value,[places])`

**Explanation:** Rounds a number to a certain number of decimal places, always rounding up to the next valid increment.

**RRI**

**Syntax:** `RRI(number_of_periods, present_value, future_value)`

**Explanation:** The RRI function returns the interest rate needed for an investment to reach a specific value within a given number of periods.

**RSQ**

**Syntax:** `RSQ(data_y, data_x)`

**Explanation:** Calculates the square of r, the Pearson product-moment correlation coefficient of a dataset.

**SEARCH**

**Syntax:** `SEARCH(search_for, text_to_search, [starting_at])`

**Explanation:** Returns the position at which a string is first found within text, ignoring case.

**SEC**

**Syntax:** `SEC(angle)`

**Explanation:** The SEC function returns the secant of an angle measured in radians.

**SECH**

**Syntax:** `SECH(value)`

**Explanation:** Returns the hyperbolic secant of an angle.

**SECOND**

**Syntax:** `SECOND(time)`

**Explanation:** Returns the second component of a specific time, in numeric format.

**SERIESSUM**

**Syntax:** `SERIESSUM(x, n, m, a)`

**Explanation:** Given parameters x, n, m, and a, returns the power series sum a1xn + a2x(n+m) + ... + aix(n+(i-1)m), where i is the number of entries in range `a`

.

**SIGN**

**Syntax:** `SIGN(value)`

**Explanation:** Given an input number, returns `-1`

if it is negative, `1`

if positive, and `0`

if it is zero.

**SIN**

**Syntax:** `SIN(angle)`

**Explanation:** The SIN function returns the sine of an angle provided in radians.

**SINH**

**Syntax:** `SINH(value)`

**Explanation:** The SINH function returns the hyperbolic sine of any real number.

**SKEW**

**Syntax:** `SKEW(value1, [value2, ...])`

**Explanation:** Calculates the skewness of a dataset, which describes the symmetry of that dataset about the mean.

**SKEW.P**

**Syntax:** `SKEW.P(value1, value2)`

**Explanation:** The SKEW.P function calculates the skewness of a dataset that represents the entire population. Skewness describes the symmetry of that dataset about the mean.

**SKEWP**

**Syntax:** `SKEW.P([value1, value2])`

**Explanation:** The SKEW.P function calculates the skewness of a dataset that represents the entire population. Skewness describes the symmetry of that dataset about the mean.

**SLN**

**Syntax:** `SLN(cost, salvage, life)`

**Explanation:** The SLN function calculates the depreciation of an asset for one period using the straight-line method.

**SLOPE**

**Syntax:** `SLOPE(data_y, data_x)`

**Explanation:** Calculates the slope of the line resulting from linear regression of a dataset.

**SMALL**

**Syntax:** `SMALL(data, n)`

**Explanation:** Returns the nth smallest element from a data set, where n is user-defined.

**SPLIT**

**Syntax:** `SPLIT(text, delimiter, [split_by_each], [remove_empty_text])`

**Explanation:** Divides text around a specified character or string, and puts each fragment into a separate .

**SQRT**

**Syntax:** `SQRT(value)`

**Explanation:** Returns the positive square root of a positive number.

**SQRTPI**

**Syntax:** `SQRTPI(value)`

**Explanation:** Returns the positive square root of the product of Pi and the given positive number.

**STANDARDIZE**

**Syntax:** `STANDARDIZE(value, mean, standard_deviation)`

**Explanation:** Calculates the normalized equivalent of a random variable given mean and standard deviation of the distribution.

**STDEV.P**

**Syntax:** `STDEV.P(value1, [value2, ...])`

**Explanation:** Calculates the standard deviation based on an entire population.

**STDEV.S**

**Syntax:** `STDEV.S(value1, [value2, ...])`

**Explanation:** Estimates standard deviation based on a sample (ignores logical values and text in the sample). The standard deviation is a measure of how widely values are dispersed from the average value (the mean).

**STDEVA**

**Syntax:** `STDEVA(value1, [value2, ...])`

**Explanation:** Calculates the standard deviation based on a sample, setting text to the value `0`

.

**STDEVP**

**Syntax:** `STDEVP(value1, [value2, ...])`

**Explanation:** Calculates the standard deviation based on an entire population.

**STDEVPA**

**Syntax:** `STDEVPA(value1, [value2, ...])`

**Explanation:** Calculates the standard deviation based on an entire population, setting text to the value `0`

.

**STDEVS**

**Syntax:** `STDEVS(number1, [number2],...)`

**Explanation:** Estimates standard deviation based on a sample (ignores logical values and text in the sample). The standard deviation is a measure of how widely values are dispersed from the average value (the mean).

**STEYX**

**Syntax:** `STEYX(known_y's, known_x's)`

**Explanation:** Returns the standard error of the predicted y-value for each x in the regression. The standard error is a measure of the amount of error in the prediction of y for an individual x.

**SUBSTITUTE**

**Syntax:** `SUBSTITUTE(text_to_search, search_for, replace_with, [occurrence_number])`

**Explanation:** Replaces existing text with new text in a string.

**SUBTOTAL**

**Syntax:** `SUBTOTAL(function_code, range1, [range2, ...])`

**Explanation:** Returns a subtotal using a specified aggregation function.

**SUM**

**Syntax:** `SUM(value1, [value2, ...])`

**Explanation:** Returns the sum of a series of numbers.

**SUMIF**

**Syntax:** `SUMIF(range, criterion, [sum_range])`

**Explanation:** Returns a conditional sum across a range.

**SUMIFS**

**Syntax:** `SUMIFS(sum_range, criteria_range1, criterion1, [criteria_range2, criterion2, ...])`

**Explanation:** Returns the sum of a range depending on multiple criteria.

**SUMPRODUCT**

**Syntax:** `SUMPRODUCT(array1, [array2, ...])`

**Explanation:** The SUMPRODUCT function calculates the sum of the products of corresponding entries in 2 equally sized arrays or ranges.

**SUMSQ**

**Syntax:** `SUMSQ(value1, [value2, ...])`

**Explanation:** Returns the sum of the squares of a series of numbers.

**SUMX2MY2**

**Syntax:** `SUMX2MY2(array_x, array_y)`

**Explanation:** Calculates the sum of the differences of the squares of values in two arrays.

**SUMX2PY2**

**Syntax:** `SUMX2PY2(array_x, array_y)`

**Explanation:** Calculates the sum of the sums of the squares of values in two arrays.

**SUMXMY2**

**Syntax:** `SUMXMY2(array_x, array_y)`

**Explanation:** Calculates the sum of the squares of differences of values in two arrays.

**SWITCH**

**Syntax:** `SWITCH(expression, case1, value1, [case2, value2, ...], [default])`

**Explanation:** 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.

**SYD**

**Syntax:** `SYD(cost, salvage, life, period)`

**Explanation:** The SYD function calculates the depreciation of an asset for a specified period using the sum of years digits method.

**T**

**Syntax:** `T(values)`

**Explanation:** Checks whether a value is text, and returns the text if it is, otherwise returns a blank

**T.DIST**

**Syntax:** `T.DIST(x, degrees_freedom, cumulative)`

**Explanation:** The T.DIST function returns the right tailed Student distribution for a value x. Along with T.DIST.2T, this function replaces TDIST and is equivalent to calling TDIST with the tails argument set to 1.

**T.DIST.2T**

**Syntax:** `T.DIST.2T(x, degrees_freedom)`

**Explanation:** The T.DIST.2T function returns the two tailed Student distribution for a value x. Along with T.DIST.RT, this function replaces TDIST and is equivalent to calling TDIST with the tails argument set to 2.

**T.DIST.RT**

**Syntax:** `T.DIST.RT(x, degrees_freedom)`

**Explanation:** Returns the right tailed Student distribution for a value x. Along with T.DIST.RT, this function replaces TDIST and is equivalent to calling TDIST with the tails argument set to 1.

**T.INV**

**Syntax:** `T.INV(probability, degrees_freedom)`

**Explanation:** Calculates the negative inverse of the one-tailed TDIST function.

**T.INV.2T**

**Syntax:** `T.INV.2T(probability, degrees_freedom)`

**Explanation:** Calculates the inverse of the two-tailed TDIST function.

**TAN**

**Syntax:** `TAN(angle)`

**Explanation:** The TAN function returns the tangent of an angle provided in radians.

**TANH**

**Syntax:** `TANH(value)`

**Explanation:** Returns the hyperbolic tangent of any real number.

**TBILLEQ**

**Syntax:** `TBILLEQ(settlement, maturity, discount)`

**Explanation:** Calculates the equivalent annualized rate of return of a US Treasury Bill based on discount rate.

**TBILLPRICE**

**Syntax:** `TBILLPRICE(settlement, maturity, discount)`

**Explanation:** Calculates the price of a US Treasury Bill based on discount rate.

**TBILLYIELD**

**Syntax:** `TBILLYIELD(settlement, maturity, price)`

**Explanation:** Calculates the yield of a US Treasury Bill based on price.

**TDIST**

**Syntax:** `TDIST(x, degrees_freedom, tails)`

**Explanation:** Calculates the probability for Student's t-distribution with a given input (x).

**TDIST2T**

**Syntax:** `TDIST2T(x,deg_freedom)`

**Explanation:** Returns the two tailed Student distribution for a value x.

**TDISTRT**

**Syntax:** `TDISTRT(x,deg_freedom)`

**Explanation:** Returns the right tailed Student distribution for a value x.

**TIME**

**Syntax:** `TIME(hour, minute, second)`

**Explanation:** Converts an hour, minute, and second into a time.

**TIMEVALUE**

**Syntax:** `TIMEVALUE(time_string)`

**Explanation:** Returns the fraction of a 24-hour day the time represents.

**TINV**

**Syntax:** `T.INV(probability, degrees_freedom)`

**Explanation:** Calculates the negative inverse of the one-tailed TDIST function.

**TINV2T**

**Syntax:** `TINV2T(probability, degrees_freedom)`

**Explanation:** Calculates the inverse of the two-tailed TDIST function.

**TODAY**

**Syntax:** `TODAY()`

**Explanation:** Returns the current date as a date value.

**TRANSPOSE**

**Syntax:** `TRANSPOSE(array_or_range)`

**Explanation:** Transposes the rows and columns of an array.

**TREND**

**Syntax:** `TREND(known_data_y, [known_data_x], [new_data_x], [b])`

**Explanation:** Given partial data about a linear trend, fits an ideal linear trend using the least squares method and/or predicts further values.

**TRIM**

**Syntax:** `TRIM(text)`

**Explanation:** Removes leading, trailing, and repeated spaces in text.

**TRIMMEAN**

**Syntax:** `TRIMMEAN(data, exclude_proportion)`

**Explanation:** Calculates the mean of a dataset excluding some proportion of data from the high and low ends of the dataset.

**TRUE**

**Syntax:** `TRUE()`

**Explanation:** Returns the logical value `TRUE`

.

**TRUNC**

**Syntax:** `TRUNC(value, [places])`

**Explanation:** Truncates a number to a certain number of significant digits by omitting less significant digits.

**UNICHAR**

**Syntax:** `UNICHAR(number)`

**Explanation:** Returns the Unicode character for a number. This method supports returning characters in both the UTF-8 and UTF-16 character set.

**UNICODE**

**Syntax:** `UNICODE(text)`

**Explanation:** The UNICODE function returns the decimal Unicode value of the first character of the text.

**UNIQUE**

**Syntax:** `UNIQUE(range)`

**Explanation:** Returns unique values in the provided source range, discarding duplicates.

**UPPER**

**Syntax:** `UPPER(text)`

**Explanation:** Converts a specified string to uppercase.

**VAR.P**

**Syntax:** `VAR.P(value1, [value2, ...])`

**Explanation:** Calculates the variance based on an entire population.

**VAR.S**

**Syntax:** `VAR.S(value1, [value2, ...])`

**Explanation:** Calculates the variance based on a sample.

**VARA**

**Syntax:** `VARA(value1, [value2, ...])`

**Explanation:** Calculates the variance based on a sample, setting text to the value `0`

.

**VARP**

**Syntax:** `VARP(value1, [value2, ...])`

**Explanation:** Calculates the variance based on an entire population.

**WEEKDAY**

**Syntax:** `WEEKDAY(date, [type])`

**Explanation:** Returns a number representing the day of the week of the date provided.

**WEEKNUM**

**Syntax:** `WEEKNUM(date, [type])`

**Explanation:** Returns a number representing the week of the year where the provided date falls.

**WEIBULLDIST**

**Syntax:** `WEIBULLDIST(x, shape, scale, cumulative)`

**Explanation:** Returns the value of the Weibull distribution function (or Weibull cumulative distribution function) for a specified shape and scale.

**WEIBULL.DIST**

**Syntax:** `WEIBULL.DIST(x, shape, scale, cumulative)`

**Explanation:** Returns the value of the Weibull distribution function (or Weibull cumulative distribution function) for a specified shape and scale.

**WORKDAY**

**Syntax:** `WORKDAY(start_date, num_days, [holidays])`

**Explanation:** Calculates the end date after a specified number of working days.

**XNPV**

**Syntax:** `XNPV(discount, cashflow_amounts, cashflow_dates)`

**Explanation:** Calculates the net present value of an investment based on a specified series of potentially irregularly spaced cash flows and a discount rate.

**XOR**

**Syntax:** `XOR(logical_expression1, [logical_expression2, ...])`

**Explanation:** The XOR function returns TRUE if an odd number of the provided arguments are logically true, and FALSE otherwise.

**YEAR**

**Syntax:** `YEAR(date)`

**Explanation:** Returns the year specified by a given date.

**YEARFRAC**

**Syntax:** `YEARFRAC(start_date, end_date, [day_count_convention])`

**Explanation:** Returns the number of years, including fractional years, between two dates using a specified day count convention.