GCC ARM 2016q1, Ergebnis von Deklarationsreihenfolge abhängig

[Vincent H. (vinci)]

Grüß euch

Ich benötige für eine Kurvenglättung eine Interpolationsmethode und habe 
aus diesem Grund eine kurze Funktion geschrieben, die kubische Splines 
erzeugt.

Die Ergebnisse der Funktion bestehen aus den drei Koeffizienten der 
Splines und werden in eine Struktur gepackt.

struct Spline
{
  float a3;
  float a2;
  float a1;
};

Nun habe ich folgendes Problem. Aus irgendeinem Grund hängt das 
Rechenergebnis der Interpolation von der Reihenfolge ab mit der ich die 
Variablen vor dem Funktionsaufruf anlege.

Und zwar rechnen folgende Zeilen richtig:

int32_t start;
int32_t high;
int32_t mid;
Spline spline_cubic[3] = {};
float x[4] = {0.1, 1.3, 1.9, 2.1};
float y[4] = {1.3, 1.5, 1.7, 2.1};
uint32_t n = 4;

splineCubicSet(x, y, n, spline_cubic);

Und folgende Zeilen falsch?

int32_t start;
int32_t high;
int32_t mid;
float x[4] = {0.1, 1.3, 1.9, 2.1};
float y[4] = {1.3, 1.5, 1.7, 2.1};
uint32_t n = 4;
Spline spline_cubic[3] = {};

splineCubicSet(x, y, n, spline_cubic);

Hat jemand ev. eine Idee woran das liegen könnte?

[Jim M. (turboj)]

Außer Stack Overflow würde mir da ertmal nix zu einfallen.
Zeige mal den vollständigen Code, da ist zu 99.99% was anderes faul.

[nicht"Gast" (Gast)]

Moin,

Initialisiere deine Deklarationen mal vernünftig.

Sieht mir danach aus, als wenn du nicht initialisierte Variablen 
benutzt. Das würde auch dein Fehlerbild erklären.

[Vincent H. (vinci)]

Jim M. schrieb:
> Außer Stack Overflow würde mir da ertmal nix zu einfallen.
> Zeige mal den vollständigen Code, da ist zu 99.99% was anderes faul.


Achtung die Funktion nutzt "variable length" arrays. Ich mach mich grad 
ran nochmal die leider recht komplexen Indizes zu prüfen...

Uninitialisierte Variablen seh ich keine.

__STATIC_INLINE void splineCubicSet(float x[], float y[], uint32_t n, Spline spline[])
{
  float h[n-1] = {};
  float u[n-2] = {};
  float z[n-2] = {};

  float tmp[2];
  uint32_t i;

  /* Do the fist one "by hand */
  h[0] = x[1] - x[0];
  h[1] = x[2] - x[1];
  tmp[0] = 2 * (x[2] - x[0]);
  u[0] = h[1] / tmp[0];
  tmp[1] = (3 / h[1]) * (y[2] - y[1]) - (3 / h[0]) * (y[1] - y[0]);
  z[0] = tmp[1] / tmp[0];

  /* Iterate others */
  for (i = 2; i < (n - 1); i++)
  {
    h[i] = x[i + 1] - x[i];
    tmp[0] = (2 * (x[i + 1] - x[i - 1])) - h[i - 1] * u[i - 2];
    u[i - 1] = h[i] / tmp[0];
    tmp[1] = (3 / h[i]) * (y[i + 1] - y[i])
        - (3 / h[i - 1]) * (y[i] - y[i - 1]);
    z[i - 1] = (tmp[1] - h[i - 1] * z[i - 2]) / tmp[0];
  }

  /* Do the last one "by hand */
  spline[n - 2].a2 = z[n - 3];
  spline[n - 2].a1 = (y[n - 1] - y[n - 2]) / h[n - 2]
      - (h[n - 2] * 2 * spline[n - 2].a2) / 3;
  spline[n - 2].a3 = -spline[n - 2].a2 / (3 * h[n - 2]);

  /* Iterate others */
  for (i = n - 2; i >= 1; i--)
  {
    spline[i].a2 = z[i - 1] - u[i - 1] * spline[i + 1].a2;
    spline[i].a1 = (y[i + 1] - y[i]) / h[i]
        - (h[i] * (spline[i + 1].a2 + 2 * spline[i].a2)) / 3;
    spline[i].a3 = (spline[i + 1].a2 - spline[i].a2) / (3 * h[i]);
  }

  /* Do the fist one "by hand */
  spline[0].a2 = 0;
  spline[0].a1 = (y[1] - y[0]) / h[0]
      - (h[0] * (spline[1].a2 + 2 * spline[0].a2)) / 3;
  spline[0].a3 = (spline[1].a2 - spline[0].a2) / (3 * h[0]);
}

[Dr. Sommer (Gast)]

  /* Iterate others */
  for (i = n - 2; i >= 1; i--)
  {
    spline[i].a2 = z[i - 1] - u[i - 1] * spline[i + 1].a2;

Wenn i=n-2 ist, ist für n=4 also i=2. Somit ist i+1=3, und spline[i+1] 
ist ein Buffer Overflow, da spline nur 3 Elemente groß ist.

Und wieder einmal ist der Programmierer, und nicht der Compiler, schuld 
:P

[Vincent H. (vinci)]

Dr. Sommer schrieb:
>

>   /* Iterate others */
>   for (i = n - 2; i >= 1; i--)
>   {
>     spline[i].a2 = z[i - 1] - u[i - 1] * spline[i + 1].a2;
>

>
> Wenn i=n-2 ist, ist für n=4 also i=2. Somit ist i+1=3, und spline[i+1]
> ist ein Buffer Overflow, da spline nur 3 Elemente groß ist.
>
> Und wieder einmal ist der Programmierer, und nicht der Compiler, schuld
> :P


Ah Gott sei Dank!!!
Ja dass der Programmierer Schuld ist war eh klar :)

Ich hab den Algorithmus zuerst in MATLAB runtergeschrieben, dass ja bei 
Indizes 1 zu zählen beginnt. Und als ob das nicht mühsam genug wär 
kommen einige temporäre Variablen dann halt auch noch entweder N-1 oder 
N-2 mal vor... was die Sache mit den Indizes nicht unbedingt 
vereinfacht. :)

Danke!