Keyword procedure arguments, introduced in GAUSS 26.1, give you the ability to write cleaner code that is more concise, easier to write, and easier to read. Just as importantly, they are intuitive enough that you can start using them immediately. Today we'll show you everything you need to know to make your work easier right away.

Self-documenting Code with Keyword Inputs

GAUSS has long had optional inputs, so you did not have to pass in every possible input. However, they were positional inputs. Positional inputs have to be passed in a specific order. So if you wanted to use the seventh input, you would have to pass in all seven--and remember which order to pass them in.

For example, let's consider a hypothetical procedure named myEstimate() that fits an ARDL-style model and takes:

• y - Time series vector.
• X - Exogenous variables.
• y_lags - Set of lags of the dependent variable to include in the estimation. Default = {}, no y-lags.
• X_lags - Set of lags of the exogenous variables to include in the estimation. Default = {}, no X-lags.
• const - 0, no constant. 1, include a constant. Default = 1.
• trend - 0, no trend. 1, include a trend. Default = 0.
• quiet - 1, no output report. 0, print an output summary. Default = 0.

// Before — to set quiet, you have to pass everything ahead of it
result = myEstimate(y, X, {1 2}, {}, 1, 0, 1);

can be written as:

// Using keyword inputs
result = myEstimate(y, X, y_lags={1 2}, quiet=1);

// Keyword inputs can be in any order
result = myEstimate(y, X, quiet=1, y_lags={1 2});

As we see above, the keyword input version:

1. Is concise and readable.
2. Does not require you to remember the input order.
3. Does not make you set inputs, like trend, that you want to leave at the default setting.

Adding Keyword Inputs to Your Own Procedures

Next we'll convert the following simple simulation procedure to use keyword inputs.

proc (1) = simulate(nrows, ncols, mu, sd);
    local X;
    X = (rndn(nrows, ncols) * sd) + mu;
    retp(X);
endp;

Declaring Keyword Inputs

To convert the inputs to simulate() to keyword arguments, all we need to do is add an equals sign and the default value after the input in the procedure definition.

proc (1) = simulate(nrows=5, ncols=1, mu=0, sd=1);
    local X;
    X = (rndn(nrows, ncols) * sd) + mu;
    retp(X);
endp;

Now we can call our procedure with no inputs if we want:

// Set for repeatable random numbers
rndseed 23423;

print simulate();

     0.4372582
    -0.3276965
     0.9718211
    -0.0842395
    -0.3505402

What Can be a Default Value

Default values can be any literal value of any data type. They can be scalars as in our previous example, matrices, strings, or string arrays.

What Cannot be a Default Value

Calling a Procedure with Keyword Inputs

Rules for Calling a Procedure with Keyword Inputs

1. Positional inputs come first. Once you pass an input by name, every input after it must also be passed by name.
2. Only inputs with a default can be passed by name. An input declared without a default is positional-only.
3. Named inputs can appear in any order.
4. Any named input you leave out uses its default.

Mixing Positional and Keyword Inputs

Coming back to our opening example:

result = myEstimate(y, X, y_lags={1 2}, quiet=1);

y and X are passed by position, everything else is by name. Since there is no sensible default for your data, they should be required. Inputs declared without a default are positional inputs. They must be passed in before any keyword inputs and they have to be passed in the order the procedure declares them.

Let's continue with a modified version of our simulate() procedure, because it's short and simple.

// Simulate with 1 required positional input
proc (1) = simulate(nrows, ncols=1, mu=0, sd=1);
    local X;
    X = (rndn(nrows, ncols) * sd) + mu;
    retp(X);
endp;

// For repeatable random numbers
rndseed 23423;

print simulate(3, sd=2.5);

       1.0931455
     -0.81924125
       2.4295527

Keyword inputs can also be passed by position, so all of the following calls are equivalent:

rndseed 23423;
print simulate(3, sd=2.5);

rndseed 23423;
print simulate(3, 1, 0, sd=2.5);

rndseed 23423;
print simulate(3, 1, 0, 2.5);

       1.0931455
     -0.81924125
       2.4295527

       1.0931455
     -0.81924125
       2.4295527

       1.0931455
     -0.81924125
       2.4295527

If you misspell the name of a keyword input, GAUSS suggests the closest match:

// Incorrect: error G0739 : Unknown keyword argument 'ncol (did you mean ncols?)'
x = simulate(3, ncol=2);

However, here are two things to watch out for. First, once you name an input, everything after must be named:

// Incorrect: error G0741 : Positional argument after keyword argument
x = simulate(3, ncols=1, 0);

Second, a positional input can't be passed by name:

// Incorrect: error G0739 : Unknown keyword argument 'nrows (did you mean ncols?)'
x = simulate(nrows=10);

nrows is an input to simulate(), but it is not a named keyword input, because the procedure did not declare a default value. Therefore, it cannot be called by name.

Will Keyword Inputs Slow Down My Code?

No. GAUSS resolves keyword inputs when your code is compiled, not when it runs. The compiler matches each name to its position, fills in the defaults for anything you left out, and rewrites the call as an ordinary positional call. By the time your program executes, the two versions are the same code.

That matters if you are calling a procedure thousands of times inside an estimation loop, so here is a test with ten million calls of each form:

proc (1) = addup(a, b=1, c=2, d=3);
    retp(a + b + c + d);
endp;

n = 10000000;

t0 = hsec;
for i (1, n, 1);
    x = addup(1, 2, 3, 4);
endfor;
print "positional:" (hsec-t0)/100 "sec";

t0 = hsec;
for i (1, n, 1);
    x = addup(1, b=2, c=3, d=4);
endfor;
print "keyword:   " (hsec-t0)/100 "sec";

positional:      0.73844300 sec
keyword:         0.73672700 sec

Your timings will differ from machine to machine, but the two forms will always track each other. Write your calls whichever way reads best.

Conclusion

Keyword inputs are a small addition to the language that makes a large difference in how your code reads. To recap:

• Give an input a default value in the procedure definition to make it a keyword input.
• Call it by name, in any order, and leave out anything you want to keep at its default.
• Inputs without a default stay positional, and they come first.
• Defaults must be literals — scalars, matrices, strings, string arrays, or an empty matrix.
• Naming your inputs costs nothing at runtime.

The best part is that there is nothing to migrate. Every procedure you have already written keeps working exactly as it does today, and you can add defaults to them whenever it's convenient. The libraries that ship with GAUSS will adopt the same style in GAUSS 27, so your calls to them will get shorter too.

Keyword inputs are one of several GAUSS 26.1 features aimed at cleaner, more concise code. We'll cover the others in upcoming posts:

• Struct type inference — call a procedure that returns a struct without declaring the receiving variable first.
• Matrix and string array literals — use {1, 2, 3} and {"a", "b"} directly in expressions and procedure calls.

It's natural in data analysis applications for parameters to have bounds; variances can't be negative, GARCH coefficients must sum to less than one for stationarity, and mixing proportions live between zero and one.

When you estimate these models by maximum likelihood, the optimizer needs to respect those bounds, not just at the solution, but throughout the search. If optimization searches wander into invalid territory, it can impact the reliability and convergence of your results. For example, you may get complex numbers from negative variances, explosive forecasts from non-stationary GARCH, or likelihoods that make no sense.

GAUSS 26.0.1 introduces minimize, the first new GAUSS optimizer in over 10 years, to handle this cleanly.

The minimize optmizer let's you specify bounds directly and GAUSS internally keeps parameters feasible at every iteration. No more log-transforms, no penalty functions, and no doublechecking.

In today's blog, we'll see the new minimize function in action, as we walk through two examples:

• A GARCH estimation where variance parameters must be positive
• A Stochastic frontier models where both variance components must be positive.

In both cases, bounded optimization makes estimation easier and aligns results with theory.

Why Bounds Matter

To see why this matters in practice, let’s look at a familiar example. Consider a GARCH(1,1) model:

$\sigma^2_t = \omega + \alpha \varepsilon^2_{t-1} + \beta \sigma^2_{t-1}$

For this model to be well-defined and economically meaningful:

• The baseline variance must be positive ($\omega \gt 0$)
• Shocks and persistence must contribute non-negatively to variance ($\alpha \geq 0$, $\beta \geq 0$)
• The model must be stationary ($\alpha + \beta \lt 1$)

The traditional workaround is to estimate transformed parameters, $\log(\omega)$ instead of $\omega$, then convert back. This works, but it distorts the optimization surface and complicates standard error calculations. You're not estimating the parameters you care about; you're estimating transforms and hoping the numerics work out.

With bounded optimization, you estimate $\omega$, $\alpha$, and $\beta$ directly, with the optimizer respecting the constraints throughout.

Example 1: GARCH(1,1) on Commodity Returns

Let's estimate a GARCH(1,1) model on a dataset of 248 observations of commodity price returns (this data is included in the GAUSS 26 examples directory).

Step One: Data and Likelihood

First, we load the data and specify our log-likelihood objective function.

// Load returns data (ships with GAUSS)
fname = getGAUSShome("examples/df_returns.gdat");
returns = loadd(fname, "rcpi");

// GARCH(1,1) negative log-likelihood
proc (1) = garch_negll(theta, y);
    local omega, alpha, beta_, sigma2, ll, t;

    omega = theta[1];
    alpha = theta[2];
    beta_ = theta[3];

    sigma2 = zeros(rows(y), 1);

    // Initialize with sample variance
    sigma2[1] = stdc(y)^2;

    // Variance recursion
    for t (2, rows(y), 1);
        sigma2[t] = omega + alpha * y[t-1]^2 + beta_ * sigma2[t-1];
    endfor;

    // Gaussian log-likelihood
    ll = -0.5 * sumc(ln(2*pi) + ln(sigma2) + (y.^2) ./ sigma2);

    retp(-ll);  // Return negative for minimization
endp;

Step Two: Setting Up Optimization

Now we set up the bounded optimization with:

• $\omega \gt 0$ (small positive lower bound to avoid numerical issues)
• $\alpha \geq 0$
• $\beta \geq 0$

Because minimize handles simple box constraints, we impose individual upper bounds on $\alpha$ and $\beta$ to keep the optimizer in a reasonable region. We'll verify the stationarity condition, $\alpha + \beta \lt 1$ after estimation.

// Starting values
theta0 = { 0.00001,   // omega (small, let data speak)
           0.05,      // alpha
           0.90 };    // beta

// Set up minimize
struct minimizeControl ctl;
ctl = minimizeControlCreate();

// Bounds: all parameters positive, alpha + beta < 1
ctl.bounds = { 1e-10      1,      // omega in [1e-10, 1]
               0          1,      // alpha in [0, 1]
               0     0.9999 };    // beta in [0, 0.9999]

Step Three: Running the Model

Finally, we call minimize to run our model.

// Estimate
struct minimizeOut out;
out = minimize(&garch_negll, theta0, returns, ctl);

Results and Visualization

After estimation, we'll extract the conditional variance series and confirm the stationarity condition:

// Extract estimates
omega_hat = out.x[1];
alpha_hat = out.x[2];
beta_hat = out.x[3];

print "omega = " omega_hat;
print "alpha = " alpha_hat;
print "beta  = " beta_hat;
print "alpha + beta = " alpha_hat + beta_hat;
print "Iterations: " out.iterations;

Output:

omega = 0.0000070
alpha = 0.380
beta  = 0.588

alpha + beta = 0.968
Iterations: 39

There are a few noteworthy results:

1. The high persistence ($\alpha + \beta \approx 0.97$) means volatility shocks decay slowly.
2. The relatively high $\alpha$ (0.38) indicates that recent shocks have substantial immediate impact on variance.
3. The optimization converged in 39 iterations with all parameters staying inside their bounds throughout. No invalid variance evaluations, no numerical exceptions.

Visualizing the conditional variance alongside the original series provides further insight:

// Compute conditional variance series for plotting
T = rows(returns);
sigma2_hat = zeros(T, 1);
sigma2_hat[1] = stdc(returns)^2;

for t (2, T, 1);
    sigma2_hat[t] = omega_hat + alpha_hat * returns[t-1]^2 + beta_hat * sigma2_hat[t-1];
endfor;

// Plot returns and conditional volatility
struct plotControl plt;
plt = plotGetDefaults("xy");
plotSetTitle(&plt, "GARCH(1,1): Returns and Conditional Volatility");
plotSetYLabel(&plt, "Returns / Volatility");

plotLayout(2, 1, 1);
plotXY(plt, seqa(1, 1, T), returns);

plotLayout(2, 1, 2);
plotSetTitle(&plt, "Conditional Standard Deviation");
plotXY(plt, seqa(1, 1, T), sqrt(sigma2_hat));

The plot shows volatility clustering: periods of high volatility tend to persist, consistent with what we observe in commodity markets.

Example 2: Stochastic Frontier Model

Stochastic frontier analysis separates random noise from systematic inefficiency. It's widely used in productivity analysis to measure how far firms operate below their production frontier.

The model:

$y = X\beta + v - u$

where:

• $v \sim N(0, \sigma^2_v)$ — symmetric noise (measurement error, luck)
• $u \sim N^+(0, \sigma^2_u)$ — one-sided inefficiency (always reduces output)

Both variance components must be positive. If the optimizer tries $\sigma^2_v \lt 0$ or $\sigma^2_u \lt 0$, the likelihood involves square roots of negative numbers.

Step One: Data and Likelihood

For this example, we'll simulate data from a Cobb-Douglas production function with inefficiency. This keeps the example self-contained and lets you see exactly what's being estimated.

// Simulate production data
rndseed 8675309;
n = 500;

// Inputs (labor, capital, materials)
labor = exp(2 + 0.5*rndn(n, 1));
capital = exp(3 + 0.7*rndn(n, 1));
materials = exp(2.5 + 0.4*rndn(n, 1));

// True parameters
beta_true = { 1.5,    // constant
              0.4,    // labor elasticity
              0.3,    // capital elasticity
              0.25 }; // materials elasticity
sig2_v_true = 0.02;   // noise variance
sig2_u_true = 0.08;   // inefficiency variance

// Generate output with noise (v) and inefficiency (u)
v = sqrt(sig2_v_true) * rndn(n, 1);
u = sqrt(sig2_u_true) * abs(rndn(n, 1));  // half-normal

X = ones(n, 1) ~ ln(labor) ~ ln(capital) ~ ln(materials);
y = X * beta_true + v - u;  // inefficiency reduces output

After simulating our data, we specify the log-likelihood function for minimization:

// Stochastic frontier log-likelihood (half-normal inefficiency)
proc (1) = sf_negll(theta, y, X);
    local k, beta_, sig2_v, sig2_u, sigma, lambda;
    local eps, z, ll;

    k = cols(X);
    beta_ = theta[1:k];
    sig2_v = theta[k+1];
    sig2_u = theta[k+2];

    sigma = sqrt(sig2_v + sig2_u);
    lambda = sqrt(sig2_u / sig2_v);

    eps = y - X * beta_;
    z = -eps * lambda / sigma;

    ll = -0.5*ln(2*pi) + ln(2) - ln(sigma)
         - 0.5*(eps./sigma).^2 + ln(cdfn(z));

    retp(-sumc(ll));
endp;

Step Two: Setting Up Optimization

As we did in our previous example, we begin with our starting values. For this model, we run OLS and use the residual variance as starting values:

// OLS for starting values
beta_ols = invpd(X'X) * X'y;
resid = y - X * beta_ols;
sig2_ols = meanc(resid.^2);

// Starting values: Split residual variance 
// between noise and inefficiency
theta0 = beta_ols | (0.5 * sig2_ols) | (0.5 * sig2_ols);

We leave our coefficients unbounded but constrain the variances to be positive:

// Bounds: coefficients unbounded, variances positive
k = cols(X);
struct minimizeControl ctl;
ctl = minimizeControlCreate();
ctl.bounds = (-1e300 * ones(k, 1) | 0.001 | 0.001) ~ (1e300 * ones(k+2, 1));

Step Three: Running the Model

Finally, we call minimize to estimate our model:

// Estimate
struct minimizeOut out;
out = minimize(&sf_negll, theta0, y, X, ctl);

Results and Visualization

Now that we've estimated our model, let's examine our results.

// Extract estimates
k = cols(X);
beta_hat = out.x[1:k];
sig2_v_hat = out.x[k+1];
sig2_u_hat = out.x[k+2];

print "Coefficients:";
print "  constant     = " beta_hat[1];
print "  ln(labor)    = " beta_hat[2];
print "  ln(capital)  = " beta_hat[3];
print "  ln(materials)= " beta_hat[4];
print "";
print "Variance components:";
print "  sig2_v (noise)       = " sig2_v_hat;
print "  sig2_u (inefficiency)= " sig2_u_hat;
print "  ratio sig2_u/total   = " sig2_u_hat / (sig2_v_hat + sig2_u_hat);
print "";
print "Iterations: " out.iterations;

This prints out coefficients and variance components:

Coefficients:
  constant     = 1.51
  ln(labor)    = 0.39
  ln(capital)  = 0.31
  ln(materials)= 0.24

Variance components:
  sig2_v (noise)       = 0.022
  sig2_u (inefficiency)= 0.087
  ratio sig2_u/total   = 0.80

Iterations: 38

The estimates recover the true parameters reasonably well. The variance ratio ($\approx 0.80$) tells us that most residual variation is systematic inefficiency, not measurement error — an important finding for policy.

We can also compute and plot firm-level efficiency scores:

// Compute efficiency estimates (Jondrow et al. 1982)
eps = y - X * beta_hat;
sigma = sqrt(sig2_v_hat + sig2_u_hat);
lambda = sqrt(sig2_u_hat / sig2_v_hat);

mu_star = -eps * sig2_u_hat / (sig2_v_hat + sig2_u_hat);
sig_star = sqrt(sig2_v_hat * sig2_u_hat / (sig2_v_hat + sig2_u_hat));

// E[u|eps] - conditional mean of inefficiency
u_hat = mu_star + sig_star * (pdfn(mu_star/sig_star) ./ cdfn(mu_star/sig_star));

// Technical efficiency: TE = exp(-u)
TE = exp(-u_hat);

// Plot efficiency distribution
struct plotControl plt;
plt = plotGetDefaults("hist");
plotSetTitle(&plt, "Distribution of Technical Efficiency");
plotSetXLabel(&plt, "Technical Efficiency (1 = frontier)");
plotSetYLabel(&plt, "Frequency");
plotHist(plt, TE, 20);

print "Mean efficiency: " meanc(TE);
print "Min efficiency:  " minc(TE);
print "Max efficiency:  " maxc(TE);

Mean efficiency: 0.80
Min efficiency:  0.41
Max efficiency:  0.95

The histogram shows substantial variation in efficiency — some firms operate near the frontier (TE $\approx$ 0.95), while others produce 40-50% below their potential. This is the kind of insight that drives productivity research.

Both variance estimates stayed positive throughout optimization. No log-transforms needed, and the estimates apply directly to the parameters we care about.

When to Use minimize

The minimize procedure is designed for one thing: optimization with bound constraints. If that's all you need, it's the right tool.

For the GARCH and stochastic frontier examples above — and most MLE problems where parameters have natural bounds — minimize handles it directly.

Conclusion

Bounded parameters show up constantly in econometric models: variances, volatilities, probabilities, shares. GAUSS 26.0.1 gives you a clean way to handle them with minimize. As we saw today minimize:

• Set bounds in the control structure
• Optimizer respects bounds throughout (not just at the solution)
• No log-transforms or penalty functions
• Included in base GAUSS

If you've been working around parameter bounds with transforms or checking for invalid values inside your likelihood function, this is the cleaner path.

Further Reading

• GARCH estimation in GAUSS
• Introduction to stochastic frontier models

Whether you're tracking down a performance bottleneck, estimating a model with bound constraints, or transforming data interactively, this release has something that will change how you work. Here's what's new.

Find your slow code in seconds

GAUSS 26 includes a built-in profiler. Open any program, press Shift+F5 (or use the run button in the Profiler), and GAUSS profiles every line and procedure call as it runs.

The profiler panel has three tabs:

• Hot Spots — every line of code ranked by time spent, so you can see exactly where your program spends the most time
• Call Tree — a hierarchical view of which procedures call which, and how long each takes
• Output — the program's normal output, so you can verify results while profiling

Double-click any entry to jump directly to that line in the editor.

If you've ever wanted to make your estimation faster, the profiler tells you exactly where to focus. No print statements, no guessing — you see the bottleneck immediately.

---

Bound-constrained optimization with L-BFGS-B

The new minimize function brings the L-BFGS-B algorithm to GAUSS — the standard method for smooth unconstrained and bound-constrained optimization problems.

// Define an objective function
proc (1) = rosenbrock(x);
    retp( (1 - x[1])^2 + 100 * (x[2] - x[1]^2)^2 );
endp;

// Set up bounds
x0 = { -1, -1 };

struct minimizeControl ctl;
ctl = minimizeControlCreate();
ctl.bounds = { -5 5, -5 5 };

// Optimize
struct minimizeOut out;
out = minimize(&rosenbrock, x0, ctl);

Solution:       x = 1.0000, 1.0000
Function value: 5.69e-14
Return code:    0 (converged)

minimize supports passing extra data arguments directly to the objective function, so you don't need globals to get data into your likelihood. This is useful for MLE where parameters must stay positive (e.g., variance components) or bounded (e.g., correlations between -1 and 1).

L-BFGS-B is the standard choice for smooth bound-constrained problems. For nonlinear equality or inequality constraints, use sqpSolveMT. For unconstrained problems, minimize and optmt are both good options — minimize uses less memory for high-dimensional problems.

---

Modern language syntax

GAUSS 26 adds conveniences that reduce friction in everyday code — sequences, printing, and error messages all work the way you'd expect.

Colon operator

GAUSS now supports the colon operator for creating sequences:

// Before
x = seqa(1, 1, 5);

// Now
x = 1:5;

1  2  3  4  5

The stepped form creates sequences with custom increments:

odds = 1:2:10;
countdown = 10:-2:1;
grid = 0:0.5:2;

odds:       1  3  5  7  9
countdown:  10  8  6  4  2
grid:       0  0.5  1  1.5  2

Both forms work with variables and expressions (a:b, (n-1):(n+1), minc(x):maxc(x)). Inside brackets, the colon continues to work as an index range — x[1:5] selects elements 1 through 5, as it always has.

Print expressions

print now accepts expressions directly without requiring them to be surrounded with parentheses:

x = 3;
y = 7;
print x + y;
print x .* y;

10
21

All arithmetic, comparison, element-wise, and string operators are supported. The existing whitespace-sensitive behavior is preserved — print a -b; still prints two items, while print a - b; prints the difference.

Better error messages

Error messages now tell you what went wrong and where to look.

x = rndn(10);

Before:  "Wrong number of arguments"
Now:     "'rndn' requires 2-3 arguments, got 1"

rndn = 100;

Before:  "Syntax error"
Now:     "Illegal use of reserved word 'rndn'"

---

Statistical testing functions

GAUSS 26 adds four statistical testing functions to the base package.

ttest — Two-sample and paired t-tests with Welch and pooled variance options, confidence intervals, and F-test for equality of variances.

// Compare treatment vs control means
result = ttest(treatment, control);

shapiroWilk — The standard test for univariate normality.

result = shapiroWilk(residuals);
print result.w;
print result.p;

W statistic: 0.9788
p-value:     0.1070

mvnTest — Multivariate normality testing using Henze-Zirkler (default), Mardia's skewness and kurtosis, Doornik-Hansen, or Royston methods. Useful for checking VAR residuals or validating distributional assumptions before estimation.

contingency — Comprehensive analysis of contingency tables: chi-squared tests, Fisher's exact test, odds ratios, relative risk, and measures of association including Cramer's V, Gamma, Kendall's tau-b, and Cohen's Kappa.

---

Transform data without writing code

The new Transform Tab in the Symbol Editor lets you apply common data transformations interactively — lag, first difference, percent change, moving average, log, standardize, normalize, and more.

Select a column, choose a transformation, and the result appears as a new column. GAUSS generates the equivalent code automatically, so you can incorporate the transformation into your scripts later.

String columns support lowercase, uppercase, trim, and text replacement. Date columns support extracting year, month, day, quarter, week, and time components.

---

Data management

New functions for the tasks that bookend every estimation: reshaping data, converting frequencies, and balancing panels.

Aggregate time series to any frequency

The new tsAggregate function converts time series data from higher to lower frequencies:

data = loadd("daily_prices.csv", "date(Date) + Price + Volume");

// Convert daily to monthly: last price, total volume
monthly = tsAggregate(data, "monthly", "last" $| "sum");

Supports second, minute, hourly, daily, monthly, quarterly, and yearly frequencies. Aggregation methods include last, first, mean, sum, max, min, median, standard deviation, count, and mode.

Add computed columns to dataframes

The new dfaddcol function adds a named column to a dataframe in one step:

auto2 = dfaddcol(auto2, "price_k", auto2[., "price"] ./ 1000);
auto2 = dfaddcol(auto2, "log_mpg", ln(auto2[., "mpg"]));

           make     price       mpg   price_k   log_mpg
    AMC Concord      4099        22     4.099     3.091
      AMC Pacer      4749        17     4.749     2.833
     AMC Spirit      3799        22     3.799     3.091
  Buick Century      4816        20     4.816     2.996
  Buick Electra      7827        15     7.827     2.708

The new columns are named and ready to use. If you're building derived variables for estimation, this keeps your workflow clean and your column names explicit.

Balance panel datasets

pdBalance standardizes panel data so each group has identical time coverage:

balanced = pdBalance(panel_data, "fill");

This fills gaps with missing values so every group spans the full time range — a common preprocessing step before panel estimation. Pairs naturally with pdLag and pdSummary introduced in GAUSS 25.

Multicolumn aggregation

The aggregate function now supports grouping by more than one variable:

method = "max";
variables = "day" $| "time";
max_tips = aggregate(tips, method, variables);

---

Editor and IDE

Spot global variables in your code

Global variables in procedures prevent you from adding threadFor or other parallelization to your code and make maintenance difficult. GAUSS 26 lets you find them instantly — procedures that reference globals now show those variables with an orange highlight in the editor. Hover over any highlighted variable to see its name in a tooltip. Toggle it on or off via Edit > Preferences > Highlight globals in procs.

Streamlined graphics interface

The Graphics page now combines Graph Settings and Canvas Settings into a single tabbed interface with tabs for Axes, Lines, Symbols, Text, and Canvas. A new toolbar toggle provides quick access.

Filter widgets for navigation

New filter widgets on the Command page and Data page let you search through command history and workspace symbols as you type. Press Ctrl+K (Cmd+K on Mac) to activate the filter in either view. The Open Symbol dialog on the Data page also includes autocomplete.

---

Additional enhancements

• repmat — tile a matrix: repmat(A, 3, 2) creates a matrix of 3x2 copies of A (MATLAB equivalent: repmat)
• findIdx — return indices where a condition is true: findIdx(x .> 0) (R equivalent: which())
• diagmat — create diagonal or off-diagonal matrices from vectors, with optional offset for super- or subdiagonals
• sortc and sortmc — new sort_order parameter for ascending (1) or descending (-1) sorting
• endswith — complements startsWith for string and dataframe filtering
• strrindx — now accepts vector input for search patterns
• quantileFit — new convergence diagnostics (qOut.converged, qOut.iterations) and improved input validation with clear error messages
• sqpSolveMT — improved robustness for challenging optimization problems with better adaptive trust region management
• eigv — 2.6x faster for 2x2 matrices using closed-form solution, with automatic fallback to the standard algorithm for near-repeated eigenvalues
• Symbol Editor — new "Starts With", "Does Not Start With", "Ends With", "Does Not End With" filters; pending changes shown in blue text; column headers show asterisk for pending filters or transforms
• Package Manager — detailed error messages with categorized troubleshooting steps
• New button on Edit and Debug pages opens matrices, strings, and dataframes directly in the Symbol Editor

---

What's coming next

Later this year, we'll be shipping new Bayesian VAR estimation with Minnesota priors, conditional forecasting, and hyperparameter optimization — directly from GAUSS, powered by new high-performance computation libraries. Stay tuned.

---

Get started with GAUSS 26

GAUSS 26 is a free update for users with active maintenance. Download for Windows or macOS, or contact us for a trial license.

New to GAUSS? See our Getting Started Guide. Coming from another language? See our Coming to GAUSS guides for R, MATLAB, Stata, and Python users.

]]> https://www.aptech.com/blog/gauss26/feed/ 0