実装

テンソルの逆テンソルを関数として以下のように実装する。

/* テンソルの逆テンソル */
void WH_Tensor3D__whInv_whT_OUT_whT
(double whT_X[3][3],
 double OUT__whT_Y[3][3])
/*
  入力引数:
    whT_X はテンソル
  出力引数:
    OUT__whT_Yはテンソルで、whT_X の逆テンソル
*/
{
  double whDet_whT_X;
  double frac;

  WH_Tensor3D__whDet_whT_OUT_s 
    (whT_X,
     &whDet_whT_X);
  frac = 1 / whDet_whT_X;

  OUT__whT_Y[0][0] = frac * 
    (whT_X[1][1] * whT_X[2][2] - whT_X[1][2] * whT_X[2][1]);
  OUT__whT_Y[0][1] = frac * 
    (whT_X[0][2] * whT_X[2][1] - whT_X[0][1] * whT_X[2][2]);
  OUT__whT_Y[0][2] = frac * 
    (whT_X[0][1] * whT_X[1][2] - whT_X[0][2] * whT_X[1][1]);

  OUT__whT_Y[1][0] = frac * 
    (whT_X[1][2] * whT_X[2][0] - whT_X[1][0] * whT_X[2][2]);
  OUT__whT_Y[1][1] = frac * 
    (whT_X[0][0] * whT_X[2][2] - whT_X[0][2] * whT_X[2][0]);
  OUT__whT_Y[1][2] = frac * 
    (whT_X[0][2] * whT_X[1][0] - whT_X[0][0] * whT_X[1][2]);

  OUT__whT_Y[2][0] = frac * 
    (whT_X[1][0] * whT_X[2][1] - whT_X[1][1] * whT_X[2][0]);
  OUT__whT_Y[2][1] = frac * 
    (whT_X[0][1] * whT_X[2][0] - whT_X[0][0] * whT_X[2][1]);
  OUT__whT_Y[2][2] = frac * 
    (whT_X[0][0] * whT_X[1][1] - whT_X[0][1] * whT_X[1][0]);
}

また、対称テンソルの場合には、以下のようになる。

/* 対称テンソルの逆テンソル */
void WH_Tensor3D__whInv_whST_OUT_whST
(double whST_X[6],
 double OUT__whST_Y[6])
/*
  入力引数:
    whST_X は対称テンソル
  出力引数:
    OUT__whST_Yは対称テンソルで、whST_X の逆テンソル
*/
{
  double whDet_whST_X;
  double frac;

  WH_Tensor3D__whDet_whST_OUT_s 
    (whST_X,
     &whDet_whST_X);
  frac = 1 / whDet_whST_X;

  OUT__whST_Y[WH_TENSOR3D__ST00] = frac * 
    (whST_X[WH_TENSOR3D__ST11] * whST_X[WH_TENSOR3D__ST22] 
   - whST_X[WH_TENSOR3D__ST12] * whST_X[WH_TENSOR3D__ST12]);
  OUT__whST_Y[WH_TENSOR3D__ST11] = frac * 
    (whST_X[WH_TENSOR3D__ST00] * whST_X[WH_TENSOR3D__ST22] 
   - whST_X[WH_TENSOR3D__ST20] * whST_X[WH_TENSOR3D__ST20]);
  OUT__whST_Y[WH_TENSOR3D__ST22] = frac * 
    (whST_X[WH_TENSOR3D__ST00] * whST_X[WH_TENSOR3D__ST11] 
   - whST_X[WH_TENSOR3D__ST01] * whST_X[WH_TENSOR3D__ST01]);
  OUT__whST_Y[WH_TENSOR3D__ST01] = frac * 
    (whST_X[WH_TENSOR3D__ST20] * whST_X[WH_TENSOR3D__ST12] 
   - whST_X[WH_TENSOR3D__ST01] * whST_X[WH_TENSOR3D__ST22]);
  OUT__whST_Y[WH_TENSOR3D__ST12] = frac * 
    (whST_X[WH_TENSOR3D__ST20] * whST_X[WH_TENSOR3D__ST01] 
   - whST_X[WH_TENSOR3D__ST00] * whST_X[WH_TENSOR3D__ST12]);
  OUT__whST_Y[WH_TENSOR3D__ST20] = frac * 
    (whST_X[WH_TENSOR3D__ST01] * whST_X[WH_TENSOR3D__ST12] 
   - whST_X[WH_TENSOR3D__ST11] * whST_X[WH_TENSOR3D__ST20]);
}