smile.data.type
│
├── DataType (interface)          – describes storage format
│     ├── Primitive types         – BooleanType, ByteType, ShortType,
│     │                             IntType, LongType, FloatType, DoubleType,
│     │                             CharType  (each has nullable=false/true)
│     ├── TemporalType            – DateType, TimeType, DateTimeType
│     ├── DecimalType             – BigDecimal
│     ├── StringType              – String
│     ├── ObjectType              – arbitrary Object
│     ├── ArrayType               – primitive array columns
│     └── StructType              – schema (ordered list of StructFields)
│
├── StructField(name, dtype, measure?)  – one column descriptor
└── DataTypes                     – constants and factory methods

smile.data.measure
│
├── Measure (interface)           – adds semantic meaning to a numeric column
│     ├── CategoricalMeasure      – discrete labeled integer codes
│     │     ├── NominalScale      – unordered categories (gender, country…)
│     │     └── OrdinalScale      – ordered categories (rating, grade…)
│     └── NumericalMeasure        – continuous numeric annotations
│           ├── IntervalScale     – no true zero (temperature °C, year)
│           └── RatioScale        – true zero (price, weight, count)
└── Measure.Currency / Percent    – built-in ratio-scale singletons

smile.data.vector
│
├── ValueVector (interface)       – one typed column of a DataFrame
│     ├── PrimitiveVector         – non-nullable: IntVector, DoubleVector…
│     ├── NullablePrimitiveVector – nullable: NullableIntVector…
│     ├── StringVector            – String column (always nullable-compatible)
│     ├── NumberVector<N>         – boxed Number column (BigDecimal…)
│     └── ObjectVector<T>         – arbitrary Object column

smile.data
│
├── Tuple (interface)             – one row; immutable ordered field list
│     └── Row (record)            – Tuple backed by a DataFrame + row index
│
├── RowIndex                      – optional label → ordinal index for rows
│
└── DataFrame (record)            – 2-D heterogeneous tabular data
      schema    : StructType
      columns   : List<ValueVector>
      index     : RowIndex?        (optional row labels)

import smile.data.type.DataTypes;
import smile.data.type.DataType;

boolean isNull = df.isNullAt(row, col);
if (!isNull) {
    double v = df.getDouble(row, col);
}

import smile.data.type.StructField;

// Plain double column
StructField age     = new StructField("age",    DataTypes.IntType);

// Nullable salary
StructField salary  = new StructField("salary", DataTypes.NullableDoubleType);

// Categorical column with a NominalScale
StructField gender  = new StructField("gender", DataTypes.ByteType,
                                      new NominalScale("Male", "Female"));

// Useful predicates
boolean numeric = age.isNumeric();      // true for non-nominal numeric
boolean nullable = salary.dtype().isNullable();

import smile.data.type.StructType;

StructType schema = new StructType(
    new StructField("name",   DataTypes.StringType),
    new StructField("age",    DataTypes.IntType),
    new StructField("salary", DataTypes.NullableDoubleType)
);

// Field access
StructField f = schema.field("age");    // by name
StructField f = schema.field(1);        // by ordinal

int j         = schema.indexOf("age");  // ordinal of "age"
String[]  ns  = schema.names();
DataType[] dt = schema.dtypes();
int       len = schema.length();

import smile.data.measure.*;

// From string labels (codes are 0, 1, 2, …)
NominalScale gender = new NominalScale("Male", "Female");

// From an enum
NominalScale color = new NominalScale(Color.class); // enum Color { Red, Green, Blue }

// From explicit code→label pairs
NominalScale custom = new NominalScale(
    new int[]    {1, 3, 7},
    new String[] {"Low", "Mid", "High"}
);

int    code  = gender.valueOf("Female").intValue(); // 1
String label = gender.level(0);                    // "Male"
int    size  = gender.size();                      // 2

OrdinalScale rating = new OrdinalScale("Poor", "Fair", "Good", "Excellent");
// ordinals: 0=Poor, 1=Fair, 2=Good, 3=Excellent

IntervalScale celsius = new IntervalScale(NumberFormat.getInstance());

// Built-in singletons
Measure price  = Measure.Currency;   // formats as currency
Measure pct    = Measure.Percent;    // formats as percentage

// Custom
RatioScale weight = new RatioScale(NumberFormat.getInstance());

import smile.data.vector.*;

StructField field = new StructField("gender", DataTypes.ByteType,
                                    new NominalScale("Male", "Female"));
ByteVector gender = new ByteVector(field, new byte[]{0, 1, 0, 1});

import java.util.BitSet;

double[] values   = {80000.0, Double.NaN, 90000.0};
BitSet   nullMask = new BitSet(3);
nullMask.set(1);  // index 1 is null

NullableDoubleVector salary = new NullableDoubleVector(
    new StructField("salary", DataTypes.NullableDoubleType),
    values, nullMask
);

salary.isNullable();     // true
salary.isNullAt(1);      // true
salary.getDouble(0);     // 80000.0
salary.getNullCount();   // 1

StringVector  names = new StringVector("name",  new String[]{"Alice","Bob"});
ObjectVector<LocalDate> dates = new ObjectVector<>(
    new StructField("birthday", DataTypes.DateType),
    new LocalDate[]{ LocalDate.of(1990,1,1), LocalDate.of(1985,6,15) }
);

ValueVector v = df.column("age");

// Size and nullability
int n  = v.size();
boolean nullable = v.isNullable();
boolean hasNull  = v.anyNull();
int nullCount    = v.getNullCount();
boolean rowNull  = v.isNullAt(2);

// Typed reads
int    i = v.getInt(0);
double d = v.getDouble(0);
String s = v.getString(0);       // uses measure for categorical columns
Object o = v.get(0);             // boxed / object value, may be null

// Bulk export
int[]    ia = v.toIntArray();
double[] da = v.toDoubleArray();
String[] sa = v.toStringArray();

// Streaming
v.intStream().sum();
v.doubleStream().average();
v.stream().filter(Objects::nonNull).count();

// Boolean filter masks
boolean[] mask = v.eq(30);       // element-wise ==
boolean[] mask = v.gt(25);       // element-wise >
boolean[] mask = v.isin(25, 30); // element-wise membership

// Sub-selection
ValueVector sub = v.get(Index.of(new int[]{0, 2, 3}));

// Rename (returns new vector)
ValueVector renamed = v.withName("years");

// In-place mutation
v.set(0, 99);

import smile.data.Tuple;
import smile.data.type.StructType;

// Construct standalone from schema + values
StructType schema = new StructType(
    new StructField("x", DataTypes.IntType),
    new StructField("y", DataTypes.DoubleType)
);
Tuple t = Tuple.of(schema, new Object[]{42, 3.14});
Tuple t = Tuple.of(schema, new int[]{42}, new double[]{3.14});

Tuple row = df.get(0);

// By ordinal
int    age    = row.getInt(0);
double salary = row.getDouble(2);
String name   = row.getString(1);

// By name
int    age    = row.getInt("age");
double salary = row.getDouble("salary");

// Generic (boxed, may return null)
Object val = row.get(0);
Object val = row.get("name");

// Null check — always check before primitive accessors on nullable columns
boolean isNull = row.isNullAt(2);
boolean isNull = row.isNullAt("salary");
boolean anyNull = row.anyNull();

// All fields as doubles (NaN for nulls, level encoding for categoricals)
double[] arr = row.toArray();

// Selective fields
double[] arr = row.toArray("age", "salary");

// With intercept (bias=1) and dummy encoding
double[] arr = row.toArray(true, CategoricalEncoder.DUMMY, "age", "gender", "salary");

StructType schema  = row.schema();
int        length  = row.length();
int        j       = row.indexOf("salary");

import smile.data.DataFrame;

DataFrame df = new DataFrame(
    new StringVector ("name",   new String[] {"Alice", "Bob", "Charlie"}),
    new IntVector    ("age",    new int[]    {25, 30, 35}),
    new DoubleVector ("salary", new double[] {60000., 80000., 90000.})
);

double[][] data = {{1.0, 2.0}, {3.0, 4.0}, {5.0, 6.0}};

// Auto-named columns: V1, V2
DataFrame df = DataFrame.of(data);

// Custom names
DataFrame df = DataFrame.of(data, "x", "y");
DataFrame df = DataFrame.of(new int[][]{{1,2},{3,4}}, "a", "b");
DataFrame df = DataFrame.of(new float[][]{{1f},{2f}}, "v");

public class Person {
    public String getName()     { return name; }
    public int    getAge()      { return age;  }
    public Double getSalary()   { return salary; }   // nullable wrapper → NullableDoubleType
    public Gender getGender()   { return gender; }   // enum → ByteVector with NominalScale
    // …
}

List<Person> persons = List.of(
    new Person("Alice", 25, 60000., Gender.Female),
    new Person("Bob",   30, null,   Gender.Male)
);
DataFrame df = DataFrame.of(Person.class, persons);

StructType schema = new StructType(
    new StructField("x", DataTypes.IntType),
    new StructField("y", DataTypes.DoubleType)
);

// Non-empty list
List<Tuple> rows = List.of(Tuple.of(schema, 1, 2.0), Tuple.of(schema, 3, 4.0));
DataFrame df = DataFrame.of(schema, rows);

// Stream variant
DataFrame df = DataFrame.of(schema, rows.stream());

// Empty list — returns a zero-row DataFrame with the correct schema
DataFrame empty = DataFrame.of(schema, List.of());

try (Connection conn = DriverManager.getConnection(url);
     Statement  stmt = conn.createStatement();
     ResultSet  rs   = stmt.executeQuery("SELECT * FROM employees")) {
    DataFrame df = DataFrame.of(rs);
}

// Dimensions
int nrow = df.nrow();          // number of rows
int ncol = df.ncol();          // number of columns
int size = df.size();          // alias for nrow()
int[] shape = {df.shape(0), df.shape(1)};  // {nrow, ncol}
boolean empty = df.isEmpty();

// Schema
StructType schema   = df.schema();
String[]   names    = df.names();
DataType[] dtypes   = df.dtypes();
Measure[]  measures = df.measures();

// Print
System.out.println(df);          // head(10)
System.out.println(df.head(5));  // first 5 rows
System.out.println(df.tail(5));  // last 5 rows
System.out.println(df.toString(2, 7, true));  // rows [2,7)

// Summary statistics
System.out.println(df.describe());

Object  val = df.get(row, col);           // boxed value, may be null
int     i   = df.getInt(row, col);
long    l   = df.getLong(row, col);
float   f   = df.getFloat(row, col);
double  d   = df.getDouble(row, col);
String  s   = df.getString(row, col);     // uses measure for categoricals
String  sc  = df.getScale(row, col);      // level name for NominalScale / OrdinalScale
boolean nil = df.isNullAt(row, col);

Tuple row = df.get(0);                    // first row
Tuple row = df.apply(0);                  // Scala alias

// Iterate all rows
for (Row row : df) { /* … */ }
df.stream().forEach(row -> /* … */);
List<Row> list = df.toList();

ValueVector col = df.column(0);           // by ordinal
ValueVector col = df.column("age");       // by name
ValueVector col = df.apply("age");        // Scala alias

df.set(row, col, value);
df.update(row, col, value);               // Scala alias

// Attach an index from an existing column (column is removed from data)
DataFrame indexed = df.setIndex("name");

// Attach an index from an external array
DataFrame indexed = df.setIndex(new Object[]{"r0","r1","r2","r3"});

// Look up by label
Tuple row  = indexed.loc("Alice");          // single row
DataFrame sub = indexed.loc("Alice","Bob"); // multiple rows

// RowIndex directly
RowIndex index = new RowIndex(new Object[]{"a","b","c"});

int  i   = index.apply("b");             // 1
int  i   = index.getOrDefault("x");     // -1 (not found)
boolean has = index.containsKey("a");   // true
int  n   = index.size();                // 3

// Select by ordinal indices
DataFrame sub = df.select(0, 2);

// Select by name
DataFrame sub = df.select("name", "salary");
DataFrame sub = df.apply("name", "salary");   // Scala alias

// Drop by ordinal index
DataFrame sub = df.drop(1);
DataFrame sub = df.drop(0, 2);

// Drop by name
DataFrame sub = df.drop("age");
DataFrame sub = df.drop("age", "birthday");

// Add new columns — all must have the same size as the DataFrame
// and names must not clash with existing columns or each other
IntVector bonus = new IntVector("bonus", new int[]{5000, 8000, 12000});
df.add(bonus);

// Two columns at once — both names must be distinct from each other
// and from existing columns
df.add(c1, c2);

// Replace an existing column (or add if not present)
df.set("salary", updatedSalaryVector);
df.update("salary", updatedSalaryVector);  // Scala alias

df.rename("age", "years");
// df.names() is now ["name", "years", "salary"]

// Build a boolean mask manually or from a column comparison
boolean[] mask = df.column("age").gt(28);
DataFrame sub  = df.get(mask);

import smile.util.Index;

// From explicit row indices
DataFrame sub = df.get(Index.of(new int[]{0, 2, 3}));

// From a boolean mask
DataFrame sub = df.get(Index.of(new boolean[]{true, false, true, true}));

// Remove any row that has at least one null/NaN value
DataFrame clean = df.dropna();

// Ascending (default)
DataFrame sorted = df.sort("age");

// Descending
DataFrame sorted = df.sort("salary", false);

// Contiguous row range [from, to)
DataFrame slice  = df.slice(1, 4);   // rows 1, 2, 3
DataFrame first  = df.slice(0, 1);   // first row only
DataFrame empty  = df.slice(2, 2);   // zero rows (valid)

// Random sample without replacement
DataFrame sample = df.sample(50);    // up to 50 rows (capped at nrow())

DataFrame wide = left.merge(right);
DataFrame wide = a.merge(b, c, d);

DataFrame tall = train.concat(test);
DataFrame tall = a.concat(b, c);

DataFrame merged = left.join(right);
// Rows present in both left.index and right.index are kept;
// unmatched rows are dropped.

// Drop rows with any null/NaN
DataFrame clean = df.dropna();

// Fill NaN/Inf in numeric columns in-place
df.fillna(0.0);    // replace with zero
df.fillna(-1.0);   // replace with sentinel

// Convert all String columns
DataFrame f = df.factorize();

// Convert specific columns
DataFrame f = df.factorize("color", "country");

// Inspect the resulting scale
NominalScale scale = (NominalScale) f.schema().field("color").measure();
String label = scale.level(0);    // first level alphabetically
int    code  = scale.valueOf("Red").intValue();

// Default: no bias, level encoding, all columns
double[][] X = df.toArray();

// Selective columns
double[][] X = df.toArray("age", "salary", "gender");

// With bias + dummy encoding for categoricals
double[][] X = df.toArray(true, CategoricalEncoder.DUMMY, "age", "gender", "salary");

// DenseMatrix form (suitable for linear algebra)
DenseMatrix M = df.toMatrix();
DenseMatrix M = df.toMatrix(true, CategoricalEncoder.DUMMY, "rowNameColumn");

DataFrame stats = df.describe();
System.out.println(stats);

System.out.println(df);            // head(10)
System.out.println(df.head(5));
System.out.println(df.tail(5));
System.out.println(df.toString(from, to, truncate));

import java.sql.*;

try (Connection conn = DriverManager.getConnection(jdbcUrl, user, pass);
     Statement  stmt = conn.createStatement();
     ResultSet  rs   = stmt.executeQuery("SELECT * FROM sales")) {
    DataFrame df = DataFrame.of(rs);
    System.out.println(df.describe());
}

import smile.data.CategoricalEncoder;

// Level encoding (default) — "gender" becomes a single int column
double[][] X = df.toArray("age", "gender");

// Dummy encoding — k levels → k-1 binary columns
// e.g. gender {Male=0, Female=1} → one binary column "gender_Female"
double[][] X = df.toArray(false, CategoricalEncoder.DUMMY, "age", "gender");

// One-hot encoding — k levels → k binary columns
double[][] X = df.toArray(false, CategoricalEncoder.ONE_HOT, "age", "gender");

import java.time.LocalDate;
import smile.data.DataFrame;
import smile.data.measure.*;
import smile.data.type.*;
import smile.data.vector.*;

public enum Department { Engineering, Marketing, HR }

public class Employee {
    public String     getName()       { return name; }
    public int        getAge()        { return age; }
    public Department getDepartment() { return dept; }
    public LocalDate  getHireDate()   { return hireDate; }
    public Double     getSalary()     { return salary; }   // nullable
    // …constructor, fields…
}

List<Employee> employees = loadEmployees();  // from DB / file / …
DataFrame df = DataFrame.of(Employee.class, employees);

System.out.println(df.schema());
// age: int
// department: byte  nominal[Engineering, HR, Marketing]
// hireDate: Date
// name: String
// salary: double?

System.out.println(df);
System.out.println(df.describe());

// How many rows have a null salary?
long nullSalaries = df.column("salary").getNullCount();
System.out.println("Missing salaries: " + nullSalaries);

import smile.data.vector.IntVector;

// Tenure in years = current year - hire year
int[] tenure = new int[df.nrow()];
for (int i = 0; i < df.nrow(); i++) {
    LocalDate d = (LocalDate) df.column("hireDate").get(i);
    tenure[i] = LocalDate.now().getYear() - d.getYear();
}
df.add(new IntVector("tenure", tenure));

// Option A: drop rows with any null
DataFrame clean = df.dropna();

// Option B: fill salary nulls with median
double medianSalary = df.column("salary").doubleStream()
        .filter(Double::isFinite).sorted()
        .skip(df.nrow() / 2).findFirst().orElse(0.0);
df.fillna(medianSalary);

// Sort by salary descending
DataFrame sorted = df.sort("salary", false);

// Top 10 earners
DataFrame top10 = sorted.slice(0, Math.min(10, sorted.nrow()));
System.out.println(top10.head(10));

// Select the columns we want for the model
DataFrame features = df.select("age", "tenure", "salary", "department");

// For algorithms that need integer encoding:
// "department" already has NominalScale (auto-detected from enum)

// Export design matrix with dummy encoding
double[][] X = features.drop("salary")
        .toArray(false, CategoricalEncoder.DUMMY,
                 "age", "tenure", "department");

// Response vector
double[] y = features.column("salary").toDoubleArray();

DataFrame indexed = df.setIndex("name");

// Later: look up a specific employee by name
Tuple alice = indexed.loc("Alice");
System.out.println("Alice's salary: " + alice.getDouble("salary"));

// Join two DataFrames on employee name
DataFrame reviews = loadReviews().setIndex("employee");
DataFrame combined = indexed.join(reviews);

DataFrame finalFeatures = df.select("age", "tenure", "department", "salary");
System.out.println(finalFeatures.describe());

// Verify no nulls remain
boolean anyNull = finalFeatures.stream().anyMatch(Tuple::anyNull);
System.out.println("Any nulls: " + anyNull);