import smile.data.DataFrame;
import smile.data.formula.Formula;
import static smile.data.formula.Terms.*;

// Load data
DataFrame df = /* ... your DataFrame ... */;

// ① Predict "salary" from all other columns
Formula f1 = Formula.lhs("salary");

// ② Predict "class" from age and log(income)
Formula f2 = Formula.of("class", $("age"), log("income"));

// ③ Get the design matrix (bias column included by default)
var X = f2.matrix(df);

// ④ Get the response vector
var y = f2.y(df);

// ⑤ Get just the predictor DataFrame
var xdf = f2.x(df);

Formula f = Formula.of("salary ~ age + log(income) + gender");

Formula.of("y ~ .")                       // y ~ all other columns
Formula.of("y ~ x1 + x2 - 1")            // no intercept
Formula.of("y ~ log(x) + sqrt(z)")        // transformations
Formula.of("y ~ (a x b x c)^2")           // interactions up to degree 2
Formula.of("y ~ a:b + c")                 // explicit interaction + main effect
Formula.of(" ~ .")                        // no response, all columns

// lhs("col")  — response only; predictors = all remaining columns (.)
Formula f = Formula.lhs("salary");
// equivalent to: Formula.of("salary ~ .")

// of(response, predictors...)  — explicit response + predictor terms
Formula f = Formula.of("salary", $("age"), log("income"), cross("a","b"));

// of(response, String... predictors) — shorthand with column names
Formula f = Formula.of("salary", "age", "gender");

// rhs(Term...)  — no response variable (unsupervised / feature extraction)
Formula f = Formula.rhs($("age"), log("income"));

// rhs(String...)  — no response, column names only
Formula f = Formula.rhs("age", "gender");

import static smile.data.formula.Terms.*;

Formula.of("salary", dot())               // salary ~ .
Formula.of("salary", dot(), delete("id")) // salary ~ . - id

Formula.of("salary ~ . - id")

Term t = $("age");          // shorthand factory in Terms
Term t = new Variable("age");

Formula.of("y", "x1", "x2")  // x1 and x2 become Variable terms

// Explicitly include intercept (default behaviour)
Formula.of("y ~ x + 1")
Formula.of("y", $("x"), new Intercept(true))

// Remove intercept — fit a line through the origin
Formula.of("y ~ x + 0")
Formula.of("y ~ x - 1")
Formula.of("y", $("x"), new Intercept(false))

// Remove a single column
Formula.of("y ~ . - id")
Formula.of("y", dot(), delete("id"))

// Remove an interaction
Formula.of("y ~ (a x b x c) - a:b")
Formula.of("y", cross("a","b","c"), delete(interact("a","b")))

Term t = delete("age");
Term t = delete(log("income"));

add("x", "y")             // x + y
sub("revenue", "cost")    // revenue - cost
mul("price", val(1.1))    // price * 1.1  (constant scale-up by 10%)
div("total", val(100))    // total / 100

Formula.of("profit", dot(), sub("revenue", "cost"), div("profit", "revenue"))
// profit ~ . + (revenue - cost) + (profit / revenue)

log("income")                  // log of the "income" column
log(add("base", "bonus"))      // log(base + bonus)  — nested terms
sqrt(div("variance", val(n)))  // sqrt(variance / n)

// Programmatic
Term t = interact("outlook", "temperature");  // outlook:temperature
Term t = interact("a", "b", "c");             // a:b:c

// String formula
Formula.of("play ~ a:b + c")

// Full crossing of three factors
Term t = cross("a", "b", "c");               // (a x b x c)

// Crossing up to degree 2 only
Term t = cross(2, "a", "b", "c");            // (a x b x c)^2

// String formula
Formula.of("y ~ (a x b x c)^2")
Formula.of("y ~ (a x b x c)")

Formula.of("y", cross("a","b","c"), delete(interact("a","b")))
// Adds a, b, c, a:c, b:c, a:b:c  (a:b removed)

date("timestamp", DateFeature.YEAR, DateFeature.MONTH, DateFeature.DAY_OF_MONTH)
date("birthday",  DateFeature.YEAR, DateFeature.DAY_OF_WEEK)
date("checkIn",   DateFeature.HOUR, DateFeature.MINUTE)

// Not currently parseable from a string; use the Java API:
Formula.rhs(date("timestamp", DateFeature.YEAR, DateFeature.MONTH))

val(1)         // integer constant 1
val(0.5)       // double constant 0.5
val(100L)      // long constant 100
val(true)      // boolean constant true
val('A')       // char constant 'A'
val((byte)  1) // byte constant 1
val((short) 2) // short constant 2
val("label")   // Object constant — produces an object column

mul("price", val(1.08))       // apply 8% tax
add("age", val(-18))          // centre age at 18
div("bytes", val(1024 * 1024)) // convert bytes → MiB

// ToIntFunction<T>
Term t = Terms.of("clip", "age", (Integer x) -> Math.max(0, Math.min(x, 100)));

// ToDoubleFunction<T>
Term t = Terms.of("normalize", "score",
                  (Double x) -> (x - mean) / stddev);

// Function<T, R> with explicit return class
Term t = Terms.of("bucket", "income", String.class,
                  (Double x) -> x < 50_000 ? "low" : x < 150_000 ? "mid" : "high");

// ToDoubleBiFunction<T, U>
Term t = Terms.of("ratio", "numerator", "denominator",
                  (Double a, Double b) -> a / b);

// ToIntBiFunction<T, U>
Term t = Terms.of("diff_days", "start", "end",
                  (LocalDate a, LocalDate b) -> (int) ChronoUnit.DAYS.between(a, b));

// BiFunction<T, U, R>
Term t = Terms.of("concat", "first", "last", String.class,
                  (String a, String b) -> a + " " + b);

Formula f = Formula.of("churn", dot(),
        Terms.of("tenure_months", "start_date", "end_date",
                 (LocalDate s, LocalDate e) ->
                     (int) ChronoUnit.MONTHS.between(s, e)));

StructType xschema = formula.bind(df.schema());
System.out.println(xschema);

DataFrame out = formula.frame(df);
// Columns: [response, predictor1, predictor2, ...]

DataFrame xdf = formula.x(df);

// As a ValueVector (for use with SMILE learners)
ValueVector y = formula.y(df);

// As a double value from a single Tuple
double yval = formula.y(tuple);

// As an int value from a single Tuple
int yint = formula.yint(tuple);

DenseMatrix X = formula.matrix(df);          // with bias column (default)
DenseMatrix X = formula.matrix(df, true);    // with bias column
DenseMatrix X = formula.matrix(df, false);   // without bias column

// Full (response + predictors) Tuple
Tuple yx = formula.apply(tuple);

// Predictors-only Tuple
Tuple x = formula.x(tuple);

Formula f = Formula.of("salary ~ . - id + log(age)");
Formula expanded = f.expand(df.schema());
System.out.println(expanded);
// salary ~ gender + birthday + name + log(age)   (id was deleted)

// Fit line through origin
Formula f = Formula.of("y ~ x + 0");
DenseMatrix X = f.matrix(df);   // single column, no bias

// Explicit bias override
DenseMatrix X = f.matrix(df, true);  // force bias regardless of formula

// salary is nullable; age is not
Formula f = Formula.rhs(add("salary", "age"));
DataFrame out = f.frame(df);
// Rows where salary == null → result is null

Formula.of("play", $("outlook"), $("temperature"))

// "outlook" has levels {sunny, overcast, rainy}
// matrix() produces two binary columns: outlook_overcast, outlook_rainy
DenseMatrix X = formula.matrix(df);

import java.time.LocalDate;
import smile.data.DataFrame;
import smile.data.formula.Formula;
import smile.data.formula.DateFeature;
import static smile.data.formula.Terms.*;

// Suppose df has columns: order_date (LocalDate), amount (double), region (String)

Formula f = Formula.of("amount",
        dot(),                      // include region
        date("order_date",          // extract calendar features
                DateFeature.YEAR,
                DateFeature.QUARTER,
                DateFeature.MONTH,
                DateFeature.DAY_OF_WEEK));

DataFrame out = f.frame(df);
// Columns: amount, region, order_date_YEAR, order_date_QUARTER,
//          order_date_MONTH, order_date_DAY_OF_WEEK
//
// order_date_MONTH    has NominalScale (JANUARY … DECEMBER)
// order_date_DAY_OF_WEEK has NominalScale (MONDAY … SUNDAY)

System.out.println(out.getString(0, 3));  // e.g. "MARCH"
System.out.println(out.getString(0, 4));  // e.g. "TUESDAY"

date("created_at",
     DateFeature.YEAR, DateFeature.MONTH, DateFeature.DAY_OF_MONTH,
     DateFeature.HOUR, DateFeature.MINUTE)

date("open_time", DateFeature.HOUR, DateFeature.MINUTE)

import java.time.LocalDate;
import java.time.temporal.ChronoUnit;
import smile.data.formula.Formula;
import static smile.data.formula.Terms.*;

Formula f = Formula.of("default",

    // Debt-to-income ratio
    div("loan_amount", "income"),

    // Log-transform income to reduce skew
    log("income"),

    // Loan duration in months via a custom binary lambda
    Terms.of("duration_months", "start_date", "end_date",
             (LocalDate s, LocalDate e) ->
                 (int) ChronoUnit.MONTHS.between(s, e)),

    // Flag high-value loans (> 50 000) via a custom unary lambda
    Terms.of("high_value", "loan_amount", String.class,
             (Double x) -> x > 50_000 ? "yes" : "no"),

    // Square-root of loan amount to reduce skew
    sqrt("loan_amount")
);

// Bind to schema to inspect output columns
var schema = f.bind(df.schema());
System.out.println(schema);

// Produce design matrix with bias
var X = f.matrix(df);
var y = f.y(df);

// Safe: one Formula object, many threads
try (Formula f = Formula.of("y ~ x")) {
    parallelStream.forEach(df -> {
        var X = f.matrix(df);  // thread-safe
    });
}  // close() removes thread-local binding and avoids memory leaks

try (Formula f = Formula.lhs("label")) {
    // ... use f ...
}