Skip to content
TheChatArchiveThe Chat Archive
gpt-4o-mini-2024-07-18· OpenAIAi2 WildChat-4.8M (AI2)

Dado el código: " #ifndef SPARSEVECTORTH_ #define SPARSEVECTORTH_ #include <iostream>…

  1. 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);
    

    }"

  2. 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:

    1. Inicialización de miembros en la lista de inicialización: Inicializamos n_ directamente con v.get_size() y delegamos la inicialización de nz_ a contar los elementos en el mismo bucle.

    2. Uso de emplace_back: Al contar y agregar elementos distintos de cero al vector pv_, ahora se usa emplace_back, que construye el objeto directamente en el vector, lo que puede ofrecer un pequeño aumento de eficiencia y claridad.

    3. Eliminación de la segunda pasada: En la implementación original, se hacía una segunda pasada sobre el vector v para copiar los elementos válidos a pv_. 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 usa emplace_back(), ya que el vector crecerá automáticamente. No se realiza la redimensión explícitamente después de la inserción porque emplace_back() maneja el tamaño del vector dinámicamente.
    • Se asume que pair_t se 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.

  3. User

    Pero emplace_back no está en el código

  4. Assistant

    Disculpa por la confusión. Si emplace_back no está disponible en tu implementación de pair_vector_t, debes usar métodos que estén definidos en el tipo. Como no tenemos la implementación de vector_t, se asumirá que tiene un método de asignación como push_back u otro que funcione en este contexto.

    Aquí está el método refactorizado usando push_back y 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:

    1. Combinar contabilidad y adición: Ahora, el bucle cuenta y agrega los elementos distintos de cero a pv_ en una sola pasada.

    2. Uso de push_back: En lugar de emplace_back, que no estaba en el código original, se utiliza push_back para agregar un nuevo pair_double_t a pv_. Dependiendo de la implementación de pair_double_t, este constructor podría ser ligeramente menos eficiente que emplace_back, pero sigue siendo adecuado para este contexto.

    3. Manejo de nz_: Se incrementa nz_ 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.