常連

注目の的

社会貢献

質問力

質問者

模範生

自己紹介

機械学習のコンペティションであるkaggleなどに参加していると、上位入賞者のgithub repositoryなどをみる機会があるのですが、可視化などのEDAにjupyter notebookを用い、特徴量エンジニアリングやモデリングの部分はnotebookではなく.pyファイル（スクリプトファイル）を用いています。私個人としては、EDAに始まりモデリングなども含めてnotebookを用いており、notebookを用いた方が正しく計算できているかの確認や試行錯誤ができ、便利だと感じているのですが、.pyファイルにすることに何か利点があるのでしょうか？もしくは、皆さんモデリング等にもnotebookを用いていても、最終的にスクリプトファイルにまとめるような作業をなさっているんでしょうか？その場合の動機はどのようなものなのでしょうか？

かなり答えづらい質問かもしれませんが、どうぞよろしくお願いします。

[追記]そもそもコマンドラインから実行することのメリットがいまいちわかっていません。。。

notebookではなく.pyファイルを用いる意味

以下のように左か右にしかいけないと思うのですが、いっきに両側というのは可能なのでしょうか？
![イメージ説明](13aaf0473c9d8dd02f1bc582acf5c828.gif)

まったく緊急ではないのですができるかどうか気になったもので・・・もしわかる方がいましたら、もしよろしければお願いいたします。

emacsで行の中心からx軸両方に選択範囲を広げることは可能ですか？

Python 初心者です。
インデントが上手くいかずに悩んでいます。

・print　入力してエンターキーを押しても
　elseの部分がきちんとインデントされません・・・
　これは自分でわざわざスペースキーを押して、インデントを合わせなくてはいけないのでしょうか？

・スペースキーでインデントを合わせても、else：のあと、エンターを押すと、
　即エラーが表示されます。

どなたか教えていただけると大変助かります！

```python
SyntaxError: invalid syntax
>>> if home=="Good":
       print("f")
       else:
	    
SyntaxError: unindent does not match any outer indentation level
>>> if home=="Good":
       print("f")
    else:
	    
SyntaxError: unindent does not match any outer indentation level
>>> if home=="Good":
	print("f")
        else:
		
SyntaxError: inconsistent use of tabs and spaces in indentation
>>> if home=="Good":
	print("f")
		else:
			
SyntaxError: unexpected indent
>>> if home=="Good":
	print("f")
	else:
```

Python初心者　インデントが上手くいきません

### 実現したいこと

pythonを使用しています。

折れ線グラフと棒グラフがあるのですが、
棒グラフだけy軸を反転させて表示させたいです。

```python
import matplotlib.pyplot as plt

a0 = [1,2,3,4,5]
a1 = [3.5,3.2,0.7,2,1]
b0 = [1,2,3,4,5]
b1 = [1.2,1.1,0.5,0.1,0.2]
```
①
```python
plt.plot(a0, a1)
plt.bar(b0, b1)
```
![イメージ説明](1006e962ac4f8809ae5e831d993a848d.png)


②
```python
plt.bar(b0, b1)
plt.gca().invert_yaxis()
```
![イメージ説明](2b99b31bb3676c13a10b2a28f1fc4ea6.png)
①の2つのグラフの棒グラフだけを、②のようにy軸を反転させて
一枚のグラフにしたいです。

どうすればよいでしょうか。

Python：グラフの反転

[リンク内容](http://fast-uploader.com/file/7095349652665/)
パスワードはuhoです
tan 135 - 1この計算は0になるはずです
-1+1=0になるので。
ですが実行結果は
tan 135
ans = -1 + 1
ans = -1.3469e-010
tan 45
ans = 1 - 1
ans = -4.48966e-011
tan 180
ans = -8.97932e-011
tan 360
ans = -1.79586e-010
cos 180 + 1　はしっかり0になります
とにかくtanは0を嫌うようです
なぜでしょうか？

tan 135 + 1について

### 前提・実現したいこと

下記に示す図のようなマススペクトルのグラフを線画したいと考えています。
実装の目処が全く立たないので指針を教えて頂けないでしょうか、よろしくお願いします。

・一部抜粋したデータをCSVデータですが下記のソースコードに示します。
・横軸にtheta, 縦軸にIをとり、thetaに対するIのグラフを線画したいと考えています。
・Iはthetaに対する値の総和です。例えば、theta = 2.036のとき I = 0, theta = 3.527のとき I = 1.718×5 = 8.59, theta = 5.761のとき I = 1.718×2 = 3.436となります。

```Python3
theta   I
2.036,0.000
2.036,0.000
2.036,0.000
3.527,1.718
3.527,1.718
3.527,1.718
3.527,1.718
3.527,1.718
4.554,0.000
4.554,0.000
4.554,0.000
5.761,1.718
5.761,1.718
6.442,0.000
6.442,0.000
6.442,0.000
7.058,1.718
7.058,1.718
7.058,1.718
```
![![イメージ説明](749e0a28e2d745ba4c5cd966a6de38b2.png)](7576f6475f558d92233522f50da3e1d3.png)

Pythonを用いたマススペクトルの線画の実装がわからない。

### 前提・実現したいこと


NVIDIA社のcudaをvisualsudio2015用いて3次元FDTD法を練習しています。今回、サイズ41×41×41の立方体中のx=20,y=20の位置における0<z<41のEzに電圧を常時印加した場合に、z=20におけるxy平面のEzの値を見ているのですが、普通にCでこのプログラムを作った場合はきれいに最後まで円形の画像が出力され続けるのですが、cudaでは出力画像でx=0とy=0付近においてmurの1次吸収境界条件の効きが悪く、それが原因で発散しているような状況となっています。（吸収境界条件を入れずに完全導体で囲んだ場合はきれいに反射された画像が続く）
正直自分ではもうどこが間違っているのかわからないので、質問させていただきました。おそらく吸収境界条件が間違っていると考えているのですが。
動画ではなく、画像ですがいくつか掲載させていただきます。（プログラムのdt(電界計算＋磁界計算時間)は2e-12s）

![イメージ説明](e0c0a20383d6d370001f9ee6503fc858.png)
___________________t=0.8e-10s
![イメージ説明](bf2159a8b51925dd33e40f653807cb0e.png)
___________________t=3.0e-10s
![イメージ説明](6836de43f553d502af21a0a3bed463fe.png)
___________________t=3.2e-10s
![イメージ説明](f49684796ca03254e31c60fd35431082.png)
___________________t=3.4e-10s
![イメージ説明](8f16568e5febefb0e804373a0c053d88.png)
___________________t=3.6e-10s
![![イメージ説明](39626614c97a340b141a73a6d7a5f326.png)
___________________t=4.0e-10s
![イメージ説明](456b82fd27bbbd8f0ddac594c1b2004c.png)
___________________t=2.0e-9s

### 該当のソースコード
```
/*--------------------------------------------メイン計算部分------------------------------------------------------------*/
while (t[0]<2e-9) {
	
		culcEx << <grid, block >> > (Ex_d, oldEx_d, oldHy_d, oldHz_d, A_d, d_d);
		culcEy << <grid, block >> > (Ey_d, oldEy_d, oldHx_d, oldHz_d, A_d, d_d);
		culcEz << <grid, block >> > (Ez_d, oldEz_d, oldHx_d, oldHy_d, A_d, d_d);
		cudaDeviceSynchronize();

	
		vin[0] = 1.0*sin(2.0e10*M_PI*t[0]);
		cudaMemcpy(vin_d, vin, sizeof(double), cudaMemcpyHostToDevice);
		Init << <grid, block >> > ( Ez_d, t_d, vin_d);
		cudaDeviceSynchronize();
		Init2 << <grid, block >> > (Ex_d, Ey_d, Ez_d);
		cudaDeviceSynchronize();
MurEx << <grid, block >> > (Ex_d, oldEx_d, A_d);
		MurEy << <grid, block >> > (Ey_d, oldEy_d, A_d);
		MurEz << <grid, block >> > (Ez_d, oldEz_d, A_d);
		cudaDeviceSynchronize();


		culct << <2,2 >> > (t_d);
		t[0] += (dt / 2);
		cudaDeviceSynchronize();

		culcHx << <grid, block >> > (Ey_d, Ez_d, Hx_d, oldHx_d, A_d, d_d);
		culcHy << <grid, block >> > (Ex_d, Ez_d, Hy_d, oldHy_d, A_d, d_d);
		culcHz << <grid, block >> > (Ex_d, Ey_d, Hz_d, oldHz_d, A_d, d_d);
		cudaDeviceSynchronize();

		change << <grid, block >> > (Ex_d, Ey_d, Ez_d, oldEx_d, oldEy_d, oldEz_d, Hx_d, Hy_d, Hz_d, oldHx_d, oldHy_d, oldHz_d);
		cudaDeviceSynchronize();

		culct << <2, 2 >> > (t_d);
		t[0] += (dt / 2);
		cudaDeviceSynchronize();
		output << <grid, block >> > (out_d, Ez_d);
		cudaDeviceSynchronize();
	
	}
/*---------------------------------------------------------------------------------------------------------------------*/

/*------------------吸収境界条件部分----------------------------*/
__global__ void MurEx(double *Ex, double *oldEx, double *A){
	int i = blockIdx.x*blockDim.x + threadIdx.x;
	int j = blockIdx.y*blockDim.y + threadIdx.y;
	int k = blockIdx.z*blockDim.z + threadIdx.z;

	if (i < nx && j < ny && k < nz) {
		Ex[(k * ny * nx + j * nx + 0)] = 
oldEx[(k * ny * nx + j * nx + 1)] + A[3] * (Ex[(k * ny * nx + j * nx + 1)] - oldEx[(k * ny * nx + j * nx + 0)]);
		Ex[(k * ny * nx + j * nx + nx - 1)] = oldEx[(k * ny * nx + j * nx + nx - 2)] + A[3] * (Ex[(k * ny * nx + j * nx + nx - 2)] - oldEx[(k * ny * nx + j * nx + nx - 1)]);
	}
	__syncthreads();
}

__global__ void MurEy( double *Ey,  double *oldEy,  double *A){
	int i = blockIdx.x*blockDim.x + threadIdx.x;
	int j = blockIdx.y*blockDim.y + threadIdx.y;
	int k = blockIdx.z*blockDim.z + threadIdx.z;

	if (i < nx && j < ny && k < nz) {
		Ey[(k * ny * nx + 0 * nx + i)] = 
oldEy[(k * ny * nx + 1 * nx + i)] + A[3] * (Ey[(k * ny * nx + 1 * nx + i)] - oldEy[(k * ny * nx + 0 * nx + i)]);
		Ey[(k * ny * nx + (ny - 1) * nx + i)] = 
oldEy[(k * ny * nx + (ny - 2) * nx + i)] + A[3] * (Ey[(k * ny * nx + (ny - 2) * nx + i)] - oldEy[(k * ny * nx + (ny - 1) * nx + i)]);
	}
	__syncthreads();
}

__global__ void MurEz( double *Ez,  double *oldEz, double *A){
	int i = blockIdx.x*blockDim.x + threadIdx.x;
	int j = blockIdx.y*blockDim.y + threadIdx.y;
	int k = blockIdx.z*blockDim.z + threadIdx.z;

	if (i < nx && j < ny && k < nz) {
		Ez[(k * ny * nx + j * nx + 0)] =
 oldEz[(k * ny * nx + j * nx + 1)] + A[3] * (Ez[(k * ny * nx + j * nx + 1)] - oldEz[(k * ny * nx + j * nx + 0)]);
		Ez[(k * ny * nx + j * nx + nx - 1)] = 
oldEz[(k * ny * nx + j * nx + nx - 2)] + A[3] * (Ez[(k * ny * nx + j * nx + nx - 2)] - oldEz[(k * ny * nx + j * nx + nx - 1)]);

		Ez[(k * ny * nx + 0 * nx + i)] = 
oldEz[(k * ny * nx + 1 * nx + i)] + A[3] * (Ez[(k * ny * nx + 1 * nx + i)] - oldEz[(k * ny * nx + 0 * nx + i)]);
		Ez[(k * ny * nx + (ny - 1) * nx + i)] 
= oldEz[(k * ny * nx + (ny - 2) * nx + i)] + A[3] * (Ez[(k * ny * nx + (ny - 2) * nx + i)] - oldEz[(k * ny * nx + (ny - 1) * nx + i)]);
	}
	__syncthreads();
}
/*------------------------------------------------------------------------------*/
//その他補足（プログラムより抜粋)
♯define nx 41
♯define ny 41
♯define nz 41

dim3 grid;
	grid.x = 3;
	grid.y = 3;
	grid.z = 24;
	dim3 block;
	block.x = 16;
	block.y = 16;
	block.z = 2;
/*--------------------------電磁界計算用係数設定------------------------*/
	A[0] = ((1 - (sig*dt) / (2 * ep)) / (1 + (sig*dt) / (2 * ep)));
	A[1] = (dt / ep) / (1 + (sig*dt / (2 * ep)));
	A[2] = dt / mu;
	A[3] = (c*dt - dx) / (c*dt + dx);
	/*-----------------------------------------------
	0:電界計算,1:電界計算,2:磁界計算,3:Mur吸収境界条件
	-------------------------------------------------*/
	d[0] = 2.0e-12;
	d[1] = 1.5e-3;
	d[2] = 1.5e-3;
	d[3] = 1.5e-3;
	/*-----------------------------------------------
	0:dt,1:dx,2:dy,3:dz
	-------------------------------------------------*/
/*----------------------------電界計算----------------------*/
__global__ void culcEx(double *Ex, double *oldEx, double *oldHy, double *oldHz, double *A, double *d)
{

	int i = blockIdx.x*blockDim.x + threadIdx.x;
	int j = blockIdx.y*blockDim.y + threadIdx.y+1;
	int k = blockIdx.z*blockDim.z + threadIdx.z+1;

	if ((0 < j) && (0 < k) && (i < nx) && (j < ny) && (k < nz)) {
		Ex[(k * ny * nx + j * nx + i)] = A[0] * oldEx[(k * ny * nx + j * nx + i)] + A[1] * (((oldHz[(k * ny * nx + j * nx + i)] - oldHz[(k * ny * nx + (j - 1) * nx + i)]) / d[2]) - ((oldHy[(k * ny * nx + j * nx + i)] - oldHy[((k - 1) * ny * nx + j * nx + i)]) / d[3])); //4
	}
	__syncthreads();

}

__global__ void culcEy(double *Ey, double *oldEy, double *oldHx, double *oldHz, double *A, double *d)
{
	int i = blockIdx.x*blockDim.x + threadIdx.x+1;
	int j = blockIdx.y*blockDim.y + threadIdx.y;
	int k = blockIdx.z*blockDim.z + threadIdx.z+1;

	if ((0<i) && (0<k) && (i < nx) && (j < ny) && (k < nz)) {
		Ey[(k * ny * nx + j * nx + i)] = A[0] * oldEy[(k * ny * nx + j * nx + i)] + A[1] * (((oldHx[(k * ny * nx + j * nx + i)] - oldHx[((k - 1) * ny * nx + j * nx + i)]) / d[3]) - ((oldHz[(k * ny * nx + j * nx + i)] - oldHz[(k * ny * nx + j * nx + (i - 1))]) / d[3])); //4

	}
	__syncthreads();

}

__global__ void culcEz(double *Ez, double *oldEz, double *oldHx, double *oldHy, double *A, double *d)
{
	int i = blockIdx.x*blockDim.x + threadIdx.x+1;
	int j = blockIdx.y*blockDim.y + threadIdx.y+1;
	int k = blockIdx.z*blockDim.z + threadIdx.z;

	if ((0<i) && (0<j) && (i < nx) && (j < ny) && (k < nz)) {
		Ez[(k * ny * nx + j * nx + i)] = A[0] * oldEz[(k * ny * nx + j * nx + i)] + A[1] * (((oldHy[(k * ny * nx + j * nx + i)] - oldHy[(k * ny * nx + j * nx + (i - 1))]) / d[1]) - ((oldHx[(k * ny * nx + j * nx + i)] - oldHx[(k * ny * nx + (j - 1) * nx + i)]) / d[2])); //4
	}
	__syncthreads();

}
/*----------------------------磁界計算----------------------*/
__global__ void culcHx(double *Ey, double *Ez, double *Hx, double *oldHx, double *A, double *d)
{

	int i = blockIdx.x*blockDim.x + threadIdx.x;
	int j = blockIdx.y*blockDim.y + threadIdx.y;
	int k = blockIdx.z*blockDim.z + threadIdx.z;

	if ((0<i)&&(i<nx) && (j<ny - 1) && (k<nz - 1)) {
		Hx[k * ny * nx + j * nx + i] = oldHx[k * ny * nx + j * nx + i] - (A[2] * (((Ez[k * ny * nx + (j + 1) * nx + i] - Ez[k * ny * nx + j * nx + i]) / d[2]) - ((Ey[(k + 1) * ny * nx + j * nx + i] - Ey[k * ny * nx + j * nx + i]) / d[3]))); //5
	}
	__syncthreads();

}


__global__ void culcHy(double *Ex, double *Ez, double *Hy, double *oldHy, double *A, double *d)
{
	int i = blockIdx.x*blockDim.x + threadIdx.x;
	int j = blockIdx.y*blockDim.y + threadIdx.y;
	int k = blockIdx.z*blockDim.z + threadIdx.z;

	if ((0<j) && (i<nx - 1) && (j<ny) && (k<nz - 1)) {
		Hy[k * ny * nx + j * nx + i] = oldHy[k * ny * nx + j * nx + i]- (A[2] * (((Ex[(k + 1) * ny * nx + j * nx + i] - Ex[k * ny * nx + j * nx + i]) / d[3]) - ((Ez[k * ny * nx + j * nx + (i + 1)] - Ez[k * ny * nx + j * nx + i]) / d[1]))); //6
	}
	__syncthreads();

}


__global__ void culcHz(double *Ex, double *Ey, double *Hz, double *oldHz, double *A, double *d)
{
	int i = blockIdx.x*blockDim.x + threadIdx.x;
	int j = blockIdx.y*blockDim.y + threadIdx.y;
	int k = blockIdx.z*blockDim.z + threadIdx.z;

	if ((0<j) && (i<nx - 1) && j<(ny - 1) && k<nz) {
		Hz[k * ny * nx + j * nx + i] = oldHz[k * ny * nx + j * nx + i]- (A[2] * (((Ey[k * ny * nx + j * nx + (i + 1)] - Ey[k * ny * nx + j * nx + i]) / d[1]) - ((Ex[k * ny * nx + (j + 1) * nx + i] - Ex[k * ny * nx + j * nx + i]) / d[2]))); //6
	}
	__syncthreads();

}
```





### 試したこと

使用している関数のif条件を様々なパターンで試しました。
0から始まるところを1にそろえてみたり、部分的に1にしてみたり、
i = blockIdx.x*blockDim.x + threadIdx.x+1;のようにしてみたり
メイン関数中のMurE関数がくるところを変更してCPUで計算させてもみましたがダメでした。
### 補足情報（FW/ツールのバージョンなど）

cuda runtime 9.2
windows10
visualstudio2015 update3