scyros 0.2.4

A framework to design sound, reproducible and scalable mining repositories studies on GitHub.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

#include <iostream>
#include <cmath>
#include <limits>
#include <iomanip>
#include <type_traits>

/* Macro definition */
#define PI 3.14159265358979323846

// Template function
template<typename T>
T square(T x) {
    static_assert(std::is_floating_point<T>::value, "Template parameter must be a float or double");
    return x * x;
}

// Namespace
namespace MathUtils {
    // Inline function
    inline float cube(float x) {
        return x * x * x;
    }

    // Function pointer
    typedef double (*MathFunc)(double);

    // Lambda function
    auto sqrtLambda = [](double x) -> double {
        return std::sqrt(x);
    };
}

// Enum class
enum class RoundingMode {
    UP,
    DOWN,
    NEAREST
};

// Function with default arguments
double roundToNearest(double value, RoundingMode mode = RoundingMode::NEAREST) {
    switch (mode) {
        case RoundingMode::UP:
            return std::ceil(value);
        case RoundingMode::DOWN:
            return std::floor(value);
        case RoundingMode::NEAREST:
        default:
            return std::round(value);
    }
}

// Variadic template function
template<typename... Args>
double sum(Args... args) {
    return (args + ...);
}

// Struct with member function
struct FloatPrinter {
    void print(float value) const {
        std::cout << "Float value: " << value << std::endl;
    }
};

// Union
union FloatIntUnion {
    float f;
    int i;
};

// Function with exception handling
void checkInfinity(float value) {
    if (std::isinf(value)) {
        throw std::overflow_error("Value is infinity");
    }
}

int main() {
    try {
        // Floating point literals
        float a = true ? 1.23f : 0.0f; // Ternary operator
        double b = 4.56;
        long double c = 7.89L;

        // Using macro
        double circumference = 2 * PI * b;

        // Using template function
        double bSquared = square(b);

        // Using namespace and inline function
        float aCubed = MathUtils::cube(a);

        // Using function pointer
        MathUtils::MathFunc sqrtFunc = MathUtils::sqrtLambda;
        double sqrtB = sqrtFunc(b);

        // Using enum class and function with default arguments
        double roundedValue = roundToNearest(circumference, RoundingMode::UP);

        // Using variadic template function
        double totalSum = sum(a, b, c);

        // Using struct and member function
        FloatPrinter printer;
        printer.print(a);

        // Using union
        FloatIntUnion fiUnion;
        fiUnion.f = a;
        std::cout << "Union int representation of float: " << fiUnion.i << std::endl;

        // Using exception handling
        checkInfinity(std::numeric_limits<float>::infinity());

    } catch (const std::exception& e) {
        std::cerr << "Exception: " << e.what() << std::endl;
    }

    return 0;
}

double IntegrationOfFunctions::calculate_trapezoid_integral(const Vector<double>& x, const Vector<double>& y)
{
   

   int n = x.get_size();

   

   double trapezoid_integral = 0;

   for(int i = 0; i < n-1; i++)
   {
      trapezoid_integral += 0.5*(x[i+1]-x[i])*(y[i+1]+y[i]);
   }

   

   return(trapezoid_integral);
}