Build a vector with step c++ - c++

Question

Is it possible to create a vector from a value to another one with a fixed step without using a loop in c++?
For example, I want to build a vector from 1 to 10 with step 0.5. In MATLAB I can do this as follow:
vector = [1:0.5:10];
Is there something similar in c++?

Answer 1

With the help of std::generate_n you can
std::vector<double> v;
const int size = 10 * 2 - 1;
v.reserve(size);
std::generate_n(std::back_inserter(v), size, []() { static double d = 0.5; return d += 0.5; });
LIVE

Answer 2

You need a loop somewhere. Matlab is simply hiding the loop from you. If this is something you do often, just create a function to make it easier to use:
#include <vector>
auto make_vector(double beg, double step, double end)
{
std::vector<double> vec;
vec.reserve((end - beg) / step + 1);
while (beg <= end) {
vec.push_back(beg);
beg += step;
}
return vec;
}
int main() {
auto vec = make_vector(1, 0.5, 10);
}

Answer 3

It's not possible without a loop, but you can hide the loop by using e.g, std::generate or std::generate_n:
constexpr size_t SIZE = (10 - 1) * 2;
std::vector<double> data(SIZE);
double new_value = 1.0;
std::generate(begin(data), end(data) [&new_value]()
{
double current_value = new_value;
new_value += 0.5;
return current_value;
});
Of course, this is quite a lot to write, and an explicit loop would probably be better:
std::vector<double> data;
for (double i = 1.0; i <= 10; i += 0.5)
data.push_back(i);
If the stepping is "one" (e.g. 1 or 1.0) then you could use std::iota instead:
std::vector<double> data(10);
std::iota(begin(data), end(data), 1.0); // Initializes the vector with values from 1.0 to 10.0

Answer 4

No, there is no such things in C++. You will have to create a loop and populate your vector, so something like:
std::vector<double> v;
v.reserve(19);
for(size_t i = 2; i < 21; ++i)
{
v.push_back(i / 2.);
}
I'm using here an integer loop instead of a double loop with .5 increments to make sure about the number of elements I get and minimize numerical rounding errors (.5 is fine, but not 1/3 for instance).

Answer 5

A simple solution using Ranges-v3 library:
#include <range/v3/all.hpp>
auto make_vector(double min, double step, double max) {
const auto size = static_cast<std::size_t>((max - min) / step);
return ranges::views::iota(std::size_t{0}, size + 1) |
ranges::views::transform([min, step](auto i) { return min + step * i; }) |
ranges::to<std::vector>();
}
int main() {
auto vec = make_vector(1, .5, 5);
for (auto x : vec)
std::cout << x << ' ';
// Output: 1 1.5 2 2.5 3 3.5 4 4.5 5
}
Ranges will be a part of C++20.

Answer 6

If you need to do a lot of this, you can easily write your own function that can work with any container (that supports reserve and is fill-able by std::generate):
template <typename TContainer>
TContainer fill(typename TContainer::value_type start,
typename TContainer::value_type step,
typename TContainer::value_type end) {
size_t size = static_cast<size_t>((end - start)/step + 1);
TContainer output(size);
std::generate(std::begin(output), std::end(output),
[&start, step]() {
return std::exchange(start, start + step);
}
);
return output;
}
Then you can use it as follows:
auto vec = fill<std::vector<int>>(0, 2, 10);
auto list = fill<std::list<float>>(1, 0.3, 5);
Live example
And you will get:
vec: 0, 2, 4, 6, 8, 10
list: 1, 1.3, 1.6, 1.9, 2.2, 2.5, 2.8, 3.1, 3.4, 3.7, 4, 4.3, 4.6, 4.9