259 UTL_NLA

UTL_NLAパッケージは、VARRAYとして表されるベクトルおよびマトリックスに対するBLAS演算およびLAPACK(バージョン3.0)演算のサブセットを表示します。

この章では、次の項目について説明します。

• UTL_NLAの使用方法

  • 概要

  • ルールおよび制限

  • セキュリティ・モデル

• サブプログラム・グループ

  • BLASレベル1(ベクトル-ベクトル演算)サブプログラム

  • BLASレベル2(マトリックス-ベクトル演算)サブプログラム

  • BLASレベル3(マトリックス-マトリックス演算)サブプログラム

  • LAPACKドライバ・ルーチン(一次方程式)サブプログラム

  • LAPACKドライバ・ルーチン(LLSおよび固有値問題)サブプログラム

• UTL_NLAサブプログラムの要約

UTL_NLAの使用方法

この項では、UTL_NLAパッケージの使用に関連する項目について説明します。

• 概要

• ルールおよび制限

• セキュリティ・モデル

概要

UTL_NLAパッケージは、VARRAYとして表されるベクトルおよびマトリックスに対するBLAS(基本線形代数サブプログラム)演算およびLAPACK(線形代数パッケージ) (バージョン3.0)演算のサブセットを表示します。

標準

BLASおよびLAPACK標準の詳細は、次の場所を参照してください。

http://www.netlib.org/blas/
http://www.netlib.org/lapack/

必要な知識

このパッケージを使用するユーザーは、一般的な線形代数、特にBLASライブラリとLAPACKライブラリについて十分に理解している必要があります。

実装

BLASおよびLAPACKのプロシージャとこれらに対応するPL/SQLコールとの間のマッピングは、1対1です。

• すべてのBLASファンクションに、BLAS_接頭辞が付いています(BLAS_ASUMファンクションなど)。BLASのサブルーチンおよびファンクションは、PL/SQLのプロシージャおよびファンクションにそれぞれマッピングされます。

• すべてのLAPACKファンクションに、LAPACK_接頭辞が付いています(LAPACK_GBSVプロシージャなど)。LAPACKのサブルーチンは、PL/SQLプロシージャにマッピングされます。同じ演算を実行し、引数のデータ・タイプのみが異なるプロシージャは、同一の多重定義名になります。

BLASとLAPACKのプロシージャのパラメータとこれらに対応するPL/SQLサブプログラムのパラメータとの間のマッピングは、ほぼ1対1です。

• また、LAPACKのPL/SQLインタフェースでは、すべての/work/引数が削除されています。UTL_NLAパッケージでは、ライブラリで必要なすべての作業領域の割当ておよび割当て解除を管理します。

• 各LAPACKプロシージャの最後に、マトリックスの線形演算が行優先または列優先(デフォルト)の形式で行われているかどうかを指定する新しいオプションのパラメータpackが追加されています。

ルールおよび制限

ベクトルおよびマトリックスは、最大サイズが100万エントリのVARRAYに格納されます。この制限のため、UTL_NLAベクトルは最大100万エントリにできますが、マトリックスのサイズはRxC <= 1,000,000である必要があります。

セキュリティ・モデル

UTL_NLAパッケージは、ユーザーSYSによって所有され、データベース・インストールの一環としてインストールされます。このパッケージの実行権限は、PUBLICに付与されます。このパッケージ内のルーチンは、実行者権限(現行のユーザーの権限)を使用して実行されます。

サブプログラム・グループ

• BLASレベル1(ベクトル-ベクトル演算)サブプログラム

• BLASレベル2(マトリックス-ベクトル演算)サブプログラム

• BLASレベル3(マトリックス-マトリックス演算)サブプログラム

• LAPACKドライバ・ルーチン(一次方程式)サブプログラム

• LAPACKドライバ・ルーチン(LLSおよび固有値問題)サブプログラム

BLASレベル1(ベクトル-ベクトル演算)サブプログラム

表259-1 BLASレベル1(ベクトル-ベクトル演算)サブプログラム

サブプログラム	説明
BLAS_ASUMファンクション	ベクトル・コンポーネントの絶対値の合計を計算します。
BLAS_AXPYプロシージャ	alpha*X + YをベクトルYにコピーします。
BLAS_COPYプロシージャ	ベクトルXの内容をベクトルYにコピーします。
BLAS_DOTファンクション	2つのベクトルXとYの内積(スカラ積)を戻します。
BLAS_IAMAXファンクション	最大絶対値を持つベクトルの最初の要素のインデックスを計算します。
BLAS_NRM2ファンクション	ベクトル2ノルム(ユークリッド・ノルム)を計算します。
BLAS_ROTプロシージャ	点の面回転を戻します。
BLAS_ROTGプロシージャ	点のギブンス回転を戻します。
BLAS_SCALプロシージャ	ベクトルのスケールを定数で変更します。
BLAS_SWAPプロシージャ	サイズがnの2つのベクトルの内容を交換します。

BLASレベル2(マトリックス-ベクトル演算)サブプログラム

表259-2 BLASレベル2(マトリックス-ベクトル演算)サブプログラム

サブプログラム	説明
BLAS_GBMVプロシージャ	マトリックス-ベクトル演算y := alpha*A*x + beta*yまたはy := alpha*A'*x + beta*yを実行します。ここで、alphaおよびbetaはスカラー、xおよびyはベクトル、Aはkl個の下対角とku個の上対角を持つm行n列のバンド・マトリックスです。
BLAS_GEMVプロシージャ	マトリックス-ベクトル演算y := alpha*A*x + beta*yまたはy := alpha*A'*x + beta*yを実行します。ここで、alphaおよびbetaはスカラー、xおよびyはベクトル、Aはm行n列のマトリックスです。
BLAS_GERプロシージャ	ランク1演算A := alpha*x*y' + Aを実行します。ここで、alphaはスカラー、xはm要素のベクトル、yはn要素のベクトル、Aはm行n列のマトリックスです。
BLAS_SBMVプロシージャ	マトリックス-ベクトル演算y := alpha*A*x + beta*yを実行します。ここで、alphaおよびbetaはスカラー、xおよびyはn要素のベクトル、Aはk個の上対角を持つn行n列の対称バンド・マトリックスです。
BLAS_SPMVプロシージャ	マトリックス-ベクトル演算y := alpha*A*x + beta*yを実行します。ここで、alphaおよびbetaはスカラー、xおよびyはn要素のベクトル、Aはパックされた形式のn行n列の対称マトリックスです。
BLAS_SPRプロシージャ	対称ランク1演算A := alpha*x*x' + Aを実行します。ここで、alphaは実スカラー、xはn要素のベクトル、Aはパックされた形式のn行n列の対称マトリックスです。
BLAS_SPR2プロシージャ	対称ランク2演算A := alpha*x*y' + alpha*y*x' +Aを実行します。ここで、alphaはスカラー、xおよびyはn要素のベクトル、Aはパックされた形式のn行n列の対称マトリックスです。
BLAS_SBMVプロシージャ	マトリックス-ベクトル演算y := alpha*A*x + beta*yを実行します。ここで、alphaおよびbetaはスカラー、xおよびyはn要素のベクトル、Aはk個の上対角を持つn行n列の対称バンド・マトリックスです。
BLAS_SYMVプロシージャ	マトリックス-ベクトル演算y := alpha*A*x + beta*yを実行します。ここで、alphaおよびbetaはスカラー、xおよびyはn要素のベクトル、Aはn行n列の対称マトリックスです。
BLAS_SYRプロシージャ	対称ランク1演算A := alpha*x*x' + Aを実行します。ここで、alphaは実スカラー、xはn要素のベクトル、Aはn行n列の対称マトリックスです。
BLAS_SYR2プロシージャ	対称ランク2演算A := alpha*x*y' + alpha*y*x' + Aを実行します。ここで、alphaはスカラー、xおよびyはn要素のベクトル、Aはn行n列の対称マトリックスです。
BLAS_TBMVプロシージャ	マトリックス-ベクトル演算x := A*xまたはA'*x = bを実行します。ここで、xはn要素のベクトル、Aは(k + 1)個の対角を持つn行n列の単位または単位以外の上三角または下三角バンド・マトリックスです。
BLAS_TBSVプロシージャ	連立方程式A*x = bまたはA'*x = bのいずれかの解を求めます。ここで、bおよびxはn要素のベクトル、Aは(k + 1)個の対角を持つn行n列の単位または単位以外の上三角または下三角バンド・マトリックスです。
BLAS_TPMVプロシージャ	マトリックス-ベクトル演算x := A*xまたはx := A'*xを実行します。ここで、xはn要素のベクトル、Aはパックされた形式のn行n列の単位または単位以外の上三角または下三角マトリックスです。
BLAS_TPSVプロシージャ	連立方程式A*x = bまたはA'*x = bのいずれかの解を求めます。ここで、bおよびxはn要素のベクトル、Aはパックされた形式のn行n列の単位または単位以外の上三角または下三角マトリックスです。
BLAS_TRMVプロシージャ	マトリックス-ベクトル演算x := A*xまたはx := A'*xを実行します。ここで、xはn要素のベクトル、Aはn行n列の単位または単位以外の上三角または下三角マトリックスです。
BLAS_TRSVプロシージャ	連立方程式A*x = bまたはA'*x = bのいずれかの解を求めます。ここで、bおよびxはn要素のベクトル、Aはn行n列の単位または単位以外の上三角または下三角マトリックスです。

BLASレベル3(マトリックス-マトリックス演算)サブプログラム

表259-3 BLASレベル3(マトリックス-マトリックス演算)サブプログラム

サブプログラム	説明
BLAS_GEMMプロシージャ	マトリックス-ベクトル演算の1つC := alpha*op(A)*op(B) + beta*Cを実行します。ここで、op(X)はop(X) = Xまたはop(X) = X'のいずれかです。また、alphaおよびbetaはスカラー、A、BおよびCはマトリックスです。op(A)はm行k列のマトリックス、op(B)はk行n列のマトリックスおよびCはm行n列のマトリックスです。
BLAS_SYMMプロシージャ	マトリックス-ベクトル演算C := alpha*A*B + beta*CまたはC := alpha*B*A + beta*Cのいずれかを実行します。ここで、alphaおよびbetaはスカラー、Aは対称マトリックス、BおよびCはm行n列のマトリックスです。
BLAS_SYR2Kプロシージャ	対称ランク2 k演算C := alpha*A*B' + alpha*B*A' + beta*CまたはC := alpha*A'*B + alpha*B'*A + beta*Cのいずれかを実行します。ここで、alphaおよびbetaはスカラー、Cはn行n列の対称マトリックス、AおよびBは1番目のケースではn行k列のマトリックス、2番目のケースではk行n列のマトリックスです。
BLAS_SYRKプロシージャ	対称ランクk演算C := alpha*A*A' + beta*CまたはC := alpha*A'*A + beta*Cのいずれかを実行します。ここで、alphaおよびbetaはスカラー、Cはn行n列の対称マトリックス、Aは1番目のケースではn行k列のマトリックス、2番目のケースではk行n列のマトリックスです。
BLAS_TRMMプロシージャ	マトリックス-ベクトル演算B := alpha*op(A)*BまたはB := alpha*B*op(A)のいずれかを実行します。ここで、alphaはスカラー、Bはm行n列のマトリックス、Aは単位または単位以外の上三角または下三角マトリックス、op(A)は2つある選択肢のうちの1つです。
BLAS_TRSMプロシージャ	マトリックス-ベクトル演算op(A)*X = alpha*BまたはX*op(A) = alpha*Bのいずれかを実行します。ここで、alphaはスカラー、XおよびBはm行n列のマトリックス、Aは単位または単位以外の上三角または下三角マトリックス、op(A)は2つある選択肢のうちの1つです。マトリックスXは、Bに上書きされます。

LAPACKドライバ・ルーチン(一次方程式)サブプログラム

表259-4 LAPACKドライバ・ルーチン(一次方程式)サブプログラム

サブプログラム	説明
LAPACK_GBSVプロシージャ	実連立一次方程式a * x = bの解を求めます。ここで、aはn行n列のマトリックス、xおよびbはn行nrhs列のマトリックスです。Aの分解には、部分ピボットおよび行交換を使用したLU分解が使用されます。
LAPACK_GESVプロシージャ	実連立一次方程式a * x = bの解を求めます。ここで、aはn行n列のマトリックス、xおよびbはn行nrhs列のマトリックスです。Aの分解には、部分ピボットおよび行交換を使用したLU分解が使用されます。
LAPACK_GTSVプロシージャ	方程式a * x = bの解を求めます。ここで、aは、部分ピボットを使用したガウス消去法によるn行n列の三重対角マトリックスです。
LAPACK_PBSVプロシージャ	実連立一次方程式a * x = bの解を求めます。ここで、aはn行n列の正定値対称バンド・マトリックス、xおよびbはn行nrhs列のマトリックスです。Aの分解には、コレスキ分解が使用されます。
LAPACK_POSVプロシージャ	実連立一次方程式a * x = bの解を求めます。ここで、aはn行n列の正定値対称マトリックス、xおよびbはn行nrhs列のマトリックスです。Aの分解には、コレスキ分解が使用されます。
LAPACK_PPSVプロシージャ	実連立一次方程式a * x = bの解を求めます。ここで、aはパックされた形式で格納されているn行n列の正定値対称マトリックス、xおよびbはn行nrhs列のマトリックスです。Aの分解には、コレスキ分解が使用されます。
LAPACK_PTSVプロシージャ	実連立一次方程式a * x = bの解を求めます。ここで、aはn行n列の正定値対称三重対角マトリックス、xおよびbはn行nrhs列のマトリックスです。
LAPACK_SPSVプロシージャ	実連立一次方程式a * x = bの解を求めます。ここで、aはパックされた形式で格納されているn行n列の対称マトリックス、xおよびbはn行nrhs列のマトリックスです。Aの分解には、対角ピボット法が使用されます。
LAPACK_SYSVプロシージャ	実連立一次方程式a * x = bの解を求めます。ここで、aはn行n列の対称マトリックス、xおよびbはn行nrhs列のマトリックスです。Aの分解には、対角ピボット法が使用されます。

LAPACKドライバ・ルーチン(LLSおよび固有値問題)サブプログラム

表259-5 LAPACKドライバ・ルーチン(LLSおよび固有値問題)

サブプログラム	説明
LAPACK_GEESプロシージャ	n行n列の実非対称マトリックスA、固有値、実Schur形TおよびオプションでSchurベクトルのマトリックスZを計算します。これによって、Schur分解A = Z*T*(Z**T)が実行されます。
LAPACK_GEEVプロシージャ	n行n列の実非対称マトリックスA、固有値およびオプションで左または右(あるいは両方)の固有ベクトルを計算します。
LAPACK_GELSプロシージャ	AのQRまたはLQ分解を使用して、m行n列のマトリックスA、またはこのマトリックスの転置マトリックスが含まれる過剰決定または過小決定の実連立一次方程式の解を求めます。Aに最大階数が含まれていることを前提とします。
LAPACK_GESDDプロシージャ	m行n列の実マトリックスAの特異値分解(SVD)を計算します。オプションで左右の特異ベクトルを計算します。特異ベクトルが必要な場合は、浮動小数点演算に関する緩やかな仮定を設ける分割統治法アルゴリズムを使用します。
LAPACK_GESVDプロシージャ	m行n列の実マトリックスAの特異値分解(SVD)を計算します。また、オプションで左または右(あるいは両方)の特異ベクトルを計算します。SVDは、A = U * SIGMA * transpose(V)のように記述されます。
LAPACK_SBEVプロシージャ	すべての固有値を計算します。また、オプションで実対称バンド・マトリックスAの固有ベクトルを計算します。
LAPACK_SBEVDプロシージャ	すべての固有値を計算します。また、オプションで実対称マトリックスAの固有ベクトルを計算します。固有ベクトルが必要な場合は、浮動小数点演算に関する緩やかな仮定を設ける分割統治法アルゴリズムを使用します。
LAPACK_SPEVプロシージャ	すべての固有値を計算します。また、オプションで、パックされた形式で格納されている実対称マトリックスAの固有ベクトルを計算します。
LAPACK_SPEVDプロシージャ	すべての固有値を計算します。また、オプションで、パックされた形式で格納されている実対称マトリックスAの固有ベクトルを計算します。固有ベクトルが必要な場合は、浮動小数点演算に関する緩やかな仮定を設ける分割統治法アルゴリズムを使用します。
LAPACK_STEVプロシージャ	すべての固有値を計算します。また、オプションで実対称三重対角マトリックスAの固有ベクトルを計算します。
LAPACK_STEVDプロシージャ	すべての固有値を計算します。また、オプションで実対称三重対角マトリックスAの固有ベクトルを計算します。固有ベクトルが必要な場合は、浮動小数点演算に関する緩やかな仮定を設ける分割統治法アルゴリズムを使用します。
LAPACK_SYEVプロシージャ	すべての固有値を計算します。また、オプションで実対称マトリックスAの固有ベクトルを計算します。
LAPACK_SYEVDプロシージャ	すべての固有値を計算します。また、オプションで実対称マトリックスAの固有ベクトルを計算します。固有ベクトルが必要な場合は、浮動小数点演算に関する緩やかな仮定を設ける分割統治法アルゴリズムを使用します。

UTL_NLAサブプログラムの要約

表259-6 UTL_NLAパッケージのサブプログラム

サブプログラム	説明	グループ
BLAS_ASUMファンクション	ベクトル・コンポーネントの絶対値の合計を計算します。	BLASレベル1(ベクトル-ベクトル演算)サブプログラム
BLAS_AXPYプロシージャ	alpha*X + YをベクトルYにコピーします。	BLASレベル1(ベクトル-ベクトル演算)サブプログラム
BLAS_COPYプロシージャ	ベクトルXの内容をベクトルYにコピーします。	BLASレベル1(ベクトル-ベクトル演算)サブプログラム
BLAS_DOTファンクション	2つのベクトルXとYの内積(スカラ積)を戻します。	BLASレベル1(ベクトル-ベクトル演算)サブプログラム
BLAS_GBMVプロシージャ	マトリックス-ベクトル演算y := alpha*A*x + beta*yまたはy := alpha*A'*x + beta*yを実行します。ここで、alphaおよびbetaはスカラー、xおよびyはベクトル、Aはkl個の下対角とku個の上対角を持つm行n列のバンド・マトリックスです。	BLASレベル2(マトリックス-ベクトル演算)サブプログラム
BLAS_GEMMプロシージャ	いずれかのマトリックス-ベクトル演算を実行します。ここで、alphaおよびbetaはスカラー、A、BおよびCはマトリックス、op(A)はm行k列のマトリックス、op(B)はk行n列のマトリックスおよびCはm行n列のマトリックスです。	BLASレベル3(マトリックス-マトリックス演算)サブプログラム
BLAS_GEMVプロシージャ	マトリックス-ベクトル演算y := alpha*A*x + beta*yまたはy := alpha*A'*x + beta*yを実行します。ここで、alphaおよびbetaはスカラー、xおよびyはベクトル、Aはm行n列のマトリックスです。	BLASレベル2(マトリックス-ベクトル演算)サブプログラム
BLAS_GERプロシージャ	ランク1演算A := alpha*x*y' + Aを実行します。ここで、alphaはスカラー、xはm要素のベクトル、yはn要素のベクトル、Aはm行n列のマトリックスです。	BLASレベル2(マトリックス-ベクトル演算)サブプログラム
BLAS_IAMAXファンクション	最大絶対値を持つベクトルの最初の要素のインデックスを計算します。	BLASレベル1(ベクトル-ベクトル演算)サブプログラム
BLAS_NRM2ファンクション	ベクトル2ノルム(ユークリッド・ノルム)を計算します。	BLASレベル1(ベクトル-ベクトル演算)サブプログラム
BLAS_ROTプロシージャ	点の面回転を戻します。	BLASレベル1(ベクトル-ベクトル演算)サブプログラム
BLAS_ROTGプロシージャ	点のギブンス回転を戻します。	BLASレベル1(ベクトル-ベクトル演算)サブプログラム
BLAS_SBMVプロシージャ	マトリックス-ベクトル演算y := alpha*A*x + beta*yを実行します。ここで、alphaおよびbetaはスカラー、xおよびyはn要素のベクトル、Aはk個の上対角を持つn行n列の対称バンド・マトリックスです。	BLASレベル2(マトリックス-ベクトル演算)サブプログラム
BLAS_SCALプロシージャ	ベクトルのスケールを定数で変更します。	BLASレベル1(ベクトル-ベクトル演算)サブプログラム
BLAS_SPMVプロシージャ	マトリックス-ベクトル演算y := alpha*A*x + beta*yを実行します。ここで、alphaおよびbetaはスカラー、xおよびyはn要素のベクトル、Aはパックされた形式のn行n列の対称マトリックスです。	BLASレベル2(マトリックス-ベクトル演算)サブプログラム
BLAS_SPRプロシージャ	対称ランク1演算A := alpha*x*x' + Aを実行します。ここで、alphaは実スカラー、xはn要素のベクトル、Aはパックされた形式のn行n列の対称マトリックスです。	BLASレベル2(マトリックス-ベクトル演算)サブプログラム
BLAS_SPR2プロシージャ	対称ランク2演算を実行します。ここで、alphaはスカラー、xおよびyはn要素のベクトル、Aはパックされた形式のn行n列の対称マトリックスです。	BLASレベル2(マトリックス-ベクトル演算)サブプログラム
BLAS_SWAPプロシージャ	サイズがnの2つのベクトルの内容を交換します。	BLASレベル1(ベクトル-ベクトル演算)サブプログラム
BLAS_SYMMプロシージャ	いずれかのマトリックス-ベクトル演算を実行します。ここで、alphaおよびbetaはスカラー、Aは対称マトリックス、BおよびCはm行n列のマトリックスです。	BLASレベル3(マトリックス-マトリックス演算)サブプログラム
BLAS_SYMVプロシージャ	マトリックス-ベクトル演算を実行します。ここで、alphaおよびbetaはスカラー、xおよびyはn要素のベクトル、Aはn行n列の対称マトリックスです。	BLASレベル2(マトリックス-ベクトル演算)サブプログラム
BLAS_SYRプロシージャ	対称ランク1演算を実行します。ここで、alphaは実スカラー、xはn要素のベクトル、Aはn行n列の対称マトリックスです。	BLASレベル2(マトリックス-ベクトル演算)サブプログラム
BLAS_SYR2プロシージャ	対称ランク2演算を実行します。ここで、alphaはスカラー、xおよびyはn要素のベクトル、Aはn行n列の対称マトリックスです。	BLASレベル2(マトリックス-ベクトル演算)サブプログラム
BLAS_SYR2Kプロシージャ	いずれかの対称ランク2 k演算を実行します。ここで、alphaおよびbetaはスカラー、Cはn行n列の対称マトリックス、AおよびBは1番目のケースではn行k列のマトリックス、2番目のケースではk行n列のマトリックスです。	BLASレベル3(マトリックス-マトリックス演算)サブプログラム
BLAS_SYRKプロシージャ	いずれかの対称ランクk演算を実行します。ここで、alphaおよびbetaはスカラー、Cはn行n列の対称マトリックス、Aは1番目のケースではn行k列のマトリックス、2番目のケースではk行n列のマトリックスです。	BLASレベル3(マトリックス-マトリックス演算)サブプログラム
BLAS_TBMVプロシージャ	マトリックス-ベクトル演算を実行します。ここで、xはn要素のベクトル、Aは(k + 1)個の対角を持つn行n列の単位または単位以外の上三角または下三角バンド・マトリックスです。	BLASレベル2(マトリックス-ベクトル演算)サブプログラム
BLAS_TBSVプロシージャ	いずれかの連立方程式の解を求めます。ここで、bおよびxはn要素のベクトル、Aは(k + 1)個の対角を持つn行n列の単位または単位以外の上三角または下三角バンド・マトリックスです。	BLASレベル2(マトリックス-ベクトル演算)サブプログラム
BLAS_TPMVプロシージャ	マトリックス-ベクトル演算を実行します。ここで、xはn要素のベクトル、Aはパックされた形式のn行n列の単位または単位以外の上三角または下三角マトリックスです。	BLASレベル2(マトリックス-ベクトル演算)サブプログラム
BLAS_TPSVプロシージャ	いずれかの連立方程式の解を求めます。ここで、bおよびxはn要素のベクトル、Aはパックされた形式のn行n列の単位または単位以外の上三角または下三角マトリックスです。	BLASレベル2(マトリックス-ベクトル演算)サブプログラム
BLAS_TRMMプロシージャ	いずれかのマトリックス-ベクトル演算を実行します。ここで、alphaはスカラー、Bはm行n列のマトリックス、Aは単位または単位以外の上三角または下三角マトリックス、op(A)は2つある選択肢のうちの1つです。	BLASレベル2(マトリックス-ベクトル演算)サブプログラム
BLAS_TRMVプロシージャ	マトリックス-ベクトル演算を実行します。ここで、xはn要素のベクトル、Aはn行n列の単位または単位以外の上三角または下三角マトリックスです。	BLASレベル2(マトリックス-ベクトル演算)サブプログラム
BLAS_TRSMプロシージャ	マトリックス-ベクトル演算op( A )*X = alpha*BまたはX*op(A) = alpha*Bのいずれかを実行します。ここで、alphaはスカラー、XおよびBはm行n列のマトリックス、Aは単位または単位以外の上三角または下三角マトリックス、op(A)は2つある選択肢のうちの1つです。マトリックスXは、Bに上書きされます。	BLASレベル3(マトリックス-マトリックス演算)サブプログラム
BLAS_TRSVプロシージャ	いずれかの連立方程式の解を求めます。ここで、bおよびxはn要素のベクトル、Aはn行n列の単位または単位以外の上三角または下三角マトリックスです。	BLASレベル2(マトリックス-ベクトル演算)サブプログラム
LAPACK_GBSVプロシージャ	実連立一次方程式a * x = bの解を求めます。ここで、aはn行n列のマトリックス、xおよびbはn行nrhs列のマトリックスです。Aの分解には、部分ピボットおよび行交換を使用したLU分解が使用されます。	LAPACKドライバ・ルーチン(一次方程式)サブプログラム
LAPACK_GEESプロシージャ	n行n列の実非対称マトリックスA、固有値、実Schur形TおよびオプションでSchurベクトルのマトリックスZを計算します。これによって、Schur分解A = Z*T*(Z**T)が実行されます。	LAPACKドライバ・ルーチン(LLSおよび固有値問題)サブプログラム
LAPACK_GEEVプロシージャ	n行n列の実非対称マトリックスA、固有値およびオプションで左または右(あるいは両方)の固有ベクトルを計算します。	LAPACKドライバ・ルーチン(LLSおよび固有値問題)サブプログラム
LAPACK_GELSプロシージャ	AのQRまたはLQ分解を使用して、m行n列のマトリックスA、またはこのマトリックスの転置マトリックスが含まれる過剰決定または過小決定の実連立一次方程式の解を求めます。Aに最大階数が含まれていることを前提とします。	LAPACKドライバ・ルーチン(LLSおよび固有値問題)サブプログラム
LAPACK_GESDDプロシージャ	m行n列の実マトリックスAの特異値分解(SVD)を計算します。オプションで左右の特異ベクトルを計算します。特異ベクトルが必要な場合は、浮動小数点演算に関する緩やかな仮定を設ける分割統治法アルゴリズムを使用します。	LAPACKドライバ・ルーチン(LLSおよび固有値問題)サブプログラム
LAPACK_GESVプロシージャ	実連立一次方程式a * x = bの解を求めます。ここで、aはn行n列のマトリックス、xおよびbはn行nrhs列のマトリックスです。Aの分解には、部分ピボットおよび行交換を使用したLU分解が使用されます。	LAPACKドライバ・ルーチン(一次方程式)サブプログラム
LAPACK_GESVDプロシージャ	m行n列の実マトリックスAの特異値分解(SVD)を計算します。また、オプションで左または右(あるいは両方)の特異ベクトルを計算します。SVDは、A = U * SIGMA * transpose(V)のように記述されます。	LAPACKドライバ・ルーチン(LLSおよび固有値問題)サブプログラム
LAPACK_GTSVプロシージャ	方程式a * x = bの解を求めます。ここで、aは、部分ピボットを使用したガウス消去法によるn行n列の三重対角マトリックスです。	LAPACKドライバ・ルーチン(一次方程式)サブプログラム
LAPACK_PBSVプロシージャ	実連立一次方程式a * x = bの解を求めます。ここで、aはn行n列の正定値対称バンド・マトリックス、xおよびbはn行nrhs列のマトリックスです。Aの分解には、コレスキ分解が使用されます。	LAPACKドライバ・ルーチン(一次方程式)サブプログラム
LAPACK_POSVプロシージャ	実連立一次方程式a * x = bの解を求めます。ここで、aはn行n列の正定値対称マトリックス、xおよびbはn行nrhs列のマトリックスです。Aの分解には、コレスキ分解が使用されます。	LAPACKドライバ・ルーチン(一次方程式)サブプログラム
LAPACK_PPSVプロシージャ	実連立一次方程式a * x = bの解を求めます。ここで、aはパックされた形式で格納されているn行n列の正定値対称マトリックス、xおよびbはn行nrhs列のマトリックスです。Aの分解には、コレスキ分解が使用されます。	LAPACKドライバ・ルーチン(一次方程式)サブプログラム
LAPACK_PTSVプロシージャ	実連立一次方程式a * x = bの解を求めます。ここで、aはn行n列の正定値対称三重対角マトリックス、xおよびbはn行nrhs列のマトリックスです。	LAPACKドライバ・ルーチン(一次方程式)サブプログラム
LAPACK_SBEVプロシージャ	すべての固有値を計算します。また、オプションで実対称バンド・マトリックスAの固有ベクトルを計算します。	LAPACKドライバ・ルーチン(LLSおよび固有値問題)サブプログラム
LAPACK_SBEVDプロシージャ	すべての固有値を計算します。また、オプションで実対称マトリックスAの固有ベクトルを計算します。固有ベクトルが必要な場合は、浮動小数点演算に関する緩やかな仮定を設ける分割統治法アルゴリズムを使用します。	LAPACKドライバ・ルーチン(LLSおよび固有値問題)サブプログラム
LAPACK_SPEVプロシージャ	すべての固有値を計算します。また、オプションで、パックされた形式で格納されている実対称マトリックスAの固有ベクトルを計算します。	LAPACKドライバ・ルーチン(LLSおよび固有値問題)サブプログラム
LAPACK_SPEVDプロシージャ	すべての固有値を計算します。また、オプションで、パックされた形式で格納されている実対称マトリックスAの固有ベクトルを計算します。固有ベクトルが必要な場合は、浮動小数点演算に関する緩やかな仮定を設ける分割統治法アルゴリズムを使用します。	LAPACKドライバ・ルーチン(LLSおよび固有値問題)サブプログラム
LAPACK_SPSVプロシージャ	実連立一次方程式a * x = bの解を求めます。ここで、aはパックされた形式で格納されているn行n列の対称マトリックス、xおよびbはn行nrhs列のマトリックスです。Aの分解には、対角ピボット法が使用されます。	LAPACKドライバ・ルーチン(一次方程式)サブプログラム
LAPACK_STEVプロシージャ	すべての固有値を計算します。また、オプションで実対称三重対角マトリックスAの固有ベクトルを計算します。	LAPACKドライバ・ルーチン(LLSおよび固有値問題)サブプログラム
LAPACK_STEVDプロシージャ	すべての固有値を計算します。また、オプションで実対称三重対角マトリックスAの固有ベクトルを計算します。固有ベクトルが必要な場合は、浮動小数点演算に関する緩やかな仮定を設ける分割統治法アルゴリズムを使用します。	LAPACKドライバ・ルーチン(LLSおよび固有値問題)サブプログラム
LAPACK_SYEVDプロシージャ	すべての固有値を計算します。また、オプションで実対称マトリックスAの固有ベクトルを計算します。固有ベクトルが必要な場合は、浮動小数点演算に関する緩やかな仮定を設ける分割統治法アルゴリズムを使用します。	LAPACKドライバ・ルーチン(LLSおよび固有値問題)サブプログラム
LAPACK_SYSVプロシージャ	実連立一次方程式a * x = bの解を求めます。ここで、aはn行n列の対称マトリックス、xおよびbはn行nrhs列のマトリックスです。Aの分解には、対角ピボット法が使用されます。	LAPACKドライバ・ルーチン(一次方程式)サブプログラム

BLAS_ASUMファンクション

このプロシージャは、ベクトル・コンポーネントの絶対値の合計を計算します。

関連項目: このグループの他のサブプログラムについては、「BLASレベル1(ベクトル-ベクトル演算)サブプログラム」を参照してください。

構文

UTL_NLA.BLAS_ASUM (
   n      IN       POSITIVEN,
   x      IN       UTL_NLA_ARRAY_DBL,
   incx   IN       POSITIVEN)
 RETURN BINARY_DOUBLE;

UTL_NLA.BLAS_ASUM (
   n      IN       POSITIVEN,
   alpha  IN       SCALAR_DOUBLE,
   x      IN       UTL_NLA_ARRAY_FLT)
 RETURN BINARY_FLOAT

パラメータ

表259-7 BLAS_ASUMファンクションのパラメータ

パラメータ	説明
n	ベクトルxおよびyの要素数を指定します。nは、0(ゼロ)以上である必要があります。
x	少なくとも次の次元を持つUTL_NLA_ARRAY_FLT/DBL。 ( 1 + ( n - 1 )*abs( incx ) )
incx	xの要素の増分値を指定します。incxは、0(ゼロ)以外の値である必要があります。

BLAS_AXPYプロシージャ

このプロシージャは、alpha*X + YをベクトルYにコピーします。

関連項目: このグループの他のサブプログラムについては、「BLASレベル1(ベクトル-ベクトル演算)サブプログラム」を参照してください。

構文

UTL_NLA.BLAS_AXPY (
   n      IN       POSITIVEN,
   alpha  IN       SCALAR_DOUBLE,
   x      IN       UTL_NLA_ARRAY_DBL,
   incx   IN       POSITIVEN,
   y      IN OUT   UTL_NLA_ARRAY_DBL,
   incy   IN       POSITIVEN);

UTL_NLA.BLAS_AXPY (
   n      IN       POSITIVEN,
   alpha  IN       SCALAR_DOUBLE,
   x      IN       UTL_NLA_ARRAY_FLT,
   incx   IN       POSITIVEN,
   y      IN OUT   UTL_NLA_ARRAY_FLT,
   incy   IN       POSITIVEN);

パラメータ

表259-8 BLAS_AXPYプロシージャのパラメータ

パラメータ	説明
n	ベクトルxおよびyの要素数を指定します。nは、0(ゼロ)以上である必要があります。
alpha	スカラーalphaを指定します。
x	少なくとも次の次元を持つUTL_NLA_ARRAY_FLT/DBL。 ( 1 + ( n - 1 )*abs( incx ) )
incx	xの要素の増分値を指定します。incxは、0(ゼロ)以外の値である必要があります。
y	少なくとも次の次元を持つUTL_NLA_ARRAY_FLT/DBL。 ( 1 + ( n - 1 )*abs( incy) )
incy	yの要素の増分値を指定します。incyは、0(ゼロ)以外の値である必要があります。

BLAS_COPYプロシージャ

このプロシージャは、ベクトルXの内容をベクトルYにコピーします。

関連項目: このグループの他のサブプログラムについては、「BLASレベル1(ベクトル-ベクトル演算)サブプログラム」を参照してください。

構文

UTL_NLA.BLAS_COPY (
   n     IN     POSITIVEN,
   x     IN     UTL_NLA_ARRAY_DBL,
   incx  IN     POSITIVEN,
   y     IN OUT UTL_NLA_ARRAY_DBL,
   incy  IN     POSITIVEN);

UTL_NLA.BLAS_COPY (
   n     IN     POSITIVEN,
   x     IN     UTL_NLA_ARRAY_FLT,
   incx  IN     POSITIVEN,
   y     IN OUT UTL_NLA_ARRAY_FLT,
   incy  IN     POSITIVEN);

パラメータ

表259-9 BLAS_COPYプロシージャのパラメータ

パラメータ	説明
n	ベクトルxおよびyの要素数を指定します。nは、0(ゼロ)以上である必要があります。
x	少なくとも次の次元を持つUTL_NLA_ARRAY_FLT/DBL。 ( 1 + ( n - 1 )*abs( incx ) )
incx	xの要素の増分値を指定します。incxは、0(ゼロ)以外の値である必要があります。
y	少なくとも次の次元を持つUTL_NLA_ARRAY_FLT/DBL。 ( 1 + ( n - 1 )*abs( incy) )
incy	yの要素の増分値を指定します。incyは、0(ゼロ)以外の値である必要があります。

BLAS_DOTファンクション

このファンクションは、2つのベクトルXとYの内積(スカラ積)を戻します。

関連項目: このグループの他のサブプログラムについては、「BLASレベル1(ベクトル-ベクトル演算)サブプログラム」を参照してください。

構文

UTL_NLA.BLAS_DOT (
   n     IN   POSITIVEN,
   x     IN   UTL_NLA_ARRAY_DBL,
   incx  IN   POSITIVEN,
   y     IN   UTL_NLA_ARRAY_DBL,
   incy  IN   POSITIVEN) 
  RETURN BINARY_DOUBLE;

UTL_NLA.BLAS_DOT (
   n     IN   POSITIVEN,
   x     IN   UTL_NLA_ARRAY_FLT,
   incx  IN   POSITIVEN,
   y     IN   UTL_NLA_ARRAY_FLT,
   incy  IN   POSITIVEN) 
  RETURN BINARY_FLOAT;

パラメータ

表259-10 BLAS_DOTファンクションのパラメータ

パラメータ	説明
n	ベクトルxおよびyの要素数を指定します。nは、0(ゼロ)以上である必要があります。
x	少なくとも次の次元を持つUTL_NLA_ARRAY_FLT/DBL。 ( 1 + ( n - 1 )*abs( incx ) )
incx	xの要素の増分値を指定します。incxは、0(ゼロ)以外の値である必要があります。
y	少なくとも次の次元を持つUTL_NLA_ARRAY_FLT/DBL。 ( 1 + ( n - 1 )*abs( incy) )
incy	yの要素の増分値を指定します。incyは、0(ゼロ)以外の値である必要があります。

BLAS_GBMVプロシージャ

このプロシージャは、次のいずれかのマトリックス-ベクトル演算を実行します。

y := alpha*A*x + beta*y

または

y := alpha*A'*x + beta*y

ここで、alphaおよびbetaはスカラー、xおよびyはベクトル、Aはkl個の下対角とku個の上対角を持つm行n列のバンド・マトリックスです。

関連項目: このグループの他のサブプログラムについては、「BLASレベル2(マトリックス-ベクトル演算)サブプログラム」を参照してください。

構文

UTL_NLA.BLAS_GEMV (
   trans  IN      flag,
   m      IN      POSITIVEN,   n      IN      POSITIVEN,
   kl     IN      NATURALN,
   ku     IN      NATURALN,
   alpha  IN      SCALAR_DOUBLE,
   a      IN      UTL_NLA_ARRAY_DBL,
   lda    IN      POSITIVEN,
   x      IN      UTL_NLA_ARRAY_DBL,
   incx   IN      POSITIVEN,
   beta   IN      SCALAR_DOUBLE,
   y      IN OUT  UTL_NLA_ARRAY_DBL,
   incy   IN      POSITIVEN,
   pack   IN      flag DEFAULT 'C');

UTL_NLA.BLAS_GEMV (
   trans  IN      flag,
   m      IN      POSITIVEN,
   n      IN      POSITIVEN,
   kl     IN      NATURALN,
   ku     IN      NATURALN,
   alpha  IN      SCALAR_FLOAT,
   a      IN      UTL_NLA_ARRAY_FLT,
   lda    IN      POSITIVEN,
   x      IN      UTL_NLA_ARRAY_FLT,
   incx   IN      POSITIVEN,
   beta   IN      SCALAR_FLOAT,
   y      IN OUT  UTL_NLA_ARRAY_FLT,
   incy   IN      POSITIVEN,
   pack   IN      flag DEFAULT 'C');

パラメータ

表259-11 BLAS_GBMVプロシージャのパラメータ

パラメータ	説明
trans	実行する演算を指定します。 transが'N'またはtransが'n'の場合: y := alpha*A*x + beta*y trans = 'T'またはtrans = 't'の場合: y := alpha*A'*x + beta*y trans = 'C'またはtrans = 'c'の場合: y := alpha*A'*x + beta*y
m	マトリックスAの行数を指定します。mは、0(ゼロ)以上である必要があります。
n	マトリックスAの列数を指定します。nは、0(ゼロ)以上である必要があります。
kl	マトリックスAの下対角の数を指定します。klは0. le. klを満たしている必要があります。
ku	マトリックスAの上対角の数を指定します。kuは0 .le. kuを満たしている必要があります。
alpha	SCALAR_FLOAT/DOUBLE。スカラーalphaを指定します。
a	次元(lda,n)を持つUTL_NLA_ARRAY_FLT/DBL。 入力する前に、配列Aの先頭の(kl + ku + 1)行n列部分に、係数マトリックスが列単位で含まれている必要があります。この場合、配列の行(ku+1)にマトリックスの先頭の対角、行kuに位置2から開始している最初の上対角、行(ku+2)に位置1から開始している最初の下対角などが含まれている必要があります。 バンド・マトリックス(左上のku行ku列の三角マトリックスなど)の要素に対応しない配列A内の要素は参照されません。
lda	コール元の(サブ)プログラムで宣言されているように、aの最初の次元を指定します。ldaは、(kl+ku+1)以上である必要があります。
x	少なくとも次の次元を持つUTL_NLA_ARRAY_FLT/DBL。 ( 1 + ( n - 1 )*abs( incx ) ) transが''N'または'n'で、少なくとも次の次元を持つ場合。 ( 1 + ( m - 1 )*abs( incx ) ) それ以外の場合。入力する前に、増分された配列Xにベクトルxが含まれている必要があります。
incx	xの要素の増分値を指定します。0(ゼロ)以外の値である必要があります。
beta	SCALAR_FLOAT/DOUBLE。スカラーbetaを指定します。betaに0(ゼロ)が指定されている場合、入力時にyを設定する必要はありません。
y	少なくとも次の次元を持つUTL_NLA_ARRAY_FLT/DBL。 ( 1 + ( m - 1 )*abs( incy ) ) transが'N'または'n'で、少なくとも次の次元を持つ場合。 (1+(n-1)*abs(incy)) それ以外の場合。betaが0(ゼロ)以外の場合、入力する前に、増分された配列Yにベクトルyが含まれている必要があります。終了時、Yは、更新されたベクトルyによって上書きされます。
incy	yの要素の増分値を指定します。0(ゼロ)以外の値である必要があります。
pack	(オプション)マトリックスのパッキングのフラグを設定します。 'C': 列優先(デフォルト) 'R': 行優先

BLAS_GEMMプロシージャ

このプロシージャは、次のマトリックス-マトリックス演算を実行します。

C := alpha*op( A )*op( B ) + beta*C

op(X)は次のいずれかです。

op(X) = X 

または

op(X) = X'

ここで、alphaおよびbetaはスカラー、A、BおよびCはマトリックス、op(A)はm行k列のマトリックス、op(B)はk行n列のマトリックスおよびCはm行n列のマトリックスです。

関連項目: このグループの他のサブプログラムについては、「BLASレベル3(マトリックス-マトリックス演算)サブプログラム」を参照してください。

構文

UTL_NLA.BLAS_GEMM (
   transa IN      flag,
   transb IN      flag,
   m      IN      POSITIVEN,
   n      IN      POSITIVEN,
   k      IN      POSITIVEN,
   alpha  IN      SCALAR_DOUBLE,
   a      IN      UTL_NLA_ARRAY_DBL,
   lda    IN      POSITIVEN,
   b      IN      UTL_NLA_ARRAY_DBL,
   ldb    IN      POSITIVEN,
   beta   IN      SCALAR_DOUBLE,
   c      IN OUT  UTL_NLA_ARRAY_DBL,
   ldc    IN      POSITIVEN,
   pack   IN      flag DEFAULT 'C');

UTL_NLA.BLAS_GEMM (
   transa IN      flag,
   transb IN      flag,
   m      IN      POSITIVEN,
   n      IN      POSITIVEN,
   k      IN      POSITIVEN,
   alpha  IN      SCALAR_FLOAT,
   a      IN      UTL_NLA_ARRAY_FLT,
   lda    IN      POSITIVEN,
   b      IN      UTL_NLA_ARRAY_FLT,
   ldb    IN      POSITIVEN,
   beta   IN      SCALAR_FLOAT,
   c      IN OUT  UTL_NLA_ARRAY_FLT,
   ldc    IN      POSITIVEN,
   pack   IN      flag DEFAULT 'C');

パラメータ

表259-12 BLAS_GEMMプロシージャのパラメータ

パラメータ	説明
transa	マトリックス乗算で使用するop(A)の形式を次のように指定します。 transaが'N'またはtransaが'n'の場合: op(A) = 'A' transaが'T'またはtransaが't'の場合: op(A) = 'A' transaが'C'またはtransaが'c'の場合: op(A) = 'A'
transb	マトリックス乗算で使用するop(B)の形式を次のように指定します。 transbが'N'またはtransbが'n'の場合: op(B) = B transbが'T'またはtransbが't'の場合: op(B) = B' transbが'C'またはtransbが'c'の場合: op(B) = B'
m	マトリックスop(A)およびマトリックスCの行数を指定します。mは、0(ゼロ)以上である必要があります。
n	マトリックスop(B)およびマトリックスCの列数を指定します。nは、0(ゼロ)以上である必要があります。
k	マトリックスop(A)の行およびマトリックスop(B)の列数を指定します。kは、0(ゼロ)以上である必要があります。
alpha	SCALAR_FLOAT/DOUBLE。スカラーalphaを指定します。
a	次元(lda, ka)を持つUTL_NLA_ARRAY_FLT/DBL。ここで、kaは、transaが'N'またはtransaが'n'の場合はk、それ以外の場合はmです。transa = 'N'またはtransa = 'n'の場合、入力する前に、配列Aの先頭のm行k列部分にマトリックスAが含まれている必要があります。それ以外の場合は、配列Aの先頭のk行m列部分にマトリックスAが含まれている必要があります。
lda	コール元の(サブ)プログラムで宣言されているように、aの最初の次元を指定します。transa = 'N'またはtransa = 'n'の場合、ldaはmax (1,k)以上である必要があります。
b	次元(lda, kb)を持つUTL_NLA_ARRAY_FLT/DBL。ここで、kbは、transb = 'N'または'n'の場合はn、それ以外の場合はkです。transb = 'N'または'n'の場合、入力する前に、配列bの先頭のk行n列部分にマトリックスBが含まれている必要があります。それ以外の場合は、配列bの先頭n行k列部分にマトリックスBが含まれている必要があります。
ldb	コール元の(サブ)プログラムで宣言されているように、bの最初の次元を指定します。transb = 'N'またはtransb = 'n'の場合、ldbはmax (1, n)以上である必要があります。
beta	SCALAR_FLOAT/DOUBLE。スカラーbetaを指定します。betaに0(ゼロ)が指定されている場合、入力時にcを設定する必要はありません。
c	次元(ldc, n)を持つUTL_NLA_ARRAY_FLT/DBL。入力する前に、配列Cの先頭のm行n列部分にマトリックスCが含まれている必要があります。ただし、betaが0 (ゼロ)の場合、入力時にCを設定する必要はありません。終了時、配列Cは、m行n列マトリックス(alpha*op(A)*op(B) + beta*C)によって上書きされます。
ldc	コール元の(サブ)プログラムで宣言されているように、Cの最初の次元を指定します。 ldcは、max(1, m)以上である必要があります。
pack	(オプション)マトリックスのパッキングのフラグを設定します。 'C': 列優先(デフォルト) 'R': 行優先

BLAS_GEMVプロシージャ

このプロシージャは、次のいずれかのマトリックス-ベクトル演算を実行します。

y := alpha*A*x + beta*y

または

y := alpha*A'*x + beta*y

ここで、alphaおよびbetaはスカラー、xおよびyはベクトル、Aはm行n列のマトリックスです。

関連項目: このグループの他のサブプログラムについては、「BLASレベル2(マトリックス-ベクトル演算)サブプログラム」を参照してください。

構文

UTL_NLA.BLAS_GEMV (
   trans  IN      flag,
   m      IN      POSITIVEN,
   n      IN      POSITIVEN,
   alpha  IN      SCALAR_DOUBLE,
   a      IN      UTL_NLA_ARRAY_DBL,
   lda    IN      POSITIVEN,
   x      IN      UTL_NLA_ARRAY_DBL,
   incx   IN      POSITIVEN,
   beta   IN      SCALAR_DOUBLE,
   y      IN OUT  UTL_NLA_ARRAY_DBL,
   incy   IN      POSITIVEN,
   pack   IN      flag DEFAULT 'C');

UTL_NLA.BLAS_GEMV (
   trans  IN      flag,
   m      IN      POSITIVEN,
   n      IN      POSITIVEN,
   alpha  IN      SCALAR_FLOAT,
   a      IN      UTL_NLA_ARRAY_FLT,
   lda    IN      POSITIVEN,
   x      IN      UTL_NLA_ARRAY_FLT,
   incx   IN      POSITIVEN,
   beta   IN      SCALAR_FLOAT,
   y      IN OUT  UTL_NLA_ARRAY_FLT,
   incy   IN      POSITIVEN,
   pack   IN      flag DEFAULT 'C');

パラメータ

表259-13 BLAS_GEMVプロシージャのパラメータ

パラメータ	説明
trans	実行する演算を指定します。 trans = 'N'またはtrans = 'n'の場合: y := alpha*A*x + beta*y trans = 'T'またはtrans = 't'の場合: y := alpha*A'*x + beta*y trans = 'C'またはtrans = 'c'の場合: y := alpha*A'*x + beta*y
m	マトリックスAの行数を指定します。mは、0(ゼロ)以上である必要があります。
n	マトリックスAの列数を指定します。nは、0(ゼロ)以上である必要があります。
alpha	SCALAR_FLOAT/DOUBLE。スカラーalphaを指定します。
a	次元(lda, n)を持つUTL_NLA_ARRAY_FLT/DBL。入力する前に、配列aの先頭のm行n列部分に係数マトリックスが含まれている必要があります。
lda	コール元の(サブ)プログラムで宣言されているように、aの最初の次元を指定します。ldaは、max(1, m)以上である必要があります。
x	少なくとも次の次元を持つUTL_NLA_ARRAY_FLT/DBL。 ( 1 + ( n - 1 )*abs( incx ) ) transが''N'または'n'で、少なくとも次の次元を持つ場合。 (1+(m-1)*abs(incx)) それ以外の場合。入力する前に、増分された配列Xにベクトルxが含まれている必要があります。
incx	xの要素の増分値を指定します。0(ゼロ)以外の値である必要があります。
beta	SCALAR_FLOAT/DOUBLE。スカラーbetaを指定します。betaに0(ゼロ)が指定されている場合、入力時にyを設定する必要はありません。
y	少なくとも次の次元を持つUTL_NLA_ARRAY_FLT/DBL。 ( 1 + ( m - 1 )*abs( incy ) ) transが'N'または'n'で、少なくとも次の次元を持つ場合。 ( 1 + ( n - 1 )*abs( incy ) ) それ以外の場合。betaが0(ゼロ)以外の場合、入力する前に、増分された配列Yにベクトルyが含まれている必要があります。終了時、Yは、更新されたベクトルyによって上書きされます。
incy	yの要素の増分値を指定します。0(ゼロ)以外の値である必要があります。
pack	(オプション)マトリックスのパッキングのフラグを設定します。 'C': 列優先(デフォルト) 'R': 行優先

BLAS_GERプロシージャ

このプロシージャは、次のランク1演算を実行します。

A := alpha*x*y' + A

ここで、alphaはスカラー、xはm要素のベクトル、yはn要素のベクトル、Aはm行n列のマトリックスです。

関連項目: このグループの他のサブプログラムについては、「BLASレベル2(マトリックス-ベクトル演算)サブプログラム」を参照してください。

構文

UTL_NLA.BLAS_GER (
   m      IN      POSITIVEN,
   n      IN      POSITIVEN,
   alpha  IN      SCALAR_DBL,
   x      IN OUT  UTL_NLA_ARRAY_DBL,
   incx   IN      POSITIVEN,
   y      IN      UTL_NLA_ARRAY_DBL,
   incy   IN      POSITIVEN,
   a      IN OUT  UTL_NLA_ARRAY_DBL,
   lda    IN      POSITIVEN,
   pack   IN      flag DEFAULT 'C');

UTL_NLA.BLAS_GER (
   m      IN      POSITIVEN,
   n      IN      POSITIVEN,
   alpha  IN      SCALAR_FLT,
   x      IN OUT  UTL_NLA_ARRAY_FLT,
   incx   IN      POSITIVEN,
   y      IN      UTL_NLA_ARRAY_FLT,
   incy   IN      POSITIVEN,
   a      IN OUT  UTL_NLA_ARRAY_FLT,
   lda    IN      POSITIVEN,
   pack   IN      flag DEFAULT 'C');

パラメータ

表259-14 BLAS_GERプロシージャのパラメータ

パラメータ	説明
m	マトリックスAの行数を指定します。mは、0(ゼロ)以上である必要があります。
n	マトリックスAの列数を指定します。nは、0(ゼロ)以上である必要があります。
alpha	スカラーalphaを指定します。
x	少なくとも次の次元を持つUTL_NLA_ARRAY_FLT/DBL。 ( 1 + ( m - 1 )*abs( incx ) ) 入力する前に、増分された配列Xにm要素のベクトルxが含まれている必要があります。
incx	xの要素の増分値を指定します。incxは、0(ゼロ)以外の値である必要があります。
y	少なくとも次の次元を持つUTL_NLA_ARRAY_FLT/DBL。 ( 1 + ( n - 1 )*abs( incy ) ) 入力する前に、増分された配列Yにm要素のベクトルyが含まれている必要があります。
incy	yの要素の増分値を指定します。incxは、0(ゼロ)以外の値である必要があります。
a	次元(lda, n)を持つUTL_NLA_ARRAY_FLT/DBL。 入力する前に、配列aの先頭のm行n列部分に係数マトリックスが含まれている必要があります。終了時、aは、更新されたマトリックスによって上書きされます。
lda	コール元の(サブ)プログラムで宣言されているように、aの最初の次元を指定します。ldaは、次の値以上である必要があります。 max( 1, m )
pack	(オプション)マトリックスのパッキングのフラグを設定します。 'C': 列優先(デフォルト) 'R': 行優先

BLAS_IAMAXファンクション

このファンクションは、最大絶対値を持つベクトルの最初の要素のインデックスを計算します。

関連項目: このグループの他のサブプログラムについては、「BLASレベル1(ベクトル-ベクトル演算)サブプログラム」を参照してください。

構文

UTL_NLA.BLAS_IAMAX (
   n     IN   POSITIVEN,
   x     IN   UTL_NLA_ARRAY_DBL,
   incx  IN   POSITIVEN,
  RETURN POSITIVEN;

UTL_NLA.BLAS_IAMAX (
   n     IN   POSITIVEN,
   x     IN   UTL_NLA_ARRAY_FLT,
   incx  IN   POSITIVEN,
  RETURN POSITIVEN;

パラメータ

表259-15 BLAS_IAMAXファンクションのパラメータ

パラメータ	説明
n	ベクトルxおよびyの要素数を指定します。nは、0(ゼロ)以上である必要があります。
x	少なくとも次の次元を持つUTL_NLA_ARRAY_FLT/DBL。 ( 1 + ( n - 1 )*abs( incx ) )
incx	xの要素の増分値を指定します。incxは、0(ゼロ)以外の値である必要があります。

BLAS_NRM2ファンクション

このファンクションは、ベクトル2ノルム(ユークリッド・ノルム)を計算します。

関連項目: このグループの他のサブプログラムについては、「BLASレベル1(ベクトル-ベクトル演算)サブプログラム」を参照してください。

構文

UTL_NLA.BLAS_NRM2 (
   n     IN   POSITIVEN,
   x     IN   UTL_NLA_ARRAY_DBL,
   incx  IN   POSITIVEN)
  RETURN BINARY_DOUBLE;

UTL_NLA.BLAS_NRM2 (
   n     IN   POSITIVEN,
   x     IN   UTL_NLA_ARRAY_FLT,
   incx  IN   POSITIVEN)
  RETURN BINARY_FLOAT;

パラメータ

表259-16 BLAS_NRM2ファンクションのパラメータ

パラメータ	説明
n	ベクトルxおよびyの要素数を指定します。nは、0(ゼロ)以上である必要があります。
x	少なくとも次の次元を持つUTL_NLA_ARRAY_FLT/DBL。 ( 1 + ( n - 1 )*abs( incx ) )
incx	xの要素の増分値を指定します。incxは、0(ゼロ)以外の値である必要があります。

BLAS_ROTプロシージャ

このプロシージャは、点の面回転を戻します。

関連項目: このグループの他のサブプログラムについては、「BLASレベル1(ベクトル-ベクトル演算)サブプログラム」を参照してください。

構文

UTL_NLA.BLAS_ROT (
   n      IN      POSITIVEN,
   x      IN OUT  UTL_NLA_ARRAY_DBL,
   incx   IN      POSITIVEN,
   y      IN OUT  UTL_NLA_ARRAY_DBL,
   incy   IN      POSITIVEN,
   c      IN      SCALAR_DOUBLE,
   s      IN      SCALAR_DOUBLE);

UTL_NLA.BLAS_ROT (
   n      IN      POSITIVEN,
   x      IN OUT  UTL_NLA_ARRAY_FLT,
   incx   IN      POSITIVEN,
   y      IN OUT  UTL_NLA_ARRAY_FLT,
   incy   IN      POSITIVEN,
   c      IN      SCALAR_DOUBLE,
   s      IN      SCALAR_DOUBLE);

パラメータ

表259-17 BLAS_ROTプロシージャのパラメータ

パラメータ	説明
n	ベクトルxおよびyの要素数を指定します。nは、0(ゼロ)以上である必要があります。
x	少なくとも次の次元を持つUTL_NLA_ARRAY_FLT/DBL。 (1+(n-1)* abs(incx))
incx	xの要素の増分値を指定します。incxは、0(ゼロ)以外の値である必要があります。
y	少なくとも次の次元を持つUTL_NLA_ARRAY_FLT/DBL。 (1+(n-1)*abs(incy))
incy	yの要素の増分値を指定します。incyは、0(ゼロ)以外の値である必要があります。
c	SCALAR_FLOAT/DOUBLE。スカラーCを指定します。
s	SCALAR_FLOAT/DOUBLE。スカラーSを指定します。

BLAS_ROTGプロシージャ

このプロシージャは、点のギブンス回転を戻します。

関連項目: このグループの他のサブプログラムについては、「BLASレベル1(ベクトル-ベクトル演算)サブプログラム」を参照してください。

構文

UTL_NLA.BLAS_ROTG (
   a   IN OUT   SCALAR_DOUBLE,
   b   IN OUT   SCALAR_DOUBLE,
   c   IN OUT   SCALAR_DOUBLE,
   s   IN OUT   SCALAR_DOUBLE);

UTL_NLA.BLAS_ROTG (
   a   IN OUT   SCALAR_FLOAT,
   b   IN OUT   SCALAR_FLOAT,
   c   IN OUT   SCALAR_FLOAT,
   s   IN OUT   SCALAR_FLOAT);

パラメータ

表259-18 BLAS_ROTGプロシージャのパラメータ

パラメータ	説明
a	SCALAR_FLOAT/DOUBLE。スカラーAを指定します。
b	SCALAR_FLOAT/DOUBLE。スカラーBを指定します。
c	SCALAR_FLOAT/DOUBLE。スカラーCを指定します。
s	SCALAR_FLOAT/DOUBLE。スカラーSを指定します。

BLAS_SCALプロシージャ

このプロシージャは、ベクトルのスケールを定数で変更します。

関連項目: このグループの他のサブプログラムについては、「BLASレベル1(ベクトル-ベクトル演算)サブプログラム」を参照してください。

構文

UTL_NLA.BLAS_SCAL (
   n      IN  POSITIVEN,
   alpha  IN  SCALAR_DOUBLE,
   x      IN  OUT UTL_NLA_ARRAY_DBL,
   incx   IN  POSITIVEN);

UTL_NLA.BLAS_SCAL (
   n      IN  POSITIVEN,
   alpha  IN  SCALAR_FLOAT,
   x      IN  OUT UTL_NLA_ARRAY_FLT,
   incx   IN  POSITIVEN);

パラメータ

表259-19 BLAS_SCALプロシージャのパラメータ

パラメータ	説明
n	ベクトルxおよびyの要素数を指定します。nは、0(ゼロ)以上である必要があります。
alpha	スカラーalphaを指定します。
x	少なくとも次の次元を持つUTL_NLA_ARRAY_FLT/DBL。 (1+(n-1)*abs(incx))
incx	xの要素の増分値を指定します。incxは、0(ゼロ)以外の値である必要があります。

BLAS_SPMVプロシージャ

このプロシージャは、次のマトリックス-ベクトル演算を実行します。

y := alpha*A*x + beta*y

ここで、alphaおよびbetaはスカラー、xおよびyはn要素のベクトル、Aはパックされた形式のn行n列の対称マトリックスです。

関連項目: このグループの他のサブプログラムについては、「BLASレベル2(マトリックス-ベクトル演算)サブプログラム」を参照してください。

構文

UTL_NLA.BLAS_SPMV (
   uplo   IN      flag,
   n      IN      POSITIVEN,
   alpha  IN      SCALAR_DOUBLE,
   ap     IN      UTL_NLA_ARRAY_DBL,
   x      IN      UTL_NLA_ARRAY_DBL,
   incx   IN      POSITIVEN,
   beta   IN      SCALAR_DOUBLE,
   y      IN OUT  UTL_NLA_ARRAY_DBL,
   incy   IN      POSITIVEN,
   pack   IN      flag DEFAULT 'C');

UTL_NLA.BLAS_SPMV (
   uplo   IN      flag,
   n      IN      POSITIVEN,
   alpha  IN      SCALAR_FLOAT,
   ap      IN     UTL_NLA_ARRAY_FLT,
   x      IN      UTL_NLA_ARRAY_FLT,
   incx   IN      POSITIVEN,
   beta   IN      SCALAR_FLOAT,
   y      IN OUT  UTL_NLA_ARRAY_FLT,
   incy   IN      POSITIVEN,
   pack   IN      flag DEFAULT 'C');

パラメータ

表259-20 BLAS_SPMVプロシージャのパラメータ

パラメータ	説明
uplo	マトリックスAの上三角または下三角部分が、パックされた配列APで提供されるように指定します。 uplo = 'U'または'u'の場合。Aの上三角部分がAPで提供されます。 uplo = 'L'または'l'の場合。Aの下三角部分がAPで提供されます。
n	マトリックスAの位数を指定します。nは、0(ゼロ)以上である必要があります。
alpha	SCALAR_FLOAT/DOUBLE。スカラーalphaを指定します。
ap	少なくとも次の次元を持つUTL_NLA_ARRAY_FLT/DBL。 ((n*(n+1))/2) uplo = 'U'またはuplo = 'u'の場合、入力する前に、配列apに、順番にパックされた対称マトリックスの上三角部分が列単位で含まれている必要があります。これによって、ap(1)にa(1,1)、ap(2)にa(1,2)、ap(3)にa(2,2)がそれぞれ含まれます。 uplo = 'L'またはuplo = 'l'の場合、入力する前に、配列apに、順番にパックされた対称マトリックスの下三角部分が列単位で含まれている必要があります。これによって、ap(1)にa(1,1)、ap(2)にa(2,1)、ap(3)にa(3,1)がそれぞれ含まれます。
x	少なくとも次の次元を持つUTL_NLA_ARRAY_FLT/DBL。 (1+(n-1)*abs(incx)) 入力する前に、増分された配列Xにn要素のベクトルxが含まれている必要があります。
incx	xの要素の増分値を指定します。0(ゼロ)以外の値である必要があります。
beta	SCALAR_FLOAT/DOUBLE。スカラーbetaを指定します。betaに0(ゼロ)が指定されている場合、入力時にYを設定する必要はありません。
y	少なくとも次の次元を持つUTL_NLA_ARRAY_FLT/DBL。 (1+(n-1)*abs(incy)) 入力する前に、増分された配列Yにn要素のベクトルyが含まれている必要があります。終了時、Yは、更新されたベクトルyによって上書きされます。
incy	yの要素の増分値を指定します。0(ゼロ)以外の値である必要があります。
pack	(オプション)マトリックスのパッキングのフラグを設定します。 'C': 列優先(デフォルト) 'R': 行優先

BLAS_SPRプロシージャ

このプロシージャは、次のランク1演算を実行します。

A := alpha*x*x' + A

ここで、alphaは実スカラー、xはn要素のベクトル、Aはパックされた形式のn行n列の対称マトリックスです。

関連項目: このグループの他のサブプログラムについては、「BLASレベル2(マトリックス-ベクトル演算)サブプログラム」を参照してください。

構文

UTL_NLA.BLAS_SPR (
   uplo   IN      flag,
   n      IN      POSITIVEN,
   alpha  IN      SCALAR_DBL,
   x      IN OUT  UTL_NLA_ARRAY_DBL,
   incx   IN      POSITIVEN,
   ap     IN OUT  UTL_NLA_ARRAY_DBL,
   pack   IN      flag DEFAULT 'C');

UTL_NLA.BLAS_SPR (
   uplo   IN      flag,
   n      IN      POSITIVEN,
   alpha  IN      SCALAR_FLT,
   x      IN OUT  UTL_NLA_ARRAY_FLT,
   incx   IN      POSITIVEN,
   ap     IN OUT  UTL_NLA_ARRAY_FLT,
   pack   IN      flag DEFAULT 'C');

パラメータ

表259-21 BLAS_SPRプロシージャのパラメータ

パラメータ	説明
uplo	マトリックスAの上三角または下三角部分が、パックされた配列apで提供されるかどうかを指定します。 uplo = 'U'またはuplo = 'u'の場合: Aの上三角部分がapで提供されます。 uplo = 'L'またはuplo = 'l'の場合: Aの下三角部分がapで提供されます。
n	マトリックスAの位数を指定します。nは、0(ゼロ)以上である必要があります。
alpha	スカラーalphaを指定します。
x	少なくとも次の次元を持つUTL_NLA_ARRAY_FLT/DBL。 (1+(n-1)*abs(incx)) 入力する前に、増分された配列Xにm要素のベクトルxが含まれている必要があります。
incx	xの要素の増分値を指定します。incxは、0(ゼロ)以外の値である必要があります。
ap	少なくとも次の次元を持つUTL_NLA_ARRAY_FLT/DBL。 ((n*(n +1))/2) uplo = 'U'またはuplo = 'u'の場合、入力する前に、配列apに、順番にパックされた対称マトリックスの上三角部分が列単位で含まれている必要があります。これによって、ap(1)にa(1,1)、ap(2)にa(1,2)、ap(3)にa(2,2)がそれぞれ含まれます。終了時、配列apは、更新されたマトリックスの上三角部分によって上書きされます。 uplo = 'L'または'l'の場合、入力する前に、配列apに、順番にパックされた対称マトリックスの下三角部分が列単位で含まれている必要があります。これによって、ap(1)にa(1,1)、ap(2)にa(2,1)、ap(3)にa(3,1)がそれぞれ含まれます。終了時、配列apは、更新されたマトリックスの下三角部分によって上書きされます。
pack	(オプション)マトリックスのパッキングのフラグを設定します。 'C': 列優先(デフォルト) 'R': 行優先

BLAS_SPR2プロシージャ

このプロシージャは、次のランク2演算を実行します。

A := alpha*x*y' + alpha*y*x' +A

ここで、alphaはスカラー、xおよびyはn要素のベクトル、Aはパックされた形式のn行n列の対称マトリックスです。

関連項目: このグループの他のサブプログラムについては、「BLASレベル2(マトリックス-ベクトル演算)サブプログラム」を参照してください。

構文

UTL_NLA.BLAS_SPR2 (
   uplo   IN      flag,
   n      IN      POSITIVEN,
   alpha  IN      SCALAR_DBL,
   x      IN      UTL_NLA_ARRAY_DBL,
   incx   IN      POSITIVEN,
   y      IN      UTL_NLA_ARRAY_DBL,
   incy   IN      POSITIVEN,
   a      IN OUT  UTL_NLA_ARRAY_DBL,
   lda    IN      POSITIVEN,
   pack   IN      flag DEFAULT 'C');

UTL_NLA.BLAS_SPR2 (
   uplo   IN      flag,
   n      IN      POSITIVEN,
   alpha  IN      SCALAR_FLT,
   x      IN      UTL_NLA_ARRAY_FLT,
   incx   IN      POSITIVEN,
   y      IN      UTL_NLA_ARRAY_FLT,
   incy   IN      POSITIVEN,
   a      IN OUT  UTL_NLA_ARRAY_FLT,
   lda    IN      POSITIVEN,
   pack   IN      flag DEFAULT 'C');

パラメータ

表259-22 BLAS_SPR2プロシージャのパラメータ

パラメータ	説明
uplo	マトリックスAの上三角または下三角部分が、パックされた配列apで提供されるかどうかを指定します。 uplo = 'U'またはuplo = 'u'の場合: Aの上三角部分がapで提供されます。 uplo = 'L'またはuplo = 'l'の場合: Aの下三角部分がapで提供されます。
n	マトリックスAの位数を指定します。nは、0(ゼロ)以上である必要があります。
alpha	スカラーalphaを指定します。
x	少なくとも次の次元を持つUTL_NLA_ARRAY_FLT/DBL。 (1+(n-1)*abs(incx)) 入力する前に、増分された配列Xにm要素のベクトルxが含まれている必要があります。
incx	xの要素の増分値を指定します。incxは、0(ゼロ)以外の値である必要があります。
y	少なくとも次の次元を持つUTL_NLA_ARRAY_FLT/DBL。 (1+(n-1)*abs(incy)) 入力する前に、増分された配列Xにm要素のベクトルyが含まれている必要があります。
incy	yの要素の増分値を指定します。incyは、0(ゼロ)以外の値である必要があります。
ap	少なくとも次の次元を持つUTL_NLA_ARRAY_FLT/DBL。 ((n*(n+1))/2) uplo = 'U'または'u'が指定されたエントリの前では、配列apに、順番にパックされた対称マトリックスの上三角部分が列単位で含まれている必要があります。これによって、ap(1)にa(1,1)、ap(2)にa(1,2)、ap(3)にa(2,2)がそれぞれ含まれます。終了時、配列apは、更新されたマトリックスの上三角部分によって上書きされます。 uplo = 'L'または'l'の場合、入力する前に、配列apに、順番にパックされた対称マトリックスの下三角部分が列単位で含まれている必要があります。これによって、ap(1)にa(1,1)、ap(2)にa(2,1)、ap(3)にa(3,1)がそれぞれ含まれます。終了時、配列apは、更新されたマトリックスの下三角部分によって上書きされます。
lda	コール元の(サブ)プログラムで宣言されているように、aの最初の次元を指定します。ldaは、(k + 1)以上である必要があります。
pack	(オプション)マトリックスのパッキングのフラグを設定します。 'C': 列優先(デフォルト) 'R': 行優先

BLAS_SBMVプロシージャ

このプロシージャは、次のマトリックス-ベクトル演算を実行します。

y := alpha*A*x + beta*y

ここで、alphaおよびbetaはスカラー、xおよびyはn要素のベクトル、Aはk個の上対角を持つn行n列の対称バンド・マトリックスです。

関連項目: このグループの他のサブプログラムについては、「BLASレベル2(マトリックス-ベクトル演算)サブプログラム」を参照してください。

構文

UTL_NLA.BLAS_SBMV (
   uplo   IN      flag,
   n      IN      POSITIVEN,
   k      IN      NATURALN,
   alpha  IN      SCALAR_DOUBLE,
   a      IN      UTL_NLA_ARRAY_DBL,
   lda    IN      POSITIVEN,
   x      IN      UTL_NLA_ARRAY_DBL,
   incx   IN      POSITIVEN,
   beta   IN      SCALAR_DOUBLE,
   y      IN OUT  UTL_NLA_ARRAY_DBL,
   incy   IN      POSITIVEN,
   pack   IN      flag DEFAULT 'C');

UTL_NLA.BLAS_SBMV (
   uplo   IN      flag,
   n      IN      POSITIVEN,
   k      IN      NATURALN,
   alpha  IN      SCALAR_FLOAT,
   a      IN      UTL_NLA_ARRAY_FLT,
   lda    IN      POSITIVEN,
   x      IN      UTL_NLA_ARRAY_FLT,
   incx   IN      POSITIVEN,
   beta   IN      SCALAR_FLOAT,
   y      IN OUT  UTL_NLA_ARRAY_FLT,
   incy   IN      POSITIVEN,
   pack   IN      flag DEFAULT 'C');

パラメータ

表259-23 BLAS_SBMVプロシージャのパラメータ

パラメータ	説明
uplo	バンド・マトリックスAの上三角または下三角部分が提供されるかどうかを指定します。 uplo = 'U'または'u'の場合。Aの上三角部分が提供されます。 uplo = 'L'または'l'の場合。Aの下三角部分が提供されます。
n	マトリックスAの位数を指定します。nは、0(ゼロ)以上である必要があります。
k	マトリックスAの上対角の数を指定します。kは0 .le. kを満たしている必要があります。
alpha	SCALAR_FLOAT/DOUBLE。スカラーalphaを指定します。
a	次元(lda,n)を持つUTL_NLA_ARRAY_FLT/DBL。 uplo = 'U'または'u'の場合、入力する前に、配列Aの先頭の(k+1)行n列部分に、対称マトリックスの上三角帯部分が列単位で含まれている必要があります。この場合、配列の行(k+1)にマトリックスの先頭の対角、行kに位置2から開始される最初の上対角などが含まれている必要があります。配列Aの左上のk行k列の三角形は参照されません。 uplo = 'L'または'l'の場合、入力する前に、配列Aの先頭の(k+1)行n列部分に、対称マトリックスの下三角帯部分が列単位で含まれている必要があります。この場合、配列の行1にマトリックスの先頭の対角、行2に位置1から開始している最初の下対角などが含まれている必要があります。配列Aの右下のk行k列の三角マトリックスは参照されません。 終了時に変更されません。
lda	コール元の(サブ)プログラムで宣言されているように、aの最初の次元を指定します。ldaは、(k + 1)以上である必要があります。
x	少なくとも次の次元を持つUTL_NLA_ARRAY_FLT/DBL。 (1+(n-1)*abs(incx)) 入力する前に、増分された配列Xにn要素のベクトルxが含まれている必要があります。
incx	xの要素の増分値を指定します。0(ゼロ)以外の値である必要があります。
beta	SCALAR_FLOAT/DOUBLE。スカラーbetaを指定します。
y	少なくとも次の次元を持つUTL_NLA_ARRAY_FLT/DBL。 (1+(n-1)*abs(incy)) 入力する前に、増分された配列Yにn要素のベクトルyが含まれている必要があります。終了時、Yは、更新されたベクトルyによって上書きされます。
incy	yの要素の増分値を指定します。0(ゼロ)以外の値である必要があります。
pack	(オプション)マトリックスのパッキングのフラグを設定します。 'C': 列優先(デフォルト) 'R': 行優先

BLAS_SWAPプロシージャ

このプロシージャは、サイズがnの2つのベクトルの内容を交換します。

構文

UTL_NLA.BLAS_SWAP (
   n     IN     POSITIVEN,
   x     IN OUT UTL_NLA_ARRAY_DBL,
   incx  IN     POSITIVEN,
   y     IN OUT UTL_NLA_ARRAY_DBL,
   incy  IN     POSITIVEN);

UTL_NLA.BLAS_SWAP (
   n     IN     POSITIVEN,
   x     IN OUT UTL_NLA_ARRAY_FLT,
   incx  IN     POSITIVEN,
   y     IN OUT UTL_NLA_ARRAY_FLT,
   incy  IN     POSITIVEN);

パラメータ

表259-24 BLAS_SWAPプロシージャのパラメータ

パラメータ	説明
n	ベクトルxおよびyの要素数を指定します。nは、0(ゼロ)以上である必要があります。
x	少なくとも次の次元を持つUTL_NLA_ARRAY_FLT/DBL。 (1+(n-1)*abs(incx))
incx	xの要素の増分値を指定します。incxは、0(ゼロ)以外の値である必要があります。
y	少なくとも次の次元を持つUTL_NLA_ARRAY_FLT/DBL。 (1+(n-1)*abs(incy))
incy	yの要素の増分値を指定します。incyは、0(ゼロ)以外の値である必要があります。

BLAS_SYMMプロシージャ

このプロシージャは、次のマトリックス-マトリックス演算を実行します。

C := alpha*A*B + beta*C

または

C := alpha*B*A + beta*C

ここで、alphaおよびbetaはスカラー、Aは対称マトリックス、BおよびCはm行n列のマトリックスです。

関連項目: このグループの他のサブプログラムについては、「BLASレベル3(マトリックス-マトリックス演算)サブプログラム」を参照してください。

構文

UTL_NLA.BLAS_SYMM (
   side   IN      flag,
   uplo   IN      flag,
   m      IN      POSITIVEN,
   n      IN      POSITIVEN,
   alpha  IN      SCALAR_DOUBLE,
   a      IN      UTL_NLA_ARRAY_DBL,
   lda    IN      POSITIVEN,
   b      IN      UTL_NLA_ARRAY_DBL,
   ldb    IN      POSITIVEN,
   beta   IN      SCALAR_DOUBLE,
   c      IN OUT  UTL_NLA_ARRAY_DBL,
   ldc    IN      POSITIVEN,
   pack   IN      flag DEFAULT 'C');

UTL_NLA.BLAS_SYMM (
   side   IN      flag,
   uplo   IN      flag,
   m      IN      POSITIVEN,
   n      IN      POSITIVEN,
   alpha  IN      SCALAR_FLOAT,
   a      IN      UTL_NLA_ARRAY_FLT,
   lda    IN      POSITIVEN,
   b      IN      UTL_NLA_ARRAY_FLT,
   ldb    IN      POSITIVEN,
   beta   IN      SCALAR_FLOAT,
   c      IN OUT  UTL_NLA_ARRAY_FLT,
   ldc    IN      POSITIVEN,
   pack   IN      flag DEFAULT 'C');

パラメータ

表259-25 BLAS_SYMMプロシージャのパラメータ

パラメータ	説明
side	対称マトリックスAが演算の左側または右側のいずれに使用されるかを指定します。 side = 'L'またはside = 'l'の場合: C := alpha*A*B + beta*C side = 'R'またはside = 'r'の場合: C := alpha*B*A + beta*C
uplo	配列Aの上三角または下三角部分を参照するかどうかを指定します。 uplo = 'U'またはuplo = 'u'の場合: 対称マトリックスの上三角部分のみを参照します。 uplo = 'L'またはuplo = 'l'の場合: 対称マトリックスの下三角部分のみを参照します。
m	マトリックスCの行数を指定します。mは、0(ゼロ)以上である必要があります。
n	マトリックスCの列数を指定します。nは、0(ゼロ)以上である必要があります。
alpha	SCALAR_FLOAT/DOUBLE。スカラーalphaを指定します。
a	次元(lda,ka)を持つUTL_NLA_ARRAY_FLT/DBL。ここで、kaは、side = 'L'またはside = 'l'の場合はm、それ以外の場合はnです。 side = 'L'またはside = 'l'の場合、入力する前に、配列Aの先頭のm行m列部分に対称マトリックスが含まれている必要があります。これは、uplo = 'U'またはuplo = 'u'の場合、配列Aの先頭のm行m列の上三角部分に対称マトリックスの上三角部分が含まれる必要があり、Aの狭義下三角部分は参照されないこと、また、uplo = 'L'またはuplo = 'l'の場合、配列Aの先頭のm行m列の下三角部分に対称マトリックスの下三角部分が含まれる必要があり、Aの狭義上三角部分は参照されないことと同様の理由から必要となります。 side = 'R'またはside = 'r'の場合、入力する前に、配列Aのn行n列部分に対称マトリックスが含まれている必要があります。これは、uplo = 'U'またはuplo = 'u'の場合、配列Aの先頭のn行n列の上三角部分に対称マトリックスの上三角部分が含まれる必要があり、Aの狭義下三角部分は参照されないこと、また、uplo = 'L'またはuplo = 'l'の場合、配列Aの先頭のn行n列の下三角部分に対称マトリックスの下三角部分が含まれる必要があり、Aの狭義上三角部分は参照されないことと同様の理由から必要となります。
lda	コール元の(サブ)プログラムで宣言されているように、aの最初の次元を指定します。side = 'L'または'l'の場合、ldaはmax(1,m)以上である必要があります。それ以外の場合は、ldaはmax(1,n)以上である必要があります。
b	次元(ldb,n)を持つUTL_NLA_ARRAY_FLT/DBL。 入力する前に、配列Bの先頭のm行n列部分にマトリックスBが含まれている必要があります。
ldb	コール元の(サブ)プログラムで宣言されているように、bの最初の次元を指定します。ldbは、max(1,m)以上である必要があります。
beta	SCALAR_FLOAT/DOUBLE。スカラーbetaを指定します。betaに0(ゼロ)が指定されている場合、入力時にcを設定する必要はありません。
c	次元(ldc,n)を持つUTL_NLA_ARRAY_FLT/DBL。入力する前に、配列Cの先頭のm行n列部分にマトリックスCが含まれている必要があります。ただし、betaが0 (ゼロ)の場合、入力時にCを設定する必要はありません。終了時、配列Cは、更新されたm行n列マトリックスによって上書きされます。
ldc	コール元の(サブ)プログラムで宣言されているように、Cの最初の次元を指定します。 ldcは、max(1, m)以上である必要があります。
pack	(オプション)マトリックスのパッキングのフラグを設定します。 'C': 列優先(デフォルト) 'R': 行優先

BLAS_SYMVプロシージャ

このプロシージャは、次のマトリックス-ベクトル演算を実行します。

y := alpha*A*x + beta*y

ここで、alphaおよびbetaはスカラー、xおよびyはn要素のベクトル、Aはn行n列の対称マトリックスです。

関連項目: このグループの他のサブプログラムについては、「BLASレベル2(マトリックス-ベクトル演算)サブプログラム」を参照してください。

構文

UTL_NLA.BLAS_SYMV (
   uplo   IN      flag,
   n      IN      POSITIVEN,
   alpha  IN      SCALAR_DOUBLE,
   a      IN      UTL_NLA_ARRAY_DBL,
   lda    IN      POSITIVEN,
   x      IN      UTL_NLA_ARRAY_DBL,
   incx   IN      POSITIVEN,
   beta   IN      SCALAR_DOUBLE,
   y      IN OUT  UTL_NLA_ARRAY_DBL,
   incy   IN      POSITIVEN,
   pack   IN      flag DEFAULT 'C');

UTL_NLA.BLAS_SYMV (
   uplo   IN      flag,
   n      IN      POSITIVEN,
   alpha  IN      SCALAR_FLOAT,
   a      IN      UTL_NLA_ARRAY_FLT,
   lda    IN      POSITIVEN,
   x      IN      UTL_NLA_ARRAY_FLT,
   incx   IN      POSITIVEN,
   beta   IN      SCALAR_FLOAT,
   y      IN OUT  UTL_NLA_ARRAY_FLT,
   incy   IN      POSITIVEN,
   pack   IN      flag DEFAULT 'C');

パラメータ

表259-26 BLAS_SYMVプロシージャのパラメータ

パラメータ	説明
uplo	配列Aの上三角または下三角部分を参照するかどうかを指定します。 uplo = 'U'または'u'の場合。Aの上三角部分のみを参照します。 uplo = 'L'または'l'の場合。Aの下三角部分のみを参照します。
n	マトリックスAの位数を指定します。nは、0(ゼロ)以上である必要があります。
alpha	SCALAR_FLOAT/DOUBLE。スカラーalphaを指定します。
a	次元(lda,n)を持つUTL_NLA_ARRAY_FLT/DBL。uplo = 'U'または'u'の場合、入力する前に、配列Aの先頭のn行n列の上三角部分に、対称マトリックスの上三角部分が含まれる必要があります。また、Aの狭義下三角部分は参照されません。 uplo = 'L'またはuplo = 'l'の場合、入力する前に、配列Aの先頭のn行n列の下三角部分に、対称マトリックスの下三角部分が含まれる必要があります。また、Aの狭義上三角部分は参照されません。
lda	コール元の(サブ)プログラムで宣言されているように、aの最初の次元を指定します。ldaはmax(1, n)以上である必要があります。
x	少なくとも次の次元を持つUTL_NLA_ARRAY_FLT/DBL。 (1+(n-1)*abs(incx)) 入力する前に、増分された配列Xにn要素のベクトルxが含まれている必要があります。
incx	xの要素の増分値を指定します。0(ゼロ)以外の値である必要があります。
beta	SCALAR_FLOAT/DOUBLE。スカラーbetaを指定します。betaに0(ゼロ)が指定されている場合、入力時にyを設定する必要はありません。
y	少なくとも次の次元を持つUTL_NLA_ARRAY_FLT/DBL。 (1+(n-1)*abs(incy)) 入力する前に、増分された配列Yにn要素のベクトルyが含まれている必要があります。終了時、Yは、更新されたベクトルyによって上書きされます。
incy	yの要素の増分値を指定します。0(ゼロ)以外の値である必要があります。
pack	(オプション)マトリックスのパッキングのフラグを設定します。 'C': 列優先(デフォルト) 'R': 行優先

BLAS_SYRプロシージャ

このプロシージャは、次のランク1演算を実行します。

A := alpha*x*x' + A

ここで、alphaは実スカラー、xはn要素のベクトル、Aはn行n列の対称マトリックスです。

関連項目: このグループの他のサブプログラムについては、「BLASレベル2(マトリックス-ベクトル演算)サブプログラム」を参照してください。

構文

UTL_NLA.BLAS_SYR (
   uplo   IN      flag,
   n      IN      POSITIVEN,
   alpha  IN      SCALAR_DBL,
   x      IN OUT  UTL_NLA_ARRAY_DBL,
   incx   IN      POSITIVEN,
   a      IN OUT  UTL_NLA_ARRAY_DBL,
   lda    IN      POSITIVEN,
   pack   IN      flag DEFAULT 'C');

UTL_NLA.BLAS_SYR (
   uplo   IN      flag,
   n      IN      POSITIVEN,
   alpha  IN      SCALAR_FLT,
   x      IN OUT  UTL_NLA_ARRAY_FLT,
   incx   IN      POSITIVEN,
   a      IN OUT  UTL_NLA_ARRAY_FLT,
   lda    IN      POSITIVEN,
   pack   IN      flag DEFAULT 'C');

パラメータ

表259-27 BLAS_SYRプロシージャのパラメータ

パラメータ	説明
uplo	配列Aの上三角または下三角部分を参照するかどうかを指定します。 uplo = 'U'またはuplo = 'u'の場合: Aの上三角部分のみを参照します。 uplo = 'L'またはuplo = 'l'の場合: Aの下三角部分のみを参照します。
n	マトリックスAの位数を指定します。nは、0(ゼロ)以上である必要があります。
alpha	スカラーalphaを指定します。
x	少なくとも次の次元を持つUTL_NLA_ARRAY_FLT/DBL。 (1+(n-1)*abs(incx)) 入力する前に、増分された配列Xにm要素のベクトルxが含まれている必要があります。
incx	xの要素の増分値を指定します。incxは、0(ゼロ)以外の値である必要があります。
a	次元(lda, n)を持つUTL_NLA_ARRAY_FLT/DBL。 uplo = 'U'または'u'の場合、入力する前に、配列Aの先頭のn行n列の上三角部分に、対称マトリックスの上三角部分が含まれる必要があります。また、Aの狭義下三角部分は参照されません。終了時、配列Aの上三角部分は、更新されたマトリックスの上三角部分によって上書きされます。 uplo = 'L'または'l'の場合、入力する前に、配列Aの先頭のn行n列の下三角部分に、対称マトリックスの下三角部分が含まれる必要があります。また、Aの狭義上三角部分は参照されません。終了時、配列Aの下三角部分は、更新されたマトリックスの下三角部分によって上書きされます。
lda	コール元の(サブ)プログラムで宣言されているように、aの最初の次元を指定します。ldaは、次の値以上である必要があります。 max( 1, n )
pack	(オプション)マトリックスのパッキングのフラグを設定します。 'C': 列優先(デフォルト) 'R': 行優先

BLAS_SYR2プロシージャ

このプロシージャは、次のランク2演算を実行します。

A := alpha*x*y' + alpha*y*x' + A

ここで、alphaはスカラー、xおよびyはn要素のベクトル、Aはn行n列の対称マトリックスです。

関連項目: このグループの他のサブプログラムについては、「BLASレベル2(マトリックス-ベクトル演算)サブプログラム」を参照してください。

構文

UTL_NLA.BLAS_SYR2 (
   uplo   IN      flag,
   n      IN      POSITIVEN,
   alpha  IN      SCALAR_DBL,
   x      IN      UTL_NLA_ARRAY_DBL,
   incx   IN      POSITIVEN,
   y      IN      UTL_NLA_ARRAY_DBL,
   incy   IN      POSITIVEN,
   a      IN OUT  UTL_NLA_ARRAY_DBL,
   lda    IN      POSITIVEN,
   pack   IN      flag DEFAULT 'C');

UTL_NLA.BLAS_SYR2 (
   uplo   IN      flag,
   n      IN      POSITIVEN,
   alpha  IN      SCALAR_FLT,
   x      IN      UTL_NLA_ARRAY_FLT,
   incx   IN      POSITIVEN,
   y      IN      UTL_NLA_ARRAY_FLT,
   incy   IN      POSITIVEN,
   a      IN OUT  UTL_NLA_ARRAY_FLT,
   lda    IN      POSITIVEN,
   pack   IN      flag DEFAULT 'C');

パラメータ

表259-28 BLAS_SYR2プロシージャのパラメータ

パラメータ	説明
uplo	配列Aの上三角または下三角部分を参照するかどうかを指定します。 uplo = 'U'またはuplo = 'u'の場合: Aの上三角部分のみを参照します。 uplo = 'L'またはuplo = 'l'の場合: Aの下三角部分のみを参照します。
n	マトリックスAの位数を指定します。nは、0(ゼロ)以上である必要があります。
alpha	スカラーalphaを指定します。
x	少なくとも次の次元を持つUTL_NLA_ARRAY_FLT/DBL。 ( 1 + ( n - 1 )*abs( incx ) ) 入力する前に、増分された配列Xにm要素のベクトルxが含まれている必要があります。
incx	xの要素の増分値を指定します。incxは、0(ゼロ)以外の値である必要があります。
y	少なくとも次の次元を持つUTL_NLA_ARRAY_FLT/DBL。 ( 1 + ( n - 1 )*abs( incy ) ) 入力する前に、増分された配列Yにm要素のベクトルyが含まれている必要があります。
incy	yの要素の増分値を指定します。incyは、0(ゼロ)以外の値である必要があります。
a	次元(lda, n)を持つUTL_NLA_ARRAY_FLT/DBL。 uplo = 'U'または'u'の場合、配列Aの先頭のn行n列の上三角部分に、対称マトリックスの上三角部分が含まれる必要があります。また、Aの狭義下三角部分は参照されません。終了時、配列Aの上三角部分は、更新されたマトリックスの上三角部分によって上書きされます。 uplo = 'L'または'l'の場合、配列Aの先頭のn行n列の下三角部分に、対称マトリックスの下三角部分が含まれる必要があります。また、Aの狭義上三角部分は参照されません。終了時、配列Aの下三角部分は、更新されたマトリックスの下三角部分によって上書きされます。
lda	コール元の(サブ)プログラムで宣言されているように、aの最初の次元を指定します。ldaは、次の値以上である必要があります。 max( 1, n )
pack	(オプション)マトリックスのパッキングのフラグを設定します。 'C': 列優先(デフォルト) 'R': 行優先

BLAS_SYR2Kプロシージャ

このプロシージャは、次のいずれかの対称ランク2 k演算を実行します。

C := alpha*A*B' + alpha*B*A' + beta*C

または

C := alpha*A'*B + alpha*B'*A + beta*C

ここで、alphaおよびbetaはスカラー、Cはn行n列の対称マトリックス、AおよびBは1番目のケースではn行k列のマトリックス、2番目のケースではk行n列のマトリックスです。

関連項目: このグループの他のサブプログラムについては、「BLASレベル3(マトリックス-マトリックス演算)サブプログラム」を参照してください。

構文

UTL_NLA.BLAS_SYR2K (
   uplo   IN      flag,
   trans  IN      flag,
   n      IN      POSITIVEN,
   k      IN      POSITIVEN,
   alpha  IN      SCALAR_DOUBLE,
   a      IN      UTL_NLA_ARRAY_DBL,
   lda    IN      POSITIVEN,
   b      IN      UTL_NLA_ARRAY_DBL,
   ldb    IN      POSITIVEN,
   beta   IN      SCALAR_DOUBLE,
   c      IN OUT  UTL_NLA_ARRAY_DBL,
   ldc    IN      POSITIVEN,
   pack   IN      flag DEFAULT 'C');

UTL_NLA.BLAS_SYR2K (
   uplo   IN      flag,
   trans  IN      flag,
   n      IN      POSITIVEN,
   k      IN      POSITIVEN,
   alpha  IN      SCALAR_FLOAT,
   a      IN      UTL_NLA_ARRAY_FLT,
   lda    IN      POSITIVEN,
   b      IN OUT  UTL_NLA_ARRAY_FLT,
   ldb    IN      POSITIVEN,
   beta   IN      SCALAR_FLOAT,
   c      IN OUT  UTL_NLA_ARRAY_FLT,
   ldc    IN      POSITIVEN,
   pack   IN      flag DEFAULT 'C');

パラメータ

表259-29 BLAS_SYR2Kプロシージャのパラメータ

パラメータ	説明
uplo	配列Cの上三角または下三角部分を参照するかどうかを指定します。 uplo = 'U'またはuplo = 'u'の場合: Cの上三角部分のみを参照します。 uplo = 'L'またはuplo = 'l'の場合: Cの下三角部分のみを参照します。
trans	実行する演算を指定します。 transが'N'または'n'の場合: C := alpha*A*B' + alpha*B*A' + beta*C transが'T'または't'の場合: C := alpha*A'*B + alpha*B'*A + beta*C transが'C'または'c'の場合: C := alpha*A'*B + alpha*B'*A + beta*C
n	マトリックスCの位数を指定します。nは、0(ゼロ)以上である必要があります。
k	trans = 'N'またはtrans = 'n'の場合、入力時に、kは、マトリックスAおよびマトリックスBの列数を指定します。trans = 'T'または't'あるいはtrans = 'C'または'c'の場合、入力時に、kはマトリックスAおよびBの行数を指定します。kは0 (ゼロ)以上である必要があります。
alpha	SCALAR_FLOAT/DOUBLE。スカラーalphaを指定します。
a	次元(lda,ka)を持つUTL_NLA_ARRAY_FLT/DBL。ここで、kbは、trans = 'N'またはtrans = 'n'の場合はk、それ以外の場合はnです。 trans = 'N'またはtrans = 'n'の場合、入力する前に、配列Aの先頭のn行k列部分にマトリックスAが含まれている必要があります。それ以外の場合は、配列Aの先頭のk行n列部分にマトリックスAが含まれている必要があります。
lda	コール元の(サブ)プログラムで宣言されているように、aの最初の次元を指定します。trans = 'N'または'n'の場合、ldaはmax(1,n)以上である必要があります。それ以外の場合は、ldaはmax(1,k)以上である必要があります。
b	次元(lda,kb)を持つUTL_NLA_ARRAY_FLT/DBL。ここで、kbは、trans = 'N'またはtrans = 'n'の場合はk、それ以外の場合はnです。 trans = 'N'またはtrans = 'n'の場合、入力する前に、配列Bの先頭のn行k列部分にマトリックスBが含まれている必要があります。それ以外の場合は、配列Bの先頭のk行n列部分にマトリックスBが含まれている必要があります。
ldb	コール元の(サブ)プログラムで宣言されているように、bの最初の次元を指定します。trans = 'N'または'n'の場合、ldbはmax (1,n)以上である必要があります。それ以外の場合は、ldbはmax (1,k)以上である必要があります。
beta	SCALAR_FLOAT/DOUBLE。スカラーbetaを指定します。
c	次元(ldc,n)を持つUTL_NLA_ARRAY_FLT/DBL。 uplo = 'U'または'u'の場合、入力する前に、配列Cの先頭のn行n列の上三角部分に、対称マトリックスの上三角部分が含まれる必要があります。また、Cの狭義下三角部分は参照されません。終了時、配列Cの上三角部分は、更新されたマトリックスの上三角部分によって上書きされます。 uplo = 'L'または'l'の場合、入力する前に、配列Cの先頭のn行n列の下三角部分に、対称マトリックスの下三角部分が含まれる必要があります。また、Cの狭義上三角部分は参照されません。終了時、配列Cの下三角部分は、更新されたマトリックスの下三角部分によって上書きされます。
ldc	コール元の(サブ)プログラムで宣言されているように、Cの最初の次元を指定します。ldcは、max(1,n)以上である必要があります。
pack	(オプション)マトリックスのパッキングのフラグを設定します。 'C': 列優先(デフォルト) 'R': 行優先

BLAS_SYRKプロシージャ

このプロシージャは、次のいずれかの対称ランクk演算を実行します。

C := alpha*A*A' + beta*C

または

C := alpha*A'*A + beta*C

ここで、alphaおよびbetaはスカラー、Cはn行n列の対称マトリックス、Aは1番目のケースではn行k列のマトリックス、2番目のケースではk行n列のマトリックスです。

関連項目: このグループの他のサブプログラムについては、「BLASレベル3(マトリックス-マトリックス演算)サブプログラム」を参照してください。

構文

UTL_NLA.BLAS_SYRK (
   uplo   IN      flag,
   trans  IN      flag,
   n      IN      POSITIVEN,
   k      IN      POSITIVEN,
   alpha  IN      SCALAR_DOUBLE,
   a      IN      UTL_NLA_ARRAY_DBL,
   lda    IN      POSITIVEN,
   beta   IN      SCALAR_DOUBLE,
   c      IN OUT  UTL_NLA_ARRAY_DBL,
   ldc    IN      POSITIVEN,
   pack   IN      flag DEFAULT 'C');

UTL_NLA.BLAS_SYRK (
   uplo   IN      flag,
   trans  IN      flag,
   n      IN      POSITIVEN,
   k      IN      POSITIVEN,
   alpha  IN      SCALAR_FLOAT,
   a      IN      UTL_NLA_ARRAY_FLT,
   lda    IN      POSITIVEN,
   beta   IN      SCALAR_FLOAT,
   c      IN OUT  UTL_NLA_ARRAY_DBL,
   ldc    IN      POSITIVEN,
   pack   IN      flag DEFAULT 'C');

パラメータ

表259-30 BLAS_SYRKプロシージャのパラメータ

パラメータ	説明
uplo	配列Cの上三角または下三角部分を参照するかどうかを指定します。 uplo = 'U'またはuplo = 'u'の場合: Cの上三角部分のみを参照します。 uplo = 'L'またはuplo = 'l'の場合: Cの下三角部分のみを参照します。
trans	実行する演算を指定します。 trans = 'N'またはtrans = 'n'の場合: C := alpha*A*A' + beta*C transが'T'またはtransが't'の場合: C := alpha*A'*A + beta*C transが'C'またはtransが'c'の場合: C := alpha*A'*A + beta*C
n	マトリックスCの位数を指定します。nは、0(ゼロ)以上である必要があります。
k	trans = 'N'または'n'の場合、入力時に、kは、マトリックスAの列数を指定します。trans = 'T'または't'あるいはtrans = 'C'または'c'の場合、入力時に、kは、マトリックスAの行数を指定します。kは0 (ゼロ)以上である必要があります。
alpha	SCALAR_FLOAT/DOUBLE。スカラーalphaを指定します。
a	次元(lda,ka)を持つUTL_NLA_ARRAY_FLT/DBL。ここで、kaは、trans = 'N'またはtrans = 'n'の場合はk、それ以外の場合はnです。 trans = 'N'またはtrans = 'n'の場合、入力する前に、配列Aの先頭のn行k列部分にマトリックスAが含まれている必要があります。それ以外の場合は、配列Aの先頭のk行n列部分にマトリックスAが含まれている必要があります。
lda	コール元の(サブ)プログラムで宣言されているように、aの最初の次元を指定します。trans = 'N'または'n'の場合、ldaはmax(1,n)以上である必要があります。それ以外の場合は、ldaはmax(1,k)以上である必要があります。
beta	SCALAR_FLOAT/DOUBLE。スカラーbetaを指定します。
c	次元(ldc,n)を持つUTL_NLA_ARRAY_FLT/DBL。 uplo = 'U'または'u'の場合、入力する前に、配列Cの先頭のn行n列の上三角部分に、対称マトリックスの上三角部分が含まれる必要があります。また、Cの狭義下三角部分は参照されません。終了時、配列Cの上三角部分は、更新されたマトリックスの上三角部分によって上書きされます。 uplo = 'L'または'l'の場合、入力する前に、配列Cの先頭のn行n列の下三角部分に、対称マトリックスの下三角部分が含まれる必要があります。また、Cの狭義上三角部分は参照されません。終了時、配列Cの下三角部分は、更新されたマトリックスの下三角部分によって上書きされます。
ldc	コール元の(サブ)プログラムで宣言されているように、Cの最初の次元を指定します。ldcは、max(1,n)以上である必要があります。
pack	(オプション)マトリックスのパッキングのフラグを設定します。 'C': 列優先(デフォルト) 'R': 行優先

BLAS_TBMVプロシージャ

このプロシージャは、次のマトリックス-ベクトル演算を実行します。

x := A*x

または

x := A'*x

ここで、xはn要素のベクトル、Aは(k+1)個の対角を持つn行n列の単位または単位以外の上三角または下三角バンド・マトリックスです。

関連項目: このグループの他のサブプログラムについては、「BLASレベル2(マトリックス-ベクトル演算)サブプログラム」を参照してください。

構文

UTL_NLA.BLAS_TBMV (
   uplo   IN      flag,
   trans  IN      flag,
   diag   IN      flag,
   n      IN      POSITIVEN,
   k      IN      NATURALN,
   a      IN      UTL_NLA_ARRAY_DBL,
   lda    IN      POSITIVEN,
   x      IN OUT  UTL_NLA_ARRAY_DBL,
   incx   IN      POSITIVEN,
   pack   IN      flag DEFAULT 'C');

UTL_NLA.BLAS_TBMV (
   uplo   IN      flag,
   trans  IN      flag,
   diag   IN      flag,
   n      IN      POSITIVEN,
   k      IN      NATURALN,
   a      IN      UTL_NLA_ARRAY_FLT,
   lda    IN      POSITIVEN,
   x      IN OUT  UTL_NLA_ARRAY_FLT,
   incx   IN      POSITIVEN,
   pack   IN      flag DEFAULT 'C');

パラメータ

表259-31 BLAS_TBMVプロシージャのパラメータ

パラメータ	説明
uplo	マトリックスが上三角マトリックスまたは下三角マトリックスのいずれであるかを指定します。 uplo = 'U'または'u'の場合。Aは上三角マトリックスです。 uplo = 'L'または'l'の場合。Aは下三角マトリックスです。
trans	実行する演算を指定します。 trans = 'N'またはtrans = 'n'の場合: x := A*x trans = 'T'またはtrans = 't'の場合: x := A'*x trans = 'C'またはtrans = 'c'の場合: x := A'*x
diag	Aが単位三角マトリックスであるかどうかを指定します。 diag = 'U'または'u'の場合。Aは単位三角マトリックスであるとみなされます。 diag = 'N'または'n'の場合。Aは単位三角マトリックスであるとはみなされません。
n	マトリックスAの位数を指定します。nは、0(ゼロ)以上である必要があります。
k	Aが単位三角マトリックスであるかどうかを指定します。 uplo = 'U'またはuplo = 'u'の場合、Kは、マトリックスAの上対角の数を指定します。 uplo = 'L'またはuplo = 'l'の場合、Kは、マトリックスAの下対角の数を指定します。 Kは、0 .le. kを満たしている必要があります。
a	次元(lda, n)を持つUTL_NLA_ARRAY_FLT/DBL。 uplo = 'U'または'u'の場合、入力する前に、配列Aの先頭の(k+1)行n列部分に、係数マトリックスの上三角帯部分が列単位で含まれている必要があります。この場合、配列の行(k+1)にマトリックスの先頭の対角、行kに位置2から開始される最初の上対角などが含まれている必要があります。配列Aの左上のk行k列の三角マトリックスは参照されません。 uplo = 'L'または'l'の場合、入力する前に、配列Aの先頭の(k+1)行n列部分に、係数マトリックスの下三角帯部分が列単位で含まれている必要があります。この場合、配列の行1にマトリックスの先頭の対角、行2に位置1から開始している最初の下対角などが含まれている必要があります。配列Aの右下のk行k列の三角マトリックスは参照されません。 diag = 'U'または'u'の場合、マトリックスの対角要素に対応している配列Aの要素は参照されませんが、1であるとみなされることに注意してください。
lda	コール元の(サブ)プログラムで宣言されているように、aの最初の次元を指定します。ldaは、(k+1)以上である必要があります。
x	少なくとも次元(1+(n-1)*abs(incx))を持つUTL_NLA_ARRAY_FLT/DBL。入力する前に、増分された配列Xにn要素のベクトルxが含まれている必要があります。終了時、Xは、変換されたベクトルxによって上書きされます。
incx	xの要素の増分値を指定します。0(ゼロ)以外の値である必要があります。
pack	(オプション)マトリックスのパッキングのフラグを設定します。 'C': 列優先(デフォルト) 'R': 行優先

BLAS_TBSVプロシージャ

このプロシージャは、次のいずれかの連立方程式の解を求めます。

A*x = b

または

A'*x = b

ここで、bおよびxはn要素のベクトル、Aは(k+1)個の対角を持つn行n列の単位または単位以外の上三角または下三角バンド・マトリックスです。

関連項目: このグループの他のサブプログラムについては、「BLASレベル2(マトリックス-ベクトル演算)サブプログラム」を参照してください。

構文

UTL_NLA.BLAS_TBSV (
   uplo   IN      flag,
   trans  IN      flag,
   diag   IN      flag,
   n      IN      POSITIVEN,
   k      IN      NATURALN,
   a      IN      UTL_NLA_ARRAY_DBL,
   lda    IN      POSITIVEN,
   x      IN OUT  UTL_NLA_ARRAY_DBL,
   incx   IN      POSITIVEN,
   pack   IN      flag DEFAULT 'C');

UTL_NLA.BLAS_STBSV (
   uplo   IN      flag,
   trans  IN      flag,
   diag   IN      flag,
   n      IN      POSITIVEN,
   k      IN      NATURALN,
   a      IN      UTL_NLA_ARRAY_FLT,
   lda    IN      POSITIVEN,
   x      IN OUT  UTL_NLA_ARRAY_FLT,
   incx   IN      POSITIVEN,
   pack   IN      flag DEFAULT 'C');

パラメータ

表259-32 BLAS_TBSVプロシージャのパラメータ

パラメータ	説明
uplo	マトリックスが上三角マトリックスまたは下三角マトリックスのいずれであるかを指定します。 uplo = 'U'または'u'の場合。Aは上三角マトリックスです。 uplo = 'L'または'l'の場合。Aは下三角マトリックスです。
trans	解を求める方程式を指定します。 trans = 'N'またはtrans = 'n'の場合: A*x = b trans = 'T'またはtrans = 't'の場合: A'*x = b trans = 'C'またはtrans = 'c'の場合: A'*x = b
diag	Aが単位三角マトリックスであるかどうかを指定します。 diag = 'U'またはdiag = 'u'の場合: Aは単位三角マトリックスであるとみなされます。 diag = 'N'またはdiag = 'n'の場合: Aは単位三角マトリックスではないとみなされます。
n	マトリックスAの位数を指定します。nは、0(ゼロ)以上である必要があります。
k	Aが単位三角マトリックスであるかどうかを指定します。 uplo = 'U'またはuplo = 'u'の場合、Kは、マトリックスAの上対角の数を指定します。 uplo = 'L'またはuplo = 'l'の場合、Kは、マトリックスAの下対角の数を指定します。 Kは、0 .le. kを満たしている必要があります。
a	次元(lda,n)を持つUTL_NLA_ARRAY_FLT/DBL。 uplo = 'U'または'u'の場合、入力する前に、配列Aの先頭の(k+1)行n列部分に、係数マトリックスの上三角帯部分が列単位で含まれている必要があります。この場合、配列の行(k+1)にマトリックスの先頭の対角、行kに位置2から開始している最初の上対角などが含まれている必要があります。配列Aの左上のk行k列の三角マトリックスは参照されません。 uplo = 'L'または'l'の場合、入力する前に、配列Aの先頭の(k+1)行n列部分に、係数マトリックスの下三角帯部分が列単位で含まれている必要があります。この場合、配列の行1にマトリックスの先頭の対角、行2に位置1から開始している最初の下対角などが含まれている必要があります。配列Aの右下のk行k列の三角マトリックスは参照されません。 diag = 'U'またはdiag = 'u'の場合、マトリックスの対角要素に対応している配列Aの要素は参照されませんが、1であるとみなされることに注意してください。
lda	入力時に、ldaは、コール元の(サブ)プログラムで宣言されているように、Aの最初の次元を指定します。ldaは、(k+1)以上である必要があります。
x	少なくとも次の次元を持つUTL_NLA_ARRAY_FLT/DBL。 ( 1 + ( n - 1 ) *abs( incx ) ) 入力する前に、増分された配列Xにn要素の右辺ベクトルbが含まれている必要があります。 終了時、Xは、解ベクトルxによって上書きされます。
incx	xの要素の増分値を指定します。incxは、0(ゼロ)以外の値である必要があります。
pack	(オプション)マトリックスのパッキングのフラグを設定します。 'C': 列優先(デフォルト) 'R': 行優先

使用上の注意

このルーチンには、特異点または特異点近傍に対するテストは含まれていません。このようなテストは、このルーチンをコールする前に実行する必要があります。

BLAS_TPMVプロシージャ

このプロシージャは、次のマトリックス-ベクトル演算を実行します。

x := A*x

または

x := A'*x

ここで、xはn要素のベクトル、Aはパックされた形式のn行n列の単位または単位以外の上三角または下三角マトリックスです。

関連項目: このグループの他のサブプログラムについては、「BLASレベル2(マトリックス-ベクトル演算)サブプログラム」を参照してください。

構文

UTL_NLA.BLAS_TPMV (
   uplo   IN      flag,
   trans  IN      flag,
   diag   IN      flag,
   n      IN      POSITIVEN,
   ap     IN      UTL_NLA_ARRAY_DBL,
   x      IN OUT  UTL_NLA_ARRAY_DBL,
   incx   IN      POSITIVEN,
   pack   IN      flag DEFAULT 'C');

UTL_NLA.BLAS_TBMV (
   uplo   IN      flag,
   trans  IN      flag,
   diag   IN      flag,
   n      IN      POSITIVEN,
   ap     IN      UTL_NLA_ARRAY_FLT,
   x      IN OUT  UTL_NLA_ARRAY_FLT,
   incx   IN      POSITIVEN,
   pack   IN      flag DEFAULT 'C');

パラメータ

表259-33 BLAS_TPMVプロシージャのパラメータ

パラメータ	説明
uplo	マトリックスが上三角マトリックスまたは下三角マトリックスのいずれであるかを指定します。 uplo = 'U'または'u'の場合。Aは上三角マトリックスです。 uplo = 'L'または'l'の場合。Aは下三角マトリックスです。
trans	実行する演算を指定します。 trans = 'N'または'n'の場合: x := A*x trans = 'T'またはtrans = 't'の場合: x := A'*x trans = 'C'またはtrans = 'c'の場合: x := A'*x
diag	Aが単位三角マトリックスであるかどうかを指定します。 diag = 'U'または'u'の場合。Aは単位三角マトリックスであるとみなされます。 diag = 'N'または'n'の場合。Aは単位三角マトリックスであるとはみなされません。
n	マトリックスAの位数を指定します。nは、0(ゼロ)以上である必要があります。
ap	次元(lda,n)を持つUTL_NLA_ARRAY_FLT/DBL。 uplo = 'U'または'u'の場合、入力する前に、配列Aの先頭の(k+1)行n列部分に、係数マトリックスの上三角帯部分が列単位で含まれている必要があります。この場合、配列の行(k+1)にマトリックスの先頭の対角、行kに位置2から開始している最初の上対角などが含まれている必要があります。配列Aの左上のk行k列の三角マトリックスは参照されません。 uplo = 'L'または'l'の場合、入力する前に、配列Aの先頭の(k+1)行n列部分に、係数マトリックスの下三角帯部分が列単位で含まれている必要があります。この場合、配列の行1にマトリックスの先頭の対角、行2に位置1から開始している最初の下対角などが含まれている必要があります。配列Aの右下のk行k列の三角マトリックスは参照されません。 diag = 'U'またはdiag = 'u'の場合、マトリックスの対角要素に対応している配列Aの要素は参照されませんが、1であるとみなされることに注意してください。
x	少なくとも次元(1+(n-1)*abs(incx))を持つUTL_NLA_ARRAY_FLT/DBL。入力する前に、増分された配列Xにn要素のベクトルxが含まれている必要があります。終了時、Xは、変換されたベクトルxによって上書きされます。
incx	xの要素の増分値を指定します。0(ゼロ)以外の値である必要があります。
pack	(オプション)マトリックスのパッキングのフラグを設定します。 'C': 列優先(デフォルト) 'R': 行優先

BLAS_TPSVプロシージャ

このプロシージャは、次のいずれかの連立方程式の解を求めます。

A*x = b

または

A'*x = b

ここで、bおよびxはn要素のベクトル、Aはパックされた形式のn行n列の単位または単位以外の上三角または下三角マトリックスです。

関連項目: このグループの他のサブプログラムについては、「BLASレベル2(マトリックス-ベクトル演算)サブプログラム」を参照してください。

構文

UTL_NLA.BLAS_TPSV (
   uplo   IN      flag,
   trans  IN      flag,
   diag   IN      flag,
   n      IN      POSITIVEN,
   ap     IN      UTL_NLA_ARRAY_DBL,
   x      IN OUT  UTL_NLA_ARRAY_DBL,
   incx   IN      POSITIVEN,
   pack   IN      flag DEFAULT 'C');

UTL_NLA.BLAS_TPSV (
   uplo   IN      flag,
   trans  IN      flag,
   diag   IN      flag,
   n      IN      POSITIVEN,
   ap     IN      UTL_NLA_ARRAY_FLT,
   x      IN OUT  UTL_NLA_ARRAY_FLT,
   incx   IN      POSITIVEN,
   pack   IN      flag DEFAULT 'C');

パラメータ

表259-34 BLAS_TPSVプロシージャのパラメータ

パラメータ	説明
uplo	マトリックスが上三角マトリックスまたは下三角マトリックスのいずれであるかを指定します。 uplo = 'U'またはuplo = 'u'の場合: Aは上三角マトリックスであるとみなされます。 uplo = 'L'またはuplo = 'l'の場合: Aは下三角マトリックスであるとみなされます。
trans	実行する演算を指定します。 trans = 'N'または'n'の場合: A*x = b trans = 'T'または't'の場合: A'*x = b trans = 'C'または'c'の場合: A'*x = b
diag	Aが単位三角マトリックスであるかどうかを指定します。 diag = 'U'または'u'の場合: Aは単位三角マトリックスであるとみなされます。 diag = 'N'または'n'の場合: Aは単位三角マトリックスではないとみなされます。
n	マトリックスAの位数を指定します。nは、0(ゼロ)以上である必要があります。
ap	少なくとも次の次元を持つUTL_NLA_ARRAY_FLT/DBL。 ((n*(n+1))/2) uplo = 'U'または'u'の場合、入力する前に、配列apに、順番にパックされた上三角マトリックスが列単位で含まれている必要があります。これによって、ap(1)にa(1,1)、ap(2)にa(1,2)、ap(3)にa(2,2)がそれぞれ含まれます。 uplo = 'L'または'l'の場合、入力する前に、配列apに、順番にパックされた下三角マトリックスが列単位で含まれている必要があります。これによって、ap(1)にa(1,1)、ap(2)にa(2,1)、ap(3)にa(3,1)がそれぞれ含まれます。 diag = 'U'または'u'の場合、Aの対角要素は参照されませんが、1であるとみなされることに注意してください。
x	少なくとも次の次元を持つUTL_NLA_ARRAY_FLT/DBL。 ( 1 + ( n - 1 ) *abs( incx ) ) 入力する前に、増分された配列Xにn要素の右辺ベクトルbが含まれている必要があります。終了時、Xは、解ベクトルxによって上書きされます。
incx	xの要素の増分値を指定します。incxは、0(ゼロ)以外の値である必要があります。
pack	(オプション)マトリックスのパッキングのフラグを設定します。 'C': 列優先(デフォルト) 'R': 行優先

使用上の注意

このルーチンには、特異点または特異点近傍に対するテストは含まれていません。このようなテストは、このルーチンをコールする前に実行する必要があります。

BLAS_TRMMプロシージャ

このプロシージャは、次のマトリックス-マトリックス演算を実行します。

B := alpha*op( A )*B

または

B := alpha*B*op( A )

ここで、alphaはスカラー、Bはm行n列のマトリックス、Aは単位または単位以外の上三角または下三角マトリックス、op(A)は次のいずれかです。

op( A ) = A

または

op( A ) = A'

関連項目: このグループの他のサブプログラムについては、「BLASレベル3(マトリックス-マトリックス演算)サブプログラム」を参照してください。

構文

UTL_NLA.BLAS_TRMM (
   side   IN      flag,
   uplo   IN      flag,
   transa IN      flag,
   diag   IN      flag,
   m      IN      POSITIVEN,
   n      IN      POSITIVEN,
   alpha  IN      SCALAR_DOUBLE,
   a      IN      UTL_NLA_ARRAY_DBL,
   lda    IN      POSITIVEN,
   b      IN OUT  UTL_NLA_ARRAY_DBL,
   ldb    IN      POSITIVEN,
   pack   IN      flag DEFAULT 'C');

UTL_NLA.BLAS_TRMM (
   side   IN      flag,
   uplo   IN      flag,
   transa IN      flag,
   diag   IN      flag,
   m      IN      POSITIVEN,
   n      IN      POSITIVEN,
   alpha  IN      SCALAR_FLOAT,
   a      IN      UTL_NLA_ARRAY_FLT,
   lda    IN      POSITIVEN,
   b      IN OUT  UTL_NLA_ARRAY_FLT,
   ldb    IN      POSITIVEN,
   pack   IN      flag DEFAULT 'C');

パラメータ

表259-35 BLAS_TRMMプロシージャのパラメータ

パラメータ	説明
side	対称マトリックスAが演算の左側または右側のいずれに使用されるかを指定します。 side = 'L'または'l'の場合: B := alpha*op(A)*B side = 'R'または'r'の場合: B := alpha*B*op(A)
uplo	配列Aの上三角または下三角部分を参照するかどうかを指定します。 uplo = 'U'またはuplo = 'u'の場合: Aは上三角マトリックスであるとみなされます。 uplo = 'L'または'l'の場合: Aは下三角マトリックスです。
transa	マトリックス乗算で使用するop(A)の形式を次のように指定します。 transa = 'N'またはtransa = 'n'の場合: op(A) = A transa = 'T'または't'の場合: op(A) = A' transa = 'C'または'c'の場合: op(A) = A'
diag	Aが単位三角マトリックスであるかどうかを指定します。 diag = 'U'または'u'の場合。Aは単位三角マトリックスであるとみなされます。 diag = 'N'または'n'の場合。Aは単位三角マトリックスであるとはみなされません。
m	Bの行数を指定します。mは、0(ゼロ)以上である必要があります。
n	Bの列数を指定します。nは、0(ゼロ)以上である必要があります。
alpha	SCALAR_FLOAT/DOUBLE。スカラーalphaを指定します。alphaが0(ゼロ)の場合、Aは参照されず、入力する前にBを設定する必要はありません。
a	次元(lda,k)を持つUTL_NLA_ARRAY_FLT/DBL。ここで、kは、side = 'L'または'l'の場合はm、side = 'R'または'r'の場合はnです。 uplo = 'U'または'u'の場合、入力する前に、配列Aの先頭のk行k列の上三角部分に上三角マトリックスが含まれる必要があります。また、Aの狭義下三角部分は参照されません。 uplo = 'L'または'l'の場合、入力する前に、配列Aの先頭のk行k列の下三角部分に下三角マトリックスが含まれる必要があります。また、Aの狭義上三角部分は参照されません。 diag = 'U'または'u'の場合、Aの対角要素は参照されませんが、1であるとみなされることに注意してください。
lda	コール元の(サブ)プログラムで宣言されているように、aの最初の次元を指定します。side = 'L'または'l'の場合、ldaはmax(1,m)以上である必要があります。それ以外の場合、ldaはmax(1,n)以上である必要があります。
b	次元(ldb,n)を持つUTL_NLA_ARRAY_FLT/DBL。 入力する前に、配列Bの先頭のm行n列部分にマトリックスBが含まれている必要があります。終了時、この部分は、変換されたマトリックスによって上書きされます。
ldb	コール元の(サブ)プログラムで宣言されているように、bの最初の次元を指定します。ldbは、max(1,m)以上である必要があります。
pack	(オプション)マトリックスのパッキングのフラグを設定します。 'C': 列優先(デフォルト) 'R': 行優先

BLAS_TRMVプロシージャ

このプロシージャは、次のマトリックス-ベクトル演算を実行します。

x := A*x

または

x := A'*x

ここで、xはn要素のベクトル、Aはn行n列の単位または単位以外の上三角または下三角マトリックスです。

関連項目: このグループの他のサブプログラムについては、「BLASレベル2(マトリックス-ベクトル演算)サブプログラム」を参照してください。

構文

UTL_NLA.BLAS_TRMV (
   uplo   IN      flag,
   trans  IN      flag,
   diag   IN      flag,
   n      IN      POSITIVEN,
   a      IN      UTL_NLA_ARRAY_DBL,
   lda    IN      POSITIVEN,
   x      IN OUT  UTL_NLA_ARRAY_DBL,
   incx   IN      POSITIVEN,
   pack   IN      flag DEFAULT 'C');

UTL_NLA.BLAS_TRMV (
   uplo   IN      flag,
   trans  IN      flag,
   diag   IN      flag,
   n      IN      POSITIVEN,
   a      IN      UTL_NLA_ARRAY_FLT,
   lda    IN      POSITIVEN,
   x      IN OUT  UTL_NLA_ARRAY_FLT,
   incx   IN      POSITIVEN,
   pack   IN      flag DEFAULT 'C');

パラメータ

表259-36 BLAS_TRMVプロシージャのパラメータ

パラメータ	説明
uplo	マトリックスが上三角マトリックスまたは下三角マトリックスのいずれであるかを指定します。 uplo = 'U'または'u'の場合。Aは上三角マトリックスです。 uplo = 'L'または'l'の場合。Aは下三角マトリックスです。
trans	実行する演算を指定します。 trans = 'N'またはtrans = 'n'の場合: x := A*x trans = 'T'または't'の場合: x := A'*x trans = 'C'またはtrans = 'c'の場合: x := A'*x
diag	Aが単位三角マトリックスであるかどうかを指定します。 diag = 'U'または'u'の場合。Aは単位三角マトリックスであるとみなされます。 diag = 'N'または'n'の場合。Aは単位三角マトリックスであるとはみなされません。
n	マトリックスAの位数を指定します。nは、0(ゼロ)以上である必要があります。
a	次元(lda, n)を持つUTL_NLA_ARRAY_FLT/DBL。 uplo = 'U'またはuplo = 'u'の場合、入力する前に、配列Aの先頭のn行n列の上三角部分に上三角マトリックスが含まれる必要があります。また、Aの狭義下三角部分は参照されません。 uplo = 'L'またはuplo = 'l'の場合、入力する前に、配列Aの先頭のn行n列の下三角部分に下三角マトリックスが含まれる必要があります。また、Aの狭義上三角部分は参照されません。 diag = 'U'または'u'の場合、Aの対角要素は参照されませんが、1であるとみなされることに注意してください。
lda	コール元の(サブ)プログラムで宣言されているように、aの最初の次元を指定します。ldaはmax(1, n)以上である必要があります。
x	少なくとも次元(1+(n-1)*as(incx))を持つUTL_NLA_ARRAY_FLT/DBL。入力する前に、増分された配列Xにn要素のベクトルxが含まれている必要があります。
incx	xの要素の増分値を指定します。0(ゼロ)以外の値である必要があります。
pack	(オプション)マトリックスのパッキングのフラグを設定します。 'C': 列優先(デフォルト) 'R': 行優先

BLAS_TRSMプロシージャ

このプロシージャは、次のマトリックス-マトリックス演算を実行します。

op( A )*X = alpha*B

または

X*op( A ) = alpha*B

ここで、alphaはスカラー、XおよびBはm行n列のマトリックス、Aは単位または単位以外の上三角または下三角マトリックス、op(A)は次のいずれかです。

op( A ) = A

または

op( A ) = A'

マトリックスXは、Bに上書きされます。

関連項目: このグループの他のサブプログラムについては、「BLASレベル3(マトリックス-マトリックス演算)サブプログラム」を参照してください。

構文

UTL_NLA.BLAS_TRSM (
   side   IN      flag,
   uplo   IN      flag,
   transa IN      flag,
   diag   IN      flag,
   m      IN      POSITIVEN,
   n      IN      POSITIVEN,
   alpha  IN      SCALAR_DOUBLE,
   a      IN      UTL_NLA_ARRAY_DBL,
   lda    IN      POSITIVEN,
   b      IN OUT  UTL_NLA_ARRAY_DBL,
   ldb    IN      POSITIVEN,
   pack   IN      flag DEFAULT 'C');

UTL_NLA.BLAS_TRSM (
   side   IN      flag,
   uplo   IN      flag,
   transa IN      flag,
   diag   IN      flag,
   m      IN      POSITIVEN,
   n      IN      POSITIVEN,
   alpha  IN      SCALAR_FLOAT,
   a      IN      UTL_NLA_ARRAY_FLT,
   lda    IN      POSITIVEN,
   b      IN OUT  UTL_NLA_ARRAY_FLT,
   ldb    IN      POSITIVEN,
   pack   IN      flag DEFAULT 'C');

パラメータ

表259-37 BLAS_TRSMプロシージャのパラメータ

パラメータ	説明
side	対称マトリックスAが演算の左側または右側のいずれに使用されるかを指定します。 side = 'L'または'l'の場合: op(A)*X = alpha*B side = 'R'または'r'の場合: X*op(A) = alpha*B
uplo	配列Aの上三角または下三角部分を参照するかどうかを指定します。 uplo = 'U'またはuplo = 'u'の場合: Aは上三角マトリックスであるとみなされます。 uplo = 'L'またはuplo = 'l'の場合: Aは下三角マトリックスであるとみなされます。
transa	マトリックス乗算で使用するop(A)の形式を次のように指定します。 transa = 'N'またはtransa = 'n'の場合: op(A) = A transa = 'T'または't'の場合: op(A) = A' transa = 'C'または'c'の場合: op(A) = A'
diag	Aが単位三角マトリックスであるかどうかを指定します。 diag = 'U'または'u'の場合。Aは単位三角マトリックスであるとみなされます。 diag = 'N'または'n'の場合。Aは単位三角マトリックスであるとはみなされません。
m	Bの行数を指定します。mは、0(ゼロ)以上である必要があります。
n	Bの列数を指定します。nは、0(ゼロ)以上である必要があります。
alpha	SCALAR_FLOAT/DOUBLE。スカラーalphaを指定します。alphaが0(ゼロ)の場合、Aは参照されず、入力する前にBを設定する必要はありません。
a	次元(lda, k)を持つUTL_NLA_ARRAY_FLT/DBL。kは、side = 'L'または'l'の場合はm、side = 'R'または'r'の場合はnです。 uplo = 'U'または'u'の場合、入力する前に、配列Aの先頭のk行k列の上三角部分に上三角マトリックスが含まれる必要があります。また、Aの狭義下三角部分は参照されません。 uplo = 'L'または'l'の場合、入力する前に、配列Aの先頭のk行k列の下三角部分に下三角マトリックスが含まれる必要があります。また、Aの狭義上三角部分は参照されません。 diag = ''U'またはdiag = 'u'の場合、Aの対角要素は参照されませんが、1であるとみなされることに注意してください。
lda	コール元の(サブ)プログラムで宣言されているように、aの最初の次元を指定します。side = 'L'または'l'の場合、ldaはmax(1, m)以上である必要があります。それ以外の場合、ldaはmax (1, n)以上である必要があります。
b	次元(ldb, n)を持つUTL_NLA_ARRAY_FLT/DBL。 入力する前に、配列Bの先頭のm行n列部分にマトリックスBが含まれている必要があります。終了時、この部分は、解マトリックスXによって上書きされます。
ldb	コール元の(サブ)プログラムで宣言されているように、bの最初の次元を指定します。ldbは、max(1, m)以上である必要があります。
pack	(オプション)マトリックスのパッキングのフラグを設定します。 'C': 列優先(デフォルト) 'R': 行優先

BLAS_TRSVプロシージャ

このプロシージャは、次のいずれかの連立方程式の解を求めます。

A*x = b

または

A'*x = b

ここで、bおよびxはn要素のベクトル、Aはn行n列の単位または単位以外の上三角または下三角マトリックスです。

関連項目: このグループの他のサブプログラムについては、「BLASレベル2(マトリックス-ベクトル演算)サブプログラム」を参照してください。

構文

UTL_NLA.BLAS_TRSV (
   uplo   IN      flag,
   trans  IN      flag,
   diag   IN      flag,
   n      IN      POSITIVEN,
   a      IN      UTL_NLA_ARRAY_DBL,
   lda    IN      POSITIVEN,
   x      IN OUT  UTL_NLA_ARRAY_DBL,
   incx   IN      POSITIVEN,
   pack   IN      flag DEFAULT 'C');

UTL_NLA.BLAS_TRSV (
   uplo   IN      flag,
   trans  IN      flag,
   diag   IN      flag,
   n      IN      POSITIVEN,
   a      IN      UTL_NLA_ARRAY_FLT,
   lda    IN      POSITIVEN,
   x      IN OUT  UTL_NLA_ARRAY_FLT,
   incx   IN      POSITIVEN,
   pack   IN      flag DEFAULT 'C');

パラメータ

表259-38 BLAS_TRSVプロシージャのパラメータ

パラメータ	説明
uplo	マトリックスが上三角マトリックスまたは下三角マトリックスのいずれであるかを指定します。 uplo = 'U'または'u'の場合。Aは上三角マトリックスです。 uplo = 'L'または'l'の場合。Aは下三角マトリックスです。
trans	実行する演算を指定します。 trans = 'N'または'n'の場合: A*x = b trans = 'T'または't'の場合: A'*x = b trans = 'C'または'c'の場合: A'*x = b
diag	Aが単位三角マトリックスであるかどうかを指定します。 diag = 'U'または'u'の場合。Aは単位三角マトリックスであるとみなされます。 diag = 'N'または'n'の場合。Aは単位三角マトリックスであるとはみなされません。
n	マトリックスAの位数を指定します。nは、0(ゼロ)以上である必要があります。
a	次元(lda, n)を持つUTL_NLA_ARRAY_FLT/DBL。 uplo = 'U'またはuplo = 'u'の場合、入力する前に、配列Aの先頭のn行n列の上三角部分に上三角マトリックスが含まれる必要があります。また、Aの狭義下三角部分は参照されません。 uplo = 'L'またはuplo = 'l'の場合、入力する前に、配列Aの先頭のn行n列の下三角部分に下三角マトリックスが含まれる必要があります。また、Aの狭義上三角部分は参照されません。 diag = ''U'またはdiag = 'u'の場合、Aの対角要素は参照されませんが、1であるとみなされることに注意してください。
lda	コール元の(サブ)プログラムで宣言されているように、Aの最初の次元を指定します。ldaは、max(1, n)以上である必要があります。
x	少なくとも次の次元を持つUTL_NLA_ARRAY_FLT/DBL。 (1 + (n - 1) * abs (incx)) 入力する前に、増分された配列Xにn要素の右辺ベクトルbが含まれている必要があります。終了時、Xは、解ベクトルxによって上書きされます。
incx	xの要素の増分値を指定します。0(ゼロ)以外の値である必要があります。
pack	(オプション)マトリックスのパッキングのフラグを設定します。 'C': 列優先(デフォルト) 'R': 行優先

使用上の注意

このルーチンには、特異点または特異点近傍に対するテストは含まれていません。このようなテストは、このルーチンをコールする前に実行する必要があります。

LAPACK_GBSVプロシージャ

このプロシージャは、実連立一次方程式の解を求めます。

a * x = b

ここで、aはkl個の下対角およびku個の上対角を持つn位のバンド・マトリックス、xおよびbはn行nrhs列のマトリックスです。

Aの分解には、部分ピボットおよび行交換を使用したLU分解が次のように使用されます。

a = L * U

ここで、Lは順列とkl個の下対角を持つ単位下三角マトリックスの積、Uはkl+ku個の上対角を持つ上三角マトリックスです。aの分解された形式を使用して、連立方程式の解が求められます。

a * x = b

関連項目: このグループの他のサブプログラムについては、「LAPACKドライバ・ルーチン(一次方程式)サブプログラム」を参照してください。

構文

UTL_NLA.LAPACK_GBSV (
   n      IN      POSITIVEN,
   kl     IN      NATURALN,
   ku     IN      NATURALN,
   nrhs   IN      POSITIVEN,
   ab     IN OUT  UTL_NLA_ARRAY_DBL,
   ldab   IN      POSITIVEN,
   ipiv   IN OUT  UTL_NLA_ARRAY_INT,
   b      IN OUT  UTL_NLA_ARRAY_DBL,
   ldb    IN      POSITIVEN,
   info   OUT  INTEGER,
   pack   IN      flag DEFAULT 'C');

UTL_NLA.LAPACK_GBSV (
   n      IN      POSITIVEN,
   kl     IN      NATURALN,
   ku     IN      NATURALN,
   nrhs   IN      POSITIVEN,
   ab     IN OUT  UTL_NLA_ARRAY_FLT,
   ldab   IN      POSITIVEN,
   ipiv   IN OUT  UTL_NLA_ARRAY_INT,
   b      IN OUT  UTL_NLA_ARRAY_FLT,
   ldb    IN      POSITIVEN,
   info   OUT  INTEGER,
   pack   IN      flag DEFAULT 'C');

パラメータ

表259-39 LAPACK_GBSVプロシージャのパラメータ

パラメータ	説明
n	一次方程式の数(マトリックスaの位数と同じ)。n >= 0。
kl	aのバンド内の下対角の数。kl >= 0。
ku	aのバンド内の上対角の数。ku >= 0。
nrhs	右辺の数(マトリックスbの列数)。nrhs >= 0。
ab	次元(ldab, n)を持つUTL_NLA_ARRAY_FLT/DBL。 入力時は、バンド・ストレージの行kl+1から2*kl+ku+1のマトリックスaです。配列の行1からklは、設定する必要がありません。Aのj番目の列は、配列abのj番目の列に格納されます。 max(1,j-ku)<=i<=min(n,j+kl)の場合: ab(kl+ku+1+i-j,j) = a(i,j) 終了時は、分解の詳細です。Uは上三角バンド・マトリックスとして格納されます。行1からKL+KU+1にkl+ku個の上対角が格納され、分解で使用された乗数が次の行に格納されます。 kl+ku+2から2*kl+ku+1
ldab	配列abの先頭の次元。 ldab >= 2*kl+ku+1
ipiv	次元(n)を持つINTEGER配列。 順列マトリックスPを定義するピボット・インデックス。マトリックスの行iは、行ipiv(i)と交換されました。
b	次元(ldb, nrhs)を持つUTL_NLA_ARRAY_FLT/DBL。 入力時は、右辺マトリックスbのn行nrhs列のマトリックスです。 終了時、info = 0の場合は、n行nrhs列の解マトリックスXです。
ldb	配列bの先頭の次元。 ldb >= max(1,n)
info	= 0: 正常終了 < 0: info = -iの場合、i番目の引数に無効な値が含まれています。 > 0: info = iの場合、U(i,i)は正確に0(ゼロ)になります。分解は完了しましたが、係数Uは真性特異点であるため、解は得られていません。
pack	(オプション)マトリックスのパッキングのフラグを設定します。 'C': 列優先(デフォルト) 'R': 行優先

LAPACK_GEESプロシージャ

このプロシージャは、n行n列の実非対称マトリックスA、固有値、実Schur形式TおよびオプションでSchurベクトルのマトリックスZを計算します。これによって、Schur分解A = Z*T*(Z**T)が実行されます。

マトリックスは、1行1列および2行2列のブロックを持つ上準三角の場合は実Schur形式になります。2行2列のブロックは、次の形式で標準化されます。

[ a b ]

[ c a ]

ここで、b*c < 0です。このようなブロックの固有値は、a +- sqrt(bc)です。

関連項目: このグループの他のサブプログラムについては、「LAPACKドライバ・ルーチン(LLSおよび固有値問題)サブプログラム」を参照してください。

構文

UTL_NLA.LAPACK_GEES (
   jobvs   IN       flag,
   n       IN       POSITIVEN,
   a       IN  OUT  UTL_NLA_ARRAY_DBL,
   lda     IN       POSITIVEN,
   wr      IN OUT   UTL_NLA_ARRAY_DBL,
   wi      IN OUT   UTL_NLA_ARRAY_DBL,
   vs      IN OUT   UTL_NLA_ARRAY_DBL,
   ldvs    IN       POSITIVEN,
   info    OUT      INTEGER,
   pack    IN       flag DEFAULT 'C');

UTL_NLA.LAPACK_GEES (
   jobvs   IN       flag,
   n       IN       POSITIVEN,
   a       IN OUT   UTL_NLA_ARRAY_FLT,
   lda     IN       POSITIVEN,
   wr      IN       OUT UTL_NLA_ARRAY_FLT,
   wi      IN       OUT UTL_NLA_ARRAY_FLT,
   vs      IN OUT   UTL_NLA_ARRAY_FLT,
   ldvs    IN       POSITIVEN,
   info    OUT      integer,
   pack    IN       flag DEFAULT 'C');

パラメータ

表259-40 LAPACK_GEESプロシージャのパラメータ

パラメータ	説明
jobz	'N': Schurベクトルが計算されません。 'V': Schurベクトルが計算されます。
n	マトリックスaの位数。N >= 0。
a	次元(lda, n)を持つUTL_NLA_ARRAY_FLT/DBL。 入力時は、n行n列のマトリックスAです。 終了時、Aは、その実Schur形式Tによって上書きされます。
lda	配列aの先頭の次元。lda >= max(1,n)。
wr	次元(n)を持つUTL_NLA_ARRAY_FLT/DBL。 wrおよびwiには、それぞれ計算済固有値の実部および虚部が、出力Schur形式Tの対角に現れる順序と同じ順序で含まれます。正の虚部を持つ固有値に続いて、固有値の複素共役対が表示されます。
wi	次元(ldz, n)を持つUTL_NLA_ARRAY_FLT/DBL。 wrおよびwiには、それぞれ計算済固有値の実部および虚部が、出力Schur形式Tの対角に現れる順序と同じ順序で含まれます。正の虚部を持つ固有値に続いて、固有値の複素共役対が表示されます。
vs	次元(n)を持つUTL_NLA_ARRAY_FLT/DBL。 jobvs = 'V'の場合、vsにはSchurベクトルの直交マトリックスZが含まれます。 jobvs = 'N'の場合、vsは参照されません。
ldvs	配列vsの先頭の次元。VS. ldvs >= 1。jobvs = 'V'の場合、ldvs >= Nです。
info	= 0: 正常終了 < 0: info = -iの場合、i番目の引数に無効な値が含まれています。 > 0: info = iで、iが<= Nの場合、QRアルゴリズムはすべての固有値の計算に失敗します。wrおよびwiの要素1:ILO-1およびi+1:Nには、これらの収束した固有値が含まれます。jobvs = 'V'の場合、vsには、Aを部分的に収束されたSchur形式に換算するマトリックスが含まれます。
pack	(オプション)マトリックスのパッキングのフラグを設定します。 'C': 列優先(デフォルト) 'R': 行優先

LAPACK_GELSプロシージャ

このプロシージャは、AのQRまたはLQ分解を使用して、m行n列マトリックスA、またはこのマトリックスの転置マトリックスが含まれる過剰決定または過小決定の実連立一次方程式の解を求めます。Aに最大階数が含まれていることを前提とします。

次のオプションがあります。

1. TRANS = 'N'およびm >= nの場合は、過剰決定連立方程式の最小二乗解を求めます。つまり、最小二乗問題を解きます。

   minimize || B - A*X ||
   

2. TRANS = 'N'およびm < nの場合は、過小決定連立方程式A * X = Bの最小ノルム解を求めます。

3. TRANS = 'T'およびm > nの場合は、過小決定連立方程式A**T * X = Bの最小ノルム解を求めます。

4. TRANS = 'T'およびm < nの場合は、過剰決定連立方程式の最小二乗解を求めます。つまり、最小二乗問題minimize || B - A**T * X ||を解きます。

関連項目: このグループの他のサブプログラムについては、「LAPACKドライバ・ルーチン(LLSおよび固有値問題)サブプログラム」を参照してください。

構文

UTL_NLA.LAPACK_GELS (
   trans   IN       flag,
   m       IN       POSITIVEN,
   n       IN       POSITIVEN,
   nrhs    IN       POSITIVEN,
   a       IN OUT   UTL_NLA_ARRAY_DBL,
   lda     IN       POSITIVEN,
   b       IN OUT   UTL_NLA_ARRAY_DBL,
   ldb     IN       POSITIVEN,
   info    OUT      INTEGER,
   pack    IN       flag DEFAULT 'C');

UTL_NLA.LAPACK_GELS (
  trans    IN       flag,
  m        IN       POSITIVEN,
  n        IN       POSITIVEN,
  nrhs     IN       POSITIVEN,
  a        IN OUT   UTL_NLA_ARRAY_FLT,
  lda      IN       POSITIVEN,
  b        IN OUT   UTL_NLA_ARRAY_FLT,
  ldb      IN       POSITIVEN,
  info     OUT      INTEGER,
  pack     IN       flag DEFAULT 'C');

パラメータ

表259-41 LAPACK_GELSプロシージャのパラメータ

パラメータ	説明
trans	CHARACTER = 'N'の場合: 連立一次方程式にAが関連します。 CHARACTER = 'T'の場合: 連立一次方程式にA**Tが関連します。
m	マトリックスaの行数。M >= 0。
n	マトリックスaの列数。N >= 0。
nrhs	右辺の数(マトリックスbおよびxの列数)。nrhs >= 0。
a	次元(lda, n)を持つUTL_NLA_ARRAY_FLT/DBL。 入力時は、右辺ベクトルのマトリックスb(列方向で格納)です。bは、TRANS = 'N'の場合はm行nrhs列、trans = 'T'の場合はn行nrhs列です。 終了時、m >= nの場合、aは、SGEQRFで戻されたときのQR分解の詳細によって上書きされます。m < nの場合、Aは、SGELQFで戻されたときのLQ分解の詳細によって上書きされます。
lda	配列Aの先頭の次元。lda >= max(1,m)。
b	次元(ldb, nrhs)を持つUTL_NLA_ARRAY_FLT/DBL。 入力時は、右辺ベクトルのマトリックスb(列方向で格納)です。bは、trans = 'n'の場合はm行bynrhs列、trans = 'T'の場合はn行nrhs列です。 終了時、bは、解ベクトルによって上書きされ、列方向で格納されます。 trans = 'n'およびm >= nの場合は、bの行1からnに最小二乗解ベクトルが含まれます。各列の解の残差平方和は、その列の要素n+1からmの平方和によって得られます。 trans = 'n'およびm < nの場合は、bの行1からnに最小ノルム解ベクトルが含まれます。 trans = 'T'およびm >= nの場合は、bの行1からmに最小ノルム解ベクトルが含まれます。 trans = 'T'およびm < nの場合は、bの行1からmに最小二乗解ベクトルが含まれます。各列の解の残差平方和は、その列の要素m+1からnの平方和によって得られます。
ldb	配列bの先頭の次元。 ldb >= max(1,m,n)
info	= 0: 正常終了 < 0: info = -iの場合、i番目の引数に無効な値が含まれています。
pack	(オプション)マトリックスのパッキングのフラグを設定します。 'C': 列優先(デフォルト) 'R': 行優先

LAPACK_GESDDプロシージャ

このプロシージャは、m行n列の実マトリックスAの特異値分解(SVD)を計算します。また、オプションで左右の特異ベクトルを計算します。特異ベクトルが必要な場合は、浮動小数点演算に関する緩やかな仮定を設ける分割統治法アルゴリズムを使用します。

SVDは、次のように記述されます。

A = U * SIGMA * transpose(V)

ここで、SIGMAは、m行n列のマトリックスで、min(m,n)個の対角要素を除いて0 (ゼロ)です。Uはm行m列の直交マトリックス、Vはn行n列の直交マトリックスです。SIGMAの対角要素はAの特異値です。これらは負ではない実数で、降順で戻されます。UおよびVの最初のmin(m,n)列は、Aの左右特異ベクトルです。

ルーチンによってVではなくV**Tが戻されることに注意してください。

関連項目: このグループの他のサブプログラムについては、「LAPACKドライバ・ルーチン(LLSおよび固有値問題)サブプログラム」を参照してください。

構文

UTL_NLA.LAPACK_GESDD (
   jobz   IN       flag,
   m      IN       POSITIVEN,
   n      IN       POSITIVEN,
   a      IN OUT   UTL_NLA_ARRAY_DBL,
   lda    IN       POSITIVEN,
   s      IN OUT   UTL_NLA_ARRAY_DBL,
   u      IN OUT   UTL_NLA_ARRAY_DBL,
   ldu    IN       POSITIVEN,
   vt     IN OUT   UTL_NLA_ARRAY_DBL,
   ldvt   IN       POSITIVEN,
   info   OUT      INTEGER,
   pack   IN       flag DEFAULT 'C');

UTL_NLA.LAPACK_GESDD (
   jobz   IN       flag,
   m      IN       POSITIVEN,
   n      IN       POSITIVEN,
   a      IN OUT   UTL_NLA_ARRAY_FLT,
   lda    IN       POSITIVEN,
   s      IN OUT   UTL_NLA_ARRAY_FLT,
   u      IN OUT   UTL_NLA_ARRAY_FLT,
   ldu    IN       POSITIVEN,
   vt     IN OUT   UTL_NLA_ARRAY_FLT,
   ldvt   IN       POSITIVEN,
   info   OUT      INTEGER,
   pack   IN       flag DEFAULT 'C');

パラメータ

表259-42 LAPACK_GESDDプロシージャのパラメータ

パラメータ	説明
jobz	マトリックスUのすべてを計算するか、一部を計算するかを指定します。 'A': uのすべてのm列およびV**Tのすべてのn行が、配列uおよびvtに戻されます。 'S': uの最初のmin(m,n)列およびV**Tのmin(m,n)行が、配列uおよびvtに戻されます。 'O': uの最初のmin(m,n)列(左特異ベクトル)が、配列aに上書きされます。jobuおよびjobvtの両方を'O'にすることはできません。 'N': uの列(左特異ベクトル)はいずれも計算されません。
m	マトリックスaの位数。m >= 0。
n	マトリックスaの位数。n >= 0。
a	次元(lda, n)を持つUTL_NLA_ARRAY_FLT/DBL。 入力時は、n行n列のマトリックスAです。 終了時: jobz = 'O'の場合、aは、uの最初のmin(m,n)列(列方向で格納された左特異ベクトル)によって上書きされます。 m >= nの場合、aは、V**Tの最初のm行(行方向で格納された右特異ベクトル)によって上書きされます。 jobz .ne. 'O'の場合は、aの内容が破損されます。
lda	配列aの先頭の次元。lda >= max(1,m)。
s	次元min(m,n)を持つUTL_NLA_ARRAY_FLT/DBL。 S(i) >= S(i+1)になるようにソートされたaの特異値。
u	UTL_NLA_ARRAY_FLT/DBL。jobz = 'A'またはjobz = 'O'でm < nの場合はucol = m、jobz = 'S'の場合はucol = min(m,n)です。 jobz = 'A'またはjobz = 'O'でm < nの場合は、uに、m行m列の直交マトリックスuが含まれます。 jobz = 'S'の場合は、uに、uの最初のmin(m,n)列(列方向で格納された左特異ベクトル)が含まれます。 jobz = 'O'でm >= nの場合またはjobz = 'n'の場合、uは参照されません。
ldu	配列Uの先頭の次元。ldu >= 1。jobz = 'S'または'A'、あるいはjobz = 'O'でm < nの場合は、ldu >= mです。
vt	次元(ldvt, n)を持つUTL_NLA_ARRAY_FLT/DBL。 jobz = 'A'またはjobz = 'O'でm >= nの場合は、vtに、n行n列の直交マトリックスV**Tが含まれます。 jobz = 'S'の場合は、vtに、V**Tの最初のmin(m,n)行(行方向で格納された右特異ベクトル)が含まれます。 jobz = 'O'でm < nの場合、またはjobz = 'N'の場合、vtは参照されません。
ldvt	配列vtの先頭の次元。ldvt >= 1。 jobz = 'A'またはjobz = 'O'でm >= nの場合は、ldvt >= nです。 jobz = 'S'の場合は、ldvt >= min(m,n)です。
info	= 0: 正常終了 < 0: info = -iの場合、i番目の引数に無効な値が含まれています。 > 0: SBDSDCは収束しませんでした。更新プロセスは失敗しました。
pack	(オプション)マトリックスのパッキングのフラグを設定します。 'C': 列優先(デフォルト) 'R': 行優先

LAPACK_GESVプロシージャ

このプロシージャは、実連立一次方程式の解を求めます。

a * x = b

ここで、aはn行n列のマトリックス、xおよびbはn行nrhs列のマトリックスです。

Aの分解には、部分ピボットおよび行交換を使用したLU分解が次のように使用されます。

a = P * L * U

ここで、Pは順列マトリックス、Lは単位下三角マトリックス、Uは上三角マトリックスです。aの分解された形式を使用して、連立方程式の解が求められます。

a * x = b

関連項目: このグループの他のサブプログラムについては、「LAPACKドライバ・ルーチン(一次方程式)サブプログラム」を参照してください。

構文

UTL_NLA.LAPACK_GESV (
   n      IN      POSITIVEN,
   nrhs   IN      POSITIVEN,
   a      IN OUT  UTL_NLA_ARRAY_DBL,
   lda    IN      POSITIVEN,
   ipiv   IN OUT  UTL_NLA_ARRAY_INT,
   b      IN OUT  UTL_NLA_ARRAY_DBL,
   ldb    IN      POSITIVEN,
   info      OUT  INTEGER,
   pack   IN      flag DEFAULT 'C');

UTL_NLA.LAPACK_GESV (
   n      IN      POSITIVEN,
   nrhs   IN      POSITIVEN,
   a      IN OUT  UTL_NLA_ARRAY_FLT,
   lda    IN      POSITIVEN,
   ipiv   IN OUT  UTL_NLA_ARRAY_INT,
   b      IN OUT  UTL_NLA_ARRAY_FLT,
   ldb    IN      POSITIVEN,
   info      OUT  INTEGER,
   pack   IN      flag DEFAULT 'C');

パラメータ

表259-43 LAPACK_GESVプロシージャのパラメータ

パラメータ	説明
n	一次方程式の数(マトリックスaの位数と同じ)。n >= 0。
nrhs	右辺の数(マトリックスbの列数)。nrhs >= 0。
a	次元(lda, n)を持つUTL_NLA_ARRAY_FLT/DBL。 入力時は、n行n列の係数マトリックスaです。 終了時は、分解a = P*L*Uの係数LおよびUです。Lの単位対角要素は格納されません。
lda	配列aの先頭の次元。 lda >= max(1,n)
ipiv	次元(n)を持つINTEGER配列。 順列マトリックスPを定義するピボット・インデックス。マトリックスの行iは、行ipiv(i)と交換されました。
b	次元(ldb, nrhs)を持つUTL_NLA_ARRAY_FLT/DBL。 入力時は、右辺マトリックスbのn行nrhs列のマトリックスです。 終了時、info = 0の場合は、n行nrhs列の解マトリックスXです。
ldb	配列bの先頭の次元。 ldb >= max(1,n)
info	= 0: 正常終了 < 0: info = -iの場合、i番目の引数に無効な値が含まれています。 > 0: info = iの場合、U(i,i)は正確に0(ゼロ)になります。分解は完了しましたが、係数Uは真性特異点であるため、解を得ることはできませんでした。
pack	(オプション)マトリックスのパッキングのフラグを設定します。 'C': 列優先(デフォルト) 'R': 行優先

LAPACK_GESVDプロシージャ

このプロシージャは、m行n列のマトリックスAの特異値分解(SVD)を計算します。また、オプションで左または右(あるいは両方)の特異ベクトルを計算します。SVDは、次のように記述されます。

A = U * SIGMA * transpose(V)

ここで、SIGMAは、m行n列のマトリックスで、min(m,n)個の対角要素を除いて0 (ゼロ)です。Uはm行m列の直交マトリックス、Vはn行n列の直交マトリックスです。SIGMAの対角要素はAの特異値です。これらは負ではない実数で、降順で戻されます。UおよびVの最初のmin(m,n)列は、Aの左右特異ベクトルです。

ルーチンによってVではなくV**Tが戻されることに注意してください。

関連項目: このグループの他のサブプログラムについては、「LAPACKドライバ・ルーチン(LLSおよび固有値問題)サブプログラム」を参照してください。

構文

UTL_NLA.LAPACK_GESVD (
   jobu   IN       flag,
   jobvt  IN       flag,
   m      IN       POSITIVEN,
   n      IN       POSITIVEN,
   a      IN OUT   UTL_NLA_ARRAY_DBL,
   lda    IN       POSITIVEN,
   s      IN OUT   UTL_NLA_ARRAY_DBL,
   u      IN OUT   UTL_NLA_ARRAY_DBL,
   ldu    IN       POSITIVEN,
   vt     IN OUT   UTL_NLA_ARRAY_DBL,
   ldvt   IN       POSITIVEN,
   info   OUT      INTEGER,
   pack   IN       flag DEFAULT 'C');

UTL_NLA.LAPACK_GESVD (
   jobu   IN       flag,
   jobvt  IN       flag,
   m      IN       POSITIVEN,
   n      IN       POSITIVEN,
   a      IN OUT   UTL_NLA_ARRAY_FLT,
   lda    IN       POSITIVEN,
   s      IN OUT   UTL_NLA_ARRAY_FLT,
   u      IN OUT   UTL_NLA_ARRAY_FLT,
   ldu    IN       POSITIVEN,
   vt     IN OUT   UTL_NLA_ARRAY_FLT,
   ldvt   IN       POSITIVEN,
   info   OUT      INTEGER,
   pack   IN       flag DEFAULT 'C');

パラメータ

表259-44 LAPACK_GESVDプロシージャのパラメータ

パラメータ	説明
jobu	マトリックスUのすべてを計算するか、一部を計算するかを指定します。 'A': Uのすべてのm列が、配列Uに戻されます。 'S': Uの最初のmin(m,n)列(左特異ベクトル)が、配列Uに戻されます。 'O': Uの最初のmin(m,n)列(左特異ベクトル)が、配列aに上書きされます。jobuおよびjobvtの両方を'O'にすることはできません。 'N': Uの列(左特異ベクトル)はいずれも計算されません。
jobvt	マトリックスV**Tのすべてを計算するか、一部を計算するかを指定します。 'A': V**Tのすべてのn行が、配列vtに戻されます。 'S': V**Tの最初のmin(m,n)行(右特異ベクトル)が、配列vtに戻されます。 'O': V**Tの最初のmin(m,n)行(右特異ベクトル)が、配列aに上書きされます。jobvtおよびjobuの両方を'O'にすることはできません。 'N': V**Tの行(右特異ベクトル)はいずれも計算されません。
m	マトリックスaの位数。M >= 0。
n	マトリックスaの位数。N >= 0。
a	次元(lda, n)を持つUTL_NLA_ARRAY_FLT/DBL。 入力時は、n行n列のマトリックスAです。 終了時: jobu = 'O'の場合、Aは、Uの最初のmin(m,n)列(列方向で格納された左特異ベクトル)によって上書きされます。 jobvt = 'O'の場合、Aは、V**Tの最初のmin(m,n)行(行方向で格納された右特異ベクトル)によって上書きされます。 jobu ≠ 'O'およびjobvt ≠'O'の場合は、Aの内容が破損されます。
lda	配列aの先頭の次元。lda >= max(1,n)。
s	次元min(m,n)を持つUTL_NLA_ARRAY_FLT/DBL。 S(i) >= S(i+1)になるようにソートされたAの特異値。
u	jobu = 'A'の場合は次元(ldu,ucol).(ldu,m)を持つUTL_NLA_ARRAY_FLT/DBL、jobu = 'S'の場合は(ldu,min(m,n))です。 jobu = 'A'の場合は、Uに、m行m列の直交マトリックスUが含まれます。 jobu = 'S'の場合は、Uに、Uの最初のmin(m,n)列(列方向で格納された左特異ベクトル)が含まれます。 jobu = 'N'またはjobu = 'O'の場合、Uは参照されません。
ldu	配列Uの先頭の次元。ldu >= 1。jobu = 'S'またはjobu = 'a'の場合は、ldu >= mです。
vt	次元(ldvt, n)を持つUTL_NLA_ARRAY_FLT/DBL。 jobvt = 'A'の場合は、vtに、n行n列の直交マトリックスV**Tが含まれます。 jobvt = 'S'の場合は、vtに、V**Tの最初のmin(m,n)行(行方向で格納された右特異ベクトル)が含まれます。 jobvt = 'N'またはjobvt = 'O'の場合、vtは参照されません。
ldvt	配列vtの先頭の次元。ldvt >= 1。 jobvt = 'A'の場合は、ldvt >= nです。 jobvt = 'S'の場合は、ldvt >= min(m,n)です。
info	= 0: 正常終了 < 0: info = -iの場合、i番目の引数に無効な値が含まれています。 > 0: SBDSQRが収束しなかった場合、infoは、中間二重対角形式Bの上対角のうち0(ゼロ)に収束しなかった上対角の数を指定します。
pack	(オプション)マトリックスのパッキングのフラグを設定します。 'C': 列優先(デフォルト) 'R': 行優先

LAPACK_GEEVプロシージャ

このプロシージャは、n行n列の実非対称マトリックスA、固有値およびオプションで左または右(あるいは両方)の固有ベクトルを計算します。

• Aの右固有ベクトルv(j)は、A * v(j) = lambda(j) * v(j)を満たします。ここで、lambda(j)はその固有値です。

• Aの左固有ベクトルu(j)は、u(j)**H * A = lambda(j) * u(j)**Hを満たします。ここで、u(j)**Hは、u(j)の共役転置マトリックスを示します。

計算された固有ベクトルは、1に等しいユークリッド・ノルムおよび最大の実部を持つように正規化されます。

関連項目: このグループの他のサブプログラムについては、「LAPACKドライバ・ルーチン(LLSおよび固有値問題)サブプログラム」を参照してください。

構文

UTL_NLA.LAPACK_GEEV (
   jobvl   IN      flag,
   jobvr   IN      flag,
   n       IN      POSITIVEN,
   a       IN OUT  UTL_NLA_ARRAY_DBL,
   lda     IN      POSITIVEN,
   wr      IN OUT  UTL_NLA_ARRAY_DBL,
   wi      IN OUT  UTL_NLA_ARRAY_DBL,
   vl      IN OUT  UTL_NLA_ARRAY_DBL,
   ldvl    IN      POSITIVEN,
   vr      IN OUT  UTL_NLA_ARRAY_DBL,
   ldvr    IN      POSITIVEN,
   info    OUT     INTEGER,
   pack    IN      flag DEFAULT 'C');

UTL_NLA.LAPACK_GEEV (
   jobvl   IN      flag,
   jobvr   IN      flag,
   n       IN      POSITIVEN,
   a       IN OUT  UTL_NLA_ARRAY_FLT,
   lda     IN      POSITIVEN,
   wr      IN OUT  UTL_NLA_ARRAY_FLT,
   wi      IN OUT  UTL_NLA_ARRAY_FLT,
   vl      IN OUT  UTL_NLA_ARRAY_FLT,
   ldvl    IN      POSITIVEN,
   vr      IN OUT  UTL_NLA_ARRAY_FLT,
   ldvr    IN      POSITIVEN,
   info    OUT     INTEGER,
   pack    IN      flag DEFAULT 'C');

パラメータ

表259-45 LAPACK_GEEVプロシージャのパラメータ

パラメータ	説明
jobvl	'N': Aの左固有ベクトルが計算されません。 'V': Aの左固有ベクトルが計算されます。
jobvr	'N': Aの右固有ベクトルが計算されません。 'V': Aの右固有ベクトルが計算されます。
n	マトリックスaの位数。N >= 0。
a	次元(lda, n)を持つUTL_NLA_ARRAY_FLT/DBL。 入力時は、n行n列のマトリックスAです。 終了時、Aは上書きされます。
lda	配列aの先頭の次元。lda >= max(1,n)。
wr	次元(n)を持つUTL_NLA_ARRAY_FLT/DBL。 wrおよびwiには、計算された固有値の実部および虚部がそれぞれ含まれます。正の虚部を持つ固有値に続いて、固有値の複素共役対が表示されます。
wi	次元(ldz, n)を持つUTL_NLA_ARRAY_FLT/DBL。 wrおよびwiには、計算された固有値の実部および虚部がそれぞれ含まれます。正の虚部を持つ固有値に続いて、固有値の複素共役対が表示されます。
vl	次元(n)を持つUTL_NLA_ARRAY_FLT/DBL。 jobvl = 'V'の場合、左固有ベクトルu(j)は、vlの列に、固有値と同じ順序で格納されます。 jobvs = 'N'の場合、vlは参照されません。 j番目の固有値が実数の場合は、u(j) = VL(:,j)(vlのj番目の列)です。 j番目の固有値および(j+1)番目の固有値で共役対を形成する場合は、u(j) = VL(:,j) + i*VL(:,j+1)およびu(j+1) = VL(:,j) - i*VL(:,j+1)です。
ldv1	配列vlの先頭の次元。ldvl >= 1。jobvl = 'v'の場合は、ldvl >= nです。
vr	次元(ldvr, n)を持つUTL_NLA_ARRAY_FLT/DBL。 jobvr = 'V'の場合、右固有ベクトルv(j)は、vrの列に、固有値と同じ順序で格納されます。 jobvr = 'N'の場合、vrは参照されません。 j番目の固有値が実数の場合は、v(j) = VR(:,j)(vrのj番目の列)です。 j番目の固有値および(j+1)番目の固有値で共役対を形成する場合は、v(j) = VR(:,j) + i*VR(:,j+1)およびv(j+1) = VR(:,j) - i*VR(:,j+1)です。
ldvr	配列vrの先頭の次元。vr.ldvr >= 1。jobvr = 'V'の場合は、ldvr >= Nです。
info	= 0: 正常終了 < 0: info = -iの場合、i番目の引数に無効な値が含まれています。 > 0: info = iで、iが<= Nの場合、QRアルゴリズムはすべての固有値の計算に失敗し、固有ベクトルは計算されません。wrおよびwiの要素i+1:Nに、収束した固有値が含まれます。
pack	(オプション)マトリックスのパッキングのフラグを設定します。 'C': 列優先(デフォルト) 'R': 行優先

LAPACK_GTSVプロシージャ

このプロシージャは、方程式の解を求めます。

a * x = b

ここで、aは、部分ピボットを使用したガウス消去法によるn行n列の三重対角マトリックスです。

方程式a'*x = bの解は、引数duおよびdlの順序を交換して求めることができます。

関連項目: このグループの他のサブプログラムについては、「LAPACKドライバ・ルーチン(一次方程式)サブプログラム」を参照してください。

構文

UTL_NLA.LAPACK_GTSV (
   n      IN      POSITIVEN,
   nrhs   IN      POSITIVEN,
   dl     IN OUT  UTL_NLA_ARRAY_DBL,
   d      IN OUT  UTL_NLA_ARRAY_DBL,
   du     IN OUT  UTL_NLA_ARRAY_DBL,
   b      IN OUT  UTL_NLA_ARRAY_DBL,
   ldb    IN      POSITIVEN,
   info      OUT  INTEGER,
   pack   IN      flag DEFAULT 'C');

UTL_NLA.LAPACK_GTSV (
   n      IN      POSITIVEN,
   nrhs   IN      POSITIVEN,
   dl     IN OUT  UTL_NLA_ARRAY_FLT,
   d      IN OUT  UTL_NLA_ARRAY_FLT,
   du     IN OUT  UTL_NLA_ARRAY_FLT,
   b      IN OUT  UTL_NLA_ARRAY_FLT,
   ldb    IN      POSITIVEN,
   info      OUT  INTEGER,
   pack   IN      flag DEFAULT 'C');

パラメータ

表259-46 LAPACK_GTSVプロシージャのパラメータ

パラメータ	説明
n	マトリックスaの位数。n >= 0。
nrhs	右辺の数(マトリックスbの列数)。nrhs >= 0。
dl	次元(n-1)を持つUTL_NLA_ARRAY_FLT/DBL。 入力時、dlに、aの(n-1)個の下対角要素が含まれている必要があります。 終了時、dlは、dl(1), ..., dl(n-2)の順序で、aのLU分解で得られた、上三角マトリックスUの2番目の上対角の(n-2)個の要素によって上書きされます。
d	次元(n)を持つUTL_NLA_ARRAY_FLT/DBL。 入力時、dに、aの対角要素が含まれている必要があります。 終了時、dは、Uのn個の対角要素によって上書きされます。
du	次元(n-1)を持つUTL_NLA_ARRAY_FLT/DBL。 入力時、duに、aの(n-1)個の上対角要素が含まれている必要があります。 終了時、duは、Uの最初の上対角の(n-1)個の要素によって上書きされます。
b	次元(LDB, nrhs)を持つUTL_NLA_ARRAY_FLT/DBL。 入力時は、右辺マトリックスbのn行nrhs列のマトリックスです。 終了時、info = 0の場合は、n行nrhs列の解マトリックスXです。
ldb	配列bの先頭の次元。 ldb >= max(1,n)
info	= 0: 正常終了 < 0: info = -iの場合、i番目の引数に無効な値が含まれています。 > 0: info = iの場合、U(i,i)は正確に0 (ゼロ)になります。解は求められていません。分解は、i = nでないかぎり完了していません。
pack	(オプション)マトリックスのパッキングのフラグを設定します。 'C': 列優先(デフォルト) 'R': 行優先

LAPACK_PBSVプロシージャ

このプロシージャは、実連立一次方程式の解を求めます。

a * x = b

ここで、aはn行n列の正定値対称バンド・マトリックス、xおよびbはn行nrhs列のマトリックスです。

Aの分解には、コレスキ分解が次のように使用されます。

UPLO = 'U'の場合は、A = U**T*Uです。

または

UPLO = 'L'の場合は、A = L * L**Tです。

ここで、Uは上三角マトリックス、Lは下三角マトリックスです。Aの分解された形式を使用して、連立方程式A * X = Bの解が求められます。

関連項目: このグループの他のサブプログラムについては、「LAPACKドライバ・ルーチン(一次方程式)サブプログラム」を参照してください。

構文

UTL_NLA.LAPACK_PBSV (
uplo       IN      flag,
n          IN      POSITIVEN,
kd         IN      NATURALN,
nrhs       IN      POSITIVEN,
ab         IN OUT  UTL_NLA_ARRAY_DBL,
ldab       IN      POSITIVEN,
b          IN OUT  UTL_NLA_ARRAY_DBL,
ldb        IN      POSITIVEN,
info       OUT     INTEGER,
pack       IN      flag DEFAULT 'C');
    

UTL_NLA.LAPACK_PBSV (
uplo      IN      flag,
n         IN      POSITIVEN,
kd        IN      NATURALN,
nrhs      IN      POSITIVEN,
ab        IN OUT  UTL_NLA_ARRAY_FLT,
ldab      IN      POSITIVEN,
b         IN OUT  UTL_NLA_ARRAY_FLT,
ldb       IN      POSITIVEN,
info      OUT     INTEGER,
pack      IN      flag DEFAULT 'C');

パラメータ

表259-47 LAPACK_PBSVプロシージャのパラメータ

パラメータ	説明
uplo	uplo = 'U'の場合。Aの上三角部分が格納されます。 uplo = 'L'の場合。Aの下三角部分が格納されます。
n	一次方程式の数(マトリックスaの位数)。n >= 0。
kd	uplo = 'U'の場合はマトリックスAの上対角の数、UPLO = 'L'の場合は下対角の数。KD >= 0。
nrhs	右辺の数(マトリックスbの列数)。nrhs >= 0。
ab	次元(ldab, n)を持つUTL_NLA_ARRAY_FLT/DBL。 入力時は、配列の最初のkd+1行に格納されている、対称バンド・マトリックスaの上三角または下三角部分です。aのj番目の列は、配列abのj番目の列に次のように格納されます。 uplo = 'U'の場合、max(1,j-KD)<=i<=j;はAB(KD+1+i-j,j) = A(i,j)に格納されます。 uplo = 'L'の場合、j<=i<=min(N,j+KD)はAB(1+i-j,j) = A(i,j)に格納されます。 詳細は、次の説明を参照してください。終了時、info = 0の場合は、バンド・マトリックスAのコレスキ分解A = U**T*UまたはA = L*L**Tからの三角係数UまたはLになります(aと同じ格納形式)。
ldab	配列abの先頭の次元。 ldb >= kd+1
b	次元(ldb, nrhs)を持つUTL_NLA_ARRAY_FLT/DBL。 入力時は、右辺マトリックスbのn行nrhs列のマトリックスです。 終了時、info = 0の場合は、n行nrhs列の解マトリックスXです。
ldb	配列bの先頭の次元。 ldb >= max(1,n)
info	= 0: 正常終了 < 0: info = -iの場合、i番目の引数に無効な値が含まれています。 > 0: info = iの場合、aの位数iの先頭の小行列式は正定値ではありません。このため、分解を完了できませんでした。解は求められていません。
pack	(オプション)マトリックスのパッキングのフラグを設定します。 'C': 列優先(デフォルト) 'R': 行優先

LAPACK_POSVプロシージャ

このプロシージャは、実連立一次方程式の解を求めます。

a * x = b

ここで、aはn行n列の正定値対称マトリックス、xおよびbはn行nrhs列のマトリックスです。

Aの分解には、コレスキ分解が次のように使用されます。

uplo = 'U'の場合は、A = U**T* Uです。

または

UPLO = 'L'の場合は、A = L * L**Tです。

ここで、Uは上三角マトリックス、Lは下三角マトリックスです。Aの分解された形式を使用して、連立方程式A * X = Bの解が求められます。

関連項目: このグループの他のサブプログラムについては、「LAPACKドライバ・ルーチン(一次方程式)サブプログラム」を参照してください。

構文

UTL_NLA.LAPACK_POSV (
   uplo      IN      flag,
   n         IN      POSITIVEN,
   nrhs      IN      POSITIVEN,
   a         IN OUT  UTL_NLA_ARRAY_DBL,
   lda       IN      POSITIVEN,
   b         IN OUT  UTL_NLA_ARRAY_DBL,
   ldb       IN      POSITIVEN,
   info      OUT     INTEGER,
   pack      IN      flag DEFAULT 'C');

UTL_NLA.LAPACK_POSV (
   uplo      IN      flag,
   n         IN      POSITIVEN,
   nrhs      IN      POSITIVEN,
   a         IN OUT  UTL_NLA_ARRAY_FLT,
   lda       IN      POSITIVEN,
   b         IN OUT  UTL_NLA_ARRAY_FLT,
   ldb       IN      POSITIVEN,
   info      OUT     INTEGER,
   pack      IN      flag DEFAULT 'C');

パラメータ

表259-48 LAPACK_POSVプロシージャのパラメータ

パラメータ	説明
uplo	uplo = 'U'の場合。Aの上三角部分が格納されます。 uplo = 'L'の場合。Aの下三角部分が格納されます。
n	一次方程式の数(マトリックスaの位数)。n >= 0。
nrhs	右辺の数(マトリックスbの列数)。nrhs >= 0。
a	次元(lda, n)を持つUTL_NLA_ARRAY_FLT/DBL。 uplo = 'U'の場合、aの先頭のNRHSのn行n列の上三角部分にマトリックスAのNRHSの上三角部分が含まれ、AのNRHSの狭義下三角部分は参照されません。 uplo = 'L'の場合、aの先頭のrhsのn行n列の下三角部分にマトリックスaのnrhsの下三角部分が含まれ、aのnrhsの狭義上三角部分は参照されません。 終了時、info = 0の場合は、コレスキ分解A = U**T*UまたはA = L*L**Tからの係数UまたはLです。
lda	配列aの先頭の次元。 lda >= max(1,n)
b	次元(ldb, nrhs)を持つUTL_NLA_ARRAY_FLT/DBL。 入力時は、右辺マトリックスbのn行nrhs列のマトリックスです。 終了時、info = 0の場合は、n行nrhs列の解マトリックスXです。
ldb	配列bの先頭の次元。 ldb >= max(1,n)
info	= 0: 正常終了 < 0: info = -iの場合、i番目の引数に無効な値が含まれています。 > 0: info = iの場合、aの位数iの先頭の小行列式は正定値ではありません。このため、分解を完了できませんでした。解は求められていません。
pack	(オプション)マトリックスのパッキングのフラグを設定します。 'C': 列優先(デフォルト) 'R': 行優先

LAPACK_PPSVプロシージャ

このプロシージャは、実連立一次方程式の解を求めます。

a * x = b

ここで、aはパックされた形式で格納されているn行n列の正定値対称マトリックス、xおよびbはn行nrhs列のマトリックスです。

Aの分解には、コレスキ分解が次のように使用されます。

UPLO = 'U'の場合は、A = U**T* Uです。

または

UPLO = 'L'の場合は、A = L * L**Tです。

ここで、Uは上三角マトリックス、Lは下三角マトリックスです。Aの分解された形式を使用して、連立方程式A * X = Bの解が求められます。

関連項目: このグループの他のサブプログラムについては、「LAPACKドライバ・ルーチン(一次方程式)サブプログラム」を参照してください。

構文

UTL_NLA.LAPACK_PPSV (
   uplo      IN      flag,
   n         IN      POSITIVEN,
   nrhs      IN      POSITIVEN,
   ap        IN OUT  UTL_NLA_ARRAY_DBL,
   b         IN OUT  UTL_NLA_ARRAY_DBL,
   ldb       IN      POSITIVEN,
   info      OUT     INTEGER,
   pack      IN      flag DEFAULT 'C');
    

UTL_NLA.LAPACK_PPSV (
   uplo      IN      flag,
   n         IN      POSITIVEN,
   nrhs      IN      POSITIVEN,
   ap        IN OUT  UTL_NLA_ARRAY_FLT,
   b         IN OUT  UTL_NLA_ARRAY_FLT,
   ldb       IN      POSITIVEN,
   info      OUT     INTEGER,
   pack      IN      flag DEFAULT 'C');

パラメータ

表259-49 LAPACK_PPSVプロシージャのパラメータ

パラメータ	説明
uplo	uplo = 'U'の場合。Aの上三角部分が格納されます。 uplo = 'L'の場合。Aの下三角部分が格納されます。
n	一次方程式の数(マトリックスaの位数)。n >= 0。
nrhs	右辺の数(マトリックスbの列数)。nrhs >= 0。
ap	次元(n*(n+1)/2)を持つUTL_NLA_ARRAY_FLT/DBL。 入力時は、線形配列に列方向でパックされている、対称マトリックスaの上三角または下三角部分です。aのj番目の列は、配列apに次のように格納されます。 uplo = 'U'の場合、1<=i<=j;はAP(i + (j-1)*j/2) = A(i,j)に格納されます。 uplo = 'L'の場合、j<=i<=n;はAP(i + (j-1)*(2n-j)/2) = A(i,j)に格納されます。 終了時、info = 0の場合は、コレスキ分解A = U**T*UまたはA = L*L**Tからの係数Uまたは'L'になります(Aと同じ格納形式)。
b	次元(ldb, nrhs)を持つUTL_NLA_ARRAY_FLT/DBL。 入力時は、右辺マトリックスbのn行nrhs列のマトリックスです。 終了時、info = 0の場合は、n行nrhs列の解マトリックスXです。
ldb	配列bの先頭の次元。 ldb >= max(1,n)
info	= 0: 正常終了 < 0: info = -iの場合、i番目の引数に無効な値が含まれています。 > 0: info = iの場合、aの位数iの先頭の小行列式は正定値ではありません。このため、分解を完了できませんでした。解は求められていません。
pack	(オプション)マトリックスのパッキングのフラグを設定します。 'C': 列優先(デフォルト) 'R': 行優先

LAPACK_PTSVプロシージャ

このプロシージャは、実連立一次方程式の解を求めます。

a * x = b

ここで、aはn行n列の正定値対称三重対角マトリックス、xおよびbはn行nrhs列のマトリックスです。

aはA = L*D*L**Tとして分解され、aの分解された形式を使用して、連立方程式の解が求められます。

関連項目: このグループの他のサブプログラムについては、「LAPACKドライバ・ルーチン(一次方程式)サブプログラム」を参照してください。

構文

UTL_NLA.LAPACK_PTSV (
   n      IN       POSITIVEN,
   nrhs   IN       POSITIVEN,
   d      IN OUT   UTL_NLA_ARRAY_DBL,
   e      IN OUT   UTL_NLA_ARRAY_DBL,
   b      IN OUT   UTL_NLA_ARRAY_DBL,
   ldb    IN       POSITIVEN,
   info   OUT      INTEGER,
   pack   IN       flag  DEFAULT 'C');
 

UTL_NLA.LAPACK_PTSV (
   n      IN       POSITIVEN,
   nrhs   IN       POSITIVEN,
   d      IN OUT   UTL_NLA_ARRAY_FLT,
   e      IN OUT   UTL_NLA_ARRAY_FLT,
   b      IN OUT   UTL_NLA_ARRAY_FLT,
   ldb    IN       POSITIVEN,
   info   OUT      INTEGER,
   pack   IN       flag DEFAULT 'C');

パラメータ

表259-50 LAPACK_PTSVプロシージャのパラメータ

パラメータ	説明
n	マトリックスaの位数。N >= 0。
nrhs	右辺の数(マトリックスbの列数)。nrhs >= 0。
d	次元(n)を持つUTL_NLA_ARRAY_FLT/DBL。 入力時は、三重対角マトリックスaのn個の対角要素です。 終了時は、分解A = L*D*L**Tで得られた、三重対角マトリックスdのn個の対角要素です。
e	次元(n-1)を持つUTL_NLA_ARRAY_FLT/DBL。 入力時は、三重対角マトリックスaの(n-1)個の下対角要素です。 終了時は、aの分解A = L*D*L**Tで得られた、単位二重対角係数Lの(n-1)個の対角要素です(eは、aのU**T*D*U分解で得られた、単位二重対角係数Uの下対角とみなすこともできます)。
b	次元(ldb, nrhs)を持つUTL_NLA_ARRAY_FLT/DBL。 入力時は、右辺マトリックスbのn行nrhs列のマトリックスです。 終了時、info = 0の場合は、n行nrhs列の解マトリックスXです。
ldb	配列bの先頭の次元。 ldb >= max(1,n)
info	= 0: 正常終了 < 0: info = -iの場合、i番目の引数に無効な値が含まれています。 > 0: info = iの場合、aの位数iの先頭の小行列式は正定値ではありません。このため、分解を完了できませんでした。解は求められていません。
pack	(オプション)マトリックスのパッキングのフラグを設定します。 'C': 列優先(デフォルト) 'R': 行優先

LAPACK_SBEVプロシージャ

このプロシージャは、すべての固有値を計算します。また、オプションで、実対称バンド・マトリックスAの固有ベクトルを計算します。

関連項目: このグループの他のサブプログラムについては、「LAPACKドライバ・ルーチン(LLSおよび固有値問題)サブプログラム」を参照してください。

構文

UTL_NLA.LAPACK_SBEV (
   jobz     IN      flag,
   uplo     IN      flag,
   n        IN      POSITIVEN,
   kd       IN      NATURALN,
   ab       IN OUT  UTL_NLA_ARRAY_DBL,
   ldab     IN      POSITIVEN,
   w        IN OUT  UTL_NLA_ARRAY_DBL,
   z        IN OUT  UTL_NLA_ARRAY_DBL,
   ldz       IN      POSITIVEN,
   info     OUT     INTEGER,
   pack     IN      flag DEFAULT 'C');

UTL_NLA.LAPACK_SBEV (
   jobz     IN      flag,
   uplo     IN      flag,
   n        IN      POSITIVEN,
   kd       IN      NATURALN,
   ab       IN OUT  UTL_NLA_ARRAY_FLT,
   ldab     IN      POSITIVEN,
   w        IN OUT  UTL_NLA_ARRAY_FLT,
   z        IN OUT  UTL_NLA_ARRAY_FLT,
   ldz      IN      POSITIVEN,
   info     OUT     INTEGER,
   pack     IN      flag DEFAULT 'C');

パラメータ

表259-51 LAPACK_SBEVプロシージャのパラメータ

パラメータ	説明
jobz	'N': 固有値のみが計算されます。 'V': 固有値および固有ベクトルが計算されます。
uplo	'U': Aの上三角部分が格納されます。 'L': Aの下三角部分が格納されます。
n	マトリックスaの位数。N >= 0。
kd	uplo = 'U'の場合はマトリックスAの上対角の数、uplo = 'L'の場合は下対角の数。kd >= 0。
ab	次元(ldab, n)を持つUTL_NLA_ARRAY_FLT/DBL。 入力時は、配列の最初のkd+1行に格納されている、対称バンド・マトリックスAの上三角または下三角部分です。Aのj番目の列は、配列abのj番目の列に次のように格納されます。 uplo = 'U'の場合、max(1,j-kd)<=i<=jはab(kd+1+i-j,j) = a(i,j)に格納されます。 uplo = 'L'の場合、j<=i<=min(n,j+kd)はAB(1+i-j,j) = A(i,j)に格納されます。 終了時、abは、三重対角形式への換算時に生成された値によって上書きされます。 uplo = 'U'の場合、三重対角マトリックスTの対角および最初の上対角が、abの行kdおよびkd+1に戻されます。 uplo = 'L'の場合、Tの対角および最初の下対角が、abの最初の2行に戻されます。
ldab	配列abの先頭の次元。ldab >= kd + 1。
w	次元(n)を持つUTL_NLA_ARRAY_FLT/DBL。 info = 0の場合は、昇順の固有値です。
z	次元(n)を持つUTL_NLA_ARRAY_FLT/DBL。 jobz = 'V'で、info = 0の場合は、zにマトリックスAの正規直交ベクトルが含まれます。この場合、zのi番目の列にw(i)に関連付けられた固有ベクトルが含まれます。 jobz = 'N'の場合、zは参照されません。
ldz	配列zの先頭の次元。ldz >= 1です。jobz = 'v'の場合は、ldz >= max(1,n)です。
info	= 0: 正常終了 < 0: info = -iの場合、i番目の引数に無効な値が含まれています。 > 0: info = iの場合、アルゴリズムを使用して収束できませんでした。中間二重対角形式のi個の非対角要素は、0(ゼロ)に収束しませんでした。
pack	(オプション)マトリックスのパッキングのフラグを設定します。 'C': 列優先(デフォルト) 'R': 行優先

LAPACK_SBEVDプロシージャ

このプロシージャは、すべての固有値を計算します。また、オプションで実対称マトリックスAの固有ベクトルを計算します。固有ベクトルが必要な場合は、浮動小数点演算に関する緩やかな仮定を設ける分割統治法アルゴリズムを使用します。

関連項目: このグループの他のサブプログラムについては、「LAPACKドライバ・ルーチン(LLSおよび固有値問題)サブプログラム」を参照してください。

構文

UTL_NLA.LAPACK_SBEVD (
   jobz     IN      flag,
   uplo     IN      flag,
   n        IN      POSITIVEN,
   kd       IN      NATURALN,
   ab       IN OUT  UTL_NLA_ARRAY_DBL,
   ldab     IN      POSITIVEN,
   w        IN OUT  UTL_NLA_ARRAY_DBL,
   z        IN OUT  UTL_NLA_ARRAY_DBL,
   ldz       IN      POSITIVEN,
   info     OUT     INTEGER,
   pack     IN      flag DEFAULT 'C');

UTL_NLA.LAPACK_SBEVD (
   jobz     IN      flag,
   uplo     IN      flag,
   n        IN      POSITIVEN,
   kd       IN      NATURALN,
   ab       IN OUT  UTL_NLA_ARRAY_FLT,
   ldab     IN      POSITIVEN,
   w        IN OUT  UTL_NLA_ARRAY_FLT,
   z        IN OUT  UTL_NLA_ARRAY_FLT,
   ldz      IN      POSITIVEN,
   info     OUT     INTEGER,
   pack     IN      flag DEFAULT 'C');

パラメータ

表259-52 LAPACK_SBEVDプロシージャのパラメータ

パラメータ	説明
jobz	'N': 固有値のみが計算されます。 'V': 固有値および固有ベクトルが計算されます。
uplo	'U': Aの上三角部分が格納されます。 'L': Aの下三角部分が格納されます。
n	マトリックスaの位数。N >= 0。
kd	uplo = 'U'の場合はマトリックスAの上対角の数、uplo = 'L'の場合は下対角の数。kd >= 0。
ab	次元(ldab, n)を持つUTL_NLA_ARRAY_FLT/DBL。 入力時は、配列の最初のkd+1行に格納されている、対称バンド・マトリックスAの上三角または下三角部分です。Aのj番目の列は、配列abのj番目の列に次のように格納されます。 uplo = 'U'の場合、max(1,j-kd)<=i<=jはab(kd+1+i-j,j) = a(i,j)に格納されます。 uplo = 'L'の場合、j<=i<=min(n,j+kd)はAB(1+i-j,j) = A(i,j)に格納されます。 終了時、abは、三重対角形式への換算時に生成された値によって上書きされます。 uplo = 'U'の場合、三重対角マトリックスTの対角および最初の上対角が、abの行kdおよびkd+1に戻されます。 uplo = 'L'の場合、Tの対角および最初の下対角が、abの最初の2行に戻されます。
ldab	配列abの先頭の次元。ldab >= kd + 1。
w	次元(ldz,n)を持つUTL_NLA_ARRAY_FLT/DBL。 info = 0の場合は、昇順の固有値です。
z	次元(n)を持つUTL_NLA_ARRAY_FLT/DBL。 jobz = 'V'で、info = 0の場合は、zにマトリックスAの正規直交ベクトルが含まれます。この場合、zのi番目の列にw(i)に関連付けられた固有ベクトルが含まれます。 jobz = 'N'の場合、zは参照されません。
ldz	配列zの先頭の次元。ldz >= 1です。jobz = 'v'の場合は、ldz >= max(1,n)です。
info	= 0: 正常終了 < 0: info = -iの場合、i番目の引数に無効な値が含まれています。 > 0: info = iの場合、アルゴリズムを使用して収束できませんでした。中間二重対角形式のi個の非対角要素は、0(ゼロ)に収束しませんでした。
pack	(オプション)マトリックスのパッキングのフラグを設定します。 'C': 列優先(デフォルト) 'R': 行優先

LAPACK_SPEVプロシージャ

このプロシージャは、すべての固有値を計算します。また、オプションで、パックされて格納されている実対称マトリックスAの固有ベクトルを計算します。

関連項目: このグループの他のサブプログラムについては、「LAPACKドライバ・ルーチン(LLSおよび固有値問題)サブプログラム」を参照してください。

構文

UTL_NLA.LAPACK_SPEV (
   jobz     IN      flag,
   uplo     IN      flag,
   n        IN      POSITIVEN,
   ap       IN OUT  UTL_NLA_ARRAY_DBL,
   w        IN OUT  UTL_NLA_ARRAY_DBL,
   z        IN OUT  UTL_NLA_ARRAY_DBL,
   ldz      IN      POSITIVEN,
   info     OUT     INTEGER,
   pack     IN      flag DEFAULT 'C');

UTL_NLA.LAPACK_SPEV (
   jobz     IN      flag,
   uplo     IN      flag,
   n        IN      POSITIVEN,
   ap       IN OUT  UTL_NLA_ARRAY_FLT,
   w        IN OUT  UTL_NLA_ARRAY_FLT,
   z        IN OUT  UTL_NLA_ARRAY_FLT,
   ldz      IN      POSITIVEN,
   info     OUT     INTEGER,
   pack     IN      flag DEFAULT 'C');

パラメータ

表259-53 LAPACK_SPEVプロシージャのパラメータ

パラメータ	説明
jobz	'N': 固有値のみが計算されます。 'V': 固有値および固有ベクトルが計算されます。
uplo	'U': Aの上三角部分が格納されます。 'L': Aの下三角部分が格納されます。
n	マトリックスaの位数。N >= 0。
ap	次元(n*(n+1)/2)を持つUTL_NLA_ARRAY_FLT/DBL。 入力時は、線形配列に列方向でパックされている、対称マトリックスaの上三角または下三角部分です。aのj番目の列は、配列apに格納されます。 uplo = 'U'の場合、1<=i<=jはap(i + (j-1)*j/2) = a(i,j)に格納されます。 uplo = 'L'の場合、j<=i<=nはap(i + (j-1)*(2*n-j)/2) = a(i,j)に格納されます。 終了時、apは、三重対角形式にするときに生成された値によって上書きされます。 uplo = 'U'の場合、三重対角マトリックスTの対角および最初の上対角によって、Aの対応する要素が上書きされます。 uplo = 'L'の場合、Tの対角および最初の下対角によって、Aの対応する要素が上書きされます。
w	次元(n)を持つUTL_NLA_ARRAY_FLT/DBL。 info = 0の場合は、昇順の固有値です。
z	次元(ldz,n)を持つUTL_NLA_ARRAY_FLT/DBL。 jobz = 'V'で、info = 0の場合は、zにマトリックスAの正規直交ベクトルが含まれます。この場合、zのi番目の列にw(i)に関連付けられた固有ベクトルが含まれます。 jobz = 'N'の場合、zは参照されません。
ldz	配列zの先頭の次元。ldz >= 1です。jobz = 'v'の場合は、ldz >= max(1,n)です。
info	= 0: 正常終了 < 0: info = -iの場合、i番目の引数に無効な値が含まれています。 > 0: info = iの場合、アルゴリズムを使用して収束できませんでした。中間二重対角形式のi個の非対角要素は、0(ゼロ)に収束しませんでした。
pack	(オプション)マトリックスのパッキングのフラグを設定します。 'C': 列優先(デフォルト) 'R': 行優先

LAPACK_SPEVDプロシージャ

このプロシージャは、すべての固有値を計算します。また、オプションで、パックされて格納されている実対称マトリックスAの固有ベクトルを計算します。固有ベクトルが必要な場合は、分割統治アルゴリズムが使用されます。分割統治アルゴリズムは、浮動小数点演算に関する緩やかな仮定を設けます。

関連項目: このグループの他のサブプログラムについては、「LAPACKドライバ・ルーチン(LLSおよび固有値問題)サブプログラム」を参照してください。

構文

UTL_NLA.LAPACK_SPEVD (
   jobz     IN      flag,
   uplo     IN      flag,
   n        IN      POSITIVEN,
   ap       IN OUT  UTL_NLA_ARRAY_DBL,
   w        IN OUT  UTL_NLA_ARRAY_DBL,
   z        IN OUT  UTL_NLA_ARRAY_DBL,
   ldz       IN      POSITIVEN,
   info     OUT     INTEGER,
   pack     IN      flag DEFAULT 'C');

UTL_NLA.LAPACK_SPEVD (
   jobz     IN      flag,
   uplo     IN      flag,
   n        IN      POSITIVEN,
   ap       IN OUT  UTL_NLA_ARRAY_FLT,
   w        IN OUT  UTL_NLA_ARRAY_FLT,
   z        IN OUT  UTL_NLA_ARRAY_FLT,
   ldz      IN      POSITIVEN,
   info     OUT     INTEGER,
   pack     IN      flag DEFAULT 'C');

パラメータ

表259-54 LAPACK_SPEVDプロシージャのパラメータ

パラメータ	説明
jobz	'N': 固有値のみが計算されます。 'V': 固有値および固有ベクトルが計算されます。
uplo	'U': Aの上三角部分が格納されます。 'L': Aの下三角部分が格納されます。
n	マトリックスaの位数。N >= 0。
ap	次元(n*(n+1)/2)を持つUTL_NLA_ARRAY_FLT/DBL。 入力時は、線形配列に列方向でパックされている、対称マトリックスaの上三角または下三角部分です。aのj番目の列は、配列apに格納されます。 uplo = 'U'の場合、1<=i<=jはap(i + (j-1)*j/2) = a(i,j)に格納されます。 uplo = 'L'の場合、j<=i<=nはap(i + (j-1)*(2*n-j)/2) = a(i,j)に格納されます。 終了時、apは、三重対角形式にするときに生成された値によって上書きされます。 uplo = 'U'の場合、三重対角マトリックスTの対角および最初の上対角によって、Aの対応する要素が上書きされます。 uplo = 'L'の場合、Tの対角および最初の下対角によって、Aの対応する要素が上書きされます。
w	次元(n)を持つUTL_NLA_ARRAY_FLT/DBL。 info = 0の場合は、昇順の固有値です。
z	次元(ldz,n)を持つUTL_NLA_ARRAY_FLT/DBL。 jobz = 'V'で、info = 0の場合は、zにマトリックスAの正規直交ベクトルが含まれます。この場合、zのi番目の列にw(i)に関連付けられた固有ベクトルが含まれます。 jobz = 'N'の場合、zは参照されません。
ldz	配列zの先頭の次元。ldz >= 1です。jobz = 'v'の場合は、ldz >= max(1,n)です。
info	= 0: 正常終了 < 0: info = -iの場合、i番目の引数に無効な値が含まれています。 > 0: info = iの場合、アルゴリズムを使用して収束できませんでした。中間二重対角形式のi個の非対角要素は、0(ゼロ)に収束しませんでした。
pack	(オプション)マトリックスのパッキングのフラグを設定します。 'C': 列優先(デフォルト) 'R': 行優先

LAPACK_SPSVプロシージャ

このプロシージャは、実連立一次方程式の解を求めます。

a * x = b

ここで、aはパックされた形式で格納されているn行n列の対称マトリックス、xおよびbはn行nrhs列のマトリックスです。

Aの分解には、対角ピボット法が次のように使用されます。

UPLO = 'U'の場合は、A = U * D * U**Tです。

または

UPLO = 'L'の場合は、A = L * D * L**Tです。

ここで、U(またはL)は順列マトリックスと単位上(下)三角マトリックスの積、Dは1行1列および2行2列の対角ブロックを持つ対称ブロック対角マトリックスです。Aの分解された形式を使用して、連立方程式A * X = Bの解が求められます。

関連項目: このグループの他のサブプログラムについては、「LAPACKドライバ・ルーチン(一次方程式)サブプログラム」を参照してください。

構文

UTL_NLA.LAPACK_SPSV (
   uplo    IN      flag,
   n       IN      POSITIVEN,
   nrhs    IN      POSITIVEN,
   ap      IN OUT  UTL_NLA_ARRAY_DBL,
   ipiv    IN OUT  UTL_NLA_ARRAY_INT,
   b       IN OUT  UTL_NLA_ARRAY_DBL,
   ldb     IN      POSITIVEN,
   info    OUT     INTEGER,
   pack    IN      flag DEFAULT 'C');

UTL_NLA.LAPACK_SPSV (
   uplo   IN       flag,
   n      IN       POSITIVEN,
   nrhs   IN       POSITIVEN,
   ap     IN OUT   UTL_NLA_ARRAY_FLT,
   ipiv   IN OUT   UTL_NLA_ARRAY_INT,
   b      IN OUT   UTL_NLA_ARRAY_FLT,
   ldb    IN       POSITIVEN,
   info   OUT      INTEGER,
   pack   IN       flag DEFAULT 'C');

パラメータ

表259-55 LAPACK_SPSVプロシージャのパラメータ

パラメータ	説明
uplo	uplo = 'U'の場合。Aの上三角部分が格納されます。 uplo = 'L'の場合。Aの下三角部分が格納されます。
n	一次方程式の数(マトリックスaの位数)。N >= 0。
nrhs	右辺の数(マトリックスbの列数)。nrhs >= 0。
ap	次元(n*(n+1)/2)を持つUTL_NLA_ARRAY_FLT/DBL。 入力時は、線形配列に列方向でパックされている、対称マトリックスAの上三角または下三角部分です。Aのj番目の列は、配列apに次のように格納されます。 uplo = 'U'の場合、1<=i<=jはAP(i + (j-1)*j/2) = A(i,j)に格納されます。 uplo = 'L'の場合、j<=i<=nはAP(i + (j-1)*(2n-j)/2) = A(i,j)に格納されます。 詳細は、次の説明を参照してください。 終了時は、ブロック対角マトリックスD、およびSSPTRFで計算される場合と同様に分解A = U*D*U**TまたはA = L*D*L**Tから係数UまたはLを取得する場合に使用される乗数です。これらは、Aと同じ格納形式で、パックされた三角マトリックスとして格納されます。
ipiv	次元(n)を持つINTEGER配列。 SSPTRFで決定される、交換およびdのブロック構造の詳細。 ipiv(k) > 0の場合、行と列kおよびipiv(k)が交換され、d(k,k)が1行1列の対角ブロックになります。 uplo = 'U'およびipiv(k) = ipiv(k-1) < 0の場合、行と列k-1および-ipiv(k)が交換され、d(k-1:k,k-1:k)が2行2列の対角ブロックになります。 uplo = 'L'およびipiv(k) = ipiv(k+1) < 0の場合、行と列k+1および-ipiv(k)が交換され、d(k:k+1,k:k+1)が2行2列の対角ブロックになります。
b	次元(ldb, nrhs)を持つUTL_NLA_ARRAY_FLT/DBL。 入力時は、n行nrhs列の右辺マトリックスbです。 終了時、info = 0の場合は、n行nrhs列の解マトリックスXです。
ldb	配列bの先頭の次元。 ldb >= max(1,n)
info	= 0: 正常終了 < 0: info = -iの場合、i番目の引数に無効な値が含まれています。 > 0: info = iの場合、d(i,i)は正確に0(ゼロ)になります。分解は完了しましたが、ブロック対角マトリックスUは真性特異点であるため、解を得ることはできませんでした。
pack	(オプション)マトリックスのパッキングのフラグを設定します。 'C': 列優先(デフォルト) 'R': 行優先

LAPACK_STEVプロシージャ

このプロシージャは、すべての固有値を計算します。また、オプションで、実対称三重対角マトリックスAの固有ベクトルを計算します。

関連項目: このグループの他のサブプログラムについては、「LAPACKドライバ・ルーチン(LLSおよび固有値問題)サブプログラム」を参照してください。

構文

UTL_NLA.LAPACK_STEV (
   jobz     IN      flag,
   n        IN      POSITIVEN,
   d        IN OUT  UTL_NLA_ARRAY_DBL,
   e        IN OUT  UTL_NLA_ARRAY_DBL,
   z        IN OUT  UTL_NLA_ARRAY_DBL,
   ldz      IN      POSITIVEN,
   info     OUT     INTEGER,
   pack     IN      flag DEFAULT 'C');

UTL_NLA.LAPACK_STEV (
   jobz     IN      flag,
   n        IN      POSITIVEN,
   d        IN OUT  UTL_NLA_ARRAY_FLT,
   e        IN OUT  UTL_NLA_ARRAY_FLT,
   z        IN OUT  UTL_NLA_ARRAY_FLT,
   ldz      IN      POSITIVEN,
   info     OUT     INTEGER,
   pack     IN      flag DEFAULT 'C');

パラメータ

表259-56 LAPACK_STEVプロシージャのパラメータ

パラメータ	説明
jobz	'N': 固有値のみが計算されます。 'V': 固有値および固有ベクトルが計算されます。
n	マトリックスaの位数。N >= 0。
d	次元(n)を持つUTL_NLA_ARRAY_FLT/DBL。 入力時は、三重対角マトリックスAのn個の対角要素です。 終了時、info = 0の場合は、昇順の固有値です。
e	次元(n)を持つUTL_NLA_ARRAY_FLT/DBL。 入力時は、eの要素1からn-1に格納されている、三重対角マトリックスAの(n-1)個の下対角要素です。e(n)は、設定する必要がありませんが、サブプログラムで使用されます。 終了時、eの内容が破損されます。
z	次元(ldz, n)を持つUTL_NLA_ARRAY_FLT/DBL。 jobz = 'V'で、info = 0の場合は、zにマトリックスAの正規直交ベクトルが含まれます。この場合、zのi番目の列にd(i)に関連付けられた固有ベクトルが含まれます。 jobz = 'N'の場合、zは参照されません。
ldz	配列zの先頭の次元。ldz >= 1です。jobz = 'v'の場合は、ldz >= max(1,n)です。
info	= 0: 正常終了 < 0: info = -iの場合、i番目の引数に無効な値が含まれています。 > 0: info = iの場合、アルゴリズムを使用して収束できませんでした。中間二重対角形式のi個の非対角要素は、0(ゼロ)に収束しませんでした。
pack	(オプション)マトリックスのパッキングのフラグを設定します。 'C': 列優先(デフォルト) 'R': 行優先

LAPACK_STEVDプロシージャ

このプロシージャは、すべての固有値を計算します。また、オプションで、実対称三重対角マトリックスの固有ベクトルを計算します。固有ベクトルが必要な場合は、浮動小数点演算に関する緩やかな仮定を設ける分割統治法アルゴリズムを使用します。

関連項目: このグループの他のサブプログラムについては、「LAPACKドライバ・ルーチン(LLSおよび固有値問題)サブプログラム」を参照してください。

構文

UTL_NLA.LAPACK_STEVD (
   jobz     IN      flag,
   n        IN      POSITIVEN,
   d        IN OUT  UTL_NLA_ARRAY_DBL,
   e        IN OUT  UTL_NLA_ARRAY_DBL,
   z        IN OUT  UTL_NLA_ARRAY_DBL,
   ldz      IN      POSITIVEN,
   info     OUT     INTEGER,
   pack     IN      flag DEFAULT 'C');

UTL_NLA.LAPACK_STEVD(
   jobz     IN      flag,
   n        IN      POSITIVEN,
   d        IN OUT  UTL_NLA_ARRAY_FLT,
   e        IN OUT  UTL_NLA_ARRAY_FLT,
   z        IN OUT  UTL_NLA_ARRAY_FLT,
   ldz      IN      POSITIVEN,
   info     OUT     INTEGER,
   pack     IN      flag DEFAULT 'C');

パラメータ

表259-57 LAPACK_STEVDプロシージャのパラメータ

パラメータ	説明
jobz	'N': 固有値のみが計算されます。 'V': 固有値および固有ベクトルが計算されます。
n	マトリックスaの位数。N >= 0。
d	次元(n)を持つUTL_NLA_ARRAY_FLT/DBL。 入力時は、三重対角マトリックスAのn個の対角要素です。 終了時、info = 0の場合は、昇順の固有値です。
e	次元(n)を持つUTL_NLA_ARRAY_FLT/DBL。 入力時は、eの要素1からn-1に格納されている、三重対角マトリックスAの(n-1)個の下対角要素です。e(n)は、設定する必要がありませんが、サブプログラムで使用されます。 終了時、eの内容が破損されます。
z	次元(ldz, n)を持つUTL_NLA_ARRAY_FLT/DBL。 jobz = 'V'で、info = 0の場合は、zにマトリックスAの正規直交ベクトルが含まれます。この場合、zのi番目の列にd(i)に関連付けられた固有ベクトルが含まれます。 jobz = 'N'の場合、zは参照されません。
ldz	配列zの先頭の次元。ldz >= 1です。jobz = 'v'の場合は、ldz >= max(1,n)です。
info	= 0: 正常終了 < 0: info = -iの場合、i番目の引数に無効な値が含まれています。 > 0: info = iの場合、アルゴリズムを使用して収束できませんでした。中間二重対角形式のi個の非対角要素は、0(ゼロ)に収束しませんでした。
pack	(オプション)マトリックスのパッキングのフラグを設定します。 'C': 列優先(デフォルト) 'R': 行優先

LAPACK_SYEVプロシージャ

このプロシージャは、すべての固有値を計算します。また、オプションで、実対称マトリックスAの固有ベクトルを計算します。

関連項目: このグループの他のサブプログラムについては、「LAPACKドライバ・ルーチン(LLSおよび固有値問題)サブプログラム」を参照してください。

構文

UTL_NLA.LAPACK_SYEV (
   jobz     IN      flag,
   uplo     IN      flag,
   n        IN      POSITIVEN,
   a        IN OUT  UTL_NLA_ARRAY_DBL,
   lda      IN      POSITIVEN,
   w        IN OUT  UTL_NLA_ARRAY_DBL,
   info     OUT     INTEGER,
   pack     IN      flag DEFAULT 'C');

UTL_NLA.LAPACK_SYEV (
   jobz     IN      flag,
   uplo     IN      flag,
   n        IN      POSITIVEN,
   a        IN OUT  UTL_NLA_ARRAY_FLT,
   lda      IN      POSITIVEN,
   w        IN OUT  UTL_NLA_ARRAY_FLT,
   info     OUT     INTEGER,
   pack     IN      flag DEFAULT 'C');

パラメータ

表259-58 LAPACK_SYEVプロシージャのパラメータ

パラメータ	説明
jobz	'N': 固有値のみが計算されます。 'V': 固有値および固有ベクトルが計算されます。
uplo	'U': Aの上三角部分が格納されます。 'L': Aの上三角部分が格納されます。
n	マトリックスaの位数。N >= 0。
a	次元(lda, n)を持つUTL_NLA_ARRAY_FLT/DBL。 入力時は、対称マトリックスaです。 uplo = 'U'の場合、aの先頭のn行n列の上三角部分にマトリックスaの上三角部分が含まれます。 uplo = 'L'の場合、aの先頭のn行n列の下三角部分にマトリックスaの下三角部分が含まれます。 終了時: jobz = 'V'で、info = 0の場合は、aにマトリックスaの正規直交固有ベクトルが含まれます。 終了時、jobz = 'N'の場合は、aの下三角部分(uplo = 'L'の場合)または上三角部分(uplo='U'の場合)が対角を含めて破損されます。
lda	配列aの先頭の次元。lda >= max(1,n)。
w	次元(n)を持つUTL_NLA_ARRAY_FLT/DBL。 info = 0の場合は、昇順の固有値です。
info	= 0: 正常終了 < 0: info = -iの場合、i番目の引数に無効な値が含まれています。 > 0: info = iの場合、アルゴリズムを使用して収束できませんでした。中間二重対角形式のi個の非対角要素は、0(ゼロ)に収束しませんでした。
pack	(オプション)マトリックスのパッキングのフラグを設定します。 'C': 列優先(デフォルト) 'R': 行優先

LAPACK_SYEVDプロシージャ

このプロシージャは、すべての固有値を計算します。また、オプションで、実対称マトリックスAの固有ベクトルを計算します。固有ベクトルが必要な場合は、浮動小数点演算に関する緩やかな仮定を設ける分割統治法アルゴリズムを使用します。

関連項目: このグループの他のサブプログラムについては、「LAPACKドライバ・ルーチン(LLSおよび固有値問題)サブプログラム」を参照してください。

構文

UTL_NLA.LAPACK_SYEVD (

   jobz     IN      flag,
   uplo     IN      flag,
   n        IN      POSITIVEN,
   a        IN OUT  UTL_NLA_ARRAY_DBL,
   lda      IN      POSITIVEN,
   w        IN OUT  UTL_NLA_ARRAY_DBL,
   info     OUT     INTEGER,
   pack     IN      flag DEFAULT 'C');

UTL_NLA.LAPACK_SYEVD (
   jobz     IN      flag,
   uplo     IN      flag,
   n        IN      POSITIVEN,
   a        IN OUT  UTL_NLA_ARRAY_FLT,
   lda      IN      POSITIVEN,
   w        IN OUT  UTL_NLA_ARRAY_FLT,
   info     OUT     INTEGER,
   pack     IN      flag DEFAULT 'C');

パラメータ

表259-59 LAPACK_SYEVDプロシージャのパラメータ

パラメータ	説明
jobz	'N': 固有値のみが計算されます。 'V': 固有値および固有ベクトルが計算されます。
uplo	'U': Aの上三角部分が格納されます。 'L': Aの上三角部分が格納されます。
n	マトリックスaの位数。N >= 0。
a	次元(lda, n)を持つUTL_NLA_ARRAY_FLT/DBL。 入力時は、対称マトリックスaです。 uplo = 'U'の場合、aの先頭のn行n列の上三角部分にマトリックスaの上三角部分が含まれます。 uplo = 'L'の場合、aの先頭のn行n列の下三角部分にマトリックスaの下三角部分が含まれます。 終了時: jobz = 'V'で、info = 0の場合は、aにマトリックスaの正規直交固有ベクトルが含まれます。 終了時、jobz = 'N'の場合は、aの下三角部分(uplo = 'L'の場合)または上三角部分(uplo='U'の場合)が対角を含めて破損されます。
lda	配列aの先頭の次元。lda >= max(1,n)。
w	次元(n)を持つUTL_NLA_ARRAY_FLT/DBL。 info = 0の場合は、昇順の固有値です。
info	= 0: 正常終了 < 0: info = -iの場合、i番目の引数に無効な値が含まれています。 > 0: info = iの場合、アルゴリズムを使用して収束できませんでした。中間二重対角形式のi個の非対角要素は、0(ゼロ)に収束しませんでした。
pack	(オプション)マトリックスのパッキングのフラグを設定します。 'C': 列優先(デフォルト) 'R': 行優先

LAPACK_SYSVプロシージャ

このプロシージャは、実連立一次方程式の解を求めます。

a * x = b

ここで、aはn行n列の対称マトリックス、xおよびbはn行nrhs列のマトリックスです。

Aの分解には、対角ピボット法が次のように使用されます。

UPLO = 'U'の場合は、A = U * D * U**Tです。

または

UPLO = 'L'の場合は、A = L * D * L**Tです。

ここで、U(またはL)は順列マトリックスと単位上(下)三角マトリックスの積、Dは1行1列および2行2列の対角ブロックを持つ対称ブロック対角マトリックスです。Aの分解された形式を使用して、連立方程式A * X = Bの解が求められます。

関連項目: このグループの他のサブプログラムについては、「LAPACKドライバ・ルーチン(一次方程式)サブプログラム」を参照してください。

構文

UTL_NLA.LAPACK_SYSV (
   uplo    IN      flag,
   n       IN      POSITIVEN,
   nrhs    IN      POSITIVEN,
   a       IN OUT  UTL_NLA_ARRAY_DBL,
   lda     IN      POSITIVEN,
   ipiv    IN OUT  UTL_NLA_ARRAY_INT,
   b       IN OUT  UTL_NLA_ARRAY_DBL,
   ldb     IN      POSITIVEN,
   info    OUT     INTEGER,
   pack    IN      flag DEFAULT 'C');

UTL_NLA.LAPACK_SYSV (
   uplo   IN       flag,
   n      IN       POSITIVEN,
   nrhs   IN       POSITIVEN,
   a      IN OUT   UTL_NLA_ARRAY_FLT,
   lda    IN       POSITIVEN,
   ipiv   IN OUT   UTL_NLA_ARRAY_INT,
   b      IN OUT   UTL_NLA_ARRAY_FLT,
   ldb    IN       POSITIVEN,
   info   OUT      INTEGER,
   pack   IN       flag DEFAULT 'C');

パラメータ

表259-60 LAPACK_SYSVプロシージャのパラメータ

パラメータ	説明
uplo	uplo = 'U'の場合。Aの上三角部分が格納されます。 uplo = 'L'の場合。Aの下三角部分が格納されます。
n	一次方程式の数(マトリックスaの位数)。N >= 0。
nrhs	右辺の数(マトリックスbの列数)。nrhs >= 0。
a	次元(n-1)を持つUTL_NLA_ARRAY_FLT/DBL。 入力時は、対称マトリックスaです。UPLO = 'U'の場合、aの先頭のn行n列の上三角部分にマトリックスaの上三角部分が含まれ、aの狭義下三角部分は参照されません。uplo = 'L'の場合、aの先頭のn行n列の下三角部分にマトリックスaの下三角部分が含まれ、aの狭義上三角部分は参照されません。 終了時、info = 0の場合は、ブロック対角マトリックスd、およびSSYTRFで計算される場合と同様に分解A = U*D*U**TまたはA = L*D*L**Tから係数UまたはLを取得する場合に使用される乗数です。
lda	配列aの先頭の次元。 lda >= max(1,n)
ipiv	次元(ldb, nrhs)を持つINTEGER配列。 SSYTRFで決定される、交換およびdのブロック構造の詳細。 ipiv(k) > 0の場合、行と列kおよびipiv(k)が交換され、d(k,k)が1行1列の対角ブロックになります。 uplo = 'U'およびipiv(k) = ipiv(k-1) < 0の場合、行と列k-1および-ipiv(k)が交換され、d(k-1:k,k-1:k)が2行2列の対角ブロックになります。 uplo = 'L'およびipiv(k) = ipiv(k+1) < 0の場合、行と列k+1および-ipiv(k)が交換され、d(k:k+1,k:k+1)が2行2列の対角ブロックになります。
b	次元(ldb, nrhs)を持つUTL_NLA_ARRAY_FLT/DBL。 入力時は、右辺マトリックスbのn行nrhs列のマトリックスです。 終了時、info = 0の場合は、n行nrhs列の解マトリックスXです。
ldb	配列bの先頭の次元。 ldb >= max(1,n)
info	= 0: 正常終了 < 0: info = -iの場合、i番目の引数に無効な値が含まれています。 > 0: info = iの場合、d(i,i)は正確に0(ゼロ)になります。分解は完了しましたが、ブロック対角マトリックスUは真性特異点であるため、解を得ることはできませんでした。
pack	(オプション)マトリックスのパッキングのフラグを設定します。 'C': 列優先(デフォルト) 'R': 行優先