vektor.c

vector.c

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int scalar(int *v1, int *v2, int len){                // parameterek: a ket osszeszorzando vektorra mutato pointerek,
                                                      // es a ket vektor dimenzioszama
   int acc = 0;                                       // az akkumulatorba 0-t teszunk
   for(int i=0; i < len; i++) {                       // ezzel a ciklussal vegiglepkedunk a vektorokon
        acc += v1[i] * v2[i];                         // az akkumulator ertekehez hozzaadjuk a ket tomb i-edik elemeinek a szorzatat
    }
    return acc;                                       // visszaadjuk az akkumulator erteket
}

int *vectorial(int *v1, int *v2){                     // Ez a fuggveny azt a pointert adja vissza, ami a ket osszeszorzott vektor altal letrehozott
                                                      // vektorra mutat.
    int *v3 = malloc(3 * sizeof(int));                // a v3 valtozo egy olyan memoriacimre mutat, ami utan lefoglalunk
                                                      // egyben egy haromszor akkora memoriat, ami az int merete
                                                      // (Itt ugye azt a vektort taroljuk majd, ami a skalaris szorzat
                                                      // erteke lesz.)
    v3[0] = v1[1] * v2[2] - v1[2] * v2[1];            // Az eredmenyvektor elso elemenek a kiszamitasa
    v3[1] = v1[2] * v2[0] - v1[0] * v2[2];            // Az eredmenyvektor masodik elemenek a kiszamitasa
    v3[2] = v1[0] * v2[1] - v1[1] * v2[0];            // Az eredmenyvektor harmadik elemenek a kiszamitasa
    return v3;                                        // Visszaadjuk a memroriacmet, ahol az eredmenyt tartjuk
}

int *readvector(int len){                             // Ez a fuggveny egy pointert ad vissza, ami a beolvasott ektorra mutat.
                                                      // parameternek a beolvasando vektor hosszat varja.
    char  vread[1024];                                // Ebbe a stringbe olvassuk be a vektort a billentyuzetrol
    char *token;                                      // Ez a string tartalmazza majd a vektorok elemeit
    int  *vector = malloc(len * sizeof(int));         // Lefoglalunk annyi memoriat, amennyi a beolvasando vektor hozza lesz
                                                      // (az adattipus merete, es a darabszam szorzata) es a vector nevu
                                                      // valtozoban eltaroljuk azt a memoriacimet, ahol ez kezdodik
    int  val;                                         // Az a valtozo, amiben majd eltaroljuk a token erteket
    scanf("%s", vread);                               // Beolvassuk a stringet a vread nevo tombbe (stringbe)
    token = strtok(vread, ",");                       // A token valtozo erteke a vread string elso ','-g tarto resze lesz
    int n=0;                                          // ez a valtozo mutat majd a vector nevu tumb n-edik elemere.
    while (token != NULL){                            // Addig haladunk a vread stringen, ameddig a token nevu valtozo erteke nem NULL
        val = atoi(token);                            // a val valtozoba beletesszuk a tokenben talalhato szamot, amit stringbol az
                                                      // atoi fuggvennyel (stdlib) alakitunk integerre
        vector[n] = val;                              // a vector nevu tomb n-edik elemebe irjuk a val valtozo erteket
        n++;                                          // noveljuk az n valtozo erteket
        token = strtok(NULL, ",");                    // a token valzoba beolvassuk a kovetkezo ,-ig tarto reszet
    }
    return vector;                                    // visszaadjuk a beolvasott vektor (tomb) kezdo memoriacimet
}

int main(){
    int *v1, *v2, *v3;                               // Ezekkel a pointerek mutatnak majd a vektorok memoriacimere
    int len;                                         // Ennyi dimenziosak lesznek a vektorok
    int scalar_result;                               // Itt taroljuk majd a skalaris szorzat erteket
    printf("Hany dimenzios vektorokat szorzunk?\n");
    scanf("%d", &len);                               // a len valtozo memoriacimeben eltaroljuk a beolvasott integer erteket
    int vector1[len];                                // letrehozom az elso vektor szamara a tombot
    int vector2[len];                                // letrehozom a masodik vektor szamara a tombot
    v1 = vector1;                                    // a v1 pointert a az elso vektorra allitom
    v2 = vector2;                                    // a v2 pointert a masodik vektorra allitom
    printf("Kerem az elso vektort!\n");
    v1 = readvector(len);                            // a v1 pointerben eltarolom a readvector fuggveny altal
                                                     // visszaadott memoriacimet, ami a beolvasott tombre mutat
    printf("Kerem a  masodik vektort!\n");
    v2 = readvector(len);                            // a v2 pointerben eltarolom a readvector fuggveny altal
                                                     // visszaadott memoriacimet, ami a beolvasott tombre mutat
    scalar_result = scalar(v1, v2, len);             // a scalar_result valtozoban taroljuk a skalaris szorzat erteket
    printf("A skalaris szorzat eredmenye: %d\n", scalar_result);
    if(len == 3){                                    // ha haromdimenzios vektoraink vannak, akkor vektorialisan is osszeszorozzuk oket
        v3 = vectorial(v1,v2);                       // a v3 pointerben eltarolom a vectorial fuggveny altal visszaadott memoriacimet
                                                     //, ami az eredmenyvektorra mutat
        printf("A vektorialis szorzat eredmenye: [%d,%d,%d]\n", v3[0], v3[1], v3[2]);
    }
    return 0;                                        // ha a program sikerrel fut le, akkor 0-t adunk visszateresi erteknek.
}