backup/C-Plus-Plus
1
0
Fork 0
mirror of https://github.com/TheAlgorithms/C-Plus-Plus.git synced 2026-06-16 23:28:15 +08:00
Code Issues Projects Releases Wiki Activity

formatting source-code for 153fb7b8a5

Browse Source
This commit is contained in:
github-actions
2020-05-30 04:02:09 +00:00
parent 92fe9495ec
commit 8a2de9842b
175 changed files with 1671 additions and 3460 deletions
Download Patch File Download Diff File Expand all files Collapse all files

29
computer_oriented_statistical_methods/bisection_method.cpp
View File

@@ -23,36 +23,29 @@
/** 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;
}
}
@@ -61,19 +54,15 @@ 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,36 +25,29 @@
/** 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;
}
}
@@ -62,8 +55,7 @@ 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);
@@ -72,8 +64,7 @@ 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,8 +6,7 @@
#include <iostream>
/** Main function */
int main()
{
int main() {
int mat_size, i, j, step;
std::cout << "Matrix size: ";
@@ -15,8 +14,7 @@ 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];
@@ -24,20 +22,16 @@ 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++)
@@ -47,10 +41,8 @@ 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] << " ";
}
@@ -58,11 +50,9 @@ 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;
}
@@ -74,8 +64,7 @@ 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,21 +21,18 @@
/** 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;
@@ -44,8 +41,7 @@ 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,13 +16,11 @@
*/
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];
@@ -36,8 +34,7 @@ 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 = ' ';
@@ -53,8 +50,7 @@ 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++)
@@ -72,8 +68,7 @@ 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
@@ -81,18 +76,15 @@ 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];
@@ -109,22 +101,19 @@ 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];
}
@@ -137,15 +126,13 @@ 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);
}
@@ -157,8 +144,7 @@ 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();
@@ -175,8 +161,7 @@ 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;
}
@@ -185,15 +170,13 @@ 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;
}
@@ -208,15 +191,13 @@ 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;
}
@@ -233,30 +214,26 @@ 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]);
@@ -264,27 +241,22 @@ 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;
@@ -295,8 +267,7 @@ 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];
@@ -313,12 +284,11 @@ 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];
@@ -336,8 +306,7 @@ std::vector<std::vector<T>> get_transpose(std::vector<std::vector<T>> const &A)
*/
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++)
@@ -368,12 +337,10 @@ 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++)
@@ -386,8 +353,7 @@ 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: ";
@@ -404,8 +370,7 @@ 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++)
@@ -426,8 +391,7 @@ 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,13 +17,11 @@ 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++;
@@ -33,8 +31,7 @@ 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;