I'm trying to create a function that fills my vector with values from beginning to end with a certain step. For type double and C++ 17 version. Any idea how to do this?
vector<double> generateRange(double start, double end, double step)
{
}
int main()
{
// return [10, 10.5, 11,...., 12]
auto range = generateRange(10, 12, 0.5);
for (auto i : range)
std::cout << i << ' ';
}
For int it would be a very simple loop, but for double...
You can for example write a simple loop to generate vector that you want.
However, the range function in python doesn't return a list but a generator, which is much faster. You should be returning a generator (range) in C++ as well instead of returning a vector. Implementing a generator is a bit more advanced.
The standard library comes with tools that can be used to build such generator. Here is your example:
auto step_fun = [=](auto x) { return x * step + start; };
auto end_pred = [=](auto x) { return x <= end; };
auto range =
std::views::iota(0)
| std::views::transform(step_fun)
| std::views::take_while(end_pred);
I don't think you absolutely need to store the values in a vector before iterating over them.
I would do something like this
/**
g++ -std=c++17 -o prog_cpp prog_cpp.cpp \
-pedantic -Wall -Wextra -Wconversion -Wno-sign-conversion \
-g -O0 -UNDEBUG -fsanitize=address,undefined
**/
#include <iostream>
#include <algorithm>
inline
auto // iterable
generate_range(double from_count,
double to_count,
double step)
{
struct Iter
{
double count;
double step;
bool operator!=(const double &rhs) const { return count<=rhs; } // oh!!!
void operator++() { count+=step; }
auto operator*() const { return count; }
};
struct Enumerate
{
double from_count;
double to_count;
double step;
auto begin() { return Iter{from_count, step}; }
auto end() { return to_count; }
};
return Enumerate{std::min(from_count, to_count),
std::max(from_count, to_count),
step};
}
int
main()
{
for(const auto &value: generate_range(10, 12, 0.5))
{
std::cout << value << ' ';
}
std::cout << '\n'; // 10 10.5 11 11.5 12
for(const auto &value: generate_range(239.99, 237.36, 1))
{
std::cout << value << ' ';
}
std::cout << '\n'; // 237.36 238.36 239.36
return 0;
}
Note that != actually tests <=; it's ugly, but it works.
This function returns something that offers begin() and end() member-functions so that a range-for loop can use it.
edit: added min/max for inverted bounds.
My solution to problem:
#include <vector>
using std::vector;
#include <iostream>
using std::cout;
#include <algorithm>
vector<double> generateRange(double start, double end, double step)
{
int vector_size = (end - start) / step;
vector<double> values(vector_size);
std::for_each(begin(values), std::end(values),
[start, step, i = 0](double &actual) mutable {
actual = start + step * i;
i++;
});
return values;
}
int main()
{
// return [10, 10.5, 11,...., 12]
auto range = generateRange(10, 12, 0.5);
for (auto i : range)
std::cout << i << ' ';
}
if you have any question about functions i used don't hesitate to ask :)
int, I suspect that if you tried writing the same fordouble, you would either succeed or have a more specific question about why your code isn't perfect.