XLKitLearn Documentation

Fits a linear regression to a dataset, to predict a continuous outcome using one or more other variables. The data you provide to the function should include one column for every variable, and one row for each observation, with the variable names in the first row. There are two ways to specify the dependent and independent variables in your linear regression model:

• To choose the predictors yourself, for example to use only some of the columns, write the outcome, a tilde (~), then the predictors joined with +. For example, if your data is in A7:C13, with columns sales, ads and price, you would write =XKL.FITLINEARREGRESSION(A7:C13,"sales ~ ads + price"). See the "Predict" section above for more details on XLKitLearn's formula language.
• To predict one specific column using every other column in the table as a predictor, write just the outcome column's name. For example, =XKL.FITLINEARREGRESSION(A7:C13,"sales") uses both ads and price.

Fits a logistic regression to a dataset, to predict the probability of a yes/no outcome (such as whether a delivery will arrive late) using one or more other variables. The data you provide to the function should include one column for every variable, and one row for each observation, with the variable names in the first row. There are two ways to specify the dependent and independent variables in your logistic regression model:

• To choose the predictors yourself, for example to use only some of the columns, write the outcome, a tilde (~), then the predictors joined with +. If your data is in A7:C27, with columns late, distance and orders_waiting, you would write =XKL.FITLOGISTICREGRESSION(A7:C27,"late ~ distance + orders_waiting"). See the "Predict" section above for more details on XLKitLearn's formula language.
• To use every other column in the table as a predictor, write just the outcome's name. With the same data, =XKL.FITLOGISTICREGRESSION(A7:C27,"late") uses both distance and orders_waiting.

Note that to fit a logistic regression, the outcome column must contain 0s or 1s only.

Fits a k-nearest-neighbors (KNN) model to a dataset to predict an outcome variable based on one or more predictor variables. The model can predict the outcome for a new row of predictors by looking at the training set, finding the k rows with predictors closest to the new predictors, and averaging the outcome for those rows. There are two ways to specify the dependent and independent variables in your model:

• To choose the predictors yourself, for example to use only some of the columns, write the outcome, a tilde (~), then the predictors joined with +. If your data is in A7:C15, with columns corresponding to total_spend, visits, and club_membership, you would write =XKL.FITKNN(A7:C15,"total_spend ~ visits + club_membership",3) to fit a k-nearest-neighbors model that looks at the 3 nearest neighbors.
• To use every other column in the table as a predictor, write just the outcome's name. With the same data, =XKL.FITKNN(A7:C15,"total_spend",3) uses both visits and club_membership.

Calculates R-squared, which measures how well a model's predictions of a number, such as weekly sales, match what actually happened. A score of 1 means the predictions are perfect, and 0 means the model is no better than predicting the average. For example, an R-squared of 0.8 means the model explains 80% of the variation in sales (how much sales go up and down from week to week).

Calculates the RMSE (root mean squared error), which tells you how far off a model's predictions of a number typically are, in the same units as what you're predicting. For example, a pizza shop that predicts weekly sales to decide how much dough to prepare needs to know how many slices those predictions are usually off by. An RMSE of 5 means they're typically off by about 5 slices. Lower is better, and 0 means every prediction is exactly right.

RMSE or R-squared: The R-squared, which you can calculate using XKL.SQUARED is a scaled version of the RMSE that falls between 0 and 1. The RMSE tells you how big the errors are in real units.

How it's calculated: for each case, take the error (actual minus predicted) and square it. Average the squares, then take the square root. Because the errors are squared, a few large misses raise RMSE more than many small ones.

Calculates the AUC (area under the curve), which evaluates how well a classification model tells two groups apart, such as customers who bought vs. didn't, or posts that break the rules vs. posts that don't. It checks the model's predicted probabilities against the actual outcomes, and calculates the area under the ROC curve, which you can draw using XKL.ROCCURVE. The score is usually between 0.5 and 1. A score of 1 means the model separates the groups perfectly, and 0.5 means it is no better than guessing.

Comparing models: calculate each model's AUC against the same actual outcomes. The model with the higher AUC is better at telling the groups apart. For example, fit one model using XKL.FITLOGISTICREGRESSION and another with XKL.FITKNN. Then get each one's predicted probabilities with XKL.PREDICT and calculate the AUC of each.

(Advanced) Three or more groups: XKL.AUC also works when there are more than two groups. Give one probability column per group, in alphabetical order of the group names: for low, medium and high, the columns go high, low, medium. Columns are matched to groups by position, not by their headers, so the wrong order gives a wrong score.

Builds a confusion matrix: a table that counts how often a classification model's predictions were right and wrong, compared with what actually happened. For example, for deliveries that are either late (1) or on time (0), a late delivery counts as a positive and an on-time delivery as a negative. The table shows how many:

• True positives: late deliveries the model correctly predicted as late
• False negatives: late deliveries it wrongly predicted as on time
• False positives: on-time deliveries it wrongly predicted as late
• True negatives: on-time deliveries it correctly predicted as on time

From probabilities to predictions: XKL.CONFUSIONMATRIX needs predicted outcomes, such as 0 or 1, not probabilities. If your model produces probabilities, for example from XKL.PREDICT, choose a threshold and turn each probability into a prediction, for example =IF(B12>=0.5,1,0). A lower threshold catches more of the 1s but also flags more of the 0s by mistake. XKL.ROCCURVE shows this trade-off across every threshold, and XKL.AUC sums it up in a single number. Use XKL.CONFUSIONMATRIX once you've chosen a threshold, to see exactly how many of each kind of mistake the model makes.

(Advanced) Three or more groups: the table works the same way, with one row and one column per group.

An ROC curve charts the tradeoff between the true positive rate and false positive rate as a model's classification threshold changes. For example, a pizza shop that texts customers when a delivery might be late has to decide when to send the text: when the predicted chance of being late is above 0.5? Above 0.3? A lower threshold warns more of the customers whose delivery really is late, but also warns more customers whose delivery arrives on time. XKL.ROCCURVE shows this trade-off at every possible threshold, so you can choose the one that fits.

Each row of the output is one threshold. It shows the share of on-time deliveries the model would wrongly predict as late (the false positive rate) and the share of late deliveries it would correctly predict as late (the true positive rate). In general, these are the share of 0s predicted as 1, and the share of 1s predicted as 1. A curve that climbs steeply toward the top-left corner means the model catches most late deliveries while warning few on-time customers. A straight diagonal line means it is no better than guessing. The area under the curve is the AUC, a single number you can calculate with XKL.AUC.

Drawing the curve: select the output, including its header row, and choose Insert > Scatter.

Choosing a threshold: each point is a threshold you could use to turn probabilities into predictions. To see the exact counts behind any point, use that threshold with XKL.CONFUSIONMATRIX.

Predicts the outcome for new data, such as next month's sales, using a model you have already built. Build the model first (either with a FIT function, or on the Predict tab with Output model object ticked). Then give XKL.PREDICT the model's cell and the new data for which you want to make a prediction. For example, if the model is in A5 and the new data is in A17:B20, you would write =XKL.PREDICT(A5,A17:B20).

Turns items described by high-dimensional vectors (i.e. many numbers, representing many dimensions) into points on a two-dimensional graph (i.e., an "x value" and a "y value"), so you can plot them and see which items are similar. Similar items end up close together, and different items end up far apart.

It is particularly when applied to embeddings. Embedding models (which you can access using XKL.EMBED), turn each piece of text or image into a long list of numbers (often more than a thousand) which capture the "essence" of that text or image. You can't plot that many dimensions, but XKL.MDS reduces them to two per item. Plot those on a scatter chart, and you can see how the model grouped your items: for example, whether it put reviews about late deliveries together, apart from reviews about taste.

Drawing the map: plot the two output columns to see how close the items are to each other. If you would like to automatically create a plot with labels, use the "Create compound plot" feature in XLKitLearn's GenAI tab: select the first output column as the x-values, the second as the y-values, and the item names as labels, so you can tell which point is which. If you embedded images, you can use the images themselves as labels.

How it works: MDS (multidimensional scaling) measures the distance between every pair of rows, using all their columns. It then places the points on the map so that those distances are kept as closely as possible.

Reading the map: only the distances between points matter. The coordinates have no units, and the map can come out rotated or flipped, for example with a different seed, while showing the same picture.

Other data: XKL.MDS works with any table of numbers, not just embeddings. For example, you could map customers by how often they visit, how much they spend and how far away they live, to see which customers are alike. Columns with bigger numbers count more, so if one column is a price in dollars and another is a 1–5 rating, the price will dominate the map. Put the columns on similar scales first, for example with Excel's STANDARDIZE.

Turns a number into a probability between 0 and 1. It is the last step of a logistic regression.

When you fit a logistic regression, you get an intercept and a coefficient for each variable. For example, a pizza shop's model for late deliveries might be -4 + 0.8 × distance in miles. Plugging in a distance gives a number, but not a probability: a 2-mile delivery gives -2.4, and an 8-mile delivery gives 2.4. The sigmoid turns these numbers into probabilities: -2.4 becomes 0.08 (an 8% chance of being late), and 2.4 becomes 0.92 (92%). That is why a logistic regression's predictions are always between 0 and 1.

The sigmoid follows an S-shaped curve. 0 becomes 0.5, large positive numbers become probabilities close to 1, and large negative numbers become probabilities close to 0, without ever quite reaching them.

When you need it: usually you don't, because XKL.PREDICT does this step for you. Use XKL.SIGMOID when you want to work out a prediction yourself from the coefficients, for example to build a what-if calculator: change a delivery's distance and see how the chance of it being late changes.

The formula is 1 / (1 + EXP(-x)).

Fit a two-stage least squares instrumental variables regression using statsmodels. Write the formula as known_y ~ exog_x | endog_x | instruments, with multiple terms joined by +. Exogenous regressors are included automatically in the instrument matrix; the final section lists excluded instruments. An intercept is included by default. Use y ~ 1 | d | z for an intercept with no exogenous predictors, or y ~ 0 | d | z to omit the intercept. Use y ~ x - 1 | d | z for exogenous predictors without an intercept. Missing or nonfinite model values, collinear columns, and underidentified models return an error. Standard errors use the usual homoskedastic 2SLS covariance with residual degrees of freedom n - k.

Sends a prompt to an AI model, such as ChatGPT or Claude, and shows its answer in the cell. Use it, for example, to label hundreds of customer reviews as Positive or Negative. Each call costs a small amount of your OpenRouter credit, so XLKitLearn does not send the prompt as soon as you type the formula. The cell shows Ready to run until you select it and click the run icon at the bottom of the XLKitLearn pane. There are two ways to call this function:

• To ask one question, write the prompt in quotes. To add a cell's text to the prompt, join it on with &. If a review is held in cell A9, you would write =XKL.LLM("Is this pizza review Positive or Negative? Reply with one word. Review: "&A9).
• To ask a follow-up question, remember that AI models have no memory. Each call starts from scratch, so you must send the whole conversation so far. Put your first prompt, the model's first answer and your next prompt in one column, in that order. If they are in A9, A10 and A11, you would write =XKL.LLM(A9:A11). Because the whole conversation is sent each time, long conversations cost more.

The other parameters, described below, are optional. They let you pick the model, limit the length of the answer, and more.

The output of this formula is an LLM response object, which shows the start of the LLM's response. To get the answer as plain text that other formulas can use, add .Content to the cell, for example =A5.Content. See the "Returns" box below for more details.

Keep the cell selected while it runs; this will allow XLKitLearn to stream the response (reveal it bit by bit) in a box at the bottom of the XLKitLearn pane.

Turns a piece of text into an embedding: a long list of numbers that captures the text's meaning. Texts with similar meanings get similar numbers, so you can measure how close two pieces of text are, for example to find which customer reviews talk about the same thing.

Like XKL.LLM, each use costs a little, so the cell shows Ready to run until you select it and click the run icon at the bottom of the XLKitLearn pane.

To compare two embeddings, for example in A5 and A6, you could write =SUMSQ(A5.Embedding-A6.Embedding), to find the Pythagorean distance between the two vectors. The smaller the result, the more similar the two texts. You could also use a more advanced measure of distance called the cosine distance.

To visualize these embeddings, you can use the XKL.MDS function.

This function produces response format fields for use in the XKL.LLM function. In particular, if you want the response from an LLM to include several specific, distinct components (eg: a review's mood, estimated star rating, and any product it might refer to), you would set up each of these components using this function, and pass the resulting three cells to the response_format argument of XKL.LLM.

Interestingly, some models have trouble following specific instructions - the example below uses gpt-6-luna, which works pretty well. Try it with deepseek and see how it performs.

Splits a piece of text into tokens, the small pieces of text an AI model reads and writes. AI models charge by the token, and there is a limit to how many tokens they can read in every prompt, so this helps you check how long a prompt is before you send it. It runs inside Excel without calling an AI model, so it's free and gives its answer straight away. For example, if your prompt is in A9, you would write =XKL.TOKENIZE(A9). To count the tokens, write =COLUMNS(A5#), where A5 is the cell with the XKL.TOKENIZE formula. The count is exact for some OpenAI models, including the default model of XKL.EMBED, and close for most others, since each model tokenizes text a little differently.

Large language models produce answers one token at a time. In each step, the model considers a what token it might generate next, and assigns a probability to each of these potential tokens. It then randomly picks from those tokens according to those probabilities.

XKL.LLMPROBS sends your prompt to GPT-4.1 and shows, for each token of the answer, the 20 top candidate tokens it was considering and how likely each one was. It always uses GPT-4.1, because newer OpenAI models no longer make these probabilities available.

The table grows to the right with every token, so ask for a short answer, for example by adding "Reply in 5 words at most" to your prompt.

**Note that XLKitLearn will format this function's response to make it readable, so we advice using it on a blank Excel sheet.*

Sends a text message to a US phone number, for example to tell a customer their order is on its way. For example, you would write =XKL.SENDTEXT("+12125550100","Your pizza is on its way."). The text comes from XLKitLearn, not from your own phone, so replies come back to XLKitLearn too. There are two ways to see them:

• Set wait_for_reply to TRUE, and the cell waits up to about 3 minutes and shows the first reply.
• Check at any time with XKL.GETTEXTRESPONSES (see that function for details).

Create an LLM tool that lets XKL.LLM send SMS text messages. Pass the returned LLM Tool entity into the tools argument of XKL.LLM.

Shows the replies to a text sent with XKL.SENDTEXT, detailed above. Give it the text's ID: if the text is in A5, you would write =XKL.GETTEXTRESPONSES(A5.[Text ID]). The cell shows how many replies have come in so far, for example "Text responses (2 responses)". It shows #VALUE until a reply arrives. To check again, select the cell, click in the formula bar and press Enter.

Create an LLM tool that lets XKL.LLM look up replies to a sent text message. Pass this LLM Tool entity into the tools argument of XKL.LLM.

Sends an email, for example to confirm a customer's catering order. For example, you would write =XKL.SENDEMAIL("[email protected]","Your catering order","Thanks for your order of 10 large pizzas for Friday."). The email comes from XLKitLearn, not from your own email account, so replies come back to XLKitLearn too. There are two ways to see them:

• Set wait_for_reply to TRUE, and the cell waits up to about 3 minutes and shows the first reply.
• Check at any time with XKL.GETEMAILTHREAD, detailed below, which shows the whole conversation.

Create an LLM tool that lets XKL.LLM send emails. Pass the returned LLM Tool entity into the tools argument of XKL.LLM.

Shows the whole conversation for an email sent with XKL.SENDEMAIL, detailed above. Give it the email's thread token: if the email is in A5, you would write =XKL.GETEMAILTHREAD(A5.[Thread token]). The cell shows how many messages the conversation has, for example "Email thread (2 messages)". It only reads messages, so it doesn't need Ready to run. It doesn't update by itself. To check for replies, select the cell, click in the formula bar and press Enter.

Create an LLM tool that lets XKL.LLM fetch an email thread by thread token. Pass this LLM Tool entity into the tools argument of XKL.LLM when the model may need to inspect a conversation.

Run Python code in the workbook's Python worker and return the value of the last expression as JSON. Use this for quick calculations, data reshaping, or analysis that is easier in Python than in formulas.

Create an LLM tool that lets llm run Python code for calculations and data analysis. Pass the returned LLM Tool entity into the tools argument of llm when a model should be able to compute rather than only reason in text.

Package an Excel range as a named table that can be queried with DuckDB SQL. Use this once per source table, then pass the resulting SQL Data Table entities to sql or sqlTool.

Run a DuckDB SQL query against one or more Excel ranges packaged by sqlDataTable. Use this when you want a normal spilled table result in Excel.

Create an LLM tool that lets llm query selected Excel tables with DuckDB SQL. Use sqlDataTable to define each source table first, then pass those entities here, and pass the returned LLM Tool entity into llm as a tool.

Search Google Maps Places with a plain-language query and return normalized place details. This function is staged because it calls an external service: after the formula shows Ready to run, select it and click Run staged cells in selection in the GenAI tab of the side bar.

Create an LLM tool that lets llm search Google Maps Places. Pass the returned LLM Tool entity into the tools argument of llm when the model may need to find businesses, addresses, or place IDs before taking another action.

Compute route duration and distance between two Google place IDs. This function is staged because it calls an external service: after the formula shows Ready to run, select it and click Run staged cells in selection in the GenAI tab of the side bar.

Create an LLM tool that lets llm compute Google Maps route time and distance between place IDs. Pair it with the Places search tool when the model first needs to look up place IDs.

Get current weather or an hourly forecast for a latitude/longitude from Google Maps Weather. This function is staged because it calls an external service: after the formula shows Ready to run, select it and click Run staged cells in selection in the GenAI tab of the side bar.

Create an LLM tool that lets llm get current or forecast weather for a latitude/longitude. Pass the returned LLM Tool entity into llm when the model may need weather context.

Fetch daily OHLCV stock prices for one or more equity tickers. This function is staged because it calls an external service: after the formula shows Ready to run, select it and click Run staged cells in selection in the GenAI tab of the side bar.

Create an LLM tool that lets llm fetch daily stock prices. Pass the returned LLM Tool entity into the tools argument of llm when the model may need historical OHLCV data.

Search Duffel flight availability for a one-way, round-trip, or multi-city itinerary. This function is staged because it calls an external service: after the formula shows Ready to run, select it and click Run staged cells in selection in the GenAI tab of the side bar.

Create an LLM tool that lets llm search Duffel flight availability. Pass the returned LLM Tool entity into llm when the model may need to find flights or compare itineraries.

Continue a Duffel multi-leg flight search after selecting a previous leg option. This function is staged because it calls an external service: after the formula shows Ready to run, select it and click Run staged cells in selection in the GenAI tab of the side bar.

Create an LLM tool that lets llm continue a Duffel flight search after selecting a previous leg. Use it together with the flight search tool for multi-leg itineraries.

Get the workbook user's public IP address, approximate location, and time zone. Use this when you need coarse location context, not precise GPS coordinates.

Create an LLM tool that lets llm look up the workbook user's public IP address, approximate location, and time zone. Use this only for coarse context; it is not a precise geolocation tool.

Draws a random number from a normal distribution: the bell-shaped curve where values near the average are most common and values far from it are rare. Use it for quantities such as the number of orders a pizza shop gets each night, daily sales, or the weight of a dough ball. You give it the mean and the standard deviation, which measures how far values typically are from the average. For example, =XKL.SIMNORMAL(40,6.3) gives a random number of orders that is normally distributed with a mean of 30 and a standard deviation of 50.

Running a simulation: each time Excel recalculates, for example when you press F9, you get a new random number. To run your model many times and see the range of outcomes, use the Simulate tab. To get the same numbers every time, turn on Seed in the Simulate tab.

Draws a random number from a binomial distribution, which counts the number of successes in a fixed number of independent yes-or-no trials. For example, a pizza shop makes 20 deliveries tonight. Each one is either late or on time, with a 10% chance of being late. =XKL.SIMBINOMIAL(20,0.1) simulates one night, and provides the number of deliveries that were late that night.

A single yes or no: with trials set to 1, XKL.SIMBINOMIAL returns 1 or 0, for example =XKL.SIMBINOMIAL(1,0.3) has a 30% chance of returning 1.

Running a simulation: each time Excel recalculates, for example when you press F9, you get a new random number. To run your model many times and see the range of outcomes, use the Simulate tab. To get the same numbers every time, turn on Seed in the Simulate tab.

Draws a random number from a Poisson distribution, which counts how many times something happens in a set period when events happen independently at a constant average rate. For example, a pizza shop gets 4 phone orders an hour on average, but some hours get 2 and others get 6. =XKL.SIMPOISSON(4) gives a random number of phone orders for one hour. Use it to count any independent arrivals in a fixed time period, such as how many customers walk in during lunch.

Running a simulation: each time Excel recalculates, for example when you press F9, you get a new random number. To run your model many times and see the range of outcomes, use the Simulate tab. To get the same numbers every time, turn on Seed in the Simulate tab.

Draws a random number from an exponential distribution, which describes how long you have to wait until something happens, when it happens independently at a steady average rate. For example, if a pizza shop gets a phone order every 15 minutes on average - the time till the next phonecall is exponentially distributed with a rate of 1/15 events per minute. Thus, =XKL.SIMEXPONENTIAL(1/15) gives a random number of minutes until the next phone order.

Exponential and Poisson: they describe the same situation from two sides. If the shop gets 4 phone orders an hour on average, XKL.SIMPOISSON(4) simulates how many orders arrive in an hour, and XKL.SIMEXPONENTIAL(1/15) simulates how many minutes until the next one.

Running a simulation: each time Excel recalculates, for example when you press F9, you get a new random number. To run your model many times and see the range of outcomes, use the Simulate tab. To get the same numbers every time, turn on Seed in the Simulate tab.

Draws a random number from a uniform distribution, where every value between a minimum and a maximum is equally likely. For example, if you randomly cut a slice out of a pizza, the angle fo the slice to the horizontal could be anywhere from 0 to 360. =XKL.SIMUNIFORM(0,360) gives a random angle in that range: 53 is just as likely as 75 or 363.

Running a simulation: each time Excel recalculates, for example when you press F9, you get a new random number. To run your model many times and see the range of outcomes, use the Simulate tab. To get the same numbers every time, turn on Seed in the Simulate tab.

(Advanced) Equally likely whole numbers: sometimes you need a whole number where each one is equally likely, for example if a customer orders 1, 2, 3 or 4 pizzas with the same chance each. Round down with INT and add 1 to the maximum: =INT(XKL.SIMUNIFORM(1,5)) gives 1, 2, 3 or 4, each with a 25% chance. Don't use ROUND instead: it makes the smallest and largest numbers half as likely as the others.

Draws a random number from a triangular distribution: values between a minimum and a maximum, with one most likely value in between. The chances rise steadily from the minimum up to the most likely value, then fall steadily to the maximum, like a triangle. Use it when you can give a rough estimate but have little data, such as "a delivery takes 20 to 50 minutes, most often about 30". For example, =XKL.SIMTRIANGLE(20,30,50) gives a random delivery time: usually between about 24 and 45 minutes, most often close to 30, and never below 20 or above 50.

Most likely is not the average: when the most likely value isn't in the middle of the range, the average shifts toward the longer side. Here the average is about 33 minutes, not 30, because some deliveries take much longer. The average is (minimum + most likely + maximum) / 3.

Running a simulation: each time Excel recalculates, for example when you press F9, you get a new random number. To run your model many times and see the range of outcomes, use the Simulate tab. To get the same numbers every time, turn on Seed in the Simulate tab.

Counts how many times each value appears in a list, for example how many orders there were for each type of pizza. It lists every distinct value once with its count, sorted from most to least common. It works like a quick pivot table, in one formula. Use it to get a feel for a column of data before you analyze it:

• See what's most common: which pizzas sell best, or which complaint comes up most in reviews.
• Spot messy data: typos and inconsistent spellings, such as "Pepperoni" and "pepperoni", show up as separate rows.
• Check the balance of outcomes: before fitting a classification model, see what share of deliveries were late (1) and on time (0).

Blank cells: blank cells in the range are counted too, as an empty value. Select only the cells with data, and leave out the header.

Lists the values in one range that don't appear in another. Each value appears once in the result, in the order it first appears in the first range. Use it to compare two lists:

• Find who's gone: customers who ordered last month but not this month.
• Find what's new: swap the two ranges to get customers who ordered this month but not last month.
• Find what's missing: menu items that got no orders this week, by starting from the full menu and removing the items that were ordered.

Exact matches only: values must match exactly. "Ana" and "ana" count as different, and so do the number 2 and the text "2". An extra space also makes two values different.

Looks at a column or row of numbers and returns the matching label for the largest one, such as the pizza that sold the most slices. You can also ask for the second largest, third largest, and so on. Give it:

• the numbers, such as slices sold
• the matching labels in the same order, such as pizza names (pictures work too)
• which rank you want: 1 for the largest, 2 for the second largest, and so on

Excel's built-in MAX and LARGE functions return the number itself (185 slices). XKL.ARGMAX returns which item it belongs to (Pepperoni). If you leave out the labels, it returns the item's position in the list instead.

Use it to:

• Find the top performer: which pizza sold the most this week.
• List the top few: put n = 1, 2 and 3 in three cells to get a top-three list.
• Pick a model's predicted group: for a row of predicted probabilities from XKL.PREDICT, with the group names as labels, it returns the group with the highest probability.

Ties: if two values are equal, the one that comes first in the list wins.

Looks at a column or row of numbers and returns the matching label for the smallest one, such as the pizza that sold the fewest slices. You can also ask for the second smallest, third smallest, and so on. Give it:

• the numbers, such as slices sold
• the matching labels in the same order, such as pizza names (pictures work too)
• which place you want: 1 for the smallest, 2 for the second smallest, and so on

Excel's built-in MIN and SMALL functions return the number itself (60 slices). XKL.ARGMIN returns which item it belongs to (Tomato Pie). If you leave out the labels, it returns the item's position in the list instead.

Use it to:

• Find the weakest performer: which pizza sold the least this week.
• List the bottom few: put n = 1, 2 and 3 in three cells to get a bottom-three list.
• Find the cheapest or fastest option: for example, the supplier with the lowest price, or the driver with the shortest delivery time.

Ties: if two values are equal, the one that comes first in the list wins.