風の迷路

本ブログ記事一覧（転載先URL表）

Thu, 01 Aug 2019 23:41:09 +0900

転載先URLへの更新ご協力をお願いします

本ブログ（風の迷路）は、12月15日に閉鎖されます。
いくつかの記事は新ブログ（RPGツクールと数学のブログ）に転載しておりますので、
お手数ですが、本ブログの記事を引用している場合は、転載先のURLに変更頂きますよう、お願いいたします。

転載対象は、基本的に以下の選定基準で決めています：
・新ブログの方針（RPGツクール、数学の話題の提供）に関係するもの。
・本ブログで概ね固有の内容で、何かに活用できそうなもの。

本ブログの記事一覧（転載先URL表）は以下に掲載しております：
https://docs.google.com/spreadsheets/d/1UQx7mLM8YkUQ4Ojm3-0eyYmBVRvbley8We-NYiPTiFU/edit?usp=sharing

上記表にて、D列「URL」が本ブログにおける記事のURLです。
K列「転載要否」が○の記事が、新ブログへの転載対象であり、L列「転載先」のURLに転載されています。
転載要否が○の記事については、D列のURLを、L列のURLに変更いただきたく、お願いします。
転載要否が×の記事については転載しない記事ですので、12月15日以降は閲覧できなくなります。
×の記事のうち、転載すべき記事がございましたら、コメントにてご相談頂けますと幸いです。

また限定記事が○の記事は、一般公開していない記事ですので、
ご相談頂きましても、基本的には転載はしない方針とさせて頂きたく思います。

ヤフーブログ終了に伴うこのブログの対応

Wed, 06 Mar 2019 22:35:43 +0900

本ブログはヤフーブログ終了に伴い12月15日に閉鎖します

フェルミウム湾です。ご無沙汰しております。
本ブログは2017年末をもって更新終了とし、以下の新ブログにすでに移転しております：

RPGツクールと数学のブログ
http://fermiumbay13.hatenablog.com/

本ブログはこのまま放置とし、ブログを消す気は全くなかったのですが、
ヤフーブログ自体が今年の12月15日に終了するとのことなので、
本ブログも自動的に12月15日に閉鎖ということになります；ｗ；

それでは惜しいので、現在、本ブログの記事を移行計画中です。
ただ、おかしな記事も多いので、全部の記事を移行する気はありません。
全部見直して、残した方がよい記事のみ選定し、リメイクして
上記の新ブログの記事として投稿するようにしていきます。

本ブログが終了してしまうとURLも当然なくなってしまいますので、
本記事をリンク先に使って頂いている方は、記事がリメイクされましたら、
お手数ですが、そちらにリンク先を変えて頂ければまことに幸せです。

どの記事を移行するかは私の独断になってしまいますので、
この記事をぜひ移行して欲しい、など、もしありましたら、コメントしていただければ是非移行します。
（基本的にはこのブログにしか書いてないような技術内容は全て移すつもりです）
11月末までであれば対応できると思いますので、よろしくお願いします…！

（2019年8月1日追記）
移行完了しました。どの記事を転載しているか、転載先のURLは何か、
以下リンク先の表に掲載していますので、URLの更新ご協力お願いします。
https://blogs.yahoo.co.jp/fermiumbay2/42346845.html

長かったねぇ。１２年間、ありがとうございました。

ジオシティーズも終了して、ヤフーブログも終了してしまうので、
ヤフーさんとの関わりはもうなくなってしまうと思います……（知恵袋も最近のぞいてないもんね）
でもほんと、色々楽しかったです。ブログに投稿するぞ！っていうのを活力に
自分でもびっくりするぐらい色々編み出しては記事にしていけたように思います。

遊んでくれたみなさん、再三だけどありがとうございました。
これからもずっとがんばるよ。みんなもがんばってね。

あけましておめでとうございます！＆移転してます

Mon, 01 Jan 2018 15:48:30 +0900

！あけましておめでとうございます！

このブログは既に放置され、新しいブログに移転して活動しています。

RPGツクールと数学のブログ
http://fermiumbay13.hatenablog.com/

今後は新ブログに記事が投稿され、このブログには投稿されなくなると思います；＿；
でも、このブログを消すことはまずありません。
姑息にもこのブログにある記事を新ブログに転載している現状です。

じゃあ、なんで移転するのだというと
別にヤフーさん批判というわけではないですが、リニューアルされてしまうじゃないですか。
ヤフーブログが一新し、過去に書いた記事もレイアウトなど含めて大きく変わってしまうようで、
今までの投稿がどんなことになるのかちょっと怖くなったので、
逃げという意味ではてなブログに移転することにした、というだけのことです。
新ブログでも投稿のスタイルは全く変わりません。
むしろ数式などを新ブログの方が書きやすいので、今までより見やすい投稿が
出来るんじゃないかと思っています。

ということで、今まで読んで頂いた多くの皆さま本当ありがとうございました。
新ブログのほうもごひいきにです。
何度も書きますが、本ブログを閉鎖とか削除はしませんよコメントいつでもウェルカムです！

あとがき（切実な会）

ヤフーブログで１０年続けてきました。（放置の時期は多かったわけですが）
言葉の通り１０年一昔に感じるものがありまして、１０年前はまさかここまで
ブログを書こうという気もなく、そしてこんなに著者自身が
ブログに翻弄されることになるとも思っていなかったことでしょう。

各年の活動の様子を表にまとめましたよ：

年	濃密度合い（適当）	主な内容
2007	★★☆☆☆	ネタ目的で開設ゲーム投稿を始め、活発に
2008	★★☆☆☆	気分で投稿
2009	★☆☆☆☆	消沈気味このまま凍結が予想された
2010	★★★★☆	趣味仲間の出現により一気に加速第一次活動期と称する（？）
2011	★★★☆☆	勢いは弱まるが、平常運転
2012	★★★★★	一番ブログしてた時期第二次活動期と称する（？）
2013	★★☆☆☆	友人関係を拗らせて低迷
2014	★★☆☆☆	低頻度ではあるが気分で投稿を続ける
2015	★★☆☆☆	さらに低迷しかし後半に謎のやる気を得て一人で活発化
2016	★☆☆☆☆	活発化虚しく低迷は続く
2017	★☆☆☆☆	落ち切った収束もうだめだ；ｗ；

開設からちょうど５年目あたり（2012年あたり）が投稿のピークでして
ブログ友達さんと好き勝手に自分のことやお友達さんのことを書き合う文化が根付き、
高頻度で楽しく記事を投稿させてもらっておりました。
ブログを書き合うようなモチベーションでもないと続かないというのは、
上の表からも明らかですね；ｗ；　自分自身が一番びっくりしてますよ。

あんまり悲観的なことばっかり書いていてもしょうがないので
振り返りはこのあたりにしておき、今年もがんばっていきましょう。
幸いにも前年2017年は、ブログの投稿が少なかっただけであって
活動はしており、水面下で色々と充実しておりました。
新ブログで是非とも第三次活動期を起こしていきたいですね。

新ブログもよろしくねぜひ来てね！待ってるよ＞＜
ほらもう一回リンク貼るから：
http://fermiumbay13.hatenablog.com/

またこんど！！

XOR交換アルゴリズム

Sun, 12 Nov 2017 22:59:44 +0900

（2019/8/2追記）
本記事の内容は新ブログに転載済みです：
https://fermiumbay13.hatenablog.com/entry/2019/04/14/181053

プログラミングで値の交換をするとき、ちょっと困ることがあります。
例えば、変数Aと変数Bがあったとして、Aの値をBに、Bの値をAに、それぞれ交換することを考えます。
しかしプログラムでは値のコピーはできても、値の交換を直接行うことができません。
A＝1234、B＝5678を交換しようとして、AにBの値をコピーしてしまうと
A＝5678、B＝5678となってしまい、もともとのAの値であった1234が消えてしまいます。
これでは交換できませんね。そのため普通は下の図のように、もう一つ変数を用意する必要があります。

一時変数tempにAの値をコピーすることで、Aの値を退避させておきます。
それからBの値をAにコピーして、最後にtempの値をBにコピーします。これで交換ができます。

このように、変数の交換はちょっと手間なのです。
現実でもそうですよね。両手がふさがっているときは、
一旦どちらかをどこかに置いて片手を空けてから交換を行います。それと同じことです。

ところが、整数のデータに限ってはこのtempがなくても交換できる
XOR交換アルゴリズムというものを使うことができます。
XORという演算を使えば、不思議なことが起こってAとBが交換されるのです。

XOR交換アルゴリズム

XOR（排他的論理和）とは、次のような2進数の演算です。

例えば、12 XOR 15 ＝ 3 になります。
それぞれ2進数に直すと、12は1100、15は1111、となり、これを筆算のように縦に並べます。
これを足し算の筆算のように各桁足し算していくのですが、普通の足し算とは異なって
1＋1＝0となるように計算します。
上の例では0＋1＝1となっていますが、1＋1＝0となるので、上の桁が落ちていって
0011が答えとなります。0011は10進数に直すと3ですから、3が答えになります。

そして、このXORを使って、次のような計算を順番に行っていきます。

A XOR B の値をAに代入
A XOR B の値をBに代入
A XOR B の値をAに代入

A XOR B をひたすら計算しながら代入していくだけですね。A＝12, B＝15の例で実際にやってみます。

12 XOR 15 ＝ 3 をAに代入 … A＝3, B＝15
3 XOR 15 ＝ 12 をBに代入 … A＝3, B＝12
3 XOR 12 ＝ 15 をAに代入 … A＝15, B＝12

なんと、AとBの値が入れ替わっていますね！
このように、XORを使うとtempを使わずに値の交換が出来てしまうのです。

回路図のイメージは上図のようになります。
途中にある3つの素子がXOR演算を表していて、左の二入力に対するXORの結果が右に出ます。

上はA＝1234、B＝5678の例です。確かにAとBが交換されていますね。

交換の仕組み

XORを使うと何で値の交換が出来るのか確認してみます。
XOR演算には、次のような性質があります。

 結合法則が成り立つ … (A XOR B) XOR C ＝ A XOR (B XOR C)
 交換法則が成り立つ … A XOR B ＝ B XOR A
 自分自身との演算結果が0（単位元）になる … A XOR A ＝ 0

これら3つの性質のおかげで、XOR交換アルゴリズムが実現します。
手順ごとに格納される値を確認していきます。
AとBの値がどんどん変わっていきますので、最初の値をそれぞれA1, B1とします。

A1 XOR B1 ＝ A2とする
A2 XOR B1 ＝ B2とする
A2 XOR B2 ＝ A3とする

B2＝A1, A3＝B1になって値が入れ替わっている、という手順でした。
それぞれ求めていきます。

B2 ＝ A2 XOR B1 ＝ (A1 XOR B1) XOR B1
＝ A1 XOR (B1 XOR B1) … 結合法則
＝ A1 XOR 0 … 自分自身が逆元
＝ A1 … 0は単位元

A3 ＝ A2 XOR B2 ＝ (A1 XOR B1) XOR A1
＝ (B1 XOR A1) XOR A1 … 交換法則
＝ B1 XOR (A1 XOR A1) … 結合法則
＝ B1 XOR 0 … 自分自身が逆元
＝ B1 … 0は単位元

以上のように、確かに B2＝A1, A3＝B1 が成り立っています。
これがXORを使って値交換が出来る仕組みです。
逆に言えば、最初に挙げた3つの法則を持っている演算なら同様にして交換アルゴリズムに使えるのです。

他の演算を使った例

結合法則、交換法則が成り立ち、さらに自分自身と演算すると単位元になる、
という3つの法則を持った演算なら、XORでなくてもこの交換アルゴリズムは使えます。
あんまりそういう演算の例がないのですが、例えばこんなものがあります。

√a×√b＝√(ab) を計算し、ルートの外に係数で出せるものを出して整理して、k√cとなるとき
a ☆ b ＝ c と表す演算子☆

この演算子☆は、上記の3つの法則が成り立ちます。
ただし、a, b, cの素因数にもともと偶数乗の素因数が入ってしまっていると
何もしなくてもルートの外に出てしまうので、そういう値には適用できません。
実用性はないでしょう……単なる例です。

A ☆ B の値をAに代入
A ☆ B の値をBに代入
A ☆ B の値をAに代入

A＝1234, B＝5678 でやってみましょう。
√1234も√5678も、これ以上ルートの中身が整理できないので、このアルゴリズムが適用できます。

√1234×√5678＝2√1751663 より A＝1751663, B＝5678
√1751663×√5678＝2839√1234 より A＝1751663, B＝1234
√1751663×√1234＝617√5678 より A＝5678, B＝1234

確かに入れ替わりましたね！

割と自分自身が逆元という性質を満たす演算を探すのが難しいですが、
見つけることができればこのように交換アルゴリズムを考えることができます。
いろいろ探してみて、ぜひ遊んでみましょう＾＾！

余談ですが、XORのグラフは下図のようになります。
X座標、Y座標に対する点の明るさを X XOR Y の大きさにしています。（明るいほど大きな値）
キレイなフラクタル図形になるのですね！　2進数の演算をグラフにすると割と幾何学模様が現れて面白いです。

C++で論理回路のシミュレーション

Sun, 01 Oct 2017 13:32:20 +0900

（2019/8/2追記）
本記事の内容は新ブログに転載済みです：
https://fermiumbay13.hatenablog.com/entry/2019/04/14/180618

論理回路のシミュレーションをプログラミングで行うための支援ライブラリを作りました。
https://github.com/fermiumbay/LogicSimulator

論理計算を行うだけであれば、単に計算式を記述して答えを出させれば済みますが、
このライブラリは素子を登録してそれぞれ接続し、回路を作ることが出来るのが特徴です。
計算式に基づいて出力値が出るのではなく、出力値を得たい素子の値からたどって計算を行います。
素子を接続して実装することから、順序回路のような循環している回路も作成できます。

本ライブラリはC++用です。（C++11以降）

導入

上のリンクからLogicParts.hとLogicParts.cppをダウンロードし、
cppファイルをコンパイルするソースに入れてください。
使用するときはLogicParts.hをインクルードします。

例えば上のような回路を実装する場合は次のように記述します。

#include <iostream>
using namespace std;

#include "LogicParts.h"
using namespace LogicParts;

int main() {
    auto A = Terminal();    // 端子Aの定義
    auto B = Terminal();    // 端子Bの定義
    auto C = And(Or(A, B), Nand(A, B));    // 端子Cに論理回路を接続

    A->set(0);    // 端子Aに入力値0をセット
    B->set(1);    // 端子Bに入力値1をセット

    cout << C->get() << endl;    // 端子Cの値を出力
}

最初に各端子を定義して論理回路を作ります。
変数の型は面倒なのでautoで宣言していますが、BaseParts*でもOKです。
後は端子にset関数で入力値をセットして、出力値を得たい端子のget関数を呼べばOKです。
上の例はXor回路なので、A＝Bのとき0、A≠Bのとき1が返ります。

例

半加算器

上図は半加算器HAの例です。出力が2つありますが、同様にして回路を作れます。

#include <iostream>
using namespace std;

#include "LogicParts.h"
using namespace LogicParts;

int main() {
    auto A = Terminal();    // 端子Aの定義
    auto B = Terminal();    // 端子Bの定義
    auto C = And(A, B);    // 端子CにAnd素子を接続
    auto S = Xor(A, B);    // 端子SにXor素子を接続

    A->set(0);    // 端子Aに入力値0をセット
    B->set(1);    // 端子Bに入力値1をセット

    cout << C->get() << endl;    // 端子Cの値を出力
    cout << S->get() << endl;    // 端子Sの値を出力
}

このHAの部分だけを一つの部品として、
次のように関数を作っておくと便利です。

#include <iostream>
using namespace std;

#include "LogicParts.h"
using namespace LogicParts;

// 半加算器(A, B) = (C, S)
vector<BaseParts*> HA(BaseParts* A, BaseParts* B) {
    auto C = And(A, B);    // 端子CにAnd素子を接続
    auto S = Xor(A, B);    // 端子SにXor素子を接続
    return { C, S };	// 出力端子の配列を返す
}

int main() {
    auto A = Terminal();    // 端子Aの定義
    auto B = Terminal();    // 端子Bの定義
    auto D = HA(A, B);    // 端子DにA, Bを接続したHAを接続
    auto C = D[0];    // A, Bを接続したHAの出力C
    auto S = D[1];    // A, Bを接続したHAの出力S

    A->set(0);    // 端子Aに入力値0をセット
    B->set(1);    // 端子Bに入力値1をセット

    cout << C->get() << endl;    // 端子Cの値を出力
    cout << S->get() << endl;    // 端子Sの値を出力
}

全加算器

HAを接続して全加算器FAを作ります。

#include <iostream>
using namespace std;

#include "LogicParts.h"
using namespace LogicParts;

// 半加算器(A, B) = (C, S)
vector<BaseParts*> HA(BaseParts* A, BaseParts* B) {
    auto C = And(A, B);    // 端子CにAnd素子を接続
    auto S = Xor(A, B);    // 端子SにXor素子を接続
    return{ C, S };	// 出力端子の配列を返す
}

// 全加算器(A, B, prevC) = (C, S)
vector<BaseParts*> FA(BaseParts* A, BaseParts* B, BaseParts* prevC) {
    auto D = HA(A, B);    // HAの出力を端子群Dとして定義
    auto E = HA(D[1], prevC);    // HAの出力を端子群Eとして定義
    auto C = Or(D[0], E[0]);    // HAの出力とOr素子を接続して端子Cに接続
    auto S = E[1];    // HAの出力を端子Sに接続
    return{ C, S };	// 出力端子の配列を返す
}

int main() {
    auto A = Terminal();    // 端子Aの定義
    auto B = Terminal();    // 端子Bの定義
    auto prevC = Terminal();    // 端子prevCの定義
    auto C = FA(A, B, prevC)[0];    // A, Bを接続したFAの出力C
    auto S = FA(A, B, prevC)[1];    // A, Bを接続したFAの出力S

    A->set(1);    // 端子Aに入力値1をセット
    B->set(1);    // 端子Bに入力値1をセット
    prevC->set(1);    // 端子prevCに入力値1をセット

    cout << C->get() << endl;    // 端子Cの値を出力
    cout << S->get() << endl;    // 端子Sの値を出力
}

一旦部品を作ってしまえば取り扱いが楽になります。

RSフリップフロップ

入力端子を循環させれば順序回路も作れます。

#include <iostream>
using namespace std;

#include "LogicParts.h"
using namespace LogicParts;

// RSフリップフロップ
vector<BaseParts*> RS_FF(BaseParts* S, BaseParts* R) {
	auto Q = Nand(Not(S), 0);    // 端子Q
	auto notQ = Nand(Not(R), Q);    // 端子notQ
	Q->input[1] = notQ;    // 端子Qの入力端子の一つにnotQをセット

	return{ Q, notQ };	// 出力端子の配列を返す
}

int main() {
	auto S = Terminal();    // 端子Sの定義
	auto R = Terminal();    // 端子Rの定義
	auto Q = RS_FF(S, R)[0];    // 出力QをA, Bを接続したHAの出力C

	S->set(0); R->set(0); cout << Q->get() << endl;    // 保持
	S->set(1); R->set(0); cout << Q->get() << endl;    // Q＝1にセット
	S->set(0); R->set(0); cout << Q->get() << endl;    // 保持
	S->set(0); R->set(1); cout << Q->get() << endl;    // Q＝0にセット
	S->set(0); R->set(0); cout << Q->get() << endl;    // 保持
}

notQが未定義の状態でQ = Nand(Not(S), notQ)とは出来ませんから、
上記のように、一旦notQの部分は0（未接続）としておいて、
notQを作ってからQの入力端子にnotQをセットする、という方法で接続しています。

うまいように設計してやれば、大規模な論理回路も作れそうですね！

計算に要する一時変数の個数

Sat, 30 Sep 2017 20:28:06 +0900

（2019/8/2追記）
本記事の内容は新ブログに転載済みです：
https://fermiumbay13.hatenablog.com/entry/2019/04/14/175538

RPGツクール2000ではプログラミング言語を使えないので、
計算式を入力して直接計算するということが出来ません。
難しい計算を入れようと思うと、変数を一個一個定義して
それらの四則演算を駆使する必要があります。

1＋2×3 みたいな式であれば、優先度の高い掛け算の方を先に計算して
◆変数1番＝ 2（2を代入）
◆変数1番 × 3（3倍する）
◆変数1番＋ 1（1足す）
みたいにしてやれば、1個の変数で足ります。

しかし、2×3＋4×5 のような式を計算する際は変数1個では足りません。
一時的に計算用の変数を用意しておいて、それを途中計算で使うことになります。
◆変数1番＝ 2
◆変数1番 × 3
◆変数2番＝ 4
◆変数2番 × 5
◆変数1番＋変数2番

一般に、計算式が複雑になればなるほど一時変数は多く必要になります。
では、最低何個あれば足りるのか、というのを計算式から判断できるでしょうか。

使用変数の個数計算アルゴリズム

まず、上のように計算式をツリー構造に置き換えます。
一つ一つの丸のことをノードと呼びます。
2＋3×5だったら3×5を先に計算するので、3と5を×の木で結び、
その結果と2を足すので、それぞれを＋の木で結びます。
計算するときは、下から順にまとめていけばいいですね。

上の式なら次のように1つの変数があれば計算できます。
◆変数1番＝ 3
◆変数1番 × 5
◆変数1番＋ 2
3×5の結果を使い、それに2を足せばOKです。

計算によって各ノードに至るまでに必要な使用変数の個数を下に数字で書いています。
ただの数値は基本変数を使わないので0としていますが、
初めの3×5の計算を行うために、3か5のどちらかを一旦変数に入れないといけません。
ここでは3を入れるものとし、3に変数を一つ使っています。
3×5の計算結果を変数1番に入れればよいので、×の使用変数は1となっています。
さらに、それに足した結果をそのまま変数1番に入れますから、
＋の使用変数はそのまま1となります。

複雑な式になっても同じです。
ただ、引き算や割り算のように交換法則が成り立たない演算の場合は
左の数の方を必ず変数に入れなければなりません。
それに注意しながら使用変数の個数を振っていくと上図のようになります。
◆変数1番＝ 1
◆変数1番 ÷ 5
◆変数2番＝ 1
◆変数2番－変数1番
◆変数2番＝ 8
◆変数2番 ÷ 変数1番
1÷5ではまず変数1番に1を入れておき、そこから5を割り算。
次に1からその結果を引く必要がありますが、変数1個では無理なので
変数2番を用意して、そこに1を入れておき、変数2番から変数1番を引けばOKです。
（A－B＝－(B－A)でいいじゃんというツッコミは禁止です＾＾；）
これを繰り返し、変数2個で計算できるということが分かります。

では、子ノードの値から親ノードの値を求めるにはどうすれば良いでしょうか。

そのノードに振られている値は、言わば計算がそこに至るまでに
使用した変数の最大個数を表します。
例えば上の式では「－」の部分で2となっていますが、
－の計算を終えた直後はもう変数1番しか使っていないので、変数2番が使えます。
8をわざわざ変数3番に入れなくても、使っていない変数2番に入れれば済みます。
だから、最後の「÷」は1＋2＝3個ではなく、
それまでの最大個数であった2個がそのまま÷に振られます。

演算を行う際には、各演算に用いるノードで使用変数が多かった部分を先に計算して
計算時に変数1個としておくことで、使用変数の節約が出来るようになります。

上図でいうと、使用変数が0個で済む2の方ではなくて、
使用変数が1個必要な3×5の方を先に計算すると最大個数が少なくて済みます。

上図のように使用変数が1個必要なもの同士を使って演算する場合は、
変数1番に左の×の結果を、変数2番に右の×の結果を入れて足し算する必要があるので、
変数は2個必要になります。

以上のことから、使用変数の個数について次の法則が言えます。

【四則演算における親ノードの使用変数個数】
2つの子ノードの使用変数個数がそれぞれa, bとすると、
・a≠bのときmax{a, b}（a, bのうち大きい方）
・a＝bのときa＋1

使用変数個数がお互い同じときしか個数が増えないということになります。
さっきの例がその法則に従って得られるか確認してみてください。

例

下のイベント命令は、変数1番に角度を入れると
sinの値を計算して、変数2番にその100倍の値を入れるものです。

◆変数の操作：[0003:一時]代入，変数[0001]の値
◆変数の操作：[0003:一時]乗算，変数[0001]の値
◆変数の操作：[0003:一時]乗算，64
◆変数の操作：[0003:一時]除算，2025
◆変数の操作：[0002:結果]代入，変数[0003]の値
◆変数の操作：[0002:結果]乗算，-20
◆変数の操作：[0002:結果]加算，12000
◆変数の操作：[0003:一時]乗算，変数[0003]の値
◆変数の操作：[0003:一時]除算，100
◆変数の操作：[0002:結果]加算，変数[0003]の値
◆変数の操作：[0002:結果]乗算，変数[0001]の値
◆変数の操作：[0002:結果]除算，6750
◆変数の操作：[0002:結果]乗算，変数[0004]の値
◆

http://www.geocities.jp/orreiclan/content/report/tkool2000math/sin.html

一時変数を含めて変数を3個使っていますが、本当に3個必要なのか確認しましょう。
この計算過程を下図のようなツリー構造にします。

たどっていくと、確かに3になっていることが分かりますね。

このように、何らかの計算アルゴリズムを作ったときに
その必要な使用変数の個数を求める際に便利だと思います。
ツクール2000では使えますが、最近のツクールだとあまり使わないかもしれませんね。

並列回路演算子の性質

Mon, 28 Aug 2017 00:19:29 +0900

電気回路において、並列回路の合成抵抗は以下のように計算されます。

例えば2Ωと3Ωを並列接続して合成抵抗を計算すると、
2//3＝2×3／(2＋3)＝6／5 Ωとなります。
このとき用いた演算子「//」は、足し算に似た色々と面白い性質を持っています。

∞を数として認めているのは一意T空間を考えていることによるものです。
ここでは実数に、0の逆数としての符号のない数「∞」を付け加えた体系を考えています。

ドモルガンの法則に似た性質があるのが見受けられますが、
スイッチを直列に繋ぐとAND回路が、並列に繋ぐとOR回路が作れることから連想されます。
＋が直列、//が並列ですので、それぞれANDとORに対応するのですね。

方程式

＋の単位元は0ですが、//の単位元は∞になりますので、
こんな方程式を考えることができます：

一次方程式と二次方程式です。どちらも通常のものとよく似ていますね。
しかし二次方程式の解の公式は係数が色々と違います。
これは次の事実に由来します：

展開公式の係数が逆数で出てくるのですね。
これは同じものの並列が半分になるためです。1//1＝1／2

並列微分

//に対応する微分を次のように定義します：

足し算がそのまま並列に置き換わっただけです。並列微分と呼ぶことにします。
この並列微分は通常の微分と同様、線形性を持っていますし、
合成関数・逆関数・積の微分など、通常の微分が持つ性質を多く持っています。

指数法則や、三角関数の加法定理は次のようになります。
逆数の関係になっていることに注意です。

これらを用いて、次のような並列微分公式が得られます。

逆数が入れ子みたいになって、何だか複雑な式になってしまいますね。

実はこの並列微分と通常の微分とは次のような関係式で結ばれます。
この式が並列微分で一番大事な式です。

変形して、f(x)の並列微分について解くとこうなります：

これさえあれば、並列微分は全部出来るようになりますね。

マクローリン展開

並列微分を用いて、//のマクローリン展開は以下のように定義出来ます：

これに当てはめれば、次のようなマクローリン展開を得られます：

これらを用いれば、オイラーの公式も作れますね。

オイラーの公式単体なら、単純にドモルガンの法則から導くことが出来ます。

他の演算子との関係性

//は、同型写像f(x)＝1／xを介して＋と同型です。
だから逆数が多発したのですね。
各演算子とは、次のような関係があります。

四則演算に新しい仲間が増えた感じがして何だかいいですね＾＾

実数のコンパクト化（一意T空間）

Sun, 27 Aug 2017 20:23:46 +0900

実数のコンパクト化

実数に∞と－∞を付け加え、実数全体を閉区間にしてしまったものを拡張実数といいます。
2＋∞＝∞や、2÷∞＝0などという計算を、便宜的なものでなく
きちんと定義して扱えるようにしたものです。
これはこれで便利なのですが、やはり∞を数として扱うことには多少の抵抗があります。
そこで、以下の関数を用いて任意の実数を有界閉区間に落とし込むことを考えます。

通常の実数に対してこの写像T(x)を適用すると、その像は(－1, 1)の区間となります。
さらに、便宜的にarctan(±∞)＝±π／2と表されることを利用して、
∞を表す1、－∞を表す－1をそれぞれ要素として加えて閉区間[－1, 1]を作ることで、
Tを適用した後の空間を実質拡張実数として扱うことが出来るようになります。
これなら拡張実数を表すのに∞を使わなくても済みますね。
この[－1, 1]区間のことをT空間と呼ぶことにします。
実数をT空間に落とし込むことを実数のコンパクト化と呼ぶことにします。ここではね。

拡張実数を考えるときは、まず実数にこのTを適用してT空間に落とし込んでから
T空間における四則演算を用いて計算を行い、最後にT^(-1)を適用して
通常の実数に戻す、ということをすれば良いでしょう。

T空間における四則演算は次のようになります：

argは複素数の偏角を表します。
単純に、一旦T^(-1)を適用してから通常の四則演算を行い、
Tを適用して戻す、ということをしています。
その際に±1は∞に変換されてしまうことから、それを避ける目的で
通常のarctanではなくargを用いています。
T空間の積の単位元は1／2になることに注意です。1／2を実数に逆変換すると1になります。

これらは通常の実数の足し算掛け算と同型になります：
T(a＋b)＝T(a)＋T(b)
T(ab)＝T(a)T(b)
同型になるというか、そうなるように定義したのが正しいですね。
そのため、実数の四則演算はT空間の四則演算に置き換えられます。

以下に足し算と掛け算の性質を示します。
それぞれ±1を±∞に置き換えてみると、通常の実数と同じような性質であることが分かります。

また、次のように逆数を定義します。
割り算は逆数との掛け算で定義することが出来ます。

以上が拡張実数をT空間で扱う方法になりますが、
0の逆数が±1となってしまい、やはり積の逆元が存在しないという問題が残ります。
拡張実数を扱う分には別にこのままでもいいのですが、
次に考えることへの準備のため、以降は単調性を失わせた
新しい定義について記述していきます。

一意T空間

T空間は[－1, 1]の区間となっているため、0の逆数が2つの値を出してしまいます。
＋∞と－∞を区別して考えているためですが、ここではその区別をなくし、
0の逆数としての∞という1つの数だけを付け加えたT空間を考えます。
0の逆数をT空間の1と定義し、－1を範囲から除することで実現します。

T：(－∞, ∞) → (－1, 1]

この修正方法は単純に、T変換及び各四則演算の度に次の変換をすることとします。

これは任意の実数xを(－1, 1]の区間に収める変換です。
各計算毎にこの変換をして区間を改めたT空間を一意T空間と呼ぶことにします。

例えば－∞を一意T変換してみると、
T(－∞)＝2／π arctan(－∞)＝2／π・(－π／2)＝－1
r(－1)＝(－1＋2)－2ceiling((－1＋1)／2)＝－1＋2＝1
となるので、1に変換されます、－∞も∞も1になるのです。

補足ですが、任意の実数を半開区間に収める変換は次のようにして記述できます：

それがどうしたというのか

一意T空間により任意の実数は無限大を考慮して単なる実数で計算出来るようになりましたが、
それがどうしたということになります。

こういう演算を考えたとします：
a//b＝1／(1／a＋1／b)＝ab／(a＋b)
これは並列回路の合成抵抗を計算する演算子ですが、一意T空間によってこの演算子はアーベル群になります。

通常の実数で考えると、a//bは単位元を持たないことが分かります。
任意の実数をa、単位元をxとすると、
a//x＝x//a＝aを満たすxが単位元になりますが、
1／(1／a＋1／x)＝a
1／a＋1／x＝1／a
1／x＝0
となり、xは0の逆数となってしまうのです。
そのため、単位元なしということで//は半群止まりになってしまうのですが、
そこで思考停止してしまうには惜しいぐらい//は色々と性質を持っていますので、
0の逆数を考えることのできる一意T空間に一度変換してやり、
一意T空間における//を考えてみると、単位元は1として扱えるようになります。
実数における∞が単位元になるということです。
確かに並列回路では∞Ωを並列に繋いでも合成抵抗は変わりません。（∞Ωは開放を表します）

さらに、単位元を考えることによって逆元を考えることができ、aの逆元は－aになります。
a//(－a)＝1／(1／a－1／a)＝1／0＝∞ということです。
これで//は群になることができます。

次の記事でこの//演算子について色々記載していくつもりですが、
これは実数に∞を付け加えることで群になることができ、∞を付け加える操作は実は
実数を一意T空間に変換した上の操作であることを明記するために
こんなものを定義したということになります。

（旧記事）高速曜日計算

Sun, 20 Aug 2017 13:51:23 +0900

本記事の内容は新ブログに転載されました：
http://fermiumbay13.hatenablog.com/entry/2017/12/03/182641

今まで曜日計算のやり方については何度も書いてきました。
最近だとこれです：https://blogs.yahoo.co.jp/fermiumbay2/41701457.html

年月日を聞かれたときに、その曜日を一瞬で求められたらスゴイですよね。
まだサマーウォーズ見てないのですけど、数学ができる主人公が
それを一瞬でやってみせるというシーンがあると聞いています。
これには次のツェラーの公式を使っています：

西暦の千、百の位をc、十、一の位をyとして、m月d日の曜日が
hに数値として出てきます。h＝0が土曜日で、1, 2, 3, … になると日, 月, 火, …
c／4とかy／4を覆っているかっこは、小数点以下切り捨ての記号で、
mod 7 は、7で割ったあまりを計算しなさい、という演算子です。
ただし1月, 2月の場合のみ例外で、前の年の13月, 14月として計算しなければなりません。

作中ではこれを用いて暗算で一瞬で求めているそうですが、
なんでもコレのことをモジュロ演算と呼んでいるらしいですね。
モジュロ演算ってたぶん最後の「mod 7」の計算のことを言ってるんでしょうけど
モジュロ演算といえば何故か曜日計算が出てきます。曜日計算をする演算の名前ではないですよ。

彼は天才なので、上のような長い数式でも一瞬で計算出来てしまうのかもしれないですが
我々でもパッと計算してみたい願望があります。
そこで今回は、上のツェラーの公式をとことん凝縮し、
１９００年～２０９９年の年月日に対するすべての曜日を暗算で当てる方法を書きます。
高速曜日計算です。でもこれには暗記と多少の訓練が必要です。

高速曜日計算

１９００年～２０９９年の年月日から曜日を当てる方法です。

まず、次の数列を暗記しておきます。

１４３６１４６２５０３５

これらは月に対する数字で、例えば４月の数字は４番目の６、というようなものです。
覚え方は様々だと思います。前回はなんとなくの位置でスペースを置いて
１４３６　１４６　２５０３５
としていましたが、利便性を考えて４文字区切りにして
１４３６　１４６２　５０３５
とかにしてみてもいいかもしれません。

あとは、数値とそれに対応する曜日を知っていればOKです。
0が土曜日ということを知っておけば、あとは順番とわかれば良いでしょう。

以上を暗記して、あとは練習です。
下図では1967年2月10日の曜日を求めています。

まず、1月か2月の場合は年だけ1年前にずらします。そうでなければ不要です。
年→月→日の順に処理していくとよく忘れてしまうので、最初は月を見て
この判定をするのを忘れないように注意しましょう。
この場合は2月なので、1967年から1年戻して1966年として考えます。

1900年代であれば1、2000年代であれば0を採用します。
今回は1900年代なので「1」を覚えておきます。

西暦の下2桁の計算に一番時間が掛かります。
ここでは66ですが、66÷4の小数切り捨てと、66をそれぞれ足す必要があります。
数字が小さければそのままできますが、大きいと暗算が難しくなります。
実はここでの計算で用いる値は28を足し引きしても全体に影響がないので
大きい場合は28で引いていき、小さくしていくことを考えます。30引いて2足せば良いですね。
66－30＝36、36＋2＝38
38－30＝8、8＋2＝10
ということで、66は10として扱っても良いことになります。これなら暗算でできますね＾＾
10÷4の小数切り捨ては2ですから、2＋10＝12ですね。
計算の最後に7で割った余りの計算があるのですが、この操作はいつ行ってもいいので
この時点で7引いておきましょう。12－7＝「5」にしておきます。

これと、さっき覚えておいた1を足して「6」にします。
この「6」が1966年の年定数です。1966年なら常に「6」になります。
以上の計算が比較的長いので、例えば今年の分だけ計算できればいいのであれば
今年の年定数をあらかじめ計算しておいてそれを覚えておけば、計算が速くなります。
例えば2017年だったら「0」です。（同じ2017年でも1, 2月は2016年として扱うのに注意です）

次に月定数を足します。2月なので、2番目の数字である「4」ですね。
さっき覚えておいた6と足して、6＋4＝10になり、7以上なので7引いて、10－7＝「3」です。
最後に日にちを足します。10日なので、3＋10＝13で、13－7＝「6」となります。

「6」は金曜日でしたから、1967年2月10日は金曜日です。

手順は長いのですけど、計算がすべて簡単なことから、
ツェラーの公式をそのまま計算するよりも暗算がずっとしやすいものと思います。
何度か練習していけばきっと、一瞬は無理でも高速に求められるようになるでしょう。
現状私は20秒ぐらいです。年定数が分かっているもの（今年とか）ならすぐできるのですが
やはり年定数の計算に時間が掛かりますね。

Javaによるオブジェクト指向講座おまけ

Sat, 12 Aug 2017 12:23:18 +0900

（2019/8/2追記）
本記事の内容は新ブログに転載済みです：
https://fermiumbay13.hatenablog.com/entry/2019/04/14/191910

＜第3回

第2回で提示したレストランのやりとりをオブジェクト指向として実装した例です。
登場人物は、お客さん（Customer）、接客（Counter）、料理人（Cook）の3人で、
それぞれBaseCharaを継承して作られます。
料理の情報はFoodInfoクラスにまとめられています。
実際たかがこれだけの処理にこんなに書く必要ないと思いますけど、
例ということでご了承ください＾＾；
また、Mainクラスで定義されているshowCharaInfoメソッドをてきとうな所に挿入してもらえば
その段階での各キャラの情報（所持金、持っている食べ物）を表示できます。
（Main以外のクラスだと、Main.showCharaInfo();で呼び出せます）
処理の流れを見るのにぜひ活用してください。

// 【Main.java】

// メインクラス
class Main{
    
    // 情報取得用のキャラクターリスト
    public static BaseChara[] charaList = new BaseChara[3];
    
    // キャラクターリストに載っているすべてのキャラクターの情報を表示
    public static void showCharaInfo(){
        for(int i = 0; i < charaList.length; i++){
            charaList[i].showInfo();
        }
    }
    
    // mainメソッド
    public static void main(String args[]){

        // （食べ物リスト）
        // 0番: オムライス（税込972円）
        // 1番: とんかつ（税込1296円）
        // 2番: たこ焼き（税込648円）
        
        // お客さんの名前はベイ助、所持金1000円、食べたいものは0番オムライス
        Customer customer = new Customer("ベイ助", 1000, 0);

        // 接客の名前はレーラ、所持金2万円
        Counter counter = new Counter("レーラ", 20000);

        // 料理人の名前はポン太、所持金なし
        Cook cook = new Cook("ポン太", 0);

        // showCharaInfoメソッドのためにそれぞれのキャラを代入しておく        
        charaList[0] = customer;
        charaList[1] = counter;
        charaList[2] = cook;
        
        System.out.println(customer.getName() + "は、レストランへ行きました。");

        // お客さんが接客に注文 成功したら後の手続きを行う        
        if(customer.order(counter)){
            
            // 接客が料理人に料理を作るよう依頼し、もらう
            counter.askToCook(cook);
            
            // 接客がお客さんに料理を提供
            counter.provideDish(customer);
            
            // お客さんがそれを食べる
            customer.eat();
        }
        
        System.out.println(customer.getName() + "はレストランを後にしました。おわり");
        
    }
}

// 【BaseChara.java】

// 各キャラクターのスーパークラス
abstract class BaseChara{
    
    // 名前
    private String name;
    
    // 所持金
    private int money;
    
    // 持っている食べ物ID（-1で何も持っていない）
    protected int foodId;
    
    public BaseChara(String name, int money){
        this.name = name;
        this.money = money;
        this.foodId = -1;
        this.sayHello();
    }
    public String getName(){
        return this.name;
    }
    public int getMoney(){
        return this.money;
    }
    public int getFoodId(){
        return this.foodId;
    }
    
    // あいさつ
    abstract public void sayHello();
    
    // 情報を表示
    public void showInfo(){
        System.out.println("【" + this.getName() + "の情報】");
        System.out.println("所持金：" + this.getMoney());
        if(this.getFoodId() != -1){
            System.out.println("持っている食べ物：" + FoodInfo.getFoodName(this.getFoodId()));
        }else{
            System.out.println("食べ物は何も持っていない……");
        }
    }
    
    // しゃべらせる
    protected void speak(String comment){
        System.out.println(this.getName() + "「" + comment + "」");
    }
    
    // お金をcharaに払う
    public void payMoney(int money, BaseChara chara){
        chara.receiveMoney(money);
        this.money -= money;
    }
    
    // お金をもらう
    private void receiveMoney(int money){
        this.money += money;
    }
    
    // 持っている食べ物をcharaに渡す
    public void giveFood(BaseChara chara){
        chara.receiveFood(this.foodId);
        this.foodId = -1;
    }
    
    // 食べ物をもらう
    private void receiveFood(int foodId){
        this.foodId = foodId;
    }
    
}

// 【Customer.java】

// お客さん
class Customer extends BaseChara{
    
    // 欲しい食べ物
    private int hopeFoodId;
    
    public Customer(String name, int money, int hopeFoodId){
        super(name, money);
        this.hopeFoodId = hopeFoodId;
    }
    public void sayHello(){
        this.speak("お客さんですっ！");
    }
    
    // 欲しい食べ物を注文する
    public Boolean order(Counter counter){
        Boolean orderSucceeded = false;
        this.speak(FoodInfo.getFoodName(this.hopeFoodId) + "食べようかな。お願いします！");
        if(this.getMoney() >= FoodInfo.getFoodPrice(this.hopeFoodId)){
            this.payMoney(FoodInfo.getFoodPrice(this.hopeFoodId), counter);
            counter.ordered(this.hopeFoodId);
            orderSucceeded = true;
        }else{
            this.speak("ああ、お金が足りなくて注文できないや……");
        }
        return orderSucceeded;
    }
    
    // 持っている食べ物を食べる
    public void eat(){
        this.speak("いただきまーす！");
        this.speak("やっぱおいしいねぇ、ごちそうさま！");
        this.foodId = -1;
    }
    
}

// 【Counter.java】

// 接客
class Counter extends BaseChara{
    
    // 注文もらった食べ物のID
    private int orderedFoodId;
    
    public Counter(String name, int money){
        super(name, money);
    }
    public void sayHello(){
        this.speak("接客しまーす！");
    }
    
    // 注文を受ける
    public void ordered(int orderedFoodId){
        this.speak("かしこまりました！　少々お待ちください！");
        this.orderedFoodId = orderedFoodId;
    }
    
    // 注文された料理を料理人に作ってもらう
    public void askToCook(Cook cook){
        this.speak(FoodInfo.getFoodName(orderedFoodId) + "の注文入りましたよ！");
        cook.cook(this, orderedFoodId);
    }
    
    // 料理を提供する
    public void provideDish(Customer customer){
        this.speak("おまちどおさまでした！　" + FoodInfo.getFoodName(this.getFoodId()) + "です！");
        this.giveFood(customer);
    }
    
}

// 【Cook.java】

// 料理人
class Cook extends BaseChara{
    
    public Cook(String name, int money){
        super(name, money);
    }
    public void sayHello(){
        this.speak("料理作ってやるよ！");
    }
    
    // 料理する
    public void cook(Counter counter, int cookFoodId){
        this.speak("よーし、いま作るから待ってな");
        System.out.println("5分後...");
        this.foodId = cookFoodId;
        this.speak("できた！　それじゃ、持ってってくれよ");
        this.giveFood(counter);
    }
    
}

// 【FoodInfo.java】

// 食べ物の情報を持ったクラス
class FoodInfo{
    
    // 消費税率
    private static final double taxRate = 0.08;
    
    // 食べ物の名前一覧
    private static String[] foodName = {"オムライス", "とんかつ", "たこ焼き"};
    
    // 食べ物の税抜き価格一覧
    private static int[] foodPrice = {900, 1200, 600};
    
    public static String getFoodName(int foodId){
        String foodName = "";
        if(foodId >= 0 && foodId < FoodInfo.foodName.length){
            foodName = FoodInfo.foodName[foodId];
        }
        else{
            foodName = "(未定義)";
        }
        return foodName;
    }
    
    public static int getFoodPrice(int foodId){
        int foodPrice = 0;
        if(foodId >= 0 && foodId < FoodInfo.foodPrice.length){
            foodPrice = addTax(FoodInfo.foodPrice[foodId]);
        }
        return foodPrice;
    }
 
    // 税込み価格にする   
    public static int addTax(int price){
        return (int)((1.0 + taxRate) * price);
    }
    
}

風の迷路

本ブログ記事一覧（転載先URL表）

転載先URLへの更新 ご協力をお願いします

ヤフーブログ終了に伴うこのブログの対応

本ブログはヤフーブログ終了に伴い12月15日に閉鎖します

あけましておめでとうございます！＆移転してます

！あけましておめでとうございます！

あとがき（切実な会）

XOR交換アルゴリズム

XOR交換アルゴリズム

交換の仕組み

他の演算を使った例

C++で論理回路のシミュレーション

導入

例

半加算器

全加算器

RSフリップフロップ

計算に要する一時変数の個数

使用変数の個数計算アルゴリズム

例

並列回路演算子の性質

方程式

並列微分

マクローリン展開

他の演算子との関係性

実数のコンパクト化（一意T空間）

実数のコンパクト化

一意T空間

それがどうしたというのか

（旧記事）高速曜日計算

高速曜日計算

１４３６１４６２５０３５

Javaによるオブジェクト指向講座 おまけ

転載先URLへの更新ご協力をお願いします

Javaによるオブジェクト指向講座おまけ