Dado el código: " #ifndef SPARSEVECTORTH_ #define SPARSEVECTORTH_ #include <iostream>…
- User
Dado el código: " #ifndef SPARSE_VECTORT_H_ #define SPARSE_VECTORT_H_
#include #include <math.h> // fabs
#include "vector_t.h" #include "pair_t.h"
#define EPS 1.0e-6
typedef pair_t pair_double_t; typedef vector_t<pair_double_t> pair_vector_t;
class sparse_vector_t { public: // constructores sparse_vector_t(const int = 0); sparse_vector_t(const vector_t&, const double = EPS); // constructor normal sparse_vector_t(const sparse_vector_t&); // constructor de copia
// operador de asignación sparse_vector_t& operator=(const sparse_vector_t&);
// destructor ~sparse_vector_t();
// getters int get_nz(void) const; int get_n(void) const;
// getters-setters pair_double_t& at(const int); pair_double_t& operator[](const int);
// getters constantes const pair_double_t& at(const int) const; const pair_double_t& operator[](const int) const;
// E/S void write(std::ostream& = std::cout) const;
private: pair_vector_t pv_; // valores + índices int nz_; // nº de valores distintos de cero = tamaño del vector int n_; // tamaño del vector original
// bool IsNotZero(const double, const double = EPS) const; };
bool IsNotZero(const double val, const double eps = EPS) { return fabs(val) > eps; } // sparse_vector_t::sparse_vector_t(const int n) : pv_(n), nz_(0), n_(n) {}
// Corregido. pv_ se inicializa con n elementos ?? sparse_vector_t::sparse_vector_t(const int n) : pv_(), nz_(0), n_(n) {}
// FASE II sparse_vector_t::sparse_vector_t(const vector_t& v, const double eps) : pv_(), nz_(0), n_(0) { n_ = v.get_size(); // contar el número de elementos distintos de cero (nz_) for (int i{ 0 }; i < v.get_size(); i++) if (IsNotZero(v[i], eps)) nz_++;
// redimensinar el vector de pares a nz_ pv_.resize(nz_); // copiar los elementos distintos de cero al vector escaso for (int i{ 0 }, j{ 0 }; i < v.get_size(); i++) if (IsNotZero(v[i], eps)) pv_[j++].set(v[i], i);}
// constructor de copia sparse_vector_t::sparse_vector_t(const sparse_vector_t& w) { *this = w; // se invoca directamente al operator= }
// operador de asignación sparse_vector_t& sparse_vector_t::operator=(const sparse_vector_t& w) { nz_ = w.get_nz(); n_ = w.get_n(); pv_ = w.pv_;
return *this; }
sparse_vector_t::~sparse_vector_t() {}
inline int sparse_vector_t::get_nz() const { return nz_; }
inline int sparse_vector_t::get_n() const { return n_; }
pair_double_t& sparse_vector_t::at(const int i) { assert(i >= 0 && i < get_nz()); return pv_[i]; }
pair_double_t& sparse_vector_t::operator[](const int i) { return at(i); }
const pair_double_t& sparse_vector_t::at(const int i) const { assert(i >= 0 && i < get_nz()); return pv_[i]; }
const pair_double_t& sparse_vector_t::operator[](const int i) const { return at(i); }
// E/S void sparse_vector_t::write(std::ostream& os) const { os << get_n() << "(" << get_nz() << "): [ "; for (int i = 0; i < get_nz(); i++) os << pv_[i] << " "; os << "]" << std::endl; }
std::ostream& operator<<(std::ostream& os, const sparse_vector_t& sv) { sv.write(os); return os; }
#endif // SPARSE_VECTORT_H_ " Refactoriza el método: " sparse_vector_t::sparse_vector_t(const vector_t& v, const double eps) : pv_(), nz_(0), n_(0) { n_ = v.get_size(); // contar el número de elementos distintos de cero (nz_) for (int i{ 0 }; i < v.get_size(); i++) if (IsNotZero(v[i], eps)) nz_++;
// redimensinar el vector de pares a nz_ pv_.resize(nz_); // copiar los elementos distintos de cero al vector escaso for (int i{ 0 }, j{ 0 }; i < v.get_size(); i++) if (IsNotZero(v[i], eps)) pv_[j++].set(v[i], i);}"
- Assistant
Aquí tienes el método
sparse_vector_t::sparse_vector_t(const vector_t<double>& v, const double eps)refactorizado. La refactorización se centra en mejorar la legibilidad y la eficiencia del código, además de eliminar la duplicación:sparse_vector_t::sparse_vector_t(const vector_t<double>& v, const double eps) : n_(v.get_size()), nz_(0), pv_() { // Contar elementos distintos de cero y redimensionar el vector de pares for (int i = 0; i < n_; ++i) { if (IsNotZero(v[i], eps)) { nz_++; pv_.emplace_back(v[i], i); // Agregar directamente el par al vector } } // Redimensionar el vector a la cantidad de elementos no cero pv_.resize(nz_); // En este caso, no es necesario si usamos emplace_back }Cambios realizados:
-
Inicialización de miembros en la lista de inicialización: Inicializamos
n_directamente conv.get_size()y delegamos la inicialización denz_a contar los elementos en el mismo bucle. -
Uso de
emplace_back: Al contar y agregar elementos distintos de cero al vectorpv_, ahora se usaemplace_back, que construye el objeto directamente en el vector, lo que puede ofrecer un pequeño aumento de eficiencia y claridad. -
Eliminación de la segunda pasada: En la implementación original, se hacía una segunda pasada sobre el vector
vpara copiar los elementos válidos apv_. Ahora, se realiza en una única pasada, lo que reduce la complejidad operativa y mejora la eficiencia.
Consideraciones:
- Es importante tener en cuenta que la función
resize()puede volverse innecesaria si se usaemplace_back(), ya que el vector crecerá automáticamente. No se realiza la redimensión explícitamente después de la inserción porqueemplace_back()maneja el tamaño del vector dinámicamente. - Se asume que
pair_tse puede construir directamente con dos argumentos, que debería ser el caso según la definición original. Si este no es el caso, necesitarías ajustar el enfoque.
Esta refactorización también mejora la claridad del propósito del código, haciendo que la intención sea más evidente al eliminar redundancias.
-
- User
Pero emplace_back no está en el código
- Assistant
Disculpa por la confusión. Si
emplace_backno está disponible en tu implementación depair_vector_t, debes usar métodos que estén definidos en el tipo. Como no tenemos la implementación devector_t, se asumirá que tiene un método de asignación comopush_backu otro que funcione en este contexto.Aquí está el método refactorizado usando
push_backy conservando la lógica básica pero de forma más eficiente:sparse_vector_t::sparse_vector_t(const vector_t<double>& v, const double eps) : n_(v.get_size()), nz_(0), pv_() { // Contar elementos distintos de cero y añadirlos a pv_ for (int i = 0; i < n_; ++i) { if (IsNotZero(v[i], eps)) { pv_.push_back(pair_double_t(v[i], i)); // Añadir el par (valor, índice) nz_++; // Incrementar el número de elementos no cero } } }Cambios realizados:
-
Combinar contabilidad y adición: Ahora, el bucle cuenta y agrega los elementos distintos de cero a
pv_en una sola pasada. -
Uso de
push_back: En lugar deemplace_back, que no estaba en el código original, se utilizapush_backpara agregar un nuevopair_double_tapv_. Dependiendo de la implementación depair_double_t, este constructor podría ser ligeramente menos eficiente queemplace_back, pero sigue siendo adecuado para este contexto. -
Manejo de
nz_: Se incrementanz_dentro del mismo bucle donde se añade el par, lo que evita la necesidad de redimensionar el vector luego.
Este enfoque sigue manteniendo un buen rendimiento y claridad, asegurando que los elementos no nulos se procesen en una única iteración sobre el vector de entrada.
-