15453345670

Committed 04 Jun 2025 09:40PM UTC coverage: 86.735% (+0.1%) from 86.608%

Build # 15453345670

Build Type

push

github

Committed by

SuperFola

Commit Message

chore: updating fuzzing corpus

Coverage Stats

2 of 3 new or added lines in 2 files covered. (66.67%)

140 existing lines in 7 files now uncovered.

7258 of 8368 relevant lines covered (86.74%)

120482.26 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

98.92

/src/arkreactor/Builtins/Mathematics.cpp

#define _USE_MATH_DEFINES
#include <cmath>
#include <fmt/core.h>
#include <random>

#include <Ark/Builtins/Builtins.hpp>

#include <Ark/TypeChecker.hpp>
#include <Ark/VM/VM.hpp>

namespace Ark::internal::Builtins::Mathematics
{
    // cppcheck-suppress constParameterReference
    Value exponential(std::vector<Value>& n, VM* vm [[maybe_unused]])
    {
        if (!types::check(n, ValueType::Number))
            throw types::TypeCheckingError(
                "math:exp",
                { { types::Contract { { types::Typedef("value", ValueType::Number) } } } },
                n);

        return Value(std::exp(n[0].number()));
    }

    // cppcheck-suppress constParameterReference
    Value logarithm(std::vector<Value>& n, VM* vm [[maybe_unused]])
    {
        if (!types::check(n, ValueType::Number))
            throw types::TypeCheckingError(
                "math:ln",
                { { types::Contract { { types::Typedef("value", ValueType::Number) } } } },
                n);

        if (n[0].number() <= 0.0)
            throw std::runtime_error(fmt::format("math:ln: value {} must be greater than 0", n[0].number()));

        return Value(std::log(n[0].number()));
    }

    // cppcheck-suppress constParameterReference
    Value ceil_(std::vector<Value>& n, VM* vm [[maybe_unused]])
    {
        if (!types::check(n, ValueType::Number))
            throw types::TypeCheckingError(
                "math:ceil",
                { { types::Contract { { types::Typedef("value", ValueType::Number) } } } },
                n);

        return Value(std::ceil(n[0].number()));
    }

    // cppcheck-suppress constParameterReference
    Value floor_(std::vector<Value>& n, VM* vm [[maybe_unused]])
    {
        if (!types::check(n, ValueType::Number))
            throw types::TypeCheckingError(
                "math:floor",
                { { types::Contract { { types::Typedef("value", ValueType::Number) } } } },
                n);

        return Value(std::floor(n[0].number()));
    }

    // cppcheck-suppress constParameterReference
    Value round_(std::vector<Value>& n, VM* vm [[maybe_unused]])
    {
        if (!types::check(n, ValueType::Number))
            throw types::TypeCheckingError(
                "math:round",
                { { types::Contract { { types::Typedef("value", ValueType::Number) } } } },
                n);

        return Value(std::round(n[0].number()));
    }

    // cppcheck-suppress constParameterReference
    Value isnan_(std::vector<Value>& n, VM* vm [[maybe_unused]])
    {
        if (n[0].valueType() != ValueType::Number)
            return falseSym;

        return std::isnan(n[0].number()) ? trueSym : falseSym;
    }

    // cppcheck-suppress constParameterReference
    Value isinf_(std::vector<Value>& n, VM* vm [[maybe_unused]])
    {
        if (n[0].valueType() != ValueType::Number)
            return falseSym;

        return std::isinf(n[0].number()) ? trueSym : falseSym;
    }

    // cppcheck-suppress constParameterReference
    Value cos_(std::vector<Value>& n, VM* vm [[maybe_unused]])
    {
        if (!types::check(n, ValueType::Number))
            throw types::TypeCheckingError(
                "math:cos",
                { { types::Contract { { types::Typedef("value", ValueType::Number) } } } },
                n);

        return Value(std::cos(n[0].number()));
    }

    // cppcheck-suppress constParameterReference
    Value sin_(std::vector<Value>& n, VM* vm [[maybe_unused]])
    {
        if (!types::check(n, ValueType::Number))
            throw types::TypeCheckingError(
                "math:sin",
                { { types::Contract { { types::Typedef("value", ValueType::Number) } } } },
                n);

        return Value(std::sin(n[0].number()));
    }

    // cppcheck-suppress constParameterReference
    Value tan_(std::vector<Value>& n, VM* vm [[maybe_unused]])
    {
        if (!types::check(n, ValueType::Number))
            throw types::TypeCheckingError(
                "math:tan",
                { { types::Contract { { types::Typedef("value", ValueType::Number) } } } },
                n);

        return Value(std::tan(n[0].number()));
    }

    // cppcheck-suppress constParameterReference
    Value acos_(std::vector<Value>& n, VM* vm [[maybe_unused]])
    {
        if (!types::check(n, ValueType::Number))
            throw types::TypeCheckingError(
                "math:arccos",
                { { types::Contract { { types::Typedef("value", ValueType::Number) } } } },
                n);

        return Value(std::acos(n[0].number()));
    }

    // cppcheck-suppress constParameterReference
    Value asin_(std::vector<Value>& n, VM* vm [[maybe_unused]])
    {
        if (!types::check(n, ValueType::Number))
            throw types::TypeCheckingError(
                "math:arcsin",
                { { types::Contract { { types::Typedef("value", ValueType::Number) } } } },
                n);

        return Value(std::asin(n[0].number()));
    }

    // cppcheck-suppress constParameterReference
    Value atan_(std::vector<Value>& n, VM* vm [[maybe_unused]])
    {
        if (!types::check(n, ValueType::Number))
            throw types::TypeCheckingError(
                "math:arctan",
                { { types::Contract { { types::Typedef("value", ValueType::Number) } } } },
                n);

        return Value(std::atan(n[0].number()));
    }

    // cppcheck-suppress constParameterReference
    Value cosh_(std::vector<Value>& n, VM* vm [[maybe_unused]])
    {
        if (!types::check(n, ValueType::Number))
            throw types::TypeCheckingError(
                "math:cosh",
                { { types::Contract { { types::Typedef("value", ValueType::Number) } } } },
                n);

        return Value(std::cosh(n[0].number()));
    }

    // cppcheck-suppress constParameterReference
    Value sinh_(std::vector<Value>& n, VM* vm [[maybe_unused]])
    {
        if (!types::check(n, ValueType::Number))
            throw types::TypeCheckingError(
                "math:sinh",
                { { types::Contract { { types::Typedef("value", ValueType::Number) } } } },
                n);

        return Value(std::sinh(n[0].number()));
    }

    // cppcheck-suppress constParameterReference
    Value tanh_(std::vector<Value>& n, VM* vm [[maybe_unused]])
    {
        if (!types::check(n, ValueType::Number))
            throw types::TypeCheckingError(
                "math:tanh",
                { { types::Contract { { types::Typedef("value", ValueType::Number) } } } },
                n);

        return Value(std::tanh(n[0].number()));
    }

    // cppcheck-suppress constParameterReference
    Value acosh_(std::vector<Value>& n, VM* vm [[maybe_unused]])
    {
        if (!types::check(n, ValueType::Number))
            throw types::TypeCheckingError(
                "math:acosh",
                { { types::Contract { { types::Typedef("value", ValueType::Number) } } } },
                n);

        return Value(std::acosh(n[0].number()));
    }

    // cppcheck-suppress constParameterReference
    Value asinh_(std::vector<Value>& n, VM* vm [[maybe_unused]])
    {
        if (!types::check(n, ValueType::Number))
            throw types::TypeCheckingError(
                "math:asinh",
                { { types::Contract { { types::Typedef("value", ValueType::Number) } } } },
                n);

        return Value(std::asinh(n[0].number()));
    }

    // cppcheck-suppress constParameterReference
    Value atanh_(std::vector<Value>& n, VM* vm [[maybe_unused]])
    {
        if (!types::check(n, ValueType::Number))
            throw types::TypeCheckingError(
                "math:atanh",
                { { types::Contract { { types::Typedef("value", ValueType::Number) } } } },
                n);

        return Value(std::atanh(n[0].number()));
    }

    /**
     * @name random
     * @brief Compute a random number in [-2147483648, 2147483647] or in a custom range passed to the function
     * @param min optional inclusive lower bound
     * @param max optional inclusive upper bound. Must be present if `min` is passed
     * =begin
     * (print (random))  # a number in [-2147483648, 2147483647]
     * (print (random 0 10))  # a number between 0 and 10
     * =end
     * @author https://github.com/SuperFola
     */
    // cppcheck-suppress constParameterReference
    Value random(std::vector<Value>& n, VM* vm [[maybe_unused]])
    {
        static std::mt19937 gen { std::random_device()() };

        if (n.size() == 2 && !types::check(n, ValueType::Number, ValueType::Number))
            throw types::TypeCheckingError(
                "random",
                { { types::Contract {
                    { types::Typedef("min", ValueType::Number), types::Typedef("max", ValueType::Number) } } } },
                n);

        if (n.size() == 2)
        {
            const auto inclusive_min = static_cast<int>(n[0].number()),
                       inclusive_max = static_cast<int>(n[1].number());

            std::uniform_int_distribution<> distrib(inclusive_min, inclusive_max);
            return Value(distrib(gen));
        }

        const auto x = static_cast<int>(gen());
        return Value(x);
    }
}

1	#define _USE_MATH_DEFINES
2	#include <cmath>
3	#include <fmt/core.h>
4	#include <random>
5
6	#include <Ark/Builtins/Builtins.hpp>
7
8	#include <Ark/TypeChecker.hpp>
9	#include <Ark/VM/VM.hpp>
10
11	namespace Ark::internal::Builtins::Mathematics
12	{
13	// cppcheck-suppress constParameterReference
14	Value exponential(std::vector<Value>& n, VM* vm [[maybe_unused]])	349✔
15	{	349✔
16	if (!types::check(n, ValueType::Number))	349✔
17	throw types::TypeCheckingError(	2✔
18	"math:exp",	1✔
19	{ { types::Contract { { types::Typedef("value", ValueType::Number) } } } },	1✔
20	n);	1✔
21
22	return Value(std::exp(n[0].number()));	348✔
23	}	1✔
24
25	// cppcheck-suppress constParameterReference
26	Value logarithm(std::vector<Value>& n, VM* vm [[maybe_unused]])	360✔
27	{	360✔
28	if (!types::check(n, ValueType::Number))	360✔
29	throw types::TypeCheckingError(	3✔
30	"math:ln",	1✔
31	{ { types::Contract { { types::Typedef("value", ValueType::Number) } } } },	1✔
32	n);	1✔
33
34	if (n[0].number() <= 0.0)	359✔
35	throw std::runtime_error(fmt::format("math:ln: value {} must be greater than 0", n[0].number()));	1✔
36
37	return Value(std::log(n[0].number()));	358✔
38	}	2✔
39
40	// cppcheck-suppress constParameterReference
41	Value ceil_(std::vector<Value>& n, VM* vm [[maybe_unused]])	345✔
42	{	345✔
43	if (!types::check(n, ValueType::Number))	345✔
44	throw types::TypeCheckingError(	2✔
45	"math:ceil",	1✔
46	{ { types::Contract { { types::Typedef("value", ValueType::Number) } } } },	1✔
47	n);	1✔
48
49	return Value(std::ceil(n[0].number()));	344✔
50	}	1✔
51
52	// cppcheck-suppress constParameterReference
53	Value floor_(std::vector<Value>& n, VM* vm [[maybe_unused]])	17✔
54	{	17✔
55	if (!types::check(n, ValueType::Number))	17✔
56	throw types::TypeCheckingError(	2✔
57	"math:floor",	1✔
58	{ { types::Contract { { types::Typedef("value", ValueType::Number) } } } },	1✔
59	n);	1✔
60
61	return Value(std::floor(n[0].number()));	16✔
62	}	1✔
63
64	// cppcheck-suppress constParameterReference
65	Value round_(std::vector<Value>& n, VM* vm [[maybe_unused]])	8✔
66	{	8✔
67	if (!types::check(n, ValueType::Number))	8✔
68	throw types::TypeCheckingError(	2✔
69	"math:round",	1✔
70	{ { types::Contract { { types::Typedef("value", ValueType::Number) } } } },	1✔
71	n);	1✔
72
73	return Value(std::round(n[0].number()));	7✔
74	}	1✔
75
76	// cppcheck-suppress constParameterReference
77	Value isnan_(std::vector<Value>& n, VM* vm [[maybe_unused]])	6✔
78	{	6✔
79	if (n[0].valueType() != ValueType::Number)	6✔
UNCOV 80	return falseSym;	×
81
82	return std::isnan(n[0].number()) ? trueSym : falseSym;	6✔
83	}	6✔
84
85	// cppcheck-suppress constParameterReference
86	Value isinf_(std::vector<Value>& n, VM* vm [[maybe_unused]])	7✔
87	{	7✔
88	if (n[0].valueType() != ValueType::Number)	7✔
UNCOV 89	return falseSym;	×
90
91	return std::isinf(n[0].number()) ? trueSym : falseSym;	7✔
92	}	7✔
93
94	// cppcheck-suppress constParameterReference
95	Value cos_(std::vector<Value>& n, VM* vm [[maybe_unused]])	3✔
96	{	3✔
97	if (!types::check(n, ValueType::Number))	3✔
98	throw types::TypeCheckingError(	2✔
99	"math:cos",	1✔
100	{ { types::Contract { { types::Typedef("value", ValueType::Number) } } } },	1✔
101	n);	1✔
102
103	return Value(std::cos(n[0].number()));	2✔
104	}	1✔
105
106	// cppcheck-suppress constParameterReference
107	Value sin_(std::vector<Value>& n, VM* vm [[maybe_unused]])	3✔
108	{	3✔
109	if (!types::check(n, ValueType::Number))	3✔
110	throw types::TypeCheckingError(	2✔
111	"math:sin",	1✔
112	{ { types::Contract { { types::Typedef("value", ValueType::Number) } } } },	1✔
113	n);	1✔
114
115	return Value(std::sin(n[0].number()));	2✔
116	}	1✔
117
118	// cppcheck-suppress constParameterReference
119	Value tan_(std::vector<Value>& n, VM* vm [[maybe_unused]])	3✔
120	{	3✔
121	if (!types::check(n, ValueType::Number))	3✔
122	throw types::TypeCheckingError(	2✔
123	"math:tan",	1✔
124	{ { types::Contract { { types::Typedef("value", ValueType::Number) } } } },	1✔
125	n);	1✔
126
127	return Value(std::tan(n[0].number()));	2✔
128	}	1✔
129
130	// cppcheck-suppress constParameterReference
131	Value acos_(std::vector<Value>& n, VM* vm [[maybe_unused]])	3✔
132	{	3✔
133	if (!types::check(n, ValueType::Number))	3✔
134	throw types::TypeCheckingError(	2✔
135	"math:arccos",	1✔
136	{ { types::Contract { { types::Typedef("value", ValueType::Number) } } } },	1✔
137	n);	1✔
138
139	return Value(std::acos(n[0].number()));	2✔
140	}	1✔
141
142	// cppcheck-suppress constParameterReference
143	Value asin_(std::vector<Value>& n, VM* vm [[maybe_unused]])	3✔
144	{	3✔
145	if (!types::check(n, ValueType::Number))	3✔
146	throw types::TypeCheckingError(	2✔
147	"math:arcsin",	1✔
148	{ { types::Contract { { types::Typedef("value", ValueType::Number) } } } },	1✔
149	n);	1✔
150
151	return Value(std::asin(n[0].number()));	2✔
152	}	1✔
153
154	// cppcheck-suppress constParameterReference
155	Value atan_(std::vector<Value>& n, VM* vm [[maybe_unused]])	3✔
156	{	3✔
157	if (!types::check(n, ValueType::Number))	3✔
158	throw types::TypeCheckingError(	2✔
159	"math:arctan",	1✔
160	{ { types::Contract { { types::Typedef("value", ValueType::Number) } } } },	1✔
161	n);	1✔
162
163	return Value(std::atan(n[0].number()));	2✔
164	}	1✔
165
166	// cppcheck-suppress constParameterReference
167	Value cosh_(std::vector<Value>& n, VM* vm [[maybe_unused]])	3✔
168	{	3✔
169	if (!types::check(n, ValueType::Number))	3✔
170	throw types::TypeCheckingError(	2✔
171	"math:cosh",	1✔
172	{ { types::Contract { { types::Typedef("value", ValueType::Number) } } } },	1✔
173	n);	1✔
174
175	return Value(std::cosh(n[0].number()));	2✔
176	}	1✔
177
178	// cppcheck-suppress constParameterReference
179	Value sinh_(std::vector<Value>& n, VM* vm [[maybe_unused]])	3✔
180	{	3✔
181	if (!types::check(n, ValueType::Number))	3✔
182	throw types::TypeCheckingError(	2✔
183	"math:sinh",	1✔
184	{ { types::Contract { { types::Typedef("value", ValueType::Number) } } } },	1✔
185	n);	1✔
186
187	return Value(std::sinh(n[0].number()));	2✔
188	}	1✔
189
190	// cppcheck-suppress constParameterReference
191	Value tanh_(std::vector<Value>& n, VM* vm [[maybe_unused]])	3✔
192	{	3✔
193	if (!types::check(n, ValueType::Number))	3✔
194	throw types::TypeCheckingError(	2✔
195	"math:tanh",	1✔
196	{ { types::Contract { { types::Typedef("value", ValueType::Number) } } } },	1✔
197	n);	1✔
198
199	return Value(std::tanh(n[0].number()));	2✔
200	}	1✔
201
202	// cppcheck-suppress constParameterReference
203	Value acosh_(std::vector<Value>& n, VM* vm [[maybe_unused]])	3✔
204	{	3✔
205	if (!types::check(n, ValueType::Number))	3✔
206	throw types::TypeCheckingError(	2✔
207	"math:acosh",	1✔
208	{ { types::Contract { { types::Typedef("value", ValueType::Number) } } } },	1✔
209	n);	1✔
210
211	return Value(std::acosh(n[0].number()));	2✔
212	}	1✔
213
214	// cppcheck-suppress constParameterReference
215	Value asinh_(std::vector<Value>& n, VM* vm [[maybe_unused]])	3✔
216	{	3✔
217	if (!types::check(n, ValueType::Number))	3✔
218	throw types::TypeCheckingError(	2✔
219	"math:asinh",	1✔
220	{ { types::Contract { { types::Typedef("value", ValueType::Number) } } } },	1✔
221	n);	1✔
222
223	return Value(std::asinh(n[0].number()));	2✔
224	}	1✔
225
226	// cppcheck-suppress constParameterReference
227	Value atanh_(std::vector<Value>& n, VM* vm [[maybe_unused]])	3✔
228	{	3✔
229	if (!types::check(n, ValueType::Number))	3✔
230	throw types::TypeCheckingError(	2✔
231	"math:atanh",	1✔
232	{ { types::Contract { { types::Typedef("value", ValueType::Number) } } } },	1✔
233	n);	1✔
234
235	return Value(std::atanh(n[0].number()));	2✔
236	}	1✔
237
238	/**
239	* @name random
240	* @brief Compute a random number in [-2147483648, 2147483647] or in a custom range passed to the function
241	* @param min optional inclusive lower bound
242	* @param max optional inclusive upper bound. Must be present if `min` is passed
243	* =begin
244	* (print (random)) # a number in [-2147483648, 2147483647]
245	* (print (random 0 10)) # a number between 0 and 10
246	* =end
247	* @author https://github.com/SuperFola
248	*/
249	// cppcheck-suppress constParameterReference
250	Value random(std::vector<Value>& n, VM* vm [[maybe_unused]])	102✔
251	{	102✔
252	static std::mt19937 gen { std::random_device()() };	103✔
253
254	if (n.size() == 2 && !types::check(n, ValueType::Number, ValueType::Number))	102✔
255	throw types::TypeCheckingError(	2✔
256	"random",	1✔
257	{ { types::Contract {	2✔
258	{ types::Typedef("min", ValueType::Number), types::Typedef("max", ValueType::Number) } } } },	1✔
259	n);	1✔
260
261	if (n.size() == 2)	101✔
262	{
263	const auto inclusive_min = static_cast<int>(n[0].number()),	100✔
264	inclusive_max = static_cast<int>(n[1].number());	100✔
265
266	std::uniform_int_distribution<> distrib(inclusive_min, inclusive_max);	100✔
267	return Value(distrib(gen));	100✔
268	}	100✔
269
270	const auto x = static_cast<int>(gen());	1✔
271	return Value(x);	1✔
272	}	102✔
273	}

ArkScript-lang / Ark / 15453345670

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous