プログラミング演習Ⅱ（課題３，第２回）

モジュール化の１つの目的は，汎用なライブラリを作成し，様々なプログラムで流用することである．
ここでは，複素数，ベクトル，行列を汎用に扱うためのモジュールを作成する．

複素数モジュールの作成

Ｃ言語では，int， float， doubleといった整数，実数を扱うための型は用意されているが，複素数を扱う型は用意されていない．
Ｃ言語で複素数を扱うことは，数値計算や信号処理などの分野で一般的であるので，ここでは，Ｃ言語での複素数を扱うモジュールを作成する．
複素数の加算や減算などの演算を行う際に，intやfloat型のような演算子(+や-など)は利用できない(C++では演算子のオーバーロードが可能（興味のある人はプログラミング演習３第5回～第7回を参照）)ので，Ｃ言語では演算用の関数を自作する必要がある．
構造体を用いて複素数を扱うための参考資料(プログラミング演習２課題１)

練習問題１）複素数構造体や関数プロトタイプが記載されているcomplex.hを参考にして、complex.cを編集して，以下の関数を作成せよ(complex.hは編集不要).
テストのためのmain関数としてcomplex_test.cを利用すること（complex_test.cの内容は必要に応じて改変可）

複素数の実部，虚部を引数に与えて，その複素数を返す関数(complex_number_new)
複素数を引数に与えて，その実部を返す関数(complex_number_real)
複素数を引数に与えて，その虚部を返す関数(complex_number_imag)
複素数を引数に与えて，その複素共役を返す関数(complex_number_conj)
複素数を引数に与えて，その絶対値を返す関数(complex_number_abs)
複素数を引数に与えて，その偏角を返す関数(complex_number_arg)
複素数の絶対値と偏角を引数に与えて，その複素数を返す関数(complex_number_polar)

数学関数に関してはプログラミング演習１課題４を参照

complex.h

#ifndef COMPLEX_H
#define COMPLEX_H

#include <stdio.h>
#include <math.h>

/*******************************************************************************
 * 複素数を表現する構造体
 ******************************************************************************/
struct complex_number { 
    double real; /**< 実数部 */
    double imag; /**< 虚数部 */
};

/*******************************************************************************
 * 複素数の表示
 * @param a 表示する複素数
 ******************************************************************************/
void complex_number_print(struct complex_number a);

/*******************************************************************************
 * 複素数の加算
 * @param a 複素数a
 * @param b 複素数b
 * @return a + b
 ******************************************************************************/
struct complex_number
complex_number_add(struct complex_number a, struct complex_number b);

/*******************************************************************************
 * 複素数の減算
 * @param a 複素数a
 * @param b 複素数b
 * @return a - b
 ******************************************************************************/
struct complex_number
complex_number_sub(struct complex_number a, struct complex_number b);

/*******************************************************************************
 * 複素数の乗算
 * @param a 複素数a
 * @param b 複素数b
 * @return a * b
 ******************************************************************************/
struct complex_number
complex_number_mul(struct complex_number a, struct complex_number b);

/*******************************************************************************
 * 複素数の除算
 * @param a 複素数a
 * @param b 複素数b
 * @return a / b
 ******************************************************************************/
struct complex_number
complex_number_div(struct complex_number a, struct complex_number b);

/*******************************************************************************
 * 複素数の実部と虚部を与えて複素数を返す
 * @param real 複素数の実部
 * @param imag 複素数の虚部
 * @return (real) + (imag) i
 ******************************************************************************/
struct complex_number
complex_number_new(double real, double imag);

/*******************************************************************************
 * 複素数の実部
 * @param a 複素数a
 * @return 複素数aの実部 (real)
 ******************************************************************************/
double
complex_number_real(struct complex_number a);

/*******************************************************************************
 * 複素数の虚部
 * @param a 複素数a
 * @return 複素数aの虚部 (imag)
 ******************************************************************************/
double
complex_number_imag(struct complex_number a);

/*******************************************************************************
 * 複素数の共役
 * @param a 複素数a
 * @return 複素数aの複素共役
 ******************************************************************************/
struct complex_number
complex_number_conj(struct complex_number a);

/*******************************************************************************
 * 複素数の絶対値
 * @param a 複素数a
 * @retval 複素数aの絶対値 (|a|)
 ******************************************************************************/
double
complex_number_abs(struct complex_number a);

/*******************************************************************************
 * 複素数の偏角
 * @param a 複素数a
 * @return 複素数aの偏角
 ******************************************************************************/
double
complex_number_arg(struct complex_number a);

/*******************************************************************************
 * 絶対値と偏角を与えて複素数を返す
 * @param abs 絶対値
 * @param arg 偏角
 * @return 複素数
 ******************************************************************************/
struct complex_number
complex_number_polar(double abs, double arg);

#endif

complex.c

#include "complex.h"

void
complex_number_print(struct complex_number a) {
    if (a.imag < 0) {
        printf("%f%fi", a.real, a.imag);
    } else {
        printf("%f+%fi", a.real, a.imag);
    }
}

struct complex_number
complex_number_add(struct complex_number a, struct complex_number b) {
    struct complex_number result;

    result.real = a.real + b.real;
    result.imag = a.imag + b.imag;

    return result;
}

struct complex_number
complex_number_sub(struct complex_number a, struct complex_number b) {
    struct complex_number result;

    result.real = a.real - b.real;
    result.imag = a.imag - b.imag;

    return result;
}

struct complex_number
complex_number_mul(struct complex_number a, struct complex_number b) {
    struct complex_number result;

    result.real = a.real * b.real - a.imag * b.imag;
    result.imag = a.real * b.imag + a.imag * b.real;

    return result;
}

struct complex_number
complex_number_div(struct complex_number a, struct complex_number b) {
    struct complex_number result = {0.0, 0.0};
    double d;

    d = b.real * b.real + b.imag * b.imag;
    if (d == 0.0) {
        printf("divided by zero\n");
        return result;
    }

    result.real = (a.real * b.real + a.imag * b.imag) / d;
    result.imag = (-a.real * b.imag + a.imag * b.real) / d;

    return result;
}

struct complex_number
complex_number_new(double real, double imag) {
    /* 複素数の実部，虚部を引数に与えて，その複素数を返す関数を実装しなさい */
}

double
complex_number_real(struct complex_number a) {
    /* 複素数を引数に与えて，その実部を返す関数を実装しなさい */
}

double
complex_number_imag(struct complex_number a) {
    /* 複素数を引数に与えて，その虚部を返す関数を実装しなさい */
}

struct complex_number
complex_number_conj(struct complex_number a) {
    /* 複素数を引数に与えて，その複素共役を返す関数を実装しなさい */
}

double
complex_number_abs(struct complex_number a) {
    /* 複素数を引数に与えて，その絶対値を返す関数を実装しなさい */
}

double
complex_number_arg(struct complex_number a) {
    /* 複素数を引数に与えて，その偏角を返す関数を実装しなさい */
}

struct complex_number
complex_number_polar(double abs, double arg) {
    /* 複素数の絶対値と偏角を引数に与えて，その複素数を返す関数を実装しなさい */
}

complex_test.c (テストのためのメイン関数)

#include <stdlib.h>
#include "complex.h"

int
main(void) {
    struct complex_number z;
    double abs, arg;

    /* 適当な複素数を設定 */
    z = complex_number_new(3.0, 4.0);

    /* zを表示 */
    /* 【解答例】 z = 3.000000+4.000000i */
    printf("z = ");
    complex_number_print(z); 
    printf("\n");


    /* zの複素共役を表示 */
    /* 【解答例】 conj(z) = 3.000000-4.000000i */
    printf("conj(z) = ");
    complex_number_print(complex_number_conj(z)); 
    printf("\n");

    /* zの絶対値を表示 */
    /* 【解答例】 abs(z) = 5.000000 */
    abs = complex_number_abs(z); 
    printf("abs(z) = %f\n", abs);

    /* zの偏角を表示 */ 
    /* 【解答例】 arg(z) = 0.927295 */
    arg = complex_number_arg(z); 
    printf("arg(z) = %f\n", arg);

    /* absとargを与えて複素数を表示 */
    /* 【解答例】 polar(abs,arg) = 3.000000+4.000000i */
    printf("polar(abs,arg) = ");
    complex_number_print(complex_number_polar(abs, arg)); 
    printf("\n");

    return (EXIT_SUCCESS);
}

ベクトル，行列モジュールの作成

ベクトル，行列を汎用に扱う場合の問題点

あらかじめ配列のサイズはわかっているが可変の場合

ソースコードを書き換えて再コンパイルが必要

あらかじめ配列のサイズがわかっていない場合 (例えば，標準入力，ファイルからパラメタが渡される)

十分に大きなサイズの配列を確保しておく(完全な方法ではない)
動的にサイズを変更できる配列を用意する (動的メモリ確保のための参考資料（プログラミング演習２課題２）)

配列を関数に渡す場合の問題点

１元配列を関数に渡す場合はその要素数は省略できるので、配列の長さに対して汎用な関数を作成することが可能
２次元以上の配列を関数に渡す場合，配列の構造を関数の引数に指示してやる必要があるので汎用な関数を作成することは不可能

関数に渡されるのはその先頭アドレスだけなので，関数側ではデータの区切りが判らない．

/* １次元配列の要素の合計を計算する関数 */
int
sum_vec(int a[],int m){ // １次元配列を関数に渡す場合、その要素数は省略できるので、配列の長さに対して汎用な関数を作成することが可能
	int i;
	int x = 0;
	for(i=0;i<m;i++) {
		x += a[i];
	}
	return x;
}
/* ２次元配列の要素の合計を計算する関数 */
int 
sum_mat(int a[][3],int n){ // ２次元以上の配列を関数に渡す場合，配列の構造を関数の引数に指示してやる必要があるので汎用な関数を作成することは不可能(a[][]とは出来ない)
	int i,j;
	int x = 0;
	for(i=0;i<n;i++) {
		for(j=0;j<3;j++) {
			x += a[i][j];
		}
	}
	return x;
}

int
main(void){
	int M = 3;
	int N = 2;
	int a[3] = {1,2,3};
	int b[2][3] = {{1,2,3},{4,5,6}};

	printf("１次元配列aの要素の合計値は %d\n",sum_vec(a,M)); /* １次元配列を関数に渡す */
	printf("２次元配列bの要素の合計値は %d\n",sum_mat(b,N)); /* ２次元配列を関数に渡す */
	
	return (EXIT_SUCCESS);
}

１次元配列を動的に確保する

練習問題２） 以下のarray1d.c, array1d.h, array1d_test.cで構成されるarray1dというプロジェクトを作成し，動作の確認をせよ．

array1d.h

#ifndef ARRAY1D_H
#define ARRAY1D_H

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

typedef double* vector;

/*******************************************************************************
 * 要素数nの１次元配列を動的に確保
 * @param n １次元配列の要素数
 * @return 確保した１次元配列
 ******************************************************************************/
vector
ARRAY1D_new(int n);

/*******************************************************************************
 * 確保した１次元配列を開放
 * @param ptr 開放する１次元配列
 ******************************************************************************/
void
ARRAY1D_delete(vector ptr);

/*******************************************************************************
 * 要素数nの１次元配列ptr2をptr1にコピー
 * @param ptr1 コピー先の１次元配列
 * @param ptr2 コピー元の１次元配列
 * @param n １次元配列の要素数
 ******************************************************************************/
void
ARRAY1D_copy(vector ptr1, const vector ptr2, int n);

/*******************************************************************************
 * 要素数nの２次元配列ptrをformatに従って標準出力に表示
 * @param ptr 出力する１次元配列
 * @param n １次元配列の要素数
 * @param format 出力形式（prinfの第１引数）
 ******************************************************************************/
void
ARRAY1D_print(const vector ptr, int n, char* format);

#endif

array1d.c

#include "array1d.h"

vector
ARRAY1D_new(int n) {
    vector ptr;
    ptr = (vector) malloc(n * sizeof (double));
    if (ptr == NULL) { // 割当に失敗したら
        printf("allocation failure in ARRAY1D_new()\n");
        exit(EXIT_FAILURE);
    }
    return ptr;
}

void
ARRAY1D_delete(vector ptr) {
    free(ptr);
}

void
ARRAY1D_copy(vector ptr1, const vector ptr2, int n) {
    int i;
    for (i = 0; i < n; i++) {
        ptr1[i] = ptr2[i];
    }
}

void
ARRAY1D_print(const vector ptr, int n, char* format) {
    int i;
    printf("[");
    for (i = 0; i < n; i++) {
        printf(format, ptr[i]);
        if (i < n - 1) {
            printf(",");
        }
    }
    printf("]\n");
}

array1d_test.c (テストのためのメイン関数)

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

int
main(int argc, char** argv) {
    int N;
    vector vec1, vec2;

    /* １次元配列の大きさ設定 */
    N = 4;

    /* 領域確保 */
    vec1 = ARRAY1D_new(N);
    vec2 = ARRAY1D_new(N);

    /* 要素の代入 */
    vec1[0] = 0.2;
    vec1[1] = 1.3;
    vec1[2] = 2.5;
    vec1[3] = 3.6;

    /* vec1の要素の表示 */ 
    /* 【解答例】 vec1 = [0.200000, 1.300000, 2.500000, 3.600000] */
    printf("vec1 = ");
    ARRAY1D_print(vec1, N, "%f"); 

    /* １次元配列の要素のコピー */
    ARRAY1D_copy(vec2, vec1, N);

    /* vec2の要素の表示 */ 
    /* 【解答例】 vec2 = [0.200000,1.300000,2.500000,3.600000] */
    printf("vec2 = ");
    ARRAY1D_print(vec2, N, "%f"); 

    /* 領域の開放 */
    ARRAY1D_delete(vec1);
    ARRAY1D_delete(vec2);

    return (EXIT_SUCCESS);
}

２次元配列を動的に確保する

練習問題３） array1d.cを参考にして，array2d.hの関数プロトタイプに従って、array2d.cに以下の関数を作成せよ（array2d.hは編集不要）

m×nの２次元配列ptr2をptr1にコピーする関数(ARRAY2D_copy)
m×nの２次元配列をformatに従って出力する関数(ARRAY2D_print)

array2d.h

#ifndef ARRAY2D_H
#define ARRAY2D_H

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

typedef double** matrix;

/*******************************************************************************
 * m×nの２次元配列を動的に確保
 * @param m 行数
 * @param n 列数
 * @return 確保した２次元配列
 ******************************************************************************/
matrix
ARRAY2D_new(int m, int n);

/*******************************************************************************
 * 確保したm×*の２次元配列を開放
 * @param ptr 開放する２次元配列
 * @param m ２次元配列の行数
 ******************************************************************************/
void
ARRAY2D_delete(matrix ptr, int m);

/*******************************************************************************
 * m×nの２次元配列ptr2をptr1にコピー
 * @param ptr1 コピー先の２次元配列
 * @param ptr2 コピー元の２次元配列
 * @param m ２次元配列の行数
 * @param n ２次元配列の列数
 ******************************************************************************/
void
ARRAY2D_copy(matrix ptr1, const matrix ptr2, int m, int n);

/*******************************************************************************
 * 要素数nの２次元配列ptrをformatに従って標準出力に表示
 * @param ptr 出力する２次元配列
 * @param m ２次元配列の行数
 * @param n ２次元配列の列数
 * @param format 出力形式（prinfの第１引数）
 ******************************************************************************/
void
ARRAY2D_print(const matrix ptr, int m, int n, char* format);

#endif

array2d.c

#include "array2d.h"

matrix
ARRAY2D_new(int m, int n) {
    int i;
    matrix ptr;
    ptr = (double**) malloc(m * sizeof (double*));
    if (ptr == NULL) { /* 割当に失敗したら */
        printf("allocation failure in ARRAY2D_new()\n");
        exit(EXIT_FAILURE);
    }
    for (i = 0; i < m; i++) {
        ptr[i] = (double*) malloc(n * sizeof (double));
        if (ptr[i] == NULL) { /* 割当に失敗したら */
            while (--i >= 0) {
                free(ptr[i]);
            }
            free(ptr);
            printf("allocation failure in ARRAY2D_new()\n");
            exit(EXIT_FAILURE);
        }
    }
    return ptr;
}

void
ARRAY2D_delete(matrix ptr, int m) {
    int i;
    for (i = 0; i < m; i++) {
        free(ptr[i]);
    }
    free(ptr);
}

void
ARRAY2D_copy(matrix ptr1, const matrix ptr2, int m, int n) {
    /* m×nの２次元配列ptr2をptr1にコピーする関数を実装せよ */
}

void
ARRAY2D_print(const matrix ptr, int m, int n, char* format) {
    /* m×nの２次元配列をformatに従って出力する関数を実装せよ */
}

array2d_test.c (テストのためのメイン関数)

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

int
main(int argc, char** argv) {
    int M, N;
    matrix mat1;
    matrix mat2;

    /* 行列の大きさ */
    M = 3;
    N = 4;

    /* 領域の確保 */
    mat1 = ARRAY2D_new(M, N);
    mat2 = ARRAY2D_new(M, N);

    /* 要素の代入 */
    mat1[0][0] = 1.9;
    mat1[0][1] = 2.8;
    mat1[0][2] = 3.7;
    mat1[0][3] = 4.6;
    mat1[1][0] = 7.1;
    mat1[1][1] = 6.2;
    mat1[1][2] = 5.3;
    mat1[1][3] = 4.4;
    mat1[2][0] = 2.3;
    mat1[2][1] = 4.6;
    mat1[2][2] = 6.9;
    mat1[2][3] = 8.1;

    /* mat1の要素の表示 */
    /* 【解答例】 mat1 = [1.900000,2.800000,3.700000,4.600000,
     * 7.100000,6.200000,5.300000,4.400000,
     * 2.300000,4.600000,6.900000,8.100000] */
    printf("mat1 = ");
    ARRAY2D_print(mat1, M, N, "%f");

    /* ２次元配列のコピー */
    ARRAY2D_copy(mat2, mat1, M, N);

    /* mat2の要素の表示 */
    /* 【解答例】 mat2 = [1.900000,2.800000,3.700000,4.600000,
     * 7.100000,6.200000,5.300000,4.400000,
     * 2.300000,4.600000,6.900000,8.100000] */
    printf("mat2 = ");
    ARRAY2D_print(mat2, M, N, "%f");

    /* 領域の開放 */
    ARRAY2D_delete(mat1, M);
    ARRAY2D_delete(mat2, M);

    return (EXIT_SUCCESS);
}

ベクトル，行列演算のモジュールの作成

練習問題４） array_utils.hの関数プロトタイプに従って，数種のベクトル，行列の演算を行う関数を作成せよ(array_utils.hは編集不要)．

ベクトル，行列の演算の参考資料

array_utils.h

#ifndef ARRAY_UTILS_H
#define ARRAY_UTILS_H

#include "array1d.h"
#include "array2d.h"

/*******************************************************************************
 * n×1の１次元配列a,b,cにおいてc=a+bを計算
 * @param c 要素nの１次元配列（a+bで上書きされる）
 * @param a 要素nの１次元配列
 * @param b 要素nの１次元配列
 * @param n １次元配列の要素数
 ******************************************************************************/
void
ARRAY_UTILS_vec_add(vector c, const vector a, const vector b, int n);

/*******************************************************************************
 * n×1の１次元配列a,b,cにおいてc=a-bを計算
 * @param c 要素nの１次元配列（a-bで上書きされる）
 * @param a 要素nの１次元配列
 * @param b 要素nの１次元配列
 * @param n １次元配列の要素数
 ******************************************************************************/
void
ARRAY_UTILS_vec_sub(vector c, const vector a, const vector b, int n);

/*******************************************************************************
 * m×nの２次元配列a,b,cにおいてc=a+bを計算
 * @param c m×nの２次元配列（a+bで上書きされる）
 * @param a m×nの２次元配列
 * @param b m×nの２次元配列
 * @param m ２次元配列の行数
 * @param n ２次元配列の列数
 ******************************************************************************/
void
ARRAY_UTILS_mat_add(matrix c, const matrix a, const matrix b, int m, int n);

/*******************************************************************************
 * m×nの２次元配列a,b,cにおいてc=a-bを計算
 * @param c m×nの２次元配列（a-bで上書きされる）
 * @param a m×nの２次元配列
 * @param b m×nの２次元配列
 * @param m ２次元配列の行数
 * @param n ２次元配列の列数
 ******************************************************************************/
void
ARRAY_UTILS_mat_sub(matrix c, const matrix a, const matrix b, int m, int n);

/*******************************************************************************
 * l×mの２次元配列a，m×nの２次元配列b，l×nの２次元配列cにおいてc=abを計算
 * @param c l×nの２次元配列（abで上書きされる）
 * @param a l×mの２次元配列
 * @param b m×nの２次元配列
 * @param l ２次元配列c, aの行数
 * @param m ２次元配列aの列数、２次元配列bの行数
 * @param n ２次元配列c, bの列数
 ******************************************************************************/
void
ARRAY_UTILS_mat_mul(matrix c, const matrix a, const matrix b, int l, int m, int n);

/*******************************************************************************
 * m×nの２次元配列a，n×1の１次元配列b，m×1の１次元配列cにおいてc=abを計算
 * @param c m×1の１次元配列（abで上書きされる）
 * @param a m×nの２次元配列
 * @param b n×1の１次元配列
 * @param m ２次元配列aの列数、１次元配列cの要素数
 * @param n ２次元配列aの列数、１次元配列bの要素数
 ******************************************************************************/
void
ARRAY_UTILS_mat_vec_mul(vector c, const matrix a, const vector b, int m, int n);

#endif

array_utils.c

#include "array_utils.h"

void
ARRAY_UTILS_vec_add(vector c, const vector a, const vector b, int n) {
    /* n×1の１次元配列a,b,cにおいてc=a+bを計算 */
}

void
ARRAY_UTILS_vec_sub(vector c, const vector a, const vector b, int n) {
    /* n×1の１次元配列a,b,cにおいてc=a-bを計算 */
}

void
ARRAY_UTILS_mat_add(matrix c, const matrix a, const matrix b, int m, int n) {
    /* m×nの２次元配列a,b,cにおいてc=a+bを計算 */
}

void
ARRAY_UTILS_mat_sub(matrix c, const matrix a, const matrix b, int m, int n) {
    /* m×nの２次元配列a,b,cにおいてc=a-bを計算 */
}

void
ARRAY_UTILS_mat_mul(matrix c, const matrix a, const matrix b, int l, int m, int n) {
    /* l×mの２次元配列a，m×nの２次元配列b，l×nの２次元配列cにおいてc=abを計算 */
}

void
ARRAY_UTILS_mat_vec_mul(vector c, const matrix a, const vector b, int m, int n) {
    /* m×nの２次元配列a，n×1の１次元配列b，m×1の１次元配列cにおいてc=abを計算 */
}

array_test.c　(テストのためのメイン関数)

#include <stdio.h>
#include <stdlib.h>
#include "array1d.h"
#include "array2d.h"
#include "array_utils.h"

int
main(void) {
    int i, j;

    /* ベクトル・行列のサイズ */
    int L = 3;
    int M = 2;
    int N = 3;

    /* ベクトル */
    vector vec1 = ARRAY1D_new(N);
    vector vec2 = ARRAY1D_new(N);
    vector vec3 = ARRAY1D_new(N);
    vector vec4 = ARRAY1D_new(M);

    /* 行列 */
    matrix mat1 = ARRAY2D_new(M, N);
    matrix mat2 = ARRAY2D_new(M, N);
    matrix mat3 = ARRAY2D_new(M, N);
    matrix mat4 = ARRAY2D_new(L, M);
    matrix mat5 = ARRAY2D_new(L, N);

    /* vec1の初期化 */
    for (i = 0; i < N; i++) {
        vec1[i] = 3 * i + 1;
    }

    /* vec1の表示 */
    /* 【解答例】 vec1 = [1.000000,4.000000,7.000000] */
    printf("vec1 = ");
    ARRAY1D_print(vec1, N, "%f");

    /* １次元配列のコピー　vec2 = vec1 */
    ARRAY1D_copy(vec2, vec1, N);

    /* vec2の表示 */
    /* 【解答例】 vec2 = [1.000000,4.000000,7.000000] */
    printf("vec2 = ");
    ARRAY1D_print(vec2, N, "%f");

    /* １次元配列の加算　vec3 = vec1 + vec2 */
    ARRAY_UTILS_vec_add(vec3, vec1, vec2, N);

    /* vec3の表示 */
    /* 【解答例】 vec3 = vec1 + vec2 = [2.000000,8.000000,14.000000] */
    printf("vec3 = vec1 + vec2 = ");
    ARRAY1D_print(vec3, N, "%f");

    /* １次元配列の減算　vec3 = vec1 - vec2 */
    ARRAY_UTILS_vec_sub(vec3, vec1, vec2, N);

    /* vec3の表示 */
    /* 【解答例】 vec3 = vec1 - vec2 = [0.000000,0.000000,0.000000] */
    printf("vec3 = vec1 - vec2 = ");
    ARRAY1D_print(vec3, N, "%f");

    /* mat1の初期化 */
    for (i = 0; i < M; i++) {
        for (j = 0; j < N; j++) {
            mat1[i][j] = i + j;
        }
    }

    /* mat1の表示 */
    /* 【解答例】 mat1 =
     * [0.000000,1.000000,2.000000,
     * 1.000000,2.000000,3.000000] */
    printf("mat1 =\n");
    ARRAY2D_print(mat1, M, N, "%f");

    /* ２次元配列のコピー　mat2 = mat1 */
    ARRAY2D_copy(mat2, mat1, M, N);

    /* mat2の表示 */
    /* 【解答例】 mat2 =
     * [0.000000,1.000000,2.000000,
     * 1.000000,2.000000,3.000000] */
    printf("mat2 =\n");
    ARRAY2D_print(mat2, M, N, "%f");

    /* ２次元配列の加算　mat3 = mat1 + mat2 */
    ARRAY_UTILS_mat_add(mat3, mat1, mat2, M, N);

    /* mat3の表示 */
    /* 【解答例】 mat3 = mat1 + mat2 =
     * [0.000000,2.000000,4.000000,
     * 2.000000,4.000000,6.000000] */
    printf("mat3 = mat1 + mat2 = \n");
    ARRAY2D_print(mat3, M, N, "%f");

    /* ２次元配列の加算　mat3 = mat1 - mat2 */
    ARRAY_UTILS_mat_sub(mat3, mat1, mat2, M, N);

    /* mat3の表示 */
    /* 【解答例】 mat3 = mat1 - mat2 =
     * [0.000000,0.000000,0.000000,
     * 0.000000,0.000000,0.000000] */
    printf("mat3 = mat1 - mat2 =\n");
    ARRAY2D_print(mat3, M, N, "%f");

    /* mat4の初期化 */
    for (i = 0; i < L; i++) {
        for (j = 0; j < M; j++) {
            mat4[i][j] = i + j;
        }
    }

    /* mat4の表示 */
    /* 【解答例】 mat4 = [0.000000,1.000000,
     * 1.000000,2.000000,
     * 2.000000,3.000000] */
    printf("mat4 =\n");
    ARRAY2D_print(mat4, L, M, "%f");

    /* ２次元配列の乗算　mat5 = mat4 * mat1 */
    ARRAY_UTILS_mat_mul(mat5, mat4, mat1, L, M, N);

    /* mat5の表示 */
    /* 【解答例】 mat5 = mat4 * mat1 =
     * [1.000000,2.000000,3.000000,
     * 2.000000,5.000000,8.000000,
     * 3.000000,8.000000,13.000000] */
    printf("mat5 = mat4 * mat1 =\n");
    ARRAY2D_print(mat5, L, N, "%f");

    /* ２次元配列と１次元配列の乗算　vec4 = mat1 * vec1 */
    ARRAY_UTILS_mat_vec_mul(vec4, mat1, vec1, M, N);

    /* vec4の表示 */
    /* 【解答例】 vec4 = mat1 * vec1 = [18.000000,30.000000] */
    printf("vec4 = mat1 * vec1 = ");
    ARRAY1D_print(vec4, M, "%f");

    return (EXIT_SUCCESS);
}