Kartesisches Produkt zweier Vektorräume

Aug 16 2020

Vor ein paar Tagen habe ich ein interessantes Problem gefunden, das wie folgt lautet:

Gegeben zwei Vektorräume erzeugen die resultierende Menge ihres kartesischen Produkts. \begin{gather} \text{Seien: } \mathcal{V}, \mathcal{W} \text{ seien Vektorräume}\\ \mathcal{V} \times \mathcal{W} = \{ (v,w ) \mid v \in \mathcal{V} \land w \in \mathcal{W} \} \end{gather}

  • Hinweis 1: Ein Vektorraum ist eine Menge von Elementen, die Vektoren genannt werden und einige Eigenschaften erfüllen
  • Hinweis 2: Entwerfen Sie die Lösung für endliche Vektorräume
  • Tipp 1: Es wird empfohlen, Strukturen zu verwenden
  • Einschränkung: Sie dürfen keine STL-Klassen verwenden

Ich habe dieses Problem mit dem nächsten Ansatz gelöst:

struct vector_pair
{
    double *vector_a;
    double *vector_b;
    size_t a_dimension;
    size_t b_dimension;
};

struct cartesian_product_set
{
    vector_pair *pairs;
    size_t pairs_number;
};

cartesian_product_set vector_spaces_cartesian_product(double **space_v, size_t v_vectors,
    size_t v_dimension, double **space_w, size_t w_vectors, size_t w_dimension)
{
    cartesian_product_set product_set{new vector_pair[v_vectors * w_vectors], v_vectors * w_vectors};
    
    for (size_t i = 0, j, k = 0; i < v_vectors; i++)
        for (j = 0; j < w_vectors; j++)
            product_set.pairs[k++] = vector_pair{space_v[i], space_w[j], v_dimension, w_dimension};

    return product_set;
}

Wie könnte ich diesen Code verbessern, wenn möglich?

Vielen Dank.

Antworten

2 cauon Aug 18 2020 at 15:28
  1. const-Korrektheit
  2. Verwenden Sie nach Möglichkeit Verweise anstelle von Zeigern
  3. Die Tatsache, dass Sie die Verpflichtung hinterlassen, den Speicher, den Sie dem Anrufer zuweisen, freizugeben, ist im Allgemeinen keine gute Praxis
  4. Ein häufiges Muster in Ihrem Code ist, dass Sie Zeiger auf Arrays und deren Länge haben - warum nicht eine Struktur erstellen, um sie zu bündeln?
  5. Versuchen Sie, Iteratoren und bereichsbasierte for-Schleifen zu verwenden, wenn Sie den Index nicht wirklich benötigen (was Sie in Ihrem Beispiel nicht tun).
  6. Da wir uns nicht wirklich um die Art der Elemente in einem Vektorraum kümmern, könnten Sie Vorlagen verwenden, um Ihren Algorithmus zu verallgemeinern

Und nur um zu sehen, ob es möglich wäre, habe ich versucht, eine Kompilierungsversion des Algorithmus zu entwickeln:

template<typename T>
struct pair
{
    T first;
    T second;
};

template<std::size_t N, typename T>
struct cvp
{
    pair<T> pairs[N];
};

template <typename T, size_t NV, size_t NW>
auto get_cvp(const T (&vs)[NV], const T (&ws)[NW])
{
    cvp<NV*NW, T> result;
    auto it_pairs = std::begin(result.pairs);
    for (const auto v : vs) {
        for (const auto w : ws) {
            *(it_pairs++) = {v, w};
        }
    }
    return result;
}

Du kannst den Code hier ausprobieren:https://godbolt.org/z/e8GvEf