例題Ｗ２－４　応用演算

次は例題Ｗ２─２で簡単な四則演算と論理演算程度の計算を行う仲間の集まり（クラス）を定義しましたが、これを少し発展させてみたいと思います。その機能拡張として、平方根、累乗、消費税計算の機能を加えてみます。

新しい計算の仲間は、応用計算を基本計算から継承させる仲間の集まり（クラス）として定義しています。また今回はクラス名を日本語カスタマイザーの自動変数定義で行いました。

//　応用計算を基本計算から継承させる仲間の集まり（クラス）を作る
入出力の仲間を呼ぶ
数学の仲間を呼ぶ
標準的な名前空間;

仲間の集まり 基本計算の仲間
{

全域で使用可:

	基本計算の仲間(型なし) { /* 表示する ← "基本計算の対象を組み立てる" ← 改行; */ };

	実数型 足す  ( 実数型, 実数型 );
	実数型 引く  ( 実数型, 実数型 );
	実数型 掛ける( 実数型, 実数型 );
	実数型 割る  ( 実数型, 実数型 );
	整数型 余り  ( 整数型, 整数型 );

	論理型 論理積( 論理型, 論理型 );
	論理型 論理和( 論理型, 論理型 );

	~基本計算の仲間(型なし) { /* 表示する ← "基本計算の対象を消滅させる" ← 改行; */ };

};

仲間の集まり 応用計算の仲間 : 全域で使用可 基本計算の仲間
{

全域で使用可:

	応用計算の仲間(型なし) { /* 表示する ← "応用計算の仲間の対象を組み立てる" ← 改行; */ };

	実数型 SINを求める( 実数型 引数一 ) ;
	実数型 COSを求める( 実数型 引数一 ) ;
	実数型 TANを求める( 実数型 引数一 ) ;

	実数型 数値根を求める( 実数型 引数一 ) ;
	実数型 累乗を求める( 実数型 引数一,  実数型 引数二 ) ;
	整数型 税込み価格を求める( 整数型 引数一 ) ;

	~応用計算の仲間(型なし) { /* 表示する ← "応用計算の仲間の対象を消滅させる" ← 改行; */ };

};

内部埋め込み 実数型 基本計算の仲間である、足す  ( 実数型 引数1, 実数型 引数2 ) { 戻る( 引数1 + 引数2 ); };
内部埋め込み 実数型 基本計算の仲間である、引く  ( 実数型 引数1, 実数型 引数2 ) { 戻る( 引数1 - 引数2 ); };
内部埋め込み 実数型 基本計算の仲間である、掛ける( 実数型 引数1, 実数型 引数2 ) { 戻る( 引数1 * 引数2 ); };
内部埋め込み 実数型 基本計算の仲間である、割る  ( 実数型 引数1, 実数型 引数2 ) { 戻る( 引数1 / 引数2 ); };
内部埋め込み 整数型 基本計算の仲間である、余り  ( 整数型 引数1, 整数型 引数2 ) { 戻る( 引数1 % 引数2 ); };
内部埋め込み 論理型 基本計算の仲間である、論理積( 論理型 引数1, 論理型 引数2 ) { 戻る( 引数1 && 引数2 ); };
内部埋め込み 論理型 基本計算の仲間である、論理和( 論理型 引数1, 論理型 引数2 ) { 戻る( 引数1 || 引数2 ); };

#日本語定義 入力文字列
#日本語定義 文字列から実数へ "atof"

#日本語定義 正弦値	"sin"
#日本語定義 余弦値	"cos"
#日本語定義 正接値	"tan"

#日本語定義 平方根	"sqrt"
#日本語定義 累乗		"pow"
#日本語定義 切り捨て	"floor"
#日本語定義 物品消費税率	"1.1"

実数型 応用計算の仲間::SINを求める( 実数型 引数一)
{
	 戻る( 正弦値(引数一) );
};

実数型 応用計算の仲間::COSを求める( 実数型 引数一)
{
	 戻る( 余弦値(引数一) );
};

実数型 応用計算の仲間::TANを求める( 実数型 引数一)
{
	 戻る( 正接値(引数一) );
};

実数型 応用計算の仲間::数値根を求める( 実数型 引数一)
{
	 戻る( 平方根(引数一) );
};

実数型 応用計算の仲間::累乗を求める( 実数型 引数一, 実数型 引数二 )
{
	 戻る( 累乗(引数一,引数二) );
};

整数型 応用計算の仲間::税込み価格を求める( 整数型 引数一)
{
	 戻る( 切り捨て(引数一 * 物品消費税率) );
};

整数型 はじまり(整数型 入力数,文字への番地型｜入力文字列[])
{

	実数型 引数1,引数2;

	もし ( 入力数 == 3  ) {
		引数1 = 文字列から実数へ( 入力文字列[1] );
		表示する ← "  "←  引数1 ← " "← 入力文字列[2]  ← " = " ;

	}
	それ以外 もし ( 入力数 == 4 ) {
		引数1 = 文字列から実数へ( 入力文字列[1] );
		引数2 = 文字列から実数へ( 入力文字列[3] );
		表示する ← "  "←  引数1 ← " "← 入力文字列[2] ←" "←  引数2 ← " = " ;

	}
	それ以外 { 異常終了;}

	応用計算の仲間 計算くん;

	振り分け( 入力文字列[2][0] ) {

		場合分け '+': 表示する ← 計算くん.足す  ( 引数1, 引数2 ) ; break;
		場合分け '-': 表示する ← 計算くん.引く  ( 引数1, 引数2 ) ; break;
		場合分け '*': 表示する ← 計算くん.掛ける  ( 引数1, 引数2 ) ; break;
		場合分け '/': 表示する ← 計算くん.割る  ( 引数1, 引数2 ) ; break;
		場合分け '%': 表示する ← 計算くん.余り  ( 引数1, 引数2 ) ; break;
		場合分け 'A': 表示する ← ( 計算くん.論理積( 引数1, 引数2 ) ? "1" : "0" ) ; break;
		場合分け 'U': 表示する ← ( 計算くん.論理和( 引数1, 引数2 ) ? "1" : "0" ) ; break;

		場合分け 'S': 表示する ← 計算くん.SINを求める( 引数1 / 360 * 6.283185 ) ; break;
		場合分け 'C': 表示する ← 計算くん.COSを求める( 引数1 / 360 * 6.283185  ) ; break;
		場合分け 'T': 表示する ← 計算くん.TANを求める( 引数1 / 360 * 6.283185  ) ; break;
		場合分け 'R': 表示する ← 計算くん.数値根を求める( 引数1 ) ; break;
		場合分け '^': 表示する ← 計算くん.累乗を求める( 引数1, 引数2 ) ; break;
		場合分け 'Z': 表示する ← 計算くん.税込み価格を求める( 引数1 ) ; break;

		どれでもない: 表示する ← "演算子が未定義です" ; break;

	}
	表示する ← 改行;

	通常終了;
}

例題Ｗ２─４

例２─４の日本語定義プログラムは次のようなＣ++言語のコードに展開されます。

//　応用計算を基本計算から継承させる仲間の集まり（クラス）を作る
#include <iostream>
#include <math.h>
using namespace std;

class 基本計算の仲間
{

public:

	基本計算の仲間(void) { /* 表示する ← "基本計算の対象を組み立てる" ← 改行; */ };

	float 足す  ( float, float );
	float 引く  ( float, float );
	float 掛ける( float, float );
	float 割る  ( float, float );
	int 余り  ( int, int );

	bool 論理積( bool, bool );
	bool 論理和( bool, bool );

	~基本計算の仲間(void) { /* 表示する ← "基本計算の対象を消滅させる" ← 改行; */ };

};

class 応用計算の仲間 : public 基本計算の仲間
{

public:

	応用計算の仲間(void) { /* 表示する ← "応用計算の仲間の対象を組み立てる" ← 改行; */ };

	float SINを求める( float 引数一 ) ;
	float COSを求める( float 引数一 ) ;
	float TANを求める( float 引数一 ) ;

	float 数値根を求める( float 引数一 ) ;
	float powを求める( float 引数一,  float 引数二 ) ;
	int 税込み価格を求める( int 引数一 ) ;

	~応用計算の仲間(void) { /* 表示する ← "応用計算の仲間の対象を消滅させる" ← 改行; */ };

};

inline float 基本計算の仲間::足す  ( float 引数1, float 引数2 ) { return( 引数1 + 引数2 ); };
inline float 基本計算の仲間::引く  ( float 引数1, float 引数2 ) { return( 引数1 - 引数2 ); };
inline float 基本計算の仲間::掛ける( float 引数1, float 引数2 ) { return( 引数1 * 引数2 ); };
inline float 基本計算の仲間::割る  ( float 引数1, float 引数2 ) { return( 引数1 / 引数2 ); };
inline int 基本計算の仲間::余り  ( int 引数1, int 引数2 ) { return( 引数1 % 引数2 ); };
inline bool 基本計算の仲間::論理積( bool 引数1, bool 引数2 ) { return( 引数1 && 引数2 ); };
inline bool 基本計算の仲間::論理和( bool 引数1, bool 引数2 ) { return( 引数1 || 引数2 ); };

float 応用計算の仲間::SINを求める( float 引数一)
{
	 return( sin(引数一) );
};

float 応用計算の仲間::COSを求める( float 引数一)
{
	 return( cos(引数一) );
};

float 応用計算の仲間::TANを求める( float 引数一)
{
	 return( tan(引数一) );
};

float 応用計算の仲間::数値根を求める( float 引数一)
{
	 return( sqrt(引数一) );
};

float 応用計算の仲間::powを求める( float 引数一, float 引数二 )
{
	 return( pow(引数一,引数二) );
};

int 応用計算の仲間::税込み価格を求める( int 引数一)
{
	 return( floor(引数一 * 1.1) );
};

int main(int 入力数,char *jp_str_0[])
{

	float 引数1,引数2;

	if ( 入力数 == 3  ) {
		引数1 = atof( jp_str_0[1] );
		cout << "  "<<  引数1 << " "<< jp_str_0[2]  << " = " ;

	}
	else if ( 入力数 == 4 ) {
		引数1 = atof( jp_str_0[1] );
		引数2 = atof( jp_str_0[3] );
		cout << "  "<<  引数1 << " "<< jp_str_0[2] <<" "<<  引数2 << " = " ;

	}
	else { return 1;}

	応用計算の仲間 計算くん;

	switch( jp_str_0[2][0] ) {

		case '+': cout << 計算くん.足す  ( 引数1, 引数2 ) ; break;
		case '-': cout << 計算くん.引く  ( 引数1, 引数2 ) ; break;
		case '*': cout << 計算くん.掛ける  ( 引数1, 引数2 ) ; break;
		case '/': cout << 計算くん.割る  ( 引数1, 引数2 ) ; break;
		case '%': cout << 計算くん.余り  ( 引数1, 引数2 ) ; break;
		case 'A': cout << ( 計算くん.論理積( 引数1, 引数2 ) ? "1" : "0" ) ; break;
		case 'U': cout << ( 計算くん.論理和( 引数1, 引数2 ) ? "1" : "0" ) ; break;

		case 'S': cout << 計算くん.SINを求める( 引数1 / 360 * 6.283185 ) ; break;
		case 'C': cout << 計算くん.COSを求める( 引数1 / 360 * 6.283185  ) ; break;
		case 'T': cout << 計算くん.TANを求める( 引数1 / 360 * 6.283185  ) ; break;
		case 'R': cout << 計算くん.数値根を求める( 引数1 ) ; break;
		case '^': cout << 計算くん.powを求める( 引数1, 引数2 ) ; break;
		case 'Z': cout << 計算くん.税込み価格を求める( 引数1 ) ; break;

		default: cout << "演算子が未定義です" ; break;

	}
	cout << endl;

	return 0;
}

例題Ｗ２-４を展開したもの

例題Ｗ２-４のプログラムを実行させ、正弦関数(S)、余弦関数(C)、正接関数(T)、平方根(R)、累乗(^)、消費税込み(Z)の計算結果例を示します。例題Ｗ２-４で既に行った基本計算結果は割愛してあます。この他、Ｃ＋＋言語では、さまざまな組み込み関数が用意されていますが、その一部を使用しています。入力は｢数値　演算子　数値｣または、｢数値　演算子｣という形式で行うようにしました。

次に、PowerShell上にcpp_ex4.cppをコピーします。ここで｢$Env:Ubuntu｣はWSL上でのcpp_ex4.cppファイルの場所をあらかじめ設定しています。これをコンパイル、リンクして実行した例を以下に示します。

このようにオブジェクト指向言語といわれるC++言語では、仲間の集まり（クラス）を継承することで、今あるソフトウェア財産をそのまま利用して無駄なく機能拡張ができます。さらに対象（オブジェクト）の生成では、まず基本（親）となる仲間の集まり（クラス）が生成され、次に継承（子）された仲間の集まり（クラス）が生成されることが、この実行結果により分かります。また、対象（オブジェクト）の消滅では、逆に継承（子）された仲間の集まり（クラス）が消滅して、最後に基本（親）となる仲間の集まり（クラス）が消滅しますので、生成と消滅はちょうど入れ子のような格好になっています。

例題Ｗ２－５　並列計算

ここでは、intelx86系プロセッサのSSE（Streaming Single-instruction,multiple-data Extentions）機能を使ってＣ＋＋言語で簡易的な並列計算をやってみます。まず、よく普及しているx86系PC上でSSE命令を実行できるプロセッサかどうかを確認します。このため、WSL上で｢lscpu | grep 'sse'｣でSSE関連のフラグを見て、SSE、SSE2、SSE3、SSE4、SSE4.2が利用できることを確認しました。

２つの配列にそれぞれ４つの数値を入力し、これをSSE命令で並列に加減乗除する日本語プログラム例題Ｗ２－５を以下に示します。

入出力の仲間を呼ぶ

//#define _BCC32C
#ifdef _BCC32C
#define __SSE2__
#define __SSE__
#define __MMX__
#include <emmintrin.h>  // SSE命令セットのヘッダー(BCC32C)
#else
#include <immintrin.h> // SSE命令セットのヘッダー(GCC)
#endif

標準的な名前空間;

#日本語定義 ベクトルの加算	"_mm_add_ps"
#日本語定義 ベクトルの減算	"_mm_sub_ps"
#日本語定義 ベクトルの乗算	"_mm_mul_ps"
#日本語定義 ベクトルの除算	"_mm_div_ps"

#日本語定義 引数をセット	"_mm_load_ps"
#日本語定義 計算結果を代入	"_mm_store_ps"
#日本語定義 アライメント指定	"alignas"　　// バイトアライメントを指定


型なし 並列加算する(実数への番地型｜引数１,  実数への番地型｜引数２, 実数への番地型｜ 計算結果) {

    実数ベクトル計算型 ベクトル１ = 引数をセット(引数１), ベクトル２ = 引数をセット(引数２);
    計算結果を代入(計算結果, ベクトルの加算(ベクトル１, ベクトル２));
}

型なし 並列減算する(実数への番地型｜引数１, 実数への番地型｜引数２, 実数への番地型｜ 計算結果) {

    実数ベクトル計算型 ベクトル１ = 引数をセット(引数１), ベクトル２ = 引数をセット(引数２) ;
    計算結果を代入(計算結果, ベクトルの減算(ベクトル１, ベクトル２));
}

型なし 並列乗算する(実数への番地型｜引数１, 実数への番地型｜引数２, 実数への番地型｜ 計算結果) {

    実数ベクトル計算型 ベクトル１ = 引数をセット( 引数１), ベクトル２ = 引数をセット(引数２);
    計算結果を代入(計算結果, ベクトルの乗算(ベクトル１, ベクトル２));
}

型なし 並列除算する(実数への番地型｜引数１, 実数への番地型｜引数２, 実数への番地型｜ 計算結果) {

    実数ベクトル計算型 ベクトル１ = 引数をセット(引数１), ベクトル２ = 引数をセット(引数２);
    計算結果を代入(計算結果,ベクトルの除算(ベクトル１, ベクトル２));
}

整数型 はじまり() {

	アライメント指定(16) 実数型 引数１[4],引数２[4],計算結果[4];

	表示する ← "最初の４つの数を入力してください: " ← 改行;
	読み込む →  引数１[0] → 引数１[1] → 引数１[2] → 引数１[3]; 

	表示する ← "次の４つの数を入力してください: " ← 改行;
	読み込む →  引数２[0] → 引数２[1] → 引数２[2] → 引数２[3]; 

	並列加算する(引数１, 引数２, 計算結果);

	表示する ← "並列加算結果: ";
	反復 (短い整数型 回 = 0; 回 < 4; 回++) {
      	表示する ← 計算結果[回] ← " ";
	}
	表示する ← 改行;

	並列減算する(引数１, 引数２, 計算結果);

	表示する ← "並列減算結果: ";
	反復 (短い整数型 回 = 0; 回 < 4; 回++) {
		表示する ← 計算結果[回] ← " ";
	}
	表示する ← 改行;

	並列乗算する(引数１, 引数２, 計算結果);

	表示する ← "並列乗算結果: ";
	反復 (短い整数型 回 = 0; 回 < 4; 回++) {
		表示する ← 計算結果[回] ←  " ";
	}
	表示する ← 改行;

	並列除算する(引数１, 引数２, 計算結果);

	表示する ← "並列除算結果: ";
	反復 (短い整数型 回 = 0; 回 < 4; 回++) {
		表示する ← 計算結果[回] ←  " ";
	}
	表示する ← 改行;

	通常終了;
}

例題Ｗ２─５

#include <iostream>

//#define _BCC32C
#ifdef _BCC32C
#define __SSE2__
#define __SSE__
#define __MMX__
#include <emmintrin.h>  // SSE命令セットのヘッダー(BCC32C)
#else
#include <<immintrin.h> // SSE命令セットのヘッダー(GCC)
#endif

using namespace std;


// バイトアライメントを指定


void 並列加算する(float *引数１,  float *引数２, float * 計算結果) {

    __m128 ベクトル１ = _mm_load_ps(引数１), ベクトル２ = _mm_load_ps(引数２);
    _mm_store_ps(計算結果, _mm_add_ps(ベクトル１, ベクトル２));
}

void 並列減算する(float *引数１, float *引数２, float * 計算結果) {

    __m128 ベクトル１ = _mm_load_ps(引数１), ベクトル２ = _mm_load_ps(引数２) ;
    _mm_store_ps(計算結果, _mm_sub_ps(ベクトル１, ベクトル２));
}

void 並列乗算する(float *引数１, float *引数２, float * 計算結果) {

    __m128 ベクトル１ = _mm_load_ps( 引数１), ベクトル２ = _mm_load_ps(引数２);
    _mm_store_ps(計算結果, _mm_mul_ps(ベクトル１, ベクトル２));
}

void 並列除算する(float *引数１, float *引数２, float * 計算結果) {

    __m128 ベクトル１ = _mm_load_ps(引数１), ベクトル２ = _mm_load_ps(引数２);
    _mm_store_ps(計算結果,_mm_div_ps(ベクトル１, ベクトル２));
}

int main() {

	alignas(16) float 引数１[4],引数２[4],計算結果[4];

	cout << "最初の４つの数を入力してください: " << endl;
	cin >>  引数１[0] >> 引数１[1] >> 引数１[2] >> 引数１[3]; 

	cout << "次の４つの数を入力してください: " << endl;
	cin >>  引数２[0] >> 引数２[1] >> 引数２[2] >> 引数２[3]; 

	並列加算する(引数１, 引数２, 計算結果);

	cout << "並列加算結果: ";
	for (short int 回 = 0; 回 < 4; 回++) {
      	cout << 計算結果[回] << " ";
	}
	cout << endl;

	並列減算する(引数１, 引数２, 計算結果);

	cout << "並列減算結果: ";
	for (short int 回 = 0; 回 < 4; 回++) {
		cout << 計算結果[回] << " ";
	}
	cout << endl;

	並列乗算する(引数１, 引数２, 計算結果);

	cout << "並列乗算結果: ";
	for (short int 回 = 0; 回 < 4; 回++) {
		cout << 計算結果[回] <<  " ";
	}
	cout << endl;

	並列除算する(引数１, 引数２, 計算結果);

	cout << "並列除算結果: ";
	for (short int 回 = 0; 回 < 4; 回++) {
		cout << 計算結果[回] <<  " ";
	}
	cout << endl;

	return 0;
}

例題Ｗ２-５を展開したもの

WSL上でこの例題Ｗ２－５をコンパイルし、任意の値を入力した実行結果を以下に示します。

PowerShell上のbcc32cでこのプログラムを実行するために、WSL上のcpp_ex5.jcppをエディタを使って//#define _BCC32Cのコメント//を外して、｢./jcpp cpp_ex5 -c｣でコンパイルだけして、bcc32c用のcpp_ex5.cppを作成します。

次に、PowerShell上にcpp_ex5.cppをコピーします。ここで｢$Env:Ubuntu｣はWSL上で、cpp_ex5.cppファイルの場所をあらかじめ設定しています。これをコンパイル、リンクして任意の値を入力した実行結果を以下に示します。

例題Ｗ２－６　長いπを検証する

2024年の円周率の最長桁は、2024年に計算された 202兆桁です。この記録は、効率的なアルゴリズムを用いた最新の計算技術と大規模なハードウェア（特にSSDの並列処理や高性能CPU）を駆使して達成されました。

これだけの計算を行っても円周率πは収束をしておらず、どこかで循環しているという報告もまだなされていません。ただし、計算桁数は膨大になっても、その計算が本当に正しく計算されているのかということは、異なるアルゴリズムで計算した結果と違いがないかを検証することが重要になるのでしょう。そこで、今回はＣ言語編とJava言語編で行ったマチンの公式を使った円周率100万桁の計算結果が正しく行われているかをＣ＋＋のプログラムを作成して検証してみます。

比較するのは、チェドノフスキーの公式を使って円周率を効率よく求めるソフトウェア、｢y-cruncher｣を使います。このソフトウェアは公開されていて、すでに数兆桁の計算まで行われています。今回はPowerShell上で以下のように｢y-cruncher｣で100万桁までの計算を実行しました。

計算結果が約１メガバイトの容量であることを確認し、ファイル名を｢y-piM.txt｣に変更し、WLS上にコピーしておきます。

同様に、WSL上でＣ言語編のプログラムを利用して100万桁まで計算しますが、このままでは結果の中に｢y-cruncher｣の計算結果にはない、不用な空白文字や改行が入っているため、これを｢trコマンド｣で削除したファイルを｢w-piM.txt｣として以下のように作成します。

一応、二つのファイルの容量と、先頭から50バイトのデータを確認して、データの形式が同じであるかを見てみます。

これで準備が整ったので、次にプログラムをＣ＋＋言語で作成します。プログラムは例題Ｗ２－５でやったようにCPUのSSEを利用して、並列処理を行い効率的に比較を行うこととします。この日本語プログラムを以下に示します。

入出力の仲間を呼ぶ
ファイル操作の仲間を呼ぶ
ベクトルの仲間を呼ぶ

#include <immintrin.h> // SSE命令セットのヘッダー(GCC)


標準的な名前空間;

#日本語定義 並列引数をセット	"_mm_loadu_si128"
#日本語定義 並列に比較する	"_mm_cmpeq_epi8"
#日本語定義 並列にマスクする	"_mm_movemask_epi8"

#日本語定義 並列整数型にする	"reinterpret_cast"


論理型 詳細に比較する( 定数指定 ベクターひな型<文字型>参照｜ファイル１, 
			     定数指定 ベクターひな型<文字型>参照｜ファイル２ ) {

	サイズ型 最大容量 = ファイル１の大きさ;
	サイズ型 回 = 0;

	// 16バイト単位で比較
	反復 (; 回 + 15 < 最大容量; 回 += 16) {

		整数ベクトル計算型 デ－タ列１ = 並列引数をセット(並列整数型にする( 参照｜ファイル１[回] ) );
		整数ベクトル計算型 デ－タ列２ = 並列引数をセット(並列整数型にする (参照｜ファイル２[回] ) );
		整数ベクトル計算型 比較結果 = 並列に比較する(デ－タ列１, デ－タ列２);

			// マスクを作成し、不一致があれば 偽
		もし ( 並列にマスクする(比較結果) != 0xffff ) ならば戻る 偽;

	}

			// 残りの部分を比較する
	反復 ( ; 回 < 最大容量; ++回) {
		もし ( ファイル１[回] != ファイル２[回] ) ならば戻る 偽;
	}

	戻る 真;
}

#日本語定義 バイナリモ－ド 	"ios::binary"
#日本語定義 位置を末尾へ	"ios::ate"
#日本語定義 入力ストリーム	"ifstream"
#日本語定義 の大きさ 		".size()"
#日本語定義 の位置指定		".seekg"
#日本語定義 のデータ		".data()"
#日本語定義 から読み込む	".read"
#日本語定義 のサイズを取得	".tellg()"


論理型 ファイルを比較する( 定数指定 文字列型 参照｜ｆ１のパス, 
				   定数指定 文字列型 参照｜ｆ２のパス ) {

	入力ストリーム ｆ１( ｆ１のパス, バイナリモ－ド | 位置を末尾へ );
	入力ストリーム ｆ２( ｆ２のパス, バイナリモ－ド | 位置を末尾へ );

	もし ( !ｆ１ または !ｆ２ ) {
		表示（注意）する ← "ファイルが存在しないか開けません。" ← 改行;
		強制終了;
	}

	サイズ型 容量１ = ｆ１のサイズを取得;
	サイズ型 容量２ = ｆ２のサイズを取得;

			 // サイズが違う場合は不一致
	もし (容量１ != 容量２) ならば戻る 偽;

	ベクターひな型<文字型> 領域１(容量１), 領域２(容量１);

	ｆ１の位置指定(0);
	ｆ２の位置指定(0);

	ｆ１から読み込む(領域１のデータ, 容量１);
	ｆ２から読み込む(領域２のデータ, 容量１);

	戻る 詳細に比較する(領域１, 領域２);

}

整数型 はじまり( 整数型 入力数, 文字への番地型｜入力文字列[] )
{

	もし ( 入力数 != 3  ) 異常終了;

	文字列型 ファイル１ = 入力文字列[1];
	文字列型 ファイル２ = 入力文字列[2];

	もし (ファイルを比較する(ファイル１,ファイル２)) {
		表示する ← "ファイルは完全に一致しました。" ← 改行;
	} それ以外 {
		表示する ← "ファイルに違いが有ります。\n" ← 改行;
	}

	通常終了;
}

#include <iostream>
#include <fstream>
#include <vector>

#include  // SSE命令セットのヘッダー(GCC)


using namespace std;




bool 詳細に比較する( const vector&ファイル１, 
			     const vector&ファイル２ ) {

	size_t 最大容量 = ファイル１.size();
	size_t 回 = 0;

	// 16バイト単位で比較
	for (; 回 + 15 < 最大容量; 回 += 16) {

		__m128i デ－タ列１ = _mm_loadu_si128(reinterpret_cast( &ファイル１[回] ) );
		__m128i デ－タ列２ = _mm_loadu_si128(reinterpret_cast (&ファイル２[回] ) );
		__m128i 比較結果 = _mm_cmpeq_epi8(デ－タ列１, デ－タ列２);

			// マスクを作成し、不一致があれば 偽
		if ( _mm_movemask_epi8(比較結果) != 0xffff )  return false;

	}

			// 残りの部分を比較する
	for ( ; 回 < 最大容量; ++回) {
		if ( ファイル１[回] != ファイル２[回] )  return false;
	}

	return true;
}



bool ファイルを比較する( const string &ｆ１のパス, 
				   const string &ｆ２のパス ) {

	ifstream ｆ１( ｆ１のパス, ios::binary | ios::ate );
	ifstream ｆ２( ｆ２のパス, ios::binary | ios::ate );

	if ( !ｆ１ || !ｆ２ ) {
		cerr << "ファイルが存在しないか開けません。" << endl;
		exit(1);
	}

	size_t 容量１ = ｆ１.tellg();
	size_t 容量２ = ｆ２.tellg();

			 // サイズが違う場合は不一致
	if (容量１ != 容量２)  return false;

	vector 領域１(容量１), 領域２(容量１);

	ｆ１.seekg(0);
	ｆ２.seekg(0);

	ｆ１.read(領域１.data(), 容量１);
	ｆ２.read(領域２.data(), 容量１);

	return 詳細に比較する(領域１, 領域２);

}

int main( int 入力数, char *入力文字列[] )
{

	if ( 入力数 != 3  ) return 1;

	string ファイル１ = 入力文字列[1];
	string ファイル２ = 入力文字列[2];

	if (ファイルを比較する(ファイル１,ファイル２)) {
		cout << "ファイルは完全に一致しました。" << endl;
	} else {
		cout << "ファイルに違いが有ります。\n" << endl;
	}

	return 0;
}

入出力の仲間を呼ぶ
集合の仲間を呼ぶ
アルゴリズムの仲間を呼ぶ 
文字列の仲間を呼ぶ
反復子の仲間を呼ぶ	//bcc32cのみで使用される


using namespace std;

#日本語定義 入力の最大値	"1024"

// 集合の内容を表示する
型なし 集合を表示( 定数指定 集合ひな型参照｜ S ) {
	表示する ← "{ "; 
	反復 ( 整数型 数 : S ) {
		表示する ← 数 ← " "; 
	} 
	表示する ← "}" ← 改行; 
} 

#日本語定義 に要素を追加	".insert"
#日本語定義 状態をクリアする	".clear()"
#日本語定義 残りを無視する	".ignore"
#日本語定義 値がエラー		".fail()"


// キーボードから集合を入力する関数 
集合ひな型 集合を入力(定数指定 文字列型参照｜ 集合名) { 

	集合ひな型 S; 
	整数型 入力値;
	表示する ← 集合名 ← "の要素を数値で入力してください（非数値入力で終了）:" ← 改行; 
	繰り返し ( 真 ) { 
		表示する ← "> ";
		読み込む → 入力値;
		もし ( !読み込む値がエラー ) { 
			Sに要素を追加(入力値); // 重複せずに集合に要素を追加
		}
		それ以外 { 
			読み込む状態をクリアする;
			読み込む残りを無視する( 入力の最大値, '\n');
			中断する; 
		} 
	} 
	戻る S; 
} 

#日本語定義 和集合の計算	"set_union"
#日本語定義 積集合の計算	"set_intersection"
#日本語定義 差集合の計算	"set_difference"
#日本語定義 対称差集合の計算	"set_symmetric_difference"


整数型 はじまり() {

 // 集合の入力
	集合ひな型 S１ = 集合を入力("集合1"); 
	集合ひな型 S２ = 集合を入力("集合2"); 

	
// 入力された集合の表示　　
	表示する ← "集合1: "; 集合を表示(S１); 
	表示する ← "集合2: "; 集合を表示(S２); 

// 和集合の計算
	集合ひな型 和集合; 
	和集合の計算(S１の最初, S１の最後, S２の最初, S２の最後, 
					入力反復子(和集合, 和集合の最初)); 
	表示する ← "和集合: "; 
	集合を表示(和集合); 


// 積集合の計算
	集合ひな型 積集合;
	積集合の計算(S１の最初, S１の最後, S２の最初, S２の最後, 
					入力反復子(積集合, 積集合の最初)); 
	表示する ← "積集合: "; 
	集合を表示(積集合); 

// 差集合 (S１ - S２) の計算
	集合ひな型 差集合; 差集合の計算(S１の最初, S１の最後, S２の最初, S２の最後, 
					入力反復子(差集合, 差集合の最初)); 
	表示する ← "差集合 (S１ - S２): "; 
	集合を表示(差集合); 

// 対称差の計算
	集合ひな型 対称差; 対称差集合の計算(S１の最初, S１の最後, S２の最初, S２の最後, 
					入力反復子(対称差, 対称差の最初)); 
	表示する ← "対称差: "; 
	集合を表示(対称差); 

	通常終了; 
}

#include <iostream>
#include <set>
#include <algorithm> 
#include <string>
#include <iterator>	//bcc32cのみで使用される


using namespace std;


// 集合の内容を表示する
void 集合を表示( const set<int>& S ) {
	cout << "{ "; 
	for ( int 数 : S ) {
		cout << 数 << " "; 
	} 
	cout << "}" << endl; 
} 



// キーボードから集合を入力する関数 
set<int> 集合を入力(const string& 集合名) { 

	set<int> S; 
	int 入力値;
	cout << 集合名 << "の要素を数値で入力してください（非数値入力で終了）:" << endl; 
	while ( true ) { 
		cout << "> ";
		cin >> 入力値;
		if ( !cin.fail() ) { 
			S.insert(入力値); // 重複せずに集合に要素を追加
		}
		else { 
			cin.clear();
			cin.ignore( 1024, '\n');
			break; 
		} 
	} 
	return S; 
} 



int main() {

 // 集合の入力
	set<int> S１ = 集合を入力("集合1"); 
	set<int> S２ = 集合を入力("集合2"); 

	
// 入力された集合の表示　　
	cout << "集合1: "; 集合を表示(S１); 
	cout << "集合2: "; 集合を表示(S２); 

// 和集合の計算
	set<int> 和集合; 
	set_union(S１.begin(), S１.end(), S２.begin(), S２.end(), 
					inserter(和集合, 和集合.begin())); 
	cout << "和集合: "; 
	集合を表示(和集合); 


// 積集合の計算
	set<int> 積集合;
	set_intersection(S１.begin(), S１.end(), S２.begin(), S２.end(), 
					inserter(積集合, 積集合.begin())); 
	cout << "積集合: "; 
	集合を表示(積集合); 

// 差集合 (S１ - S２) の計算
	set<int> 差集合; set_difference(S１.begin(), S１.end(), S２.begin(), S２.end(), 
					inserter(差集合, 差集合.begin())); 
	cout << "差集合 (S１ - S２): "; 
	集合を表示(差集合); 

// 対称差の計算
	set<int> 対称差; set_symmetric_difference(S１.begin(), S１.end(), S２.begin(), S２.end(), 
					inserter(対称差, 対称差.begin())); 
	cout << "対称差: "; 
	集合を表示(対称差); 

	return 0; 
}