backup/C-Plus-Plus
1
0
Fork 0
mirror of https://github.com/TheAlgorithms/C-Plus-Plus.git synced 2026-04-15 11:20:05 +08:00
Code Issues Projects Releases Wiki Activity

formatting source-code for d7af6fdc8c

Browse Source
This commit is contained in:
github-actions
2020-05-29 23:26:30 +00:00
parent edb3d51ec2
commit 7ad1f171c1
176 changed files with 5342 additions and 4288 deletions
Download Patch File Download Diff File Expand all files Collapse all files

29
computer_oriented_statistical_methods/bisection_method.cpp
View File

@@ -23,29 +23,36 @@
/** define \f$f(x)\f$ to find root for
*/
static double eq(double i) {
static double eq(double i)
{
return (std::pow(i, 3) - (4 * i) - 9); // original equation
}
/** get the sign of any given number */
template <typename T>
int sgn(T val) {
int sgn(T val)
{
return (T(0) < val) - (val < T(0));
}
/** main function */
int main() {
int main()
{
double a = -1, b = 1, x, z;
int i;
// loop to find initial intervals a, b
for (int i = 0; i < MAX_ITERATIONS; i++) {
for (int i = 0; i < MAX_ITERATIONS; i++)
{
z = eq(a);
x = eq(b);
if (sgn(z) == sgn(x)) { // same signs, increase interval
if (sgn(z) == sgn(x))
{ // same signs, increase interval
b++;
a--;
} else { // if opposite signs, we got our interval
}
else
{ // if opposite signs, we got our interval
break;
}
}
@@ -54,15 +61,19 @@ int main() {
std::cout << "\nSecond initial: " << b;
// start iterations
for (i = 0; i < MAX_ITERATIONS; i++) {
for (i = 0; i < MAX_ITERATIONS; i++)
{
x = (a + b) / 2;
z = eq(x);
std::cout << "\n\nz: " << z << "\t[" << a << " , " << b
<< " | Bisect: " << x << "]";
if (z < 0) {
if (z < 0)
{
a = x;
} else {
}
else
{
b = x;
}

25
computer_oriented_statistical_methods/false_position.cpp
View File

@@ -25,29 +25,36 @@
/** define \f$f(x)\f$ to find root for
*/
static double eq(double i) {
static double eq(double i)
{
return (std::pow(i, 3) - (4 * i) - 9); // origial equation
}
/** get the sign of any given number */
template <typename T>
int sgn(T val) {
int sgn(T val)
{
return (T(0) < val) - (val < T(0));
}
/** main function */
int main() {
int main()
{
double a = -1, b = 1, x, z, m, n, c;
int i;
// loop to find initial intervals a, b
for (int i = 0; i < MAX_ITERATIONS; i++) {
for (int i = 0; i < MAX_ITERATIONS; i++)
{
z = eq(a);
x = eq(b);
if (sgn(z) == sgn(x)) { // same signs, increase interval
if (sgn(z) == sgn(x))
{ // same signs, increase interval
b++;
a--;
} else { // if opposite signs, we got our interval
}
else
{ // if opposite signs, we got our interval
break;
}
}
@@ -55,7 +62,8 @@ int main() {
std::cout << "\nFirst initial: " << a;
std::cout << "\nSecond initial: " << b;
for (i = 0; i < MAX_ITERATIONS; i++) {
for (i = 0; i < MAX_ITERATIONS; i++)
{
m = eq(a);
n = eq(b);
@@ -64,7 +72,8 @@ int main() {
a = c;
z = eq(c);
if (std::abs(z) < EPSILON) { // stoping criteria
if (std::abs(z) < EPSILON)
{ // stoping criteria
break;
}
}

33
computer_oriented_statistical_methods/gaussian_elimination.cpp
View File

@@ -6,7 +6,8 @@
#include <iostream>
/** Main function */
int main() {
int main()
{
int mat_size, i, j, step;
std::cout << "Matrix size: ";
@@ -14,7 +15,8 @@ int main() {
// create a 2D matrix by dynamic memory allocation
double **mat = new double *[mat_size + 1], **x = new double *[mat_size];
for (i = 0; i <= mat_size; i++) {
for (i = 0; i <= mat_size; i++)
{
mat[i] = new double[mat_size + 1];
if (i < mat_size)
x[i] = new double[mat_size + 1];
@@ -22,16 +24,20 @@ int main() {
// get the matrix elements from user
std::cout << std::endl << "Enter value of the matrix: " << std::endl;
for (i = 0; i < mat_size; i++) {
for (j = 0; j <= mat_size; j++) {
for (i = 0; i < mat_size; i++)
{
for (j = 0; j <= mat_size; j++)
{
std::cin >>
mat[i][j]; // Enter (mat_size*mat_size) value of the matrix.
}
}
// perform Gaussian elimination
for (step = 0; step < mat_size - 1; step++) {
for (i = step; i < mat_size - 1; i++) {
for (step = 0; step < mat_size - 1; step++)
{
for (i = step; i < mat_size - 1; i++)
{
double a = (mat[i + 1][step] / mat[step][step]);
for (j = step; j <= mat_size; j++)
@@ -41,8 +47,10 @@ int main() {
std::cout << std::endl
<< "Matrix using Gaussian Elimination method: " << std::endl;
for (i = 0; i < mat_size; i++) {
for (j = 0; j <= mat_size; j++) {
for (i = 0; i < mat_size; i++)
{
for (j = 0; j <= mat_size; j++)
{
x[i][j] = mat[i][j];
std::cout << mat[i][j] << " ";
}
@@ -50,9 +58,11 @@ int main() {
}
std::cout << std::endl
<< "Value of the Gaussian Elimination method: " << std::endl;
for (i = mat_size - 1; i >= 0; i--) {
for (i = mat_size - 1; i >= 0; i--)
{
double sum = 0;
for (j = mat_size - 1; j > i; j--) {
for (j = mat_size - 1; j > i; j--)
{
x[i][j] = x[j][j] * x[i][j];
sum = x[i][j] + sum;
}
@@ -64,7 +74,8 @@ int main() {
std::cout << "x" << i << "= " << x[i][i] << std::endl;
}
for (i = 0; i <= mat_size; i++) {
for (i = 0; i <= mat_size; i++)
{
delete[] mat[i];
if (i < mat_size)
delete[] x[i];

12
computer_oriented_statistical_methods/newton_raphson_method.cpp
View File

@@ -21,18 +21,21 @@
/** define \f$f(x)\f$ to find root for
*/
static double eq(double i) {
static double eq(double i)
{
return (std::pow(i, 3) - (4 * i) - 9); // original equation
}
/** define the derivative function \f$f'(x)\f$
*/
static double eq_der(double i) {
static double eq_der(double i)
{
return ((3 * std::pow(i, 2)) - 4); // derivative of equation
}
/** Main function */
int main() {
int main()
{
std::srand(std::time(nullptr)); // initialize randomizer
double z, c = std::rand() % 100, m, n;
@@ -41,7 +44,8 @@ int main() {
std::cout << "\nInitial approximation: " << c;
// start iterations
for (i = 0; i < MAX_ITERATIONS; i++) {
for (i = 0; i < MAX_ITERATIONS; i++)
{
m = eq(c);
n = eq_der(c);

112
computer_oriented_statistical_methods/ordinary_least_squares_regressor.cpp
View File

@@ -16,11 +16,13 @@
*/
template <typename T>
std::ostream &operator<<(std::ostream &out,
std::vector<std::vector<T>> const &v) {
std::vector<std::vector<T>> const &v)
{
const int width = 10;
const char separator = ' ';
for (size_t row = 0; row < v.size(); row++) {
for (size_t row = 0; row < v.size(); row++)
{
for (size_t col = 0; col < v[row].size(); col++)
out << std::left << std::setw(width) << std::setfill(separator)
<< v[row][col];
@@ -34,7 +36,8 @@ std::ostream &operator<<(std::ostream &out,
* operator to print a vector
*/
template <typename T>
std::ostream &operator<<(std::ostream &out, std::vector<T> const &v) {
std::ostream &operator<<(std::ostream &out, std::vector<T> const &v)
{
const int width = 15;
const char separator = ' ';
@@ -50,7 +53,8 @@ std::ostream &operator<<(std::ostream &out, std::vector<T> const &v) {
* \returns 1 if true, 0 if false
*/
template <typename T>
inline bool is_square(std::vector<std::vector<T>> const &A) {
inline bool is_square(std::vector<std::vector<T>> const &A)
{
// Assuming A is square matrix
size_t N = A.size();
for (size_t i = 0; i < N; i++)
@@ -68,7 +72,8 @@ inline bool is_square(std::vector<std::vector<T>> const &A) {
**/
template <typename T>
std::vector<std::vector<T>> operator*(std::vector<std::vector<T>> const &A,
std::vector<std::vector<T>> const &B) {
std::vector<std::vector<T>> const &B)
{
// Number of rows in A
size_t N_A = A.size();
// Number of columns in B
@@ -76,15 +81,18 @@ std::vector<std::vector<T>> operator*(std::vector<std::vector<T>> const &A,
std::vector<std::vector<T>> result(N_A);
if (A[0].size() != B.size()) {
if (A[0].size() != B.size())
{
std::cerr << "Number of columns in A != Number of rows in B ("
<< A[0].size() << ", " << B.size() << ")" << std::endl;
return result;
}
for (size_t row = 0; row < N_A; row++) {
for (size_t row = 0; row < N_A; row++)
{
std::vector<T> v(N_B);
for (size_t col = 0; col < N_B; col++) {
for (size_t col = 0; col < N_B; col++)
{
v[col] = static_cast<T>(0);
for (size_t j = 0; j < B.size(); j++)
v[col] += A[row][j] * B[j][col];
@@ -101,19 +109,22 @@ std::vector<std::vector<T>> operator*(std::vector<std::vector<T>> const &A,
*/
template <typename T>
std::vector<T> operator*(std::vector<std::vector<T>> const &A,
std::vector<T> const &B) {
std::vector<T> const &B)
{
// Number of rows in A
size_t N_A = A.size();
std::vector<T> result(N_A);
if (A[0].size() != B.size()) {
if (A[0].size() != B.size())
{
std::cerr << "Number of columns in A != Number of rows in B ("
<< A[0].size() << ", " << B.size() << ")" << std::endl;
return result;
}
for (size_t row = 0; row < N_A; row++) {
for (size_t row = 0; row < N_A; row++)
{
result[row] = static_cast<T>(0);
for (size_t j = 0; j < B.size(); j++) result[row] += A[row][j] * B[j];
}
@@ -126,13 +137,15 @@ std::vector<T> operator*(std::vector<std::vector<T>> const &A,
* \returns resultant vector
*/
template <typename T>
std::vector<float> operator*(float const scalar, std::vector<T> const &A) {
std::vector<float> operator*(float const scalar, std::vector<T> const &A)
{
// Number of rows in A
size_t N_A = A.size();
std::vector<float> result(N_A);
for (size_t row = 0; row < N_A; row++) {
for (size_t row = 0; row < N_A; row++)
{
result[row] += A[row] * static_cast<float>(scalar);
}
@@ -144,7 +157,8 @@ std::vector<float> operator*(float const scalar, std::vector<T> const &A) {
* \returns resultant vector
*/
template <typename T>
std::vector<float> operator*(std::vector<T> const &A, float const scalar) {
std::vector<float> operator*(std::vector<T> const &A, float const scalar)
{
// Number of rows in A
size_t N_A = A.size();
@@ -161,7 +175,8 @@ std::vector<float> operator*(std::vector<T> const &A, float const scalar) {
* \returns resultant vector
*/
template <typename T>
std::vector<float> operator/(std::vector<T> const &A, float const scalar) {
std::vector<float> operator/(std::vector<T> const &A, float const scalar)
{
return (1.f / scalar) * A;
}
@@ -170,13 +185,15 @@ std::vector<float> operator/(std::vector<T> const &A, float const scalar) {
* \returns resultant vector
*/
template <typename T>
std::vector<T> operator-(std::vector<T> const &A, std::vector<T> const &B) {
std::vector<T> operator-(std::vector<T> const &A, std::vector<T> const &B)
{
// Number of rows in A
size_t N = A.size();
std::vector<T> result(N);
if (B.size() != N) {
if (B.size() != N)
{
std::cerr << "Vector dimensions shouldbe identical!" << std::endl;
return A;
}
@@ -191,13 +208,15 @@ std::vector<T> operator-(std::vector<T> const &A, std::vector<T> const &B) {
* \returns resultant vector
*/
template <typename T>
std::vector<T> operator+(std::vector<T> const &A, std::vector<T> const &B) {
std::vector<T> operator+(std::vector<T> const &A, std::vector<T> const &B)
{
// Number of rows in A
size_t N = A.size();
std::vector<T> result(N);
if (B.size() != N) {
if (B.size() != N)
{
std::cerr << "Vector dimensions shouldbe identical!" << std::endl;
return A;
}
@@ -214,26 +233,30 @@ std::vector<T> operator+(std::vector<T> const &A, std::vector<T> const &B) {
**/
template <typename T>
std::vector<std::vector<float>> get_inverse(
std::vector<std::vector<T>> const &A) {
std::vector<std::vector<T>> const &A)
{
// Assuming A is square matrix
size_t N = A.size();
std::vector<std::vector<float>> inverse(N);
for (size_t row = 0; row < N; row++) {
for (size_t row = 0; row < N; row++)
{
// preallocatae a resultant identity matrix
inverse[row] = std::vector<float>(N);
for (size_t col = 0; col < N; col++)
inverse[row][col] = (row == col) ? 1.f : 0.f;
}
if (!is_square(A)) {
if (!is_square(A))
{
std::cerr << "A must be a square matrix!" << std::endl;
return inverse;
}
// preallocatae a temporary matrix identical to A
std::vector<std::vector<float>> temp(N);
for (size_t row = 0; row < N; row++) {
for (size_t row = 0; row < N; row++)
{
std::vector<float> v(N);
for (size_t col = 0; col < N; col++)
v[col] = static_cast<float>(A[row][col]);
@@ -241,22 +264,27 @@ std::vector<std::vector<float>> get_inverse(
}
// start transformations
for (size_t row = 0; row < N; row++) {
for (size_t row2 = row; row2 < N && temp[row][row] == 0; row2++) {
for (size_t row = 0; row < N; row++)
{
for (size_t row2 = row; row2 < N && temp[row][row] == 0; row2++)
{
// this to ensure diagonal elements are not 0
temp[row] = temp[row] + temp[row2];
inverse[row] = inverse[row] + inverse[row2];
}
for (size_t col2 = row; col2 < N && temp[row][row] == 0; col2++) {
for (size_t col2 = row; col2 < N && temp[row][row] == 0; col2++)
{
// this to further ensure diagonal elements are not 0
for (size_t row2 = 0; row2 < N; row2++) {
for (size_t row2 = 0; row2 < N; row2++)
{
temp[row2][row] = temp[row2][row] + temp[row2][col2];
inverse[row2][row] = inverse[row2][row] + inverse[row2][col2];
}
}
if (temp[row][row] == 0) {
if (temp[row][row] == 0)
{
// Probably a low-rank matrix and hence singular
std::cerr << "Low-rank matrix, no inverse!" << std::endl;
return inverse;
@@ -267,7 +295,8 @@ std::vector<std::vector<float>> get_inverse(
temp[row] = temp[row] / divisor;
inverse[row] = inverse[row] / divisor;
// Row transformations
for (size_t row2 = 0; row2 < N; row2++) {
for (size_t row2 = 0; row2 < N; row2++)
{
if (row2 == row)
continue;
float factor = temp[row2][row];
@@ -284,11 +313,12 @@ std::vector<std::vector<float>> get_inverse(
* \returns resultant matrix
**/
template <typename T>
std::vector<std::vector<T>> get_transpose(
std::vector<std::vector<T>> const &A) {
std::vector<std::vector<T>> get_transpose(std::vector<std::vector<T>> const &A)
{
std::vector<std::vector<T>> result(A[0].size());
for (size_t row = 0; row < A[0].size(); row++) {
for (size_t row = 0; row < A[0].size(); row++)
{
std::vector<T> v(A.size());
for (size_t col = 0; col < A.size(); col++) v[col] = A[col][row];
@@ -306,7 +336,8 @@ std::vector<std::vector<T>> get_transpose(
*/
template <typename T>
std::vector<float> fit_OLS_regressor(std::vector<std::vector<T>> const &X,
std::vector<T> const &Y) {
std::vector<T> const &Y)
{
// NxF
std::vector<std::vector<T>> X2 = X;
for (size_t i = 0; i < X2.size(); i++)
@@ -337,10 +368,12 @@ std::vector<float> fit_OLS_regressor(std::vector<std::vector<T>> const &X,
template <typename T>
std::vector<float> predict_OLS_regressor(std::vector<std::vector<T>> const &X,
std::vector<float> const &beta /**< */
) {
)
{
std::vector<float> result(X.size());
for (size_t rows = 0; rows < X.size(); rows++) {
for (size_t rows = 0; rows < X.size(); rows++)
{
// -> start with constant term
result[rows] = beta[X[0].size()];
for (size_t cols = 0; cols < X[0].size(); cols++)
@@ -353,7 +386,8 @@ std::vector<float> predict_OLS_regressor(std::vector<std::vector<T>> const &X,
/**
* main function
*/
int main() {
int main()
{
size_t N, F;
std::cout << "Enter number of features: ";
@@ -370,7 +404,8 @@ int main() {
<< "Enter training data. Per sample, provide features ad one output."
<< std::endl;
for (size_t rows = 0; rows < N; rows++) {
for (size_t rows = 0; rows < N; rows++)
{
std::vector<float> v(F);
std::cout << "Sample# " << rows + 1 << ": ";
for (size_t cols = 0; cols < F; cols++)
@@ -391,7 +426,8 @@ int main() {
std::vector<std::vector<float>> data2(T);
// vector<float> Y2(T);
for (size_t rows = 0; rows < T; rows++) {
for (size_t rows = 0; rows < T; rows++)
{
std::cout << "Sample# " << rows + 1 << ": ";
std::vector<float> v(F);
for (size_t cols = 0; cols < F; cols++) std::cin >> v[cols];

9
computer_oriented_statistical_methods/successive_approximation.cpp
View File

@@ -17,11 +17,13 @@ static float eq(float y) { return (3 * y) - cos(y) - 2; }
static float eqd(float y) { return 0.5 * (cos(y) + 2); }
/** Main function */
int main() {
int main()
{
float y, x1, x2, x3, sum, s, a, f1, f2, gd;
int i, n;
for (i = 0; i < 10; i++) {
for (i = 0; i < 10; i++)
{
sum = eq(y);
std::cout << "value of equation at " << i << " " << sum << "\n";
y++;
@@ -31,7 +33,8 @@ int main() {
std::cout << "enter the no iteration to perform->\n";
std::cin >> n;
for (i = 0; i <= n; i++) {
for (i = 0; i <= n; i++)
{
x2 = eqd(x1);
std::cout << "\nenter the x2->" << x2;
x1 = x2;