Array [] ... /* Matrizenmultiplikation */

This site uses cookies. By continuing to browse this site, you are agreeing to our Cookie Policy.

  • Array [] ... /* Matrizenmultiplikation */

    Source Code

    1. /* MATRIX * VEKTOR */
    2. /* Matrizenmultiplikation */
    3. #include <stdio.h>
    4. #include <stdlib.h>
    5. void einlesen(unsigned *a, unsigned n);
    6. void ausgabe(unsigned *y, unsigned n);
    7. double mult(unsigned *a, unsigned *x,unsigned *y, unsigned n);
    8. void Vekein(unsigned *x, unsigned n);
    9. int main()
    10. {
    11. unsigned *a, *x, *y; /* Zeiger auf Matrizen */
    12. unsigned n; /* Anzahl der Zeilen/Spalten */
    13. printf("Anzahl der Zeilen/Spalten: ");
    14. scanf("%d", &n);
    15. a = (unsigned *) calloc (n*n, sizeof(unsigned));
    16. x = (unsigned *) calloc (n*n, sizeof(unsigned));
    17. y = (unsigned *) calloc (n*n, sizeof(unsigned));
    18. printf("Erste Matrix einlesen\n");
    19. einlesen(a,n);
    20. printf("\nVektor einlesen\n");
    21. Vekein(x,n);
    22. mult(a, x,y, n);
    23. ausgabe (y,n);
    24. free(a);
    25. free(x);
    26. free(y);
    27. return 0;
    28. }
    29. void einlesen(unsigned *a, unsigned n)
    30. { int i,j;
    31. for (i=0; i<n; i++)
    32. {
    33. for (j=0; j<n; j++)
    34. scanf("%u", a+i*n+j); // i Zeile , j Spl.
    35. }
    36. }
    37. void Vekein(unsigned *x, unsigned n)
    38. { int i;
    39. for (i=0; i<n; i++)
    40. scanf("%u", &x[i]);
    41. }
    42. double mult(unsigned *a, unsigned *x, unsigned *y, unsigned n)
    43. { unsigned i, j, k;
    44. for (i = 0; i < n; i++)
    45. for (j = 0; j < n; j++)
    46. { y[i] = 0;
    47. for (k = 0; k < n; k++)
    48. y[i] += *(a+i*n+k) * x[k];
    49. }
    50. return y[i];
    51. }
    52. void ausgabe(unsigned *y, unsigned n)
    53. {
    54. unsigned i;
    55. printf("\nErgebnis:\n");
    56. for (i=0;i<n;i++)
    57. printf("\n %u \n", y[i]);
    58. }
    Display All

    #######################################################################################################################





    Source Code

    1. /* Matrix * Matrix = Vektor.
    2. #include <stdio.h>
    3. #include <stdlib.h>
    4. void einlesen(unsigned *a, unsigned n);
    5. void ausgabe(unsigned *a, unsigned n);
    6. void mult(unsigned *a, unsigned *b, unsigned
    7. *c, unsigned n);
    8. /* Cpp */
    9. #include "global.h"
    10. void einlesen(unsigned *a, unsigned n)
    11. { int i,j;
    12. for (i=0; i<n; i++)
    13. {
    14. for (j=0; j<n; j++)
    15. scanf("%d", a+i*n+j);
    16. }
    17. }
    18. void ausgabe(unsigned *a, unsigned n)
    19. { unsigned i, j;
    20. for (i = 0; i < n; i++)
    21. { for (j = 0; j < n ; j++)
    22. printf("%u ", *(a+i*n+j));
    23. printf("\n");
    24. }
    25. // printf("\n");
    26. }
    27. void mult(unsigned *a, unsigned *b, unsigned
    28. *c, unsigned n)
    29. /* Multipiziert a mit b; Ergebnis in c
    30. */
    31. { unsigned i, j, k;
    32. for (i = 0; i < n; i++)
    33. for (j = 0; j < n; j++)
    34. {
    35. *(c+i*n+j) = 0;
    36. for (k = 0;
    37. k < n; k++)
    38. *(c+i*n+j) += *(a+i*n+k) * *(b+k*n+j); }
    39. }
    40. */ main.cpp*/
    41. #include "global.h"
    42. int main()
    43. {
    44. unsigned *a, *b, *c;
    45. /* Zeiger auf Matrizen */
    46. unsigned n;
    47. /* Anzahl der Zeilen/Spalten */
    48. printf("Anzahl der Zeilen/Spalten: ");
    49. scanf("%u", &n);
    50. a = (unsigned *) calloc (n*n, sizeof(unsigned));
    51. b = (unsigned *) calloc (n*n, sizeof(unsigned));
    52. c = (unsigned *) calloc (n*n, sizeof(unsigned));
    53. printf("Erste Matrix einlesen\n");
    54. einlesen(a,n);
    55. printf("\nZweite Matrix einlesen\n");
    56. einlesen(b,n);
    57. mult(a, b,
    58. c, n);
    59. printf("\nErgebnismatrix:\n");
    60. ausgabe(c,
    61. n);
    62. free(a);
    63. free(b);
    64. free(c);
    65. getchar();
    66. getchar();
    67. }
    68. Normal
    69. 0
    70. 21
    71. false
    72. false
    73. false
    74. DE
    75. X-NONE
    76. X-NONE
    Display All

    ######################################################################################################################

    Source Code

    1. /* Matrizenmultiplikation Matrix * Zahl */
    2. #include <stdio.h>
    3. #include <stdlib.h>
    4. void einlesen(unsigned *a, unsigned n);
    5. void ausgabe(unsigned *a, unsigned n);
    6. void mult(unsigned *a, unsigned *e,double z, unsigned n);
    7. int main()
    8. {
    9. unsigned *a,*e; /* Zeiger auf Matrizen */
    10. unsigned n; /* Anzahl der Zeilen/Spalten */
    11. double z;
    12. printf("Anzahl der Zeilen/Spalten: ");
    13. scanf("%u", &n);
    14. a = (unsigned *) calloc (n*n, sizeof(unsigned));
    15. e = (unsigned *) calloc (n*n, sizeof(unsigned));
    16. printf("Matrix einlesen\n");
    17. einlesen(a,n);
    18. printf("Geben Sie ein Vergroesserungsfaktor ein: "); // die Zahl
    19. scanf("%lf", &z);
    20. mult(a, e,z, n);
    21. printf("\nErgebnismatrix:\n");
    22. ausgabe(e, n);
    23. free(a);
    24. free(e);
    25. return 0;
    26. }
    27. void einlesen(unsigned *a, unsigned n)
    28. { int i,j;
    29. for (i=0; i<n; i++)
    30. {
    31. for (j=0; j<n; j++)
    32. scanf("%d", a+i*n+j);
    33. }
    34. }
    35. void ausgabe(unsigned *a, unsigned n)// Das musst du auswendig.
    36. { unsigned i, j;
    37. for (i = 0; i < n; i++)
    38. { for (j = 0; j < n ; j++)
    39. printf("%u ", *(a+i*n+j));
    40. printf("\n");
    41. }
    42. printf("\n");
    43. }
    44. void mult(unsigned *a, unsigned *e, double z, unsigned n)
    45. { unsigned i, j;
    46. for (i = 0; i < n; i++)
    47. for (j = 0; j < n; j++)
    48. { *(e+i*n+j) = 0;
    49. *(e+i*n+j) = *(a+i*n+j) * z;
    50. }
    51. }
    Display All
  • hier mal damit du da etwas einordnen kannst:

    Source Code

    1. Keyword Bytes Range
    2. char 1 -128 .. 127
    3. unsigned char 1 0 .. 255
    4. int
    5. unsigned = unsigned int
    6. double => double-precision floating-point

    Für int ist im C-Standard keine absolute Grösse zugeordnet.
    Es gilt: short <= int <= long
    Diese können je nach Compiler und Betriebssystem unterschiedlich gross sein. Beispiel: int kann 2 byte, 4 byte oder sonst eine Grösse haben. Wenn ihr die Grösse braucht, müsst ihr die im Programm ermitteln oder in den Unterlagen des Compilers nachsehen.

    Hier noch etwas Neueres für Grössen von Arrays, Matrizen und Ähnlichem:
    stackoverflow.com/questions/2550774/what-is-size-t-in-c


    Irgend wie sieht das so aus als wüsstest du nicht was "dein" Quelltext macht und deine Kommentare gehen auch in die Richtung. Aber für 3 Richtige im Lotto sollte dein Glück reichen, wenn man die Trefferquote im Quelltext sieht.

    Versuche den Quelltext besser zu formatieren. Dann kannst du den besser verstehen.
  • Keine Konflikte? ;)

    Gibt mal bei deinem letzten Beispiel-Quelltext:
    eine Matrix: 2_4_0_1 ein und einen Vergrösserungsfaktor von 3.8 und erkläre uns das Ergebnis. ;)

    Echt Windows 3.0? Schreib das doch sofort - zu der Zeit tickte C noch etwas anders.
    Wenn du es relativ einfach haben willst, vergiss die Windows vor 2000 bezüglich C.

    The post was edited 1 time, last by bcc-fan ().