OmniAICreator/Qiita-1.07M huggingface dataset:
ExcelでSQLを効率的に作るメモ

#０．テンプレSQLを用意する
```sql:SQLメモ
CREATE TABLE IF NOT EXISTS W_OUT_CSV (   
 ID INT UNSIGNED AUTO_INCREMENT NOT NULL    ,
 PRIMARY KEY (ID)      
);         
```

#１．新規作成したExcelのA1にテンプレSQLを貼り付ける
そしたらSQL全部が選択された状態になるのでそのまま「データ - 区切り位置」
![image](https://qiita-image-store.s3.amazonaws.com/0/94562/30f90a43-11e0-f194-5e03-9bfa6387d01c.png)![image](https://qiita-image-store.s3.amazonaws.com/0/94562/926a0efe-7770-4e84-de04-967f8518b7a2.png)

![image](https://qiita-image-store.s3.amazonaws.com/0/94562/bded3fad-2256-c723-4232-0395a197a4d3.png)

最低限のSQL配置ができたのであとは行追加なり列追加なりExcelの操作を駆使して
SQLをくみたてる
![image](https://qiita-image-store.s3.amazonaws.com/0/94562/d8022a67-533c-f66f-3430-0218d48b9458.png)

こんな感じね
![image](https://qiita-image-store.s3.amazonaws.com/0/94562/3d35cfaa-7110-b4b9-2291-744850e5381f.png)

これのなにがいいかっていうと
・項目名が、テーブル定義書からの '縦列入れ替えコピペ' で済むケースがある
・項目名などをオートフィル機能で連続して入力できる
・手直しするときも、矢印キーとかを駆使しなくてもピンポイントで修正できる
・一番これの効果が出るのは「項目名は同じだけどテーブル構造は違うどうしのテーブルへの移し替え系のUPDATE（更新）クエリ」だね

#２．セルをコピーしてメモ帳で開く
SQLが書かれたセルをコピーしてメモ帳に貼り付けてみると、図の青いところのように、セルの仕切りは 'TAB' として貼り付けられる
![image](https://qiita-image-store.s3.amazonaws.com/0/94562/cb1ffa9f-1e5a-ea4a-05e8-875818813026.png)

#３．置換
であるならば、その 'TAB' をコピーして '△'(1文字半角空白) へと置換してやればいい
![image](https://qiita-image-store.s3.amazonaws.com/0/94562/75f617c3-d633-c379-a829-4082b94a1c0f.png)

```sql:SQLメモ
CREATE TABLE IF NOT EXISTS W_OUT_CSV (   
 ID INT UNSIGNED AUTO_INCREMENT NOT NULL    ,
 COL1 VARCHAR( 20 )   COMMENT 'お客様管理番号' ,
 COL2 TINYINT UNSIGNED  NOT NULL DEFAULT 0 COMMENT '送り状種類' ,
 COL3 TINYINT UNSIGNED  NOT NULL DEFAULT 0 COMMENT 'クール区分' ,
 COL4 VARCHAR( 12 )   COMMENT '伝票番号' ,
 COL5 VARCHAR( 10 ) NOT NULL  COMMENT '出荷予定日' ,
 COL6 VARCHAR( 10 ) NOT NULL DEFAULT '最短日' COMMENT 'お届け予定（指定）日' ,
 COL7 VARCHAR( 4 ) NOT NULL DEFAULT '0812' COMMENT '配達時間帯' ,
 ・
 ・
 ・
 PRIMARY KEY (ID)      
);         
```

世の中にはほかにどんなアプローチがあるんだろう
Ansible+Vagrantで開発環境とAnsibleで本番環境の構築 Ruby + MySQL ①

#前提
* VagrantとVirtualBoxはインストール済み

#CentOS7.2環境の構築
*  [Vagrantbox.es](http://www.vagrantbox.es/)にアクセスして、BOXのURLを取得
*  コマンドプロンプトを立ち上げて、下記コマンドを実行して、BOXを作成

```
C:\>vagrant box add CentOS7_x64 https://github.com/CommanderK5/packer-centos-template/releases/download/0.7.2/vagrant-centos-7.2.box
==> box: Box file was not detected as metadata. Adding it directly...
==> box: Adding box 'CentOS7_x64' (v0) for provider:
    box: Downloading: https://github.com/CommanderK5/packer-centos-template/releases/download/0.7.2/vagrant-centos-7.2.box
    box: Progress: 100% (Rate: 1448k/s, Estimated time remaining: --:--:--)
==> box: Successfully added box 'CentOS7_x64' (v0) for 'virtualbox'!
```

出来上がりましたね。


* 早速確認

```
vagrant box list
CentOS7_x64       (virtualbox, 0)
```

* 仮想マシンを格納するフォルダを作成する。<br>ここではUserユーザのものとして、 C:\Users\User\VM\CentOS7_x64_001とする。
コマンドプロンプトで以下のとおり実行する。

```
C:\Users\User>cd vm
C:\Users\User\VM>cd CentOS7_x64_001
C:\Users\User\VM\CentOS7_x64_001>
```

* 仮想マシンの作成

```
C:\Users\User\VM\CentOS7_x64_001>vagrant init CentOS7_x64
A `Vagrantfile` has been placed in this directory. You are now
ready to `vagrant up` your first virtual environment! Please read
the comments in the Vagrantfile as well as documentation on
`vagrantup.com` for more information on using Vagrant.
```

これで、vagrantfileが作成されました。

* 下記コマンドで立ち上げてみましょう

```
C:\Users\User\VM\CentOS7_x64_001>vagrant up
```

* 接続してみよう。<BR>C:\Users\User\VM\CentOS7_x64_001でgitのbashHereにて下記コマンドを実行

```
$ vagrant ssh
Last login: Thu Jul 16 08:48:31 2015 from 10.0.2.2
Welcome to your Vagrant-built virtual machine.
[vagrant@localhost ~]$
```
ログインできましたね。。
#Ansibleのインストール

*EPEL（Extra Package for Enterprise Linux）レポジトリを利用する。

```
sudo yum install epel-release
```

*ようやくたどり着いたこのコマンド でansibleのインストール

```
sudo yum install ansible --enablerepo=epel-testing
```

途中でY/Nを聞かれる場合、すべてYとします。
技術英語 > you can represent elements in the real world [with great variety]. / the sheer variety of

@ Introducing Python: Modern Computing in Simple Packages by Bill Lubanovic
(No. 1880 / 12833)

> you can represent elements in the real world **with great variety**.

この文章の前は

> ... lists, tuples, dictionaries, and sets. Using these and those from Chapters 2 (numbers and strings), 

<hr>
varietyを強調する文章は以下を思い出した。
56才になってからもしたいこと。

> the sheer variety of choices of languages,

http://thecodist.com/article/yes_i_still_want_to_be_doing_this_at_56
> The biggest difference between today and when I started is **the sheer variety of** choices of languages, tools, platforms, methodologies and in general options that one can choose from (or have chosen for you). 

意訳「今日と私(著者)が(コーディングの仕事を)始めた頃との大きな違いは、非常に多くの言語、ツール、プラットフォーム、方法論、およびそれらにおける様々なオプションである」
(in generalを「一般に」と訳す部分は未消化)

the sheer variety of @ カシオ EX-word XD-N8600 搭載辞書

> used to emphasize the size, degree or amount of sth

Note: sthはsomethingのこと。
pythonによるネットワークの片道遅延の測定

# モチベーション
ある遅延と変動が大きい国際間通信について、往路、復路のどちらが通信に影響しているのか調べたい。PingによるRTT遅延測定ではなく、往路復路別々に測定したい。現状片道遅延が難しい理由は測定する2ノードの時間が正確に同期していなければならないため。ただ、今回のような国際回線はRTT 100msもあるので最寄りNTP同期で良しとする。せいぜい誤差数msだろうし、理論的な最短片道遅延も推測でき、そこからNTP同期ズレ値もある程度推測できると想定。
また、処理オーバーヘッドを考えると本来スクリプトで処理するべきではないけど、スクリプトにしたところで昨今のサーバなら1msも誤差を生じないだろう、ということで、楽ちんなPythonを選択。
かんたんにいうと、「ざっくり、てきとうに手抜きして」

# 手法
クライアント～サーバー間でupdパケット1往復
1. クライアントは(a)開始時刻を保存しサーバへパケット到着時間を問い合わせる
2. サーバは(b)そのパケットを受信した時間をクライアントへ返信
3. クライアントは(c)サーバからの返信を受信した時間を記録
4. (b) - (a) = 往路遅延 / (c) - (b) = 復路遅延 

# コード(minimum)
## Server
```python:owpingserver.py
#!/usr/bin/env python

import socket
import time

host = '0.0.0.0'
port = 12345
bufsize = 512

sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.bind((host,port))
while True:
   data,addr = sock.recvfrom(bufsize)
   sock.sendto("%.6f" % time.time(), addr)
```

## Client
```python:owpingclient.py
#!/usr/bin/env python

import socket
import time

host = 'localhost' # とりあえず自ＩＰを指定
port = 12345
bufsize = 512

sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
stime = "%.6f" % time.time()
sock.sendto(stime, (socket.gethostbyname(host), port))
data, addr = sock.recvfrom(bufsize)
etime = "%.6f" % time.time()

print  "forward : " + str(float(data) - float(stime))
print  "backward: " + str(float(etime) - float(data))
print  "total:    " + str(float(etime) - float(stime))

time.sleep(1)
sock.close()
```

実際はパケロスもひどいので、リトライ処理とか、タイムアウト処理も必要だし、もう少し扱いやすい出力で実装したけど、今は省略。

## とりあえずローカルホストで実行
同一ホスト内（localhost）で実施

```text
$ python owpingserver.py &
$ python owpingclient.py
forward : 0.000324964523315
backward: 4.81605529785e-05
total:    0.000373125076294

$ ping localhost -c 1
PING localhost (127.0.0.1) 56(84) bytes of data.
64 bytes from localhost (127.0.0.1): icmp_seq=1 ttl=64 time=0.017 ms

--- localhost ping statistics ---
1 packets transmitted, 1 received, 0% packet loss, time 0ms
rtt min/avg/max/mdev = 0.017/0.017/0.017/0.000 ms
```

ping より精度が少なくとも1桁は劣る。。。主に往路のオーバーヘッドが重いなあ。まあ10μsと100μsの精度の差、だいたい想定どおり。国際回線じゃ無視していいだろ。（あきらめが肝心）

#実際の国際回線での測定結果
青線:往復、オレンジ:往路、緑:復路。半日ぐらいバッチで走らせて、グラフ化して読み取れることは
1. 明らかにRTT遅延に対する往路遅延の影響はでかい
2. 地理的経路はほぼ同じ（はず）で片道15msはやや短めな気がするので、ノードの時間が最大3msぐらいずれてるかも。
3. 私は休日の早朝からなにやってるんだろう。
![image](https://qiita-image-store.s3.amazonaws.com/0/132165/5c57534d-9c04-982c-0391-17f7ac54096f.png)

ちなみに同じデータセンタの違うインスタンスで試したら1マイクロ秒ぐらい未来の時間が帰ってきたｗ

# 追記
2017/2/26: Cで等価なコードに書いてみたけど150μs減ぐらい。思ったより改善しなかった。当面pythonでいいや。
演算性能とは

演算性能とは、システムやアプリケーションの性能評価に使われる指標です！
1秒間にCPUが浮動小数点演算(Flop)を何回できるかを示しています。
>演算性能(Flops) = 浮動小数点演算(Flop) ÷ 秒(Sec)

下に例を示すので、自分のプログラムと見比べると感覚的にわかります！

#どんな時に使う？
アプリケーションと、パソコンの性能の評価や比較をする時

#まず用語の説明
##理論演算性能
理論演算性能とは、システムが理論上で、1秒間に浮動小数点演算を、最大何回行えるかという数値である。

##実測値(実行性能)
実行性能とは、1秒間にそのシステムが浮動小数点演算数を何回できるかのことである。

#実測値(実行性能)の計算方法

### (例1)
<pre><code>for(i = 0; i < 100000; i++){
 A[i] = B[i] * C[i];
}</code></pre>

というプログラムが0.01秒かかったとすると、
１ループあたりに「＊演算」を1回行なっているので、
100000(ループ) × 1Flop ÷ 0.01(sec) = 1000Flops
となる。

### (例2)
<pre><code>for(i = 0; i < 100000; i++){
 A[i] = B[i] * C[i] * C[i] * C[i];
}</code></pre>

このプログラムが0.01秒かかったとすると、
１ループあたりに「＊演算」を3回行なっているので、
100000(ループ) × 3Flop ÷ 0.01(sec) = 3000Flops
となる。

### (例3)
<pre><code>for(i = 0; i < 100000; i++){
for(j = 0; j < 100000; j++){
 A[i] = B[i] * C[i] * C[i] * C[i];
}
}</code></pre>

このプログラムが0.01秒かかったとすると、
１ループあたりに「＊演算」を3回行なっていて、100000の２段のループなので
100000(ループ) × 100000(ループ) × 3Flop ÷ 0.01(sec)
 = 300000000Flops = 0.3GFlops
となる。
また、基本的にはGFlops（ギガフロップス）を使う。

#理論演算性能の計算方法
クロック周波数=2.1GHz
コア数=10
CPU内部の演算器の数=2
の場合、
2.1GHz × 10コア × 2(演算装置数) = 42GFlops
となる。

#SIMD命令(256ビットSIMD)を使った場合の理論演算性能

クロック周波数=2.1GHz
コア数=10
CPU内部の演算器の数=2
**SIMD(256ビットSIMD)=4**
の場合、
2.1GHz × 10コア × 2(演算装置数) × 4(256ビットSIMD) = 168GFlops
となる。

#SIMD命令(128ビットSIMD)を使った場合の理論演算性能

クロック周波数=2.1GHz
コア数=10
CPU内部の演算器の数=2
**SIMD(128ビットSIMD)=2**
の場合、
2.1GHz × 10コア × 2(演算装置数) × 2(128ビットSIMD) = 84GFlops
となる。

#SIMD命令でFMA命令を使って、FMA演算器が２つある場合の理論演算性能

クロック周波数=2.1GHz
コア数=10
CPU内部の演算器の数=2
SIMD(256ビットSIMD)=4
**FMA(Fused Multiply-Add)演算器の数=2**
の場合、
2.1GHz × 10コア × 2(演算装置数) × 4(256ビットSIMD) × 2(FMA演算器) = 336GFlops
となる。

#MPIを使った場合の理論演算性能

クロック周波数=2.1GHz
コア数=10
CPU内部の演算器の数=2
SIMD(256ビットSIMD)=4
**プロセス並列数=10**
の場合、
2.1GHz × 10コア × 2(演算装置数) × 4(256ビットSIMD) × 10(プロセス並列数) = 1680GFlops
となる。

# 参考
演算器（ALU）
https://ja.wikipedia.org/wiki/%E6%BC%94%E7%AE%97%E8%A3%85%E7%BD%AE
SIMD
https://ja.wikipedia.org/wiki/SIMD
プロセス並列
https://web.kudpc.kyoto-u.ac.jp/manual/ja/parallel

SIMD, FMA引用
https://ja.wikipedia.org/wiki/SIMD
>FMA命令に対応した演算器においては、上記の浮動小数点演算を1クロックサイクルのスループットで実行可能で、加算のみ、乗算のみを実行できる演算器と比較すると理論FLOPSを倍にすることができる。また、乗算の結果に対しては丸めを行わず、加算を行った後に一度だけ丸めを行うため、乗算と加算を独立して実行するのと比較して丸め誤差を小さくできるという利点もある。実装としてはAMDのBulldozerマイクロアーキテクチャでサポートされたのが最初で、モジュールあたり2つの128ビットFMA演算器を搭載している。IntelはHaswellマイクロアーキテクチャで初めてサポートしており、コアあたり2つの256ビットFMA演算器を搭載している。
別法： Pythonの辞書を属性としてアクセスできるようにする

@yutaka2487 さんの「[Pythonの辞書を属性としてアクセスできるようにする](http://qiita.com/yutaka2487/items/a7c57960c2b6befa5edf)」を拝見して、別の方法でもできそうに思えたので試してみました。
辞書自身(`self`)を属性辞書(`__dict__`)にもしてしまうという単純な方法です。
テストは全部okでしたが、何か落とし穴などありましたら是非コメントください。

```py:attrdict.py
class attrdict(dict):
    '''A dictionary that can also access attributes using its keyword.

    >>> ad = attrdict(a=1, b=2)
    >>> sorted(ad.items())
    [('a', 1), ('b', 2)]
    >>> ad['a'], ad.a
    (1, 1)
    >>> ad['b'], ad.b
    (2, 2)
    >>> ad['a'] = 3
    >>> ad['a'], ad.a
    (3, 3)
    >>> ad.b = 4
    >>> ad['b'], ad.b
    (4, 4)
    >>> ad['c'] = 5
    >>> ad['c'], ad.c
    (5, 5)
    >>> ad.d = 6
    >>> ad['d'], ad.d
    (6, 6)
    >>> sorted(ad.items())
    [('a', 3), ('b', 4), ('c', 5), ('d', 6)]
    '''

    def __init__(self, *args, **kwargs):
        dict.__init__(self, *args, **kwargs)
        self.__dict__ = self

if __name__ == '__main__':
    import doctest
    doctest.testmod()
```

```text:テスト結果
$ python attrdict.py -v
Trying:
    ad = attrdict(a=1, b=2)
Expecting nothing
ok
Trying:
    sorted(ad.items())
Expecting:
    [('a', 1), ('b', 2)]
ok
Trying:
    ad['a'], ad.a
Expecting:
    (1, 1)
ok
Trying:
    ad['b'], ad.b
Expecting:
    (2, 2)
ok
Trying:
    ad['a'] = 3
Expecting nothing
ok
Trying:
    ad['a'], ad.a
Expecting:
    (3, 3)
ok
Trying:
    ad.b = 4
Expecting nothing
ok
Trying:
    ad['b'], ad.b
Expecting:
    (4, 4)
ok
Trying:
    ad['c'] = 5
Expecting nothing
ok
Trying:
    ad['c'], ad.c
Expecting:
    (5, 5)
ok
Trying:
    ad.d = 6
Expecting nothing
ok
Trying:
    ad['d'], ad.d
Expecting:
    (6, 6)
ok
Trying:
    sorted(ad.items())
Expecting:
    [('a', 3), ('b', 4), ('c', 5), ('d', 6)]
ok
2 items had no tests:
    __main__
    __main__.attrdict.__init__
1 items passed all tests:
  13 tests in __main__.attrdict
13 tests in 3 items.
13 passed and 0 failed.
Test passed.
```
AlfredでFinderにtouchできるExtension作った

# こんな感じ
![2017-02-26 09_29_16.gif](https://qiita-image-store.s3.amazonaws.com/0/124062/bb59cd9a-9612-0ab2-71ad-962b5117e149.gif)


[ダウンロードリンク](https://github.com/Pteroid/Alfred-touch)

スクリプトの内容は

```
target=`osascript -e 'tell application "Finder" to if (count of Finder windows) > 0 then get POSIX path of (target of front Finder window as text)'`

cd "$target"
touch "$1"
```

中でネットから適当に拾ってきたApple Scriptを用いている．アイコンはIcons8 Liteというアプリで適当に拾ってきた．
ルーフラインモデルとは

全てのプログラムが、そのCPUの最大性能を出せるわけではない。
実際にはデータ転送時間がネックとなり、プログラムごとで性能上限がある。
メモリ性能が10GB/sであれば一秒間に10GBしか送れないということであり、基本的にCPUはデータ転送時間より早く処理するからデータが来るまで待ち時間が発生する。
(また、VPSなどの仮想サーバなどでも、メモリ性能があまり良くないことが多くあるようである。３項目目にさくらVPSのルーフラインモデルを計測した結果があります。)

# ルーフラインモデル
データ転送量によってプログラムの演算性能に上限があることを示したモデル。
途中で折れ曲がるため屋根のようであることからルーフラインモデルと呼ばれる。
「データ転送時間 < CPU内部の演算時間」となった瞬間にデータ転送時間のネックはなくなり、実測値の上限となる。
![ルーフラインモデル.png](https://qiita-image-store.s3.amazonaws.com/0/89992/5c632367-52c8-66c7-ea84-77748e04fe48.png)

# さくらVPS仮想3coreサーバでは
メモリ性能は予測上の最大値を考慮したが、実際にはもう少し低かったようである。
この図では、さくらVPS仮想3coreがメモリ性能が高くないことを示している。
左側のグラフはすぐにデータ転送時間のネックがなくなっているのに対して、右側のグラフはデータ転送時間のネックがなかなか無くなっていない。
このように半分ぐらい性能が変わったりもする。
右側のさくらVPSは最大値まで計測されてないがおそらく6GFlopsぐらいが上限値であると思われる。
青のグラフは最大値、緑のグラフは実測値である。
<img width="903" alt="スクリーンショット 2017-01-22 18.51.56.png" src="https://qiita-image-store.s3.amazonaws.com/0/89992/0e570d82-1f5f-5034-37f7-3fc238c696ef.png">


## データ転送時間がネックになる
for(i=0;i<N;i++){
　　A=B*C;
}
という演算を例にする。
BとCを読み込んで、Aに書き込みをするという処理であり、３つのデータがCPUとメモリとの間を移動している。
一方、CPUの方での計算はB*C(mul命令)とデータを移動する(mov命令)の処理しかしていない。
ここでメモリ転送時間が演算時間よりも大きいと、データ転送が終わってから次のループが始まる。
以下の図で説明ができる。

![ルーフラインモデル2.png](https://qiita-image-store.s3.amazonaws.com/0/89992/32070fa6-b2b7-e882-ff49-e2ef68a3ba0f.png)

これを計算式にすると、
以下の式が１反復ループあたりの演算時間となる。

>MAX(データ転送時間, CPU内での演算時間)

このようにデータ転送時間がプログラムに大きな影響を与えている。
メモリを大量に読み込むプログラムの性能を上げるのであれば、DDR4などメモリの性能も考える必要がある。複数のCPUで処理を分散させるとメモリアクセスも分散されるためネックになりにくくなる。

## 演算強度とは
１Byteデータ転送あたりに何回浮動小数点演算をしているか(Flop/Byte)
Flop ÷ Byte

## 演算性能とは
一秒間に浮動小数点演算が何回できるか(GFlops)
Flop ÷ Time(Sec)

## 理論演算性能とは
そのシステムの最大の演算性能(GFLOPS)
・2.1GHz
・4コア
・加算器の数2つ
であった場合は、
2.1 × 4 × 2 = 16.8GFlops
がこのシステムの最大の演算性能である。（実際にはここまで性能はでない）
SIMDやMPIの処理を入れるとさらに大きくなる。

## 演算強度からの演算性能の求め方
・メモリバスの速度が16(GB/sec)
・演算強度が0.25
であった場合の最大性能は、
16 × 0.25 = 4GFlops
つまりメモリ性能が倍になると理論的な性能も倍になる。

# 演算強度の計測方法
演算強度はこのように設定できる。
※ 配列は全てdouble(8Byte）とする。
・FLOP=1, データ転送数 = 3, 演算強度 = 1Flop / (8Byte * 3) = 0.0416
for(i=0;i<N;i++){
A[i] = B[i] * C[i];
}
・FLOP=2, データ転送数 = 3, 演算強度 = 2Flop / (8Byte * 3) = 0.083
for(i=0;i<N;i++){
A[i] = B[i] * C[i] * C[i];
}
・FLOP=3, データ転送数 = 3, 演算強度 = 3Flop / (8Byte * 3) = 0.125
for(i=0;i<N;i++){
A[i] = B[i] * C[i] * C[i] * C[i];
}
配列Cが増えてもCPU内部のレジスタに保存されるため、データ転送数は３のままである。
*の数が増えれば、演算強度は増えていくことになる。

# 参考
ルーフラインモデル
https://www2.eecs.berkeley.edu/Pubs/TechRpts/2008/EECS-2008-134.pdf
文字列リテラルを扱うtemplate関数と一致度調節

# 文字列リテラルと文字列クラスのハンドリング
テンプレート関数で文字列を扱う際、リテラルやC言語文字列を別に処理したい欲求が生じた。~~その方が実行が速いかなって思った~~
そこで、初めに単純に次のようにtemplate関数を用意した。

```cpp
template<typename String, typename Delimiter>
inline std::vector<String> split(const String&, Delimiter&&); // (1)

template<typename CharT, size_t N, typename Delimiter>
inline std::vector<typename std::basic_string<CharT>> split(const CharT (&)[N], Delimiter&&); // (2)

template<typename CharT, typename Delimiter>
inline std::vector<typename std::basic_string<CharT>> split(const CharT*, Delimiter&&); // (3)
```

これらの関数は `const char [N]` 型以外の型に対しては期待通りハンドリングされる。なお`N`はコンパイル時整数とする。
`char (&)[N]`型なら(2)が選ばれ、`const char* const`型なら(3)が選ばれ、`std::string`型なら(1)が選ばれる。

## `const char [N]` の一致度
前述のtemplate関数に`const char [N]`を渡すとオーバーロードに失敗しコンパイルエラーになる。原因は一致度が同じ関数が2つあるからである。コンパイラはオーバーロード候補が3つあるとしか教えてくれないので一致度の比較に苦労した。
なおコンパイラはg++ 5.4.0を用いた。

手で確認してゆくと

(1)は`String = char [N]`として解釈されるので `split(const char (&)[N], Delimiter&&)` のsplit関数ができる。
(2)は`CharT = char`として解釈されるので `split(const char (&)[N], Delimiter&&)` のsplit関数ができる。
(3)は`CharT = char`として解釈されるので `split(const char*, Delimiter&&)` のsplit関数ができる。

次にオーバーロードの解釈に入る。
`const char[]`はキャスト無く(1), (2)へ送れるがテンプレートの指定の差によって(2)の方が一致度が高くなる。
(3)はポインタを渡しているが、仮引数がポインタの値渡しであるため配列がポインタと同等の扱いを受ける。このため完全一致とみなされ(2)と同等の一致度となる。

## 解決法
(3)のポインタが値渡しされているので配列とポインタの区別がなくなっていることが先ほどの分析で分かった。配列のポインタ渡しを抑制するためにポインタを参照渡しするように変更する。

```cpp
template<typename CharT, typename Delimiter>
inline std::vector<typename std::basic_string<CharT>> split(const CharT*&, Delimiter&&); // (3')
```

これで`const char[]`を渡したときは CharT を `const CharT*` へ解釈できなくなり、めでたくオーバーロードは(2)を選んでくれるようになった。

# 配列とポインタ参照仮引数
なぜ、ポインタ参照の仮引数は配列を受け取れないのか。疑問に思った方はいるだろうか。
これには参照渡しでは配列の型が維持されるという特性が関係している。つまり(2)で使っているテクニックが答えだ。

```cpp
template<typename CharT, size_t N, typename Delimiter>
inline std::vector<typename std::basic_string<CharT>> split(const CharT (&)[N], Delimiter&&); // (2)
```

配列を参照渡しすると、正確に `const char []` が渡され、`const CharT (&)[N]`に当てはめて、`CharT`と`N`を推論していることがわかる。
同様に(3')も引数が参照であるから、`const char[]` 型がテンプレートの解釈候補に入る。だがこれは `const CharT*` としてみようとしても`*`がどこにもないので`CharT`を推論できない。
こうして(3')はオーバーロード候補から外れました。

# オーバーロードのテストに使用したリポジトリ(コードとテスト)
[repository: forno/xmaho](https://github.com/forno/xmaho)
[source code: include/xmaho/string/split.hpp](https://github.com/forno/xmaho/blob/master/include/xmaho/string/split.hpp)
[test code: test/string/split.cpp](https://github.com/forno/xmaho/blob/master/test/string/split.cpp)
[travis log: Pull Request #29](https://travis-ci.org/forno/xmaho/builds/202990649)

# 追記
なお、真に正確にハンドリングするには、(3')にも誤りがありconstな参照で受け取らなければならない。
const lvalue referenceでなければ右辺値を受け取る際にエラーとなってしまう。完成した関数はこちらとなる。 

```cpp
template<typename String, typename Delimiter>
inline std::vector<String> split(const String&, Delimiter&&); // (1)

template<typename CharT, size_t N, typename Delimiter>
inline std::vector<typename std::basic_string<CharT>> split(const CharT (&)[N], Delimiter&&); // (2)

template<typename CharT, typename Delimiter>
inline std::vector<typename std::basic_string<CharT>> split(const CharT* const&, Delimiter&&); // (3'')
```
Pythonの辞書を属性としてアクセスできるようにする

#やりたいこと

タイトルが正しくやりたいことを表現できてるのかいまいちわかりませんが、要はこういうことをやりたいなと思うことがたまにあります。JSを書いた後とかは特に。。

```py3
d = dict(a=1, b=2)

# ふつうこんな感じで使う
d["c"] = d["a"] + d["b"]

# こんな感じがいいんだけどなぁ
d.c = d.a + d.b

```

#こたえ

辞書をちょっと拡張して、``__setattr__``を``__setitem__``にマッピングすればいいのですね（getもしかり）。ハッピー！

[sklearn.datasets.base.Bunch](https://github.com/scikit-learn/scikit-learn/blob/0.18.X/sklearn/datasets/base.py#L29-L72)


#おまけ

属性になることで、IPython上で補完が効くようになります。例えば、requestsモジュールを使っているとして、「いまのレスポンスヘッダの中身が見たい！」ってときに、タブだけで候補がずらっと出てくれるようになります。

```py3

import requests
from sklearn.datasets.base import Bunch as dict

# GitHub APIを叩いてみる
response = requests.get("https://api.github.com")
headers = dict(**response.headers)
```

この状態で``header.<TAB>``とすると・・・

![スクリーンショット 2017-02-19 2.49.59.png](https://qiita-image-store.s3.amazonaws.com/0/79374/11dd453c-4f07-8609-c4fd-ab5db26435d4.png)

こうなりますので、いちいち``headers["X-RateLimit-Remaining"]``などと打つのに比べてストローク数はだいぶ減らせますね。ウェーイ！！からの・・

![スクリーンショット 2017-02-19 3.12.07.png](https://qiita-image-store.s3.amazonaws.com/0/79374/595c2808-25fc-001b-78bd-cc2d204ccda7.png)

お・・おお・・・
Pythonでオンライン線形回帰

はじめに
--------------------

Pythonで線形回帰 $y=ax+b$ の係数 $a,b$ を、オンライン推定します。

数式
--------------------

#### 最小二乗法

- 参考 : [回帰分析 (1) － 共分散と相関，線形単回帰](http://racco.mikeneko.jp/Kougi/10s/AS/AS02pr.pdf)

```math
a = \frac{\overline{xy} - \bar{x}\bar{y}}{\overline{x^2} - \bar{x}^2}
, \hspace{2em} b = \bar{y} - a \bar{x}
```

#### 平均値のオンライン推定
```math
\bar{x}_n = \alpha \bar{x}_{n-1} + (1-\alpha)x_n
```

ソースコード
--------------------

```py
#!/usr/bin/env python
# -*- coding: utf-8 -*-

import matplotlib.pyplot as plt
import matplotlib.animation as animation
import scipy as sp
sp.seterr(divide='ignore', invalid='ignore')

alpha = 0.9
def mean(old, new):
    return new if sp.isnan(old) else alpha * old + ( 1.0 - alpha ) * new

def plot(fig):
    xyhist = sp.ones([100, 2]) * sp.nan
    mean_x  = sp.array([sp.nan])
    mean_y  = sp.array([sp.nan])
    mean_x2 = sp.array([sp.nan])
    mean_xy = sp.array([sp.nan])

    ax = fig.gca()
    ax.hold(True)
    ax.grid(True)
    ax.set_xlim([0, 1.0])
    ax.set_ylim([0, 1.0])

    xyscat = ax.scatter([],[], c='black', s=10, alpha=0.4)
    approx = ax.add_line(plt.Line2D([], [], color='r'))

    def inner(i):
        x = sp.random.rand()
        y = x + 0.05 * sp.random.normal()

        xyhist[:-1, :] = xyhist[1:, :]
        xyhist[-1, 0] = x
        xyhist[-1, 1] = y

        mean_x[:]  = mean( mean_x,  x )
        mean_y[:]  = mean( mean_y,  y )
        mean_xy[:] = mean( mean_xy, x *  y )
        mean_x2[:] = mean( mean_x2, x ** 2 )

        a = ( mean_xy - mean_x * mean_y ) / ( mean_x2 - mean_x ** 2 )
        b = mean_y - a * mean_x

        xyscat.set_offsets(xyhist)
        approx.set_data([0, 1], [b, a*1+b])
        ax.title.set_text('y = %.3fx %+.3f' % (a, b))
        plt.draw()

    return inner


fig = plt.figure()
ani = animation.FuncAnimation(fig, plot(fig), interval=300, frames=100)
ani.save('result.gif', writer='imagemagick')
```

結果
--------------------

![result.gif](https://qiita-image-store.s3.amazonaws.com/0/111801/c2dcc024-3505-819f-05d8-5667af7b7f99.gif)
bash on ubuntu on windows に anaconda をサクッとに入れる

GPU付きのwindows10を入手したので機械学習の勉強用に使おうと思いました。
予想はしていましたがwindows版をインストールしてもbash上ではpythonのバージョンは3系にならず。
入手したてのマシンでpyenvとか入ってないし、apt-getとか使わずにサクッと入れられないか試しました
#anaconda for linux をinstallするまで
## ダウンロード
ダウンロード先はこちら。
https://www.continuum.io/downloads
Download for Linux というタブがあるので、そちらからインストーラをダウンロード。

## コマンドを実行
サイトにあるコマンドはこちら
```bash Anaconda3-4.3.0-Linux-x86_64.sh ```
ただ、今回参照したい対象ファイルはwindowsでダウンロードしたので、ubuntu側のルートディレクトリにはありません。

そこで以下のコマンド
``` bash /mnt/c/Users/user_name/Downloads/Anaconda3-4.3.0-Linux-x86_64.sh
```
インストールされました
```:~$ ls /home/user_name/anaconda3/
LICENSE.txt  bin  conda-meta  doc  envs  etc  include  lib  libexec  mkspecs  phrasebooks  pkgs  plugins  qml  sbin  share  ssl  t
```
ドライブの設定によっては /c/ のところもdだったりするかもしれません。
どうやらwindowsのディスクは /mnt ディレクトリにマウントされているようです。
これを理解してればwindowsでダウンロードしたファイルをubuntuで参照するの簡単そうだなと思いました。
webpack&モジュールバンドラ(Module Bundler)&ローダー(Loader)概要

# webpack&モジュールバンドラ&ローダー

最近、webpackを使用した<br>
その時に、webpackとモジュールバンドラ、ローダーの基本的なことについて学んだので、まとめようと思う<br>

なお、本記事では、基本的な概念や使用する際の注意事項のメモが中心となるので、設定ファイルの説明などは行っていない<br>

## モジュールバンドラ(Module Bundler)
### モジュールバンドラ(Module Bundler)とは
* 複数に分割されたJavaScriptのファイル（Module）を結びつけて1つのJavaScriptファイルにするツール

### なぜモジュールバンドラ(Module Bundler)が必要か
* 現在、最新のECMAScriptでは、1ファイル=1モジュールの考え方が考案され徐々に広まってきている
* しかし、現存のほとんどのブラウザでは、それに対応しておらず、scriptタグに書かれたJavaScriptのみを実行するのが普通だ
* モジュールバンドラ(Module Bundler)を使用すれば、複数のJavaScriptファイルをまとめ上げて1つのJavaScriptファイルに統合してくれる
* また、HTMLにエントリポイントとなるJavaScriptファイルのみを貼っておいても、現在のブラウザではモジュール間の依存関係を解決して、他のモジュールまで利用するということはできない（複数のJavaScriptファイル間の依存関係を解決してくれない）
* そこで、モジュールバンドラ(Module Bundler)は、複数に分割されたJavaScripファイル(モジュール)を1つのJavaScriptファイルにしてしまい、さらにその際に複数のJavaScriptファイル(Module)間の依存関係を解決してくれる


## webpack

### webpackとは
* モジュールバンドラ

### webpackの機能（ざっくり）
1. 分割したJavaScriptファイルを1つにまとめ上げられる（1つのファイルにビルドできる）=>bundle.jsになる
2. JavaScript同士の依存関係も解決してくれる

参考にさせていただいたサイト<br>
https://webpack.js.org/
https://ics.media/entry/12140
http://qiita.com/ossan-engineer/items/8352bdeab9ce8c8c00ef
http://qiita.com/chuck0523/items/caacbf4137642cb175ec

さらにwebpackは複数のbundle.jsをアウトプットすることもできる<br>
=> 例えばテストには、テスト用のtest_bundle.jsを作ることができる<br>
=>テストにおいても、JavaScriptはモジュールの分割の依存関係を解消するために、バンドルする必要があるのでそれに役立つ<br>

複数の出力ファイルをバラバラに出力するのに参考にさせていただいたサイト<br>
http://webdesign-dackel.com/2015/09/10/webpack-multiple-output/

### webpackで注意すべきこと
* webpackは循環依存は解決できない<br>
=> 例えば、エントリポイントであるA.jsとB.jsがお互いに依存しあっている場合、ループしてしまう<br>
=>index.js(エントリポイントとなるファイル)はimportできない<br>

                              
## loader
* loaderとは、JavaScriptのファイル中でimportした静的リソースをブラウザで扱える形に変換してくれるものである
* もっと詳しく言えば、loaderに対してパラメータ(引数)としてリソースファイルを与えると、JavaScriptで扱えるファイルに変換して返してくれる<br>
=> 例えば、ts-loaderを使用すると、TypeScriptのファイルでimportしたファイルをjsファイルに変換してくれる<br>

参考にさせていただいたサイト<br>
http://qiita.com/chuck0523/items/caacbf4137642cb175ec
http://qiita.com/howdy39/items/48d85c430f90a21075cd
https://webpack.js.org/concepts/loaders/(公式)


## おまけ : TypeScript with webpack

### TypeScriptでのwebpackの流れ
1. TypeScriptに対して、ts-loaderを使い、内部的に個別のjsファイルを作成する<br>
例)A.ts, B.ts, C.tsが存在するとき、ts-loaderを使用すると、A.js, B.js, C.jsがwebpack内部で生成される<br>

2. web packの本来の機能を使用して、内部的に生成された複数の.jsファイルを1つのbundle.jsにまとめ上げる<br>


### TypeScriptでwebpackを使用する際の諸注意
* 複数のJavaScriptファイルを生成しなくても、bundle.jsを生成すれば良い
* 例えば、Gi tHubでソースコードを管理している場合、基本的には、後で再生成可能なファイルは、Git Hub上に置かないほうがよしとされている
=> 万が一、複数のjsファイルを生成しても、それは再生成可能なファイルなので、.gitignoreするといいかもしれない


※ 同一内容を個人のブログでも書いている
http://www.sekky0905.com/entry/2017/02/19/%E3%80%90webpack%E3%80%91webpack%26%E3%83%A2%E3%82%B8%E3%83%A5%E3%83%BC%E3%83%AB%E3%83%90%E3%83%B3%E3%83%89%E3%83%A9(Module_Bundler)%26%E3%83%AD%E3%83%BC%E3%83%80%E3%83%BC(Loader)%E6%A6%82%E8%A6%81
Python - 数値データファイルからデータを読み込み共分散を計算

以下のようなタブ区切りの数値データ系列ファイルからデータを読み込み共分散を計算するプログラム。

```ruby:MultipleRegressionAnalysis_Data1.txt
65.7	67.8	70.3	72.0	74.3	76.2
3.27	3.06	4.22	4.10	5.26	6.18
69.7	69.7	71.3	77.6	81.0	78.7
```


```correlation.py
import numpy as np

def load_data(filename):
    x = []
    for line in open(filename, 'r'):
        x.append([])
        for data in line.strip().split('\t'):
            x[len(x)-1].append(float(data))
    return x

def calc_correlation(data1, data2):
    ave1 = calc_average(data1)
    ave2 = calc_average(data2)
    sum = 0.0
    for i in range(len(data1)):
        sum += data1[i] * data2[i]
    return (sum / len(data1)) - (ave1 * ave2)
    
def calc_average(data):
    sum = 0.0
    for d in data:
        sum += d
    return sum / len(data)

if __name__ == "__main__":
    data = load_data('MultipleRegressionAnalysis_Data1.txt')
    corr = []
    for i in range(len(data)):
        corr.append([])
        for j in range(len(data)):
            corr[len(corr)-1].append(calc_correlation(data[i],data[j]))
            
    print(np.array(corr))
```

```ruby:結果
>python correlation.py
[[ 12.95583333   3.70208333  14.89666667]
 [  3.70208333   1.18114722   4.10327778]
 [ 14.89666667   4.10327778  20.94222222]]
AtomでPythonプログラミング

# AtomでPythonプログラミング書く時のパッケージセット

### 前回記事
[AtomでVIM](http://qiita.com/hogeai/items/a70213b21124964945db)
- space space は、まじで神がかってるのでおすすめ。
- ほかは好みでいいと思う。

### 今回はパッケージ紹介(各項目は、上から順にお勧め)

- Python 実行
    - Hydrogen
        - jupyterバックエンドでPython
        - セルを意識しないJupyterが気持ちいい
    - script
        - AtomでPython実行の王道はこっち
        - 完成したソースはこれ使ってる

- Python コーディング
    - linter
    - linter-pylama
        - 文法チェック、わかりやすい。
    - atom-beutify
        - オートでコードを綺麗にしてくれます。上のと併用
        - 対応ソースも多い
    - autocomplete-python
        - DL数で決めたPython用オートコンプリート。
        - クラウド連携は切ってます。

- プログラミング全般
    - highlight-selected
        - 選択文字をハイライト、これがないエディタは使いません。
    - show-ideographic-space
        - 全角スペース表示
    - minimap
    - minimap-bookmarks
    - minimap-cursorline
    - minimap-find-and-replace
    - minimap-highlight-selected
        - 有名なあれシリーズ
    - todo-show
        - TODO/TESTなどを一覧化
    - regex-railroad-diagram
        - 正規表現をマップ表示
    - autocomplete-paths
        - ファイルパスのオートコンプリート
    - jumpy
        - カーソルジャンプ、慣れると便利
    - split-diff
    - sort-lines

- Atom周り
    - project-manager
        - プロジェクトフォルダを保存/復活
    - save-session
        - 最後に開いていたタブを復活
    - open-recent
        - 最近のファイルを開く
    - maximize-panes
        - パネルを最大化
    - file-icons
        - TreeのIconをわかりやすくする。こういうのが地味に効く
    - highlight-line
        - 今いるカーソル行をハイライト。好みが別れる

- vim
    - vim-mode-plus
    - vim-mode-plus-ex-mode
    - vim-mode-plus-keymaps-for-surround
Amazon AIのレイヤー構造

各社aiクラウドについてウォッチ。

今回はaws。３つのレイヤーに分けて構築されてるそう。
こちらの記事です。
https://aws.amazon.com/jp/blogs/ai/welcome-to-the-new-aws-ai-blog/

100人に "人工知能"の定義を尋ねると、100以上の回答が得られます。 AWSでは、視覚認識、音声認識、意思決定、翻訳などの人間レベルのインテリジェンスが必要なタスクを実行できるサービスまたはシステムとして定義します。この新しいAWSブログでは、詳細な技術コンテンツ、カスタマーストーリー、新機能発表などで、これらの分野などをカバーします。

高度なAIシステムの構築に関連する課題は、大部分がスケールに左右されます。データセットは大きく、トレーニングは計算量が多く、予測を推論することは、規模の小さい、または低消費電力のモバイルデバイスでは困難です。顧客はAWSを使用してこれらの一般的な問題を長年にわたって解決してきました。要求に応じてストレージ、GPU、CPU、IoTサービスにアクセスできるようになったのは、生産現場のインテリジェントシステムに最適です。 AmazonとAWSの両方の顧客にとって、AWSはAIの重心となっています。

自律的な運転のためのコンピュータビジョンシステムからFDA承認の医療画像化まで、AWSは既存製品の革新を推進してきました。また、Netflix、Pinterest、Airbnb、GE、Capital One、Wolfram Alphaなど、また、アマゾンでは、ロボットの充実による注文受注時間の短縮、X線（テーマや文字、ビデオやテキストでのインタラクションの表示）などの新機能の作成、Amazon Echoなどの新しい体験の実現にも幅広く使用されています、Alexa、または新しい深遠な学習機能を備えたラインフリーのチェックアウトのない食料雑貨店、Amazon Go（現在はシアトルのベータテスト中）があります。

私たちのビジョンは、できるだけ多くの開発者に知性を提供するために、顧客とAIに焦点を当てた何千人ものエンジニアから得た専門知識と教訓を使用し、技術レベルにかかわらずAIを誰にでも利用できるようにすることですスキルまたは能力。今日では、AWSのインフラストラクチャとネットワークの上位に位置する3つの主要レイヤーに分かれています。これを総称して「Amazon AI」と呼びます。

![amazon_ai_launch.gif](https://qiita-image-store.s3.amazonaws.com/0/64334/90c3c1fd-8f89-f015-ac16-90df3273469d.gif)

AIモデルを実装するために必要な技術的スキルを持っていない開発者や、訓練するための高品質の「真実の」データがない開発者にとっては、Amazonの画像認識と顔認識分析、Amazon-Pollyによるテキスト音声変換、会話型チャットボットを構築するための自動音声認識と自然言語理解サービスであるAmazon Lexなどがあります。ここで必要となる深い学習の専門知識はありません：AWSコンソールを訪れて始めましょう。

従来のデータを使用してカスタムモデルを構築したいお客様には、AIトレーニングとモデルホスティングの導入と管理に関連する未分化の重労働を取り除く一連のAIプラットフォームを提供しています。Amazon Machine Learningカスタム線形モデルの時間予測）とAmazon EMR（SparkとSpark MLサポート）

最後に、私たちはAIエンジンを提供しています。これは、オープンソースの学術研究者やデータ科学者にとって、便利なマシンイメージにあらかじめインストールされた最先端の洗練されたインテリジェントシステムを構築するためのフレームワークです。 Apache MXNet、TensorFlow、Caffe、Theano、Torch、CNTKなどのエンジンは、カスタムモデルのトレーニングに柔軟なプログラミングモデルを提供します。私たちの好きな、そしてAmazonで選ばれている深いラーニングエンジンは、数百のGPUにほぼ直線的に拡大するApache MXNetです。新しいカスタムIntelプロセッサやフィールドプログラマブルゲートアレイ（FPGA）からどこでも実行できる効率的なモデルを訓練します。 Amazon EC2、AWS Lambda、ロボットとドローンの組み込み機器へ

AI研究の最先端の学界にいても、アプリケーションにインテリジェンスを追加する簡単な方法を求めている開発者でも、世界最高レベルの科学技術チームがサポートする、最も幅広いAIサービスを提供します。

今日、AIは大多数の開発者にとって重要な話題です（Mark Cubanは最近、「恐竜」にならないようにするために、これを最も重要な技術と語りました）が、AIの出現はまだ非常に早い 。 このブログでは、チュートリアル、ガイダンス、ベストプラクティス、ヒントなどを通してAIを探求します。
Endless Runner 追加機能 Magnetic #UE4Study

# Endless Runner 追加機能 Magnetic

Endless Runnner
http://qiita.com/gansaibow/items/385431852e83b377d710

## RunCharacterに関数:MagneticItemを追加する

**MagneticItem**

**Input**

|変数名  |変数の型  |
|---|---|
|DeltaTime |float |

![image](https://qiita-image-store.s3.amazonaws.com/0/111261/4e800f8a-0a85-0797-16f6-dc09ef205b17.png)

![image](https://qiita-image-store.s3.amazonaws.com/0/111261/57de50a4-32ce-839f-47b5-da0e0883f946.png)

### 変数を追加する

|変数名  |変数の型  |デフォルト値 |
|---|---|---|
|IsMagnetic |Boolean |True |
|MagneticRadius |float |1500.0 |

![image](https://qiita-image-store.s3.amazonaws.com/0/111261/998fceae-cb8f-144c-b150-4cbd47940f2f.png)

### Local 変数を追加する
|変数名  |変数の型  |
|---|---|
|TmpDeltaTime |float |


![image](https://qiita-image-store.s3.amazonaws.com/0/111261/0aa10f18-03d9-7c6d-a4a5-849245b785ca.png)

![image](https://qiita-image-store.s3.amazonaws.com/0/111261/fadf728d-0c67-ca09-3330-62cfc73d664b.png)


### 処理のイメージ
![image](https://qiita-image-store.s3.amazonaws.com/0/111261/44a110c7-8f54-e563-883d-31b9026d1055.png)

左側
![image](https://qiita-image-store.s3.amazonaws.com/0/111261/0b18ee84-3f68-4eb6-9fd8-4e52a187532e.png)


右側
![image](https://qiita-image-store.s3.amazonaws.com/0/111261/7bd79057-8137-91e0-6aee-a179ca6a0d37.png)

## RunCharacterのイベントグラフ：Tick処理で関数：MagneticItemを呼び出す
![image](https://qiita-image-store.s3.amazonaws.com/0/111261/44f70bff-4191-043e-5131-4ec62ba157f9.png)

## プレイして確認する
![image](https://qiita-image-store.s3.amazonaws.com/0/111261/85667cd6-0254-b9d9-67e2-dadd97444e64.png)


## 参照
Magnet
https://forums.unrealengine.com/showthread.php?65770-Magnet

UE4BP Make Literal 型ノード
http://qiita.com/gansaibow/items/8e4a8cd33b412274c637

２点間の座標が分かると出来ること
http://qiita.com/gansaibow/items/9bedde0d69f76686a347
mb_convert_encodingについて第２引数の補足（Mac OS X10.11.6）

これはハマった。

よくCSVとかのファイルをアップロードするじゃないですか。
それを処理する場合、
<pre>
//$uploadPath: アップロードされたファイル

mb_convert_encoding(
    file_get_contents($uploadPath),
    "UTF-8", "ASCII,JIS,UTF-8,CP51932,SJIS-win, EUC-JP,UTF-16"
);
</pre>

とかあるじゃないですか。
Macの場合、これダメ。
CSVなので、元ファイルはExcelなどから出力されるものを想定しますが、もちろんその場合、文字コードはSJISです。

で、mb_convert_encodingする際、上記の例で言うと、SJIS-winに該当されません。
だから、UTF-8になりません。SJISのままで処理されます。

（SJIS-winは、いわゆるPHPの5C文字を含む拡張文字コード用ですね。）

ところが、

<pre>
//$uploadPath: アップロードされたファイル

mb_convert_encoding(
    file_get_contents($uploadPath),
    "UTF-8", "ASCII,JIS,UTF-8,CP51932,SJIS-win"
);
</pre>

だと、大丈夫です。SJIS-winを最期にすると、キチンと文字エンコードコンバートされます。

この問題は、恐らくMac OS X10.11.6 にした時から出たときからですので、

ローカルの開発環境で、突然インポート処理などが動かなくなった時はお試しあれ。

本番環境でも、CSVアップロードなどを想定する場合は、別にEUCとか、UTF-16とか、ある程度切っても大丈夫ですよね。。。
（多分）

終わり。
システム起動時に１度だけ実行されるCronを設定する

Cronにそのような構文があらかじめ用意されている。

普段時刻を設定している箇所に`@reboot`を指定すれば良い。

```
echo '@reboot /path/to/script' | crontab
```

@からはじまる構文は他にも下記のようなものがある。(Ubuntu 16.04.2 LTSの"man 5 crontab"より抜粋)

```
              string         meaning
              ------         -------
              @reboot        Run once, at startup.
              @yearly        Run once a year, "0 0 1 1 *".
              @annually      (same as @yearly)
              @monthly       Run once a month, "0 0 1 * *".
              @weekly        Run once a week, "0 0 * * 0".
              @daily         Run once a day, "0 0 * * *".
              @midnight      (same as @daily)
              @hourly        Run once an hour, "0 * * * *".
```
RailsでERBの代わりにSlimを利用する手順と、おすすめSlim学習方法

# はじめに

Railsでviewを作成する際、デフォルトのテンプレートエンジンとしてERBが利用されています。しかし、SlimやHamlなどはERBよりも簡潔にかけたりパフォーマンスに優れたりといったメリットがあります。
今回は特に評判のよいSlimをERBの代わりにRailsで利用するための手順を説明します。



# 新規アプリケーションでSlimを利用する場合



Gemfileに`slim-rails`を追加します。このgemを利用することでSlimが利用できるようになります。

```diff:Gemfile
+ gem 'slim-rails'
```

`bundle install`を実行します。

```
$ bundle
```

これで`*.html.slim`というファイルがviewのテンプレートエンジンとして認識され、`*.html.erb`のように利用することができます。

# 既に存在するerbファイルをslimに変換したい場合

既にいくつか`*.html.erb`というファイルを既に作成していたとします。
この場合は`html2slim`というgemを利用することで既存のerbファイルをslimファイルに変換することができます。

```diff:Gemfile
+ gem html2slim
```

`bundle install`を実行します。

```
$ bundle
```

以下のコマンドを実行することでerbファイルがslimファイルに変換されます。

```
$ bundle exec erb2slim app/views app/views
```
なお、以下のように-dを付けるとslimファイルに変換した後にerbファイルは削除されます。

```
$ bundle exec erb2slim app/views app/views -d
```

# (余談)おすすめのSlim学習方法

Slimで書き始めると慣れないうちはERBで書いていたものはどうやって書くんだろうと思うことが何度もあると思います。
そこでおすすめの学習方法としては、**scaffoldでRailsアプリを作成し、そこで作成されたerbファイルをslimファイルに変換し、適宜参考にする**という方法です。

具体的には以下のような感じです。

まず、サンプルのアプリを作成します。

```
rails new scaffold-slim
cd scaffold-slim
```

Gemfileにテンプレートエンジン変換用gemを追加してインストールします。

```diff:Gemfile
+ gem 'html2slim'
```

```
$ bundle install --path vendor/bundler
```

適当なモデルをscaffoldで作成します。

```
$ bundle exec rails scaffold
$ bundle exec rails g scaffold Event title:string body:text
```

以下のコマンドを実行します。(erbファイルを削除してしまうとslimと比較ができないので`-d`オプションをつけていないです。)

```
$ bundle exec erb2slim app/views app/views
```

これでerbで書かれていたコードがslimではどのように書かれるのかを適宜参考にできるようになります。


# 参考
[erbをslimに変換する](http://qiita.com/hmuronaka/items/f0e4da231ce97da49043)
[Rubyのテンプレートエンジンをerbからslimに変更する際に変えた事](http://qiita.com/moriyaman/items/c0d60406422677bcb398)
brewでMariaDBを入れたらMAMP ProのMySQLにSequel Proで接続できなくなったのでソケットを指定した


タイトルまんま^^;

brewでMariaDBを入れて起動しっぱなしにしたら、MariaDB側のポートを変更してても、Sequel Proでローカルにソケット接続すると、MAMP ProのMySQLでなくMariaDBに接続されてしまうので、Sequel Proでソケットオプションを指定しました。

（MariaDBを入れたときの話はこちら→[Mac OSX El Capitanにbrewで MariaDB+Mroonga環境を入れてNetCommons3(CakePHP2)で使う - Qiita](http://qiita.com/RyujiAMANO/items/8f5da16b37ad29a892a3)）


# Sequel Pro の設定

MAMP ProのMySQLへの接続設定でソケットオプション指定するだけ。

![Sequel_Pro.png](https://qiita-image-store.s3.amazonaws.com/0/9845/30bd15d8-9c4b-f759-518c-4c16137b59c9.png "Sequel_Pro.png")

ソケットの場所は

/Applications/MAMP/tmp/mysql/mysql.sock

になります。これをソケット欄に入力するだけでOK。

これで、MariaDBとMAMP ProのMySQLを同時に起動して両方にSequel Proから接続出来るようになりました。(^^)
Eitherについて調べてみた

##Eitherとは
Eitherとは「２つの型のうちどちらか」を表す型です。
例えば、正常値とエラー値どちらかを返したい場合に使用します。
ただしEitherへ与える左右の型引数は平等に扱われるため、「AもしくはBどちらかを返す型」といった一般的な使い方ができます。

## 実装例
```Either.swift
enum Either<Left, Right> {
	case left(Left)
	case right(Right)
}

```

```Left.swift
class Left {
    var name: String = "left"
}
```

```Right.swift
class Right {
    var name: String = "right"
}
```

```ViewController.swift
override func viewDidLoad() {
        super.viewDidLoad()
        let leftResult = toResult(.left(Left()))  // left
        let rightResult = toResult(.right(Right())) // right
        
        NSLog("leftClassName = \(leftResult)")
        NSLog("rightClassName = \(rightResult)")
    }

    func toResult(type: Either<Left, Right>) -> String {
        switch type {
        case .left(let left):
            return left.name
            
        case .right(let right):
            return right.name
        }
    }
}

```

## 感想
APIとかの通信エラーのハンドリングとかに使えそう

参考記事
Swift 3.0で追加されそうなEitherについて:
http://qiita.com/koher/items/288f01cddb0bbb6aa4e1
DataBase作成メモ：Ruby on Rails v5.0.1(環境macOS Sierra v10.12.3)

Qiita初登録＆初投稿です。これまでは閲覧側で、多くの方の有用な記事に助けられて来ました。
ヒヨコ🐥に毛が生えた程度のビギナーですが宜しくお願い致します(_ _)。
と言う事で、試しに1つ掲載します。

rails newコマンドで新規作成すると、dbディレクトリとシードデータと言うデータを保存する為のseeds.rbファイルが作成される。
<pre class="toolbar:1 start-line:62 lang:sh decode:true " title="dbフォルダとseeds.rbが作成される" >create  db
create  db/seeds.rb</pre>
この後でlocalhost:3000にアクセスすることで、自動的にdevelopment.sqlite3と言うデータベースが作成される。因みに、このデータベースは削除しても上記URLにアクセスする度に生き返る。
<pre class="toolbar:1 lang:sh decode:true " title="データベースが作成される" >$ ls
development.sqlite3	seeds.rb</pre>
データベース作成のコマンド。既にデータベースdevelopment.sqlite3は存在していると表示されるが、新たにデータベースtest.sqlite3が作成される。
<pre class="toolbar:1 lang:sh decode:true " title="データベース作成のコマンド" >$ rake db:create
Database 'db/development.sqlite3' already exists
Created database 'db/test.sqlite3'</pre>
<blockquote>Railsでは3つのデータベース：development.sqlite3(開発用)、test.sqlite3(テスト用)、production.sqlite3(本番用)を使用出来る。</blockquote>
<pre class="toolbar:1 lang:sh decode:true " title="production.sqlite3の作成" >$ rake db:create RAILS_ENV=production
Created database 'db/production.sqlite3'</pre>
development.sqlite3、test.sqlite3のデータベースは下記コマンドで削除出来るが、production.sqlite3は削除出来ない。
<pre class="toolbar:1 lang:sh decode:true " title="データベースの削除" >$ rake db:drop</pre>
<pre class="toolbar:1 lang:sh decode:true " title="production.sqlite3の削除" >$ rake db:drop RAILS_ENV=production</pre>
<blockquote>DBMSへの接続設定はconfig/database.ymlファイル(YAML形式)で行い、アプリケーション作成時に自動生成される。</blockquote>
DBMSを指定しないでrails newすると、デフォルトでSQLite3用の設定を作成する。Railsには3つの実行環境(開発、テスト、本番)があり、環境ごとに別々のデータベースを使うことになる。
<pre class="toolbar:1 wrap:true lang:yaml decode:true " title="config/database.yml" ># SQLite version 3.x
#   gem install sqlite3
#
#   Ensure the SQLite 3 gem is defined in your Gemfile
#   gem 'sqlite3'
#
default: &amp;default
  adapter: sqlite3
  pool: 5
  timeout: 5000

development:
  &lt;&lt;: *default
  database: db/development.sqlite3

# Warning: The database defined as "test" will be erased and
# re-generated from your development database when you run "rake".
# Do not set this db to the same as development or production.
test:
  &lt;&lt;: *default
  database: db/test.sqlite3

production:
  &lt;&lt;: *default
  database: db/production.sqlite3</pre>
また、実行環境ごとの設定ファイルはconfig/environmentsに、development.rb、test.rb、production.rbがある。
クラスター分析について

#クラスター分析とは
- 観測対象を互いに似た者同士でグループ分けをする手法。似たような傾向を示す消費者をいくつかのグループに分類することで消費者の大まかなニーズを掴むことができる。

- 大きく分けて階層的手法と非階層的手法がある。それぞれの代表的な手法として、ウォード法、k-means法とがある。

- 教師データを用いない手法のひとつ。


##教師ありと教師なし
**教師あり**
- 与えられたデータを適切なクラスへ振り分ける。
- 既存データを基に作成したルールで、新規データを振り分ける。
![image](https://qiita-image-store.s3.amazonaws.com/0/151919/8b57442c-68a0-26da-695c-54481746c9b6.png)

**教師なし**
- 与えられたデータを複数のグループへ分ける。
- データの特徴を基に意味のあるグループがないかみつける。
![image](https://qiita-image-store.s3.amazonaws.com/0/151919/67fd1d37-5480-53ca-5da7-367e7f1e909c.png)


##階層型と非階層型
**階層型クラスター分析**
- 各データをひとつのクラスタとみなし、距離が近いクラスタを段階的に結合する手法。
- ウォード法など
![image](https://qiita-image-store.s3.amazonaws.com/0/151919/481b5714-a273-ddb5-ee77-a0dd9f7ce43c.png)

**非階層型クラスター分析**
- 決められたクラスタ数でデータを分割し、最適分割となる分割方法を探索する手法。
- k-means法など
![image](https://qiita-image-store.s3.amazonaws.com/0/151919/727ca6fd-3619-69a3-af0a-aea547120dc8.png)

##類似度とは
- 東京と北海道、東京と沖縄の２地点間の距離を調べる。
- ３地点の都道県庁の軽度と緯度から、２地点間の距離を求める。

| 県庁所在地 | 緯度 | 経度 |
|:-:|:-:|:-:|
|東京都庁|139.69|35.69|
|沖縄県庁|127.68|26.21|
|北海道庁|141.35|43.06|

２地点間の距離は、三平方の定理から、都市間の経度の差の２乗と緯度の差の２乗の和について正の平方根をとった。

|  | 東京都庁 | 沖縄県庁 |
|:-:|:-:|:-:|
| 沖縄県庁 | 15.30  |   |
| 北海道庁 | 7.35  |  21.70 |

- 東京と北海道が最も近く、東京と沖縄の約1/2。
- このような一般的に利用する距離を「ユークリッド距離」と呼び、クラスタリングにおいてはこの「距離」の概念を用いて、似ているものどうしをまとめていく。
DNSの設定メモ

ガッツリ躓いたし、単なる見落としみたいな感じだったから辛かった。
今後用のメモ。
###なんでDNS？

ぼく「アップデートかけるかー」
`$yum check-update -y`
`Error: Failed to synchronize cache for repo 'fedora'`

####は？
ネットワークおかしいのかなーってpingを飛ばした。
ping
`$ping fedoraproject.org`
お返事
`PING: fedoraproject.org: Name or service not known`
####はーーーーーーーー？
これ完全にDNS設定じゃん
* * *


#/etc/resolv.confを編集する

```/etc/resolv.conf
nameserver 8.8.8.8
nameserver 8.8.4.4
```
という感じに編集しました。ありがとうGoogle

これでpingを飛ばしてみると…？
`$ping fedoraproject.org`

無事以下のように返ってきました！
`PING fedoraproject.org (67.219.144.68) 56(84) bytes of data.`
`64 bytes from 67.219.144.68 (67.219.144.68): icmp_seq=1 ttl=43 time=198 ms`

やったぁ！

##実は問題がある
/etc/resolv.confに自分で追加したのはいいんだけど、/etc/resolv.confって再起動とかすると中身が自動で消えるんだね！
(消えるわけじゃないんだけど、この時は消える認識だった)
もし何か再起動したらその度に自分で書かないとダメじゃん。
ということで調べると毎回書かなくてもいい設定が存在するじゃん、当たり前じゃん。

##/etc/sysconfig/networkscripts/ifcfg-eth0を編集する

以下を追記

```/etc/sysconfig/networkscripts/ifcfg-eth0.
PEERDNS=yes
DNS1=8.8.8.8
DNS2=8.8.4.4
```

これで再起動してもDNS設定が保持されたままになりました。
保持というかこの設定通り/etc/resolv.confに書き込まれるみたい。

##これで問題は解決。

ぼく「アップデートして再起動しよーっと」
ぼく「アップデートしたらSSHできなくなった」

####次はfirewallの設定だね

#参考

[IPアドレス設定とのPEERDNSパラメーターについてのメモ](http://think-t.hatenablog.com/entry/20110113/p1)
[dhcpでresolv.confを更新させない方法](http://www.server-memo.net/server-setting/dhcp/dhclient-resolv.html)
2.54mmピッチヘッダーピンへの配線は2550 QIコネクタを使って専用のケーブルハーネスを作成

#概要

[自作中のドローン](http://qiita.com/shigeru-yokochi/items/746a520b6c0c00243993)のセンサー配線が適当に仕上げてあり、断線や接触不良が発生しやすかったので専用のケーブルハーネスを作成した時のメモ。

---

##使った材料
- QIコネクタ
- 2.54mmピンソケット
- 電線(AWG26を使用)
- 収縮チューブ(3Φを使用)
- スパイラスチューブ(結束径1.5~10.0を使用)

##使った工具
- 圧着工具(PA-20を使用)
- 工具ではないが収縮チューブに使うライター
- ワイヤーストリッパー
- ニッパー
- ラジオペンチ
 
---

元の配線↓
![20170128_204243.jpg](https://qiita-image-store.s3.amazonaws.com/0/146154/9ae96483-f331-767f-4f44-2599a1b114e7.jpeg)

材料と工具↓
![20170128_202429.jpg](https://qiita-image-store.s3.amazonaws.com/0/146154/956eb13f-958f-fe64-7786-ac4b6893759a.jpeg)


完成したケーブルハーネス↓
![20170128_231448.jpg](https://qiita-image-store.s3.amazonaws.com/0/146154/30569193-e3da-1f50-ebab-80aecce76445.jpeg)


きれいになりました↓
![20170128_232350.jpg](https://qiita-image-store.s3.amazonaws.com/0/146154/9e5a3000-a230-db48-c8f0-8b3a9ce2c3be.jpeg)
AtCoder Beginner Contest 055

2017年2月18日のAtCoderの記録。言語はRubyです。

問題はこちら：[AtCoder Beginner Contest 055](http://abc055.contest.atcoder.jp/)
私の回答一覧はこちら：[自分の結果](http://abc055.contest.atcoder.jp/submissions/all?user_screen_name=Linus)

#A問題
特に言うことなし。問題文そのまま。

```ruby
n = gets().to_i
puts n*800-n/15*200
```

#B問題
$N!$ を $10^9+7$ で割った余りを求める問題。最後に割ろうとすると数が大きくなりすぎるので良くない。1つ掛けるごとに剰余を出せばよい。

```ruby
i = gets.to_i
ans = 1
1.upto(i) do |k|
	ans = ans * k % (1000000000+7)
end
puts ans
```

#C問題
書いたコードの量は、[前回のC問題(深さ優先探索)](http://qiita.com/Linus_MK/items/3bce31d68b6fcacb29c4)に比べて随分少なくなった。頭を使えば書くべきコードを減らせるタイプの問題である。

全数探索：cを組み合わせてSにする回数さえ決まれば最大数は決まる。したがってcをSにする回数に関して、全ての可能性を調べて最大値を取れば良い。しかし、cの個数の最大が$10^{12}$なので、この方法では時間オーバーする。
二分探索：これもダメ。計算量を減らせそうだが、「cをSにする操作」をi回行ったときのSccの個数をf(i)とすると、f(i)は山型の関数になる。したがって最大値を二分探索で求めることは不可能。

正解の解法は以下のようになる。
頭の中で一旦、Sを全て2つのcにバラす。最初にn個のsとm個のcがあったので、全部で(2*m+n)個のcができる。この状態からSccを作るには、4つずつ組にしていってからcを組み合わせてSにすればよい。(※1)
しかし実際には「Sを全て2つのcにバラす操作」はできない。そのため最初にSが多くてcが少ないと、(※1)の数よりも少なくなる。(たとえばSが10個でcが2個の場合、Sccは1組しかできない)その場合はcの数が制約条件になるので、m/2が答え。

```ruby
n,m = gets.split(" ").map{|v|
	v.to_i
}
 
all = n * 2 + m
if m >= all/4*2 then
	puts all / 4
else
	puts m/2
end
```

短くしようとすると2行までは縮められる(下記のコードから変数allを削除すれば良い)。ワンライナーでできるかは分からない。しかし……ここまで簡潔に書ける問題がC問題で良いのかなぁ。

```ruby
n,m = gets.split.map &:to_i
all = n * 2 + m
puts m >= all/4*2 ? all / 4 : m/2
```

#D問題
ある点の動物と両隣の動物がわかれば、その点の解答が分かる。
自身と両隣のうちどれか1つが(羊から狼に/狼から羊に)入れ替わると、回答の○×も入れ替わる。これより、自身と両隣の3匹のうち、羊の匹数の偶奇によって回答が決まる(全員羊なら○なので、羊が奇数なら○、偶数なら×になる)。論理演算子としてはXOR を使えば良い。
1,2番の動物を仮に決めると、2番の発言から3番の動物がきまり、3番の発言から4番の動物がきまり……最後にN番の動物が決まる。最後にN番と1番の発言に合致するかをチェックすれば良い。(実際のコードでは代わりに、1番の動物と2番の動物が最初に仮に決めたものと合致するかを調べている。直前のコードをそのまま利用できるからである。)
仮に決める方法は4通りあるので、全部試してダメだったら-1を出力。

```ruby
def check(ans, n, s)
	# 2番からn-1番の回答に合致させる
	1.upto(n-2) do |i|
		temp = (ans[i-1] == "S") ^ (ans[i] == "S") ^ (s[i] == "o") 
		ans[i+1] = temp ? "S" : "W"
	end
 
	temp = (ans[n-2] == "S") ^ (ans[n-1] == "S") ^ (s[n-1] == "o")
	ans_zero = temp ? "S" : "W"
 
	temp = (ans[n-1] == "S") ^ (ans[0] == "S") ^ (s[0] == "o")
	ans_one = temp ? "S" : "W"
 
	if ans_zero == ans[0] && ans_one == ans[1] then
		return true
	else
		return false
	end
end
 
 
n = gets.to_i
s = gets.chomp
 
ans = []
ans[0] = "S"
ans[1] = "S"
if check(ans, n, s) 
	puts ans.join
	exit
end
 
ans = []
ans[0] = "S"
ans[1] = "W"
if check(ans, n, s) 
	puts ans.join
	exit
end
 
ans = []
ans[0] = "W"
ans[1] = "S"
if check(ans, n, s) 
	puts ans.join
	exit
end
 
ans = []
ans[0] = "W"
ans[1] = "W"
if check(ans, n, s) 
	puts ans.join
	exit
end
 
puts -1
```

コードの後半に関しては「ループ使えばスマートに書けそうだけど時間かかるし、いいやベタに書いちゃえ」という方針。
ans = ["W", "S"]みたいに書けば良かったな。

何かいい方法が無いかと調べてみたら、repeated_permutationというメソッドが今回の目的にぴったりだった。重複を許した順列、というと仰々しいが、n個の候補から重複を許してm個並べた、n^m個の全通りの並べ方を返すものである。[公式リファレンス](http://ref.xaio.jp/ruby/classes/array/repeated_permutation)も参照。
このメソッドを使うと、このように簡潔に書ける。

```ruby
["S", "W"].repeated_permutation(2) { |ans|
	if check(ans, n, s)
		puts ans.join
		exit
	end
}
puts -1
```

以上。レートが1113まで上がったので、上手く行けばもうすぐABCは卒業かな。
Raspberry Pi Zero で自律飛行ドローンを作るぞ（第２回：姿勢制御は簡単にはできないぞ！！）

#概要

前回の[Raspberry Pi Zero で自律飛行ドローンを作るぞ（第１回：浮上まで）](http://qiita.com/shigeru-yokochi/items/0a0a4f06cd8dec553159)　から約一か月、姿勢制御に挑戦してみて難しさが見えてきた。
ここらで一回整理することにしました。

#やろうとしたこと
ジャイロセンサ([MPU-6050](https://www.invensense.com/products/motion-tracking/6-axis/mpu-6050/))出力の3軸(roll(ロール:進行方向に対し前後を軸にした回転）pitch(ピッチ:進行方向に対し左右を軸にした回転）Yaw(ヨー:進行方向に対し上下を軸にした回転））を制御して機体の水平維持を試みる。
そこで、<font color="Red">まずはrollだけを制御することにした。</font>

#やったこと

###ハード面
- 機体前後を押さえる冶具を作った。
- [センサ配線をしっかりと作った](http://qiita.com/shigeru-yokochi/items/3ade778ce3f752a60b6b)
- raspberrypi zeroはLipoバッテリ1セルで駆動することにした。（5vに昇圧しなくても動作しているのでOKとした）
- プロペラガードを付けた。
- プロペラを5030から5045に変えた。
- モーター用Lipoバッテリを2セルから3セルに増やした。

###ソフト面
- [roll角](https://ja.wikipedia.org/wiki/%E3%83%AD%E3%83%BC%E3%83%AA%E3%83%B3%E3%82%B0)の制御した。
- [PID制御](https://ja.wikipedia.org/wiki/PID%E5%88%B6%E5%BE%A1)を追加した。
- 重量バランスを吸収するため、モータ毎に回転数を設定した。

###動作検証結果
- 冶具ありの場合となしの場合で浮上させてみたが、納得のいくものにはらなかった。。

冶具あり動画(YouTube)
- 回転数を上げれば上昇することはわかった。
- ふらつきはまだまだ大きすぎる。
- roll制御は未完成。。
[![IMAGE ALT TEXT HERE](http://img.youtube.com/vi/aSFKkPWQR6Y/0.jpg)](https://www.youtube.com/watch?v=aSFKkPWQR6Y)

冶具なし動画(YouTube)
- roll制御だけなので、やはりどっかに行ってしまう。（機体の重い方とか）
- 飛んでいく方向が制御できないので出力を上げられない。
- roll制御どころではない。
[![IMAGE ALT TEXT HERE](http://img.youtube.com/vi/rDUfgTAslts/0.jpg)](https://www.youtube.com/watch?v=rDUfgTAslts)

#わかったこと
- 難しいことがわかった。（実感した）
- PID制御の値を定めることができない。
- 冶具ありとなしで同じ制御は使えなそう。
- 回転するプロペラが危険。
- 機体の重量バランスは大事
- 加速度も取得できるので考慮したほうがよさそう。（下図はpitchと加速度aaWorld.xの測定結果)
![ピッチと加速度.PNG](https://qiita-image-store.s3.amazonaws.com/0/146154/58281c1c-10f8-8e59-3143-b1e4c0919899.png)


#次にやること
- 冶具なしで検証できるようする方法を考える。
- 加速度を計算に加える
- 継続してPID制御を検証する
- プロペラガードを強化する。 
- roll以外の制御も考えないと。。

この続きは、[Raspberry Pi Zero で自律飛行ドローンを作るぞ（第3回：フライトコントローラを使いました...）](http://qiita.com/shigeru-yokochi/items/7dd15952011f47397d4a)


# コード(GitHub)
https://github.com/shigeru-yokochi/drone