public:

/// Creates a sparse vector from a dense vector.

explicit SparseVector(const std::vector<float>& value) : SparseVector(std::span<const float>{value}) {}

/// Creates a sparse vector from a span.

explicit SparseVector(std::span<const float> value) {

if (value.size() > std::numeric_limits<int>::max()) {

throw std::invalid_argument{"sparsevec cannot have more than max int dimensions"};

}

dimensions_ = static_cast<int>(value.size());

// do not reserve capacity for indices/values since likely many zeros

for (size_t i = 0; i < value.size(); i++) {

float v = value[i];

if (v != 0) {

indices_.push_back(static_cast<int>(i));

values_.push_back(v);

}

}

}

/// Creates a sparse vector from a map of non-zero elements.

SparseVector(const std::unordered_map<int, float>& map, int dimensions) {

if (dimensions < 0) {

throw std::invalid_argument{"sparsevec cannot have negative dimensions"};

}

dimensions_ = dimensions;

// could probably reserve capacity for indices since not expecting zeros

for (const auto& [i, v] : map) {

if (i < 0 || i >= dimensions) {

throw std::invalid_argument{"sparsevec index out of bounds"};

}

if (v != 0) {

indices_.push_back(i);

}

}

std::ranges::sort(indices_);

values_.reserve(indices_.size());

for (const auto i : indices_) {

values_.push_back(map.at(i));

}

}

/// Returns the number of dimensions.

int dimensions() const {

return dimensions_;

}

/// Returns the non-zero indices.

const std::vector<int>& indices() const {

return indices_;

}

/// Returns the non-zero values.

const std::vector<float>& values() const {

return values_;

}

friend bool operator==(const SparseVector& lhs, const SparseVector& rhs) {

return lhs.dimensions_ == rhs.dimensions_ && lhs.indices_ == rhs.indices_ && lhs.values_ == rhs.values_;

}

friend std::ostream& operator<<(std::ostream& os, const SparseVector& value) {

os << "{";

for (size_t i = 0; i < value.indices_.size(); i++) {

if (i > 0) {

os << ",";

}

os << value.indices_[i] + 1;

os << ":";

os << value.values_[i];

}

os << "}/";

os << value.dimensions_;

return os;

}

private:

int dimensions_;

std::vector<int> indices_;

std::vector<float> values_;