odegeniter := proc(V, t, y, differential_eq, param_list, solve_all, range)
    local params, eq, numrows, i, single_row, dataframe, param_names;
    local param_values, param_combination, p, generate_combinations, param_combinations, j, solution, all_zero, invalid_combination, total_combinations, valid_combinations;
    local rows, row_eqs, max_combinations, num_params;
    uses PDEtools;

    if not has(differential_eq, diff(y(t), t)) then
        error "The input must contain a differential equation with diff(y(t), t).";
    end if;

    if not (solve_all = true or solve_all = false) then
        error "solve_all must be true or false.";
    end if;

    if not (range = "all" or range = 'all' or type(range, nonnegint) or type(range, range)) then
        error "range must be 'all', a non-negative integer, or a valid range (e.g., 0..5).";
    end if;

    # Controleer of de parameterlijst correct is
    if not (type(param_list, list) and nops(param_list) > 0) then
        error "The parameter list must be a list containing at least one parameter name.";
    end if;

    # Zoek de parameters in de differentiaalvergelijking
    params := select(p -> member(p, param_list), indets(differential_eq));
    param_names := convert(params, list);
    num_params := nops(param_names);

    if num_params = 0 then
        error "No parameters from the given list were found in the differential equation.";
    end if;

    generate_combinations := proc(variables, values)
        local result, i, sub_combinations, v;
        if nops(variables) = 0 then
            return [[]];
        end if;
        result := [];
        for v in values do
            sub_combinations := generate_combinations(variables[2..-1], values);
            for i to nops(sub_combinations) do
                result := [op(result), [v, op(sub_combinations[i])]];
            end do;
        end do;
        return result;
    end proc;

    param_combinations := generate_combinations(param_names, V);
    max_combinations := nops(param_combinations);

    if max_combinations = 0 then
        error "No parameter combinations generated. Check the input values.";
    end if;

    printf("�� Expected total rows before filtering: %d\n", max_combinations);

    valid_combinations := 0;
    rows := Array(1..max_combinations, 1..(num_params + 3), datatype=anything);
    row_eqs := Array(1..max_combinations, datatype=anything);

    for i from 1 to max_combinations do
        param_combination := param_combinations[i];
        eq := differential_eq;

        # Controleer op ongeldige parameter combinaties
        all_zero := true;
        invalid_combination := false;

        for j to num_params do
            if param_combination[j] <> 0 then
                all_zero := false;
            end if;
            # **Voorkom deling door nul in de differentiaalvergelijking**
            if (param_names[j] = xi and param_combination[j] = 0) or
               (param_names[j] = omega and param_combination[j] = 0) then
                invalid_combination := true;
            end if;
        end do;

        if all_zero then
            printf("⚠️ Row %d skipped: Differential equation is undefined (all parameters = 0).\n", i-1);
            next;
        end if;

        if invalid_combination then
            printf("⚠️ Row %d skipped: Invalid parameter combination (division by zero detected).\n", i-1);
            next;
        end if;

        # **Voer substitutie uit als de combinatie geldig is**
        for j to num_params do
            p := param_names[j];
            eq := subs(p = param_combination[j], eq);
        end do;

        eq := simplify(eq);

        valid_combinations := valid_combinations + 1;
        rows[valid_combinations, 1] := valid_combinations - 1;
        for j to num_params do
            rows[valid_combinations, j+1] := param_combination[j];
        end do;
        rows[valid_combinations, num_params + 2] := eq;
        rows[valid_combinations, num_params + 3] := "";  
        row_eqs[valid_combinations] := eq;
    end do;

    numrows := valid_combinations;
    printf("✅ Valid rows after filtering: %d\n", numrows);

    if numrows = 0 then
        error "No valid parameter combinations remain after filtering out undefined ODE cases.";
    end if;

    if solve_all = true and (range = "all" or range = 'all') then
        printf("�� Generating full DataFrame...\n");
        for i from 1 to numrows do
            try
                solution := simplify(rhs(dsolve(row_eqs[i], y(t))));
                rows[i, num_params + 3] := solution;
            catch:
                rows[i, num_params + 3] := "No explicit solution";
            end try;
        end do;

        dataframe := DataFrame(
            Matrix(rows[1..numrows, 1..(num_params + 3)], datatype=anything),
            columns = ['Row', op(param_names), 'Equation', 'Solution']
        );
        return dataframe;

    elif solve_all = true and type(range, nonnegint) then
        printf("�� Fetching row %d...\n", range);
        if range >= numrows then
            error "Index out of range: There are only " || numrows || " valid rows (indices 0.." || (numrows-1) || ").";
        end if;

        single_row := rows[range+1, 1..(num_params + 3)];

        dataframe := DataFrame(
            Matrix([single_row], datatype=anything),
            columns = ['Row', op(param_names), 'Equation', 'Solution']
        );
        return dataframe;

    else
        error "Invalid combination of solve_all and range.";
    end if;
end proc:

V :=[1];
differential_eq := diff(y(t), t) = alpha * y(t) + beta * t + delta + sin(t)/xi - 2/omega;
param_list := [alpha, beta, delta, xi, omega];

result := odegeniter(V, t, y, differential_eq, param_list, true, all);

�� Expected total rows before filtering: 1
✅ Valid rows after filtering: 1
�� Generating full DataFrame...

V := [ Pi, exp(1), 1/2, sqrt(2)];

differential_eq := diff(y(t), t) = alpha * y(t) + beta * t + delta + sin(t)/xi - 2/omega;
param_list := [alpha, beta, delta, xi, omega];

result := odegeniter(V, t, y, differential_eq, param_list, true, all);
 

�� Expected total rows before filtering: 1024
✅ Valid rows after filtering: 1024
�� Generating full DataFrame...