0

struct内にいくつかの変数があります。

struct my_struct{
    float variable_2_x[2],variable_2_y[2],variable_2_z[2];
    float coef_2_xyz[3];    

    float variable_3_x[3],variable_3_y[3],variable_3_z[3];
    float coef_3_xyz[3];

    float variable_4_x[4],variable_4_y[4],variable_4_z[4];
    float coef_4_xyz[3];
};

この構造体には、ラグランジュ多項式 (en.wikipedia.org/wiki/Lagrange_polynomial) の係数が含まれます。多項式の長さは 2、3、4 です。この係数の値は簡単に計算できますが、問題は、私がしなければならないことです。同じコードを繰り返して、すべての多項式を作成します。例えば

// T_space is a cube with {[-1:1][-1:1][-1:1]} dimension, 
// its call transformed space.
// distance is the distance between two points of T_space
// point_1 its the point where the function has value 1
p = 2; 
step = distance / p;

polinoms.coef_2_xyz[0] = 1.0:
polinoms.coef_2_xyz[1] = 1.0:
polinoms.coef_2_xyz[2] = 1.0:
for( i = 0; i < p ; ++i) 
{
    polinoms.pol_2_x[i] = (T_space.xi[point_1] + step) + (i * step);
    polinoms.pol_2_y[i] = (T_space.eta[point_1] + step) + (i * step);
    polinoms.pol_2_z[i] = (T_space.sigma[point_1] + step) + (i * step);


    polinoms.coef_2_xyz[0]*= (T_space.eta[point_1] - polinoms.pol_2_x[i]);
    polinoms.coef_2_xyz[1]*= (T_space.eta[point_1] - polinoms.pol_2_y[i]);
    polinoms.coef_2_xyz[2]*= (T_space.eta[point_1] - polinoms.pol_2_z[i]);

}

コード内で同じループを何度も繰り返したくないので。そして、コードの次のステップでさらに重要なことは、多項式の勾配の積を立方体のすべての点に統合する必要があることです。

構造体のすべての配列を個別に呼び出すことができると非常に便利です。私が知っているように、実行時に変数を動的に呼び出すことはできません。structのメモリ方向を含む配列を作成することを考えています。このようなもの。

// declare variable to store memory directions
float mem_array[12];

// some code

mem_array[0] = &variable_2_x;
mem_array[1] = &variable_2_y;
mem_array[2] = &variable_2_z;
mem_array[3] = &coef_2_xyz;
mem_array[4] = &variable_3_x;

mem_array[11] = &variable_4_z;
mem_array[12] = &coef_4_xyz;

// work calling mem_array.

しかし、これが可能かどうか、またはうまくいくかどうかはわかりません。これが問題に対処する適切な方法ではないと思われる場合は、アドバイスをお待ちしています。私は本当にこれで立ち往生しているからです。

質問をより明確にするために編集しました。役立つことを願っています。

4

1 に答える 1

2

必要なメモリを動的に割り当てる方がよいでしょう。単一のラグランジュ多項式 (任意の次数) を表す構造体を作成し、次数ごとに 1 つずつ、これらの配列を作成できます。

必要に応じて、構造体のメンバーとして多項式の次数を格納することもできます。これらを処理するコードを、LagrangePolynomial* を受け取り、順序を決定し、必要な計算を行う関数に分解できるはずです。

これらすべての主な利点は、次数ごとに特別なコードを用意する必要がなく、任意のサイズの多項式に同じコード (および同じ構造体) を使用できることです。

以下の例:

struct LagrangePolynomial {
    float *x;
    float *y;
    float *z;
};

p=2 の場合:

LagrangePolynomial p;
p.x = malloc(sizeof(float)*2);
p.y = malloc(sizeof(float)*2);
p.z = malloc(sizeof(float)*2);
for (size_t i=0; i<2; i++) {
    p.x[i] = ...;
    p.y[i] = ...;
    p.z[i] = ...;
}

構造が完成したら、割り当てたすべてのメモリを解放できます。

free(p.x);
free(p.y);
free(p.z);

前述のように、これらの配列を持つことができます。

LagrangePolynomial ps[4];
for (size_t i=0; i<4; i++) {
    p[i].x = malloc(sizeof(float)*2);
    p[i].y = malloc(sizeof(float)*2);
    p[i].z = malloc(sizeof(float)*2);
    for (size_t j=0; j<2; j++) {
        p[i].x[j] = ...;
        p[i].y[j] = ...;
        p[i].z[j] = ...;
    }
}
于 2012-08-09T16:08:21.343 に答える