ForgeCurves Documentation & User Manual

A = [1, 2, 3; 4, 5, 6; 7, 8, 9];   % 3x3 matrix
v = 1:2:10;                        % Range vector [1, 3, 5, 7, 9]
sub = A(1:2, 2:3);                 % Submatrix slicing
row_sum = sum(A, 2);               % Sum across rows

A = [4, 1; 2, 3];
b = [1; 2];
x = A \ b;                         % Left matrix division (Solve Ax = b)
d = det(A);                        % Determinant
[V, D] = eig(A);                   % Eigenvalues & Eigenvectors
[U, S, V] = svd(A);                % Singular Value Decomposition

pkg load dataframe;

% Construct table from heterogeneous records
raw_data = {
  "Sample", "GeneA", "GeneB", "Group";
  "S1",     45.2,    12.8,    1;
  "S2",     88.1,    14.2,    2;
  "S3",     12.3,    89.4,    1
};
df = dataframe(raw_data(2:end, :), raw_data(1, :));

% 1. Dynamic projection to standard column vectors for matrix algebra
gene_a_vec = df.GeneA;             % Returns dense Octave column vector [45.2; 88.1; 12.3]
norm_a = norm(gene_a_vec, 2);      % Direct handoff to linear algebra engine

% 2. In-place column addition, cell update, and column deletion
df.Ratio = df.GeneA ./ df.GeneB;   % Append computed column via dot assignment
df(2, "GeneA") = 92.5;             % Coordinate indexed cell update
df.Group = [];                     % In-place column deletion

% 3. Missing value identification & filtering
na_mask = isna(df);                % Boolean logical bitmask
df_clean = dropna(df);             % Drop rows containing NA
summary_stats = summary(df);       % Comprehensive column reduction (mean, std, min, max)

% Structural Invariants & Matrix Rank
A = [1, 2, 3; 4, 5, 6; 7, 8, 9];
r = rank(A);                       % Matrix rank = 2
Z = null(A);                       % Orthonormal basis for null space
Q = orth(A);                       % Orthonormal basis for range space
c = cond(A);                       % 2-norm condition number

% Polynomial Roots, Characteristic Polynomial & Deconvolution
coeffs = poly([2; 1; -3]);         % Recover coefficients from roots
p_roots = roots(coeffs);           % Solve roots from polynomial coefficients
[q, r] = deconv([2, 7, 11, 4], [2, 1]); % Polynomial division: quotient & remainder

% Complex Fourier Transform with Parseval Energy Conservation
signal = [1, 2, 3, 4, 3, 2];
F = fft(signal);                   % Discrete complex Fourier transform
recovered = ifft(F);               % Inverse Fourier transform (energy conserved)

% Special Mathematical Functions
g = gamma(5.5);                    % Euler gamma function
b = besselj(1, 2.5);               % Bessel function of the first kind J_1(2.5)
e = erfc(0.75);                    % Complementary error function

pkg load io;

% Delimited Matrix R/W with Custom Row & Column Offsets
dlmwrite("offsets.csv", [10, 20; 30, 40], "delimiter", ",", "roffset", 2, "coffset", 1);
M_read = dlmread("offsets.csv", ",", 2, 1);

% Formatted Heterogeneous Parsing with Header Lines
fid = fopen("experiment.tsv", "w");
fputs(fid, "# Experiment Results Table\n");
fputs(fid, "101\tAlpha\t45.2\t1\n102\tBeta\t12.8\t0\n");
fclose(fid);

fid = fopen("experiment.tsv", "r");
C = textscan(fid, "%d %s %f %d", "HeaderLines", 1);
fclose(fid);
% C{1}: IDs, C{2}: Names, C{3}: Values, C{4}: Status

% Binary Byte Packing & Direct Seeking
fid = fopen("archive.bin", "wb", "ieee-le");
fwrite(fid, uint32(0xCAFEBABE), "uint32");
fwrite(fid, single([1.1, 2.2, 3.3]), "single");
fclose(fid);

fid = fopen("archive.bin", "rb", "ieee-le");
magic = fread(fid, 1, "uint32=>uint32");
fseek(fid, 4, "bof");              % Direct byte offset seek
data = fread(fid, 3, "single=>single");
fclose(fid);

pkg load optim;

% 1. Quasi-Newton BFGS with Analytic Gradient passing via deal()
rosen = @(p) 100 * (p(2) - p(1)^2)^2 + (1 - p(1))^2;
grad_rosen = @(p) [-400*p(1)*(p(2) - p(1)^2) - 2*(1 - p(1)); 200*(p(2) - p(1)^2)];
obj_fn = @(p) deal(rosen(p), grad_rosen(p));
opt = optimset("GradObj", "on", "Display", "off");
[x_opt, fval] = fminunc(obj_fn, [-1.2; 1.0], opt);

% 2. Box-Constrained Minimization (nonlin_min)
quad_fn = @(p) (p(1) - 4)^2 + (p(2) + 2)^2;
settings = struct("lbound", [5; -1], "ubound", [10; 5]);
[p_box, f_box] = nonlin_min(quad_fn, [0; 0], settings);

% 3. Coupled System of Nonlinear Equations (fsolve)
sys_fn = @(x) [2*x(1) - x(2) - exp(-x(1)); -x(1) + 2*x(2) - exp(-x(2))];
[x_root, fval, exitflag] = fsolve(sys_fn, [0.0; 0.0]);

% 4. Quadratic Programming with Inequality & Equality Constraints (qp)
% Minimize 0.5 * x' * H * x + q' * x  s.t.  A_ineq * x <= b_ineq, lb <= x <= ub
H = [4, 1; 1, 2]; q = [-8; -6];
A_ineq = [1, 1]; b_ineq = 2.0;
[x_qp, obj_val, status] = qp([0; 0], H, q, [], [], [0; 0], [5; 5], -inf, A_ineq, b_ineq);

% 5. Numerical Differentiation Stencils (numgradient & numhessian)
surface_fn = @(p) 3*p(1)^2 + 2*p(1)*p(2) + p(2)^2 + 5*p(1) - 3*p(2);
g_eval = numgradient(surface_fn, [1.5; -2.0]);
H_eval = numhessian(surface_fn, [1.5; -2.0]);

pkg load statistics;

% Train Support Vector Machine (Linear or RBF kernel)
model = fitcsvm(X_train, y_train, 'KernelFunction', 'rbf');
y_pred = predict(model, X_test);

% Diagnostic Plotting
plotconfusion(y_test, y_pred);
plotroc(y_test, y_scores);
plotperform(model.history);

t = linspace(0, 10, 120);
y = exp(-0.25*t) .* cos(2*pi*0.5*t);
plot(t, y, 'r-');
title('Damped Sinusoidal Oscillation');
xlabel('Time (seconds)');
ylabel('Displacement (m)');
grid on;

window.__FORGECURVES_AGENT_SPEC__.getSpec();
window.__FORGECURVES_AGENT_SPEC__.listActions();
window.__FORGECURVES_AGENT_SPEC__.triggerAction('run-all');