1

私はファジー分類に取り組んでいます。私は本当のソフトウェア開発者ではないので...C言語では、行列の最大最小構成を実装できないことに気付きました。

もっと明確にしようと思います。

次のような正方行列があるとします。

float matrix[2][2] = {
                        { 1.0, 0.4 },
                        { 0.4, 1.0 }
                     };

「マトリックス」自体の最大最小構成は、

result_matrix[2][2] = {
                         { 1.0, 0.4 }
                         { 0.4, 1.0 }
                      };

例えば

最初に実行する

min(1.0, 0.4) = 0.4 /* first row */
min(1.0, 0.4) = 0.4 /* first col */

それから

max(0.4, 0.4) = 0.4それが新しい行列の (0, 0) の要素です。

例えば

min(1.0, 0.4) = 0.4; /* first row */
min(0.4, 1.0) = 0.4; /* second col */

max(0.4, 0.4) = 0.4;

(0, 1) の要素

言語で実装する必要がCあるのは、マトリックスの一種の「列ごとの行」チェックです。

これを行う方法が本当にわかりません。

いくつかの提案？

前もって感謝します。

4

4 に答える 4

1

解決しました！

ここに最大最小構成のソースコードがあります。

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

float get_max(float a[], int num_elements);

int main(int argc, char **argv)
{
   int i;

   int j;

   int k;

   float firstMatrix[4][4] = {
                                { 1, 0.6, 0.3, 0.8 },
                                { 0.6, 1, 0.1, 0.4 },
                                { 0.3, 0.1, 1, 0.5 },
                                { 0.8, 0.4, 0.5, 1 }
                             };


   float resultMatrix[4][4];

   float min_array[4];

      for (i = 0; i < 4; i++)
      {
            for (j = 0; j < 4; j++)
            {
                  for (k = 0; k < 4; k++)
                  {
                        if (firstMatrix[i][k] <= firstMatrix[k][j])
                        { min_array[k] = firstMatrix[i][k]; }

                        else
                        { min_array[k] = firstMatrix[k][j]; }

                     resultMatrix[i][j] = get_max(min_array, 4);                                          
                  }

               fprintf(stdout, "%.1f ", resultMatrix[i][j]);                 
            }

         fprintf(stdout, "\n");
      }

   return 0;
}

float get_max(float a[], int num_elements)
{
   int i;

   float max = 0.0;

      for (i = 0; i < num_elements; i++)
      {
        if (a[i] > max)
        { max = a[i]; }
      }

   return(max);
}
于 2013-05-06T16:00:11.090 に答える
1

これを解決するには、行列の乗算に使用されるものと同様のアプローチに従う必要があることがわかりました。

それ以外の

resultMatrix[i][j] += firstMatrix[i][k] * firstMatrix[k][j];

私はこのようなものが必要です

resultMatrix[i][j] = MAX(MIN(firstMatrix[i][k], firstMatrix[k][j]));

WhereMIN(firstMatrix[i][k], firstMatrix[k][j])は別の配列です。

私は推測する。

于 2013-05-06T15:08:47.017 に答える
0

比較している行/列についてもう少し具体的に教えてください。あなたが比較しているものとその順序を正確に知っていれば、あなたをもっと助けることができます. これが私があなたに与えることができるものです。これは、配列の最小値を見つけるための関数です

float min(int n, float *array)
{
    int i;
    float minval;

    minval = *array;

    for (i=1; i<n;i++)
    {
        if (array[i] < minval)
        minval = array[i];
    }

    return minval;
}

最初の行の最小値を見つけるには、使用します

x = min(2, *matrix);

他の行の場合

x = min(NUMCOLS, *matrix+row*NUMCOLS + column));

行列の要素に行単位でアクセスするには、ネストされた 2 つの for ループを使用します。

for (i = 0; i < 2; i++) 
    for (j = 0; j < 2; j++) 
        printf("%f\n", matrix[i][j]);

Row-major_orderを見てください

于 2013-05-05T22:26:15.783 に答える
0

これが役立つと思います。

「アルゴリズム」は、新しい行列の新しい各要素を計算する必要があります。

ところで...

のような入力行列がありますfirstMatrix。

ステップ 1: の最初の行から最初の要素を取得し、: の最初の列の最初の要素を取得しますfirstMatrix。firstMatrixfirstMatrix[0][0]firstMatrix[0][0]

ステップ 2: の行と列ごとに「ステップ 1」を繰り返しfirstMatrixます。

/* row */
temp_array_1[i] = firstMatrix[i][j]

と

/* col */
temp_array_2[i] = firstMatrix[j][i]

ステップ 3:

for (i = 0; i < 4; i++)
{
   if (temp_array_1[i] <= temp_array_2[i])
   { min_array[i] = temp_array_1[i]; }

   else
   { min_array[i] = temp_array_2[i]; }
}

ステップ 4: の最大値を取得しmin_array[i]ます。

ここに私のソースコードがあります...

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

int main(int argc, char **argv)
{
   int i;

   int j;

   float firstMatrix[4][4] = {
                                { 1, 0.6, 0.3, 0.8 },
                                { 0.6, 1, 0.1, 0.4 },
                                { 0.3, 0.1, 1, 0.5 },
                                { 0.8, 0.4, 0.5, 1 }
                             };


   float max = 0.0;

   float temp_array_1[4];

   float temp_array_2[4];

   float min_array[4];


      for (i = 0; i < 4; i++)
      {
         /* row */
         temp_array_1[i] = firstMatrix[0][i];

         /* col */
         temp_array_2[i] = firstMatrix[i][0];
      }

      for (i = 0; i < 4; i++)
      {
            if (temp_array_1[i] <= temp_array_2[i])
            { min_array[i] = temp_array_1[i]; }

            else
            { min_array[i] = temp_array_2[i]; }

            for (i = 0; i < 4; i++)
            {         
                  if (min_array[i] > max)
                  { max = min_array[i]; }         
            }
      }

   fprintf(stdout, "\nMax element: %.1f\n", max);

   return 0;
}

ポイントは、の各要素に対してこれを「反復」できないことですfirstMatrix。

この大混乱から出てくる出力行列は次のとおりです。

outputMatrix[4][4] = {
                     { 1.0, 0.6, 0.5, 0.8 },
                     { 0.6, 1.0, 0.4, 0.6 },
                     { 0.5, 0.4, 1.0, 0.5 },
                     { 0.8, 0.6, 0.5, 1.0 }
                  }
于 2013-05-06T10:16:13.090 に答える