> For the complete documentation index, see [llms.txt](https://ykkim.gitbook.io/dlip/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://ykkim.gitbook.io/dlip/programming/markdown/example-api-documentation.md).

# Example: API documentation

## Numerical Programming API

`#include "myNM.h"`

## Non-Linear Solver

### newtonRaphson()

Solves the non-linear problem using Newton-Raphson method

```
double newtonRaphson(double x0, double tol);
```

**Parameters**

* **x0:** initial value.
* **tol**: tolerance error

**Example code**

```
double tol = 0.00001;
double x0 = 3;
double NR_result;
​
NR_result = newtonRaphson(x0, tol);
```

## Linear Solver

### gaussElim()

solves for vector **x** from Ax=b, a linear system problem Using Gauss Elimination

```cpp
void gaussElim(Matrix _A, Matrix _B, Matrix* _U, Matrix* _B_out);
```

**Parameters**

* **A**: Matrix **A** in structure Matrix form. Should be (nxn) square.
* **B**: vector **b** in structure Matrix form. Should be (nx1)
* **U**: Matrix **U** in structure Matrix form. Should be (nxn) square.
* **B\_out**: vector **B\_out** in structure Matrix form. Should be (nx1)

**Example code**

```
Matrix matA = txt2Mat(path, "prob1_matA");
Matrix vecb = txt2Mat(path, "prob1_vecb");
Matrix matU = zeros(matA.rows, matA.cols);
Matrix vecd = zeros(vecb.rows, vecb.cols);
​
gaussElim(matA, vecb, matU, vecd);
```

### inv()

Find the inverse Matrix.

```
void inv(Matrix _A, Matrix _Ainv);
```

**Parameters**

* **A**: Matrix **A** in structure Matrix form. Should be (nxn) square.
* **Ainv**: Matrix **Ainv** in structure Matrix form. Should be (nxn) square.

**Example code**

```
Matrix matA = txt2Mat(path, "prob1_matA");
Matrix matAinv = zeros(matA.rows, matA.cols);
​
inv(matA, matAinv);
```

###

## Numerical Differentiation

### gradient1D()

Solve for numerical gradient (dy/dt) from a 1D-array form.

```
void gradient1D(double x[], double y[], double dydx[], int m);
```

**Parameters**

* **x\[]**: input data vector **x** in 1D-array .
* **y\[]**: input data vector **y** in 1D-array.
* **dydx\[]**: output vector **dydx** in 1D-array.
* **m**: length **x** and **y**.

**Example code**

```cpp
double x[21];
    for (int i = 0; i < 21; i++) {
        x[i] = 0.2 * i;
    }
double y[] = { -5.87, -4.23, -2.55, -0.89, 0.67, 2.09, 3.31, 4.31, 5.06, 5.55, 5.78, 5.77, 5.52, 5.08, 4.46, 3.72, 2.88, 2.00, 1.10, 0.23, -0.59 };
double dydx[21];
​
gradient1D(x, y, dydx, 21);
```

## Integration

### integral()

Integral using Simpson 1/3 Method.

```
double integral(double func(const double _x), double a, double b, int n);
```

**Parameters**

* **func**: Function **func** is defined.
* **a** is starting point of x.
* **b** is ending point of x.
* **n** is the length between **a** and **b**

**Example code**

```
double I_simpson13 = integral(myFunc, -1, 1, 12);

double myFunc(const double _x) {
	return sqrt(1 - (_x * _x));
}
```

## ODE-IVP

### odeEU()

Solve the 1st-order ODE using Euler's Explicit Method.

```
void odeEU(double func(const double x, const double y), double y[], double t0, double tf, double h, double y0);
```

**Parameters**

* **func**: Function **func** is defined.
* **y\[]**: Solution of ODE in structure 1D-array form.
* **t0** is starting point.
* **tf** is ending point.
* **h** is length of step.
* **y0** is initial value of **y\[]**.

**Example code**

```
double a = 0;
double b = 0.1;
double h = 0.001;
double y_EU[200] = { 0 };
double v0 = 0;

odeEU(odeFunc_rc, y_EU, a, b, h, v0);

double odeFunc_rc(const double t, const double v) {
	double tau = 1;
	double T = 1 / tau;
	double f = 10;
	double Vm = 1;
	double omega = 2 * PI * f;
	return  -T * v + T * Vm * cos(omega * t);
}
```

\-------------------------------------------------------------------------------------------------------

## Class or Header name

### Function Name

```
```

**Parameters**

* p1
* p2

**Example code**

```
```


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://ykkim.gitbook.io/dlip/programming/markdown/example-api-documentation.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.