// グローバル変数------------------------------------------

// 入力
var inItaatu;		// 板厚
var inGaikei;		// 外経
var inNaikei;		// 内径
var inJiyuu;		// 自由高さ
var inHeiretu;		// 並列枚数
var inTyokuretu;	// 直列枚数
var inTawami1;		// 自由〜第１荷重間タワミ
var inTawami2;		// 第１〜第２荷重間タワミ
// -- 2005/11/30 add -----------------
var inInputType1;	// 入力方法１
var inInputType2;	// 入力方法２
//------------------------------------

// 出力
var out1Kajuu;		// 第一荷重
var out2Kajuu;		// 第二荷重
var out1Ouryoku;	// 第一荷重応力
var out2Ouryoku;	// 第ニ荷重応力
var outMaxTawami;	// 最大タワミ
var outJumyou;		// 推定寿命

var outTantai;		// 単体
var outht;			// h/t
var outKumi;		// 組
var outDd;			// D/d

var outAdv1;		// 入力支援アドバイス１
var outAdv2;		// 入力支援アドバイス２
var outAdv3;		// 入力支援アドバイス３
var outAdv4;		// 入力支援アドバイス４

var outTakasa1;		// 第1荷重高さ
var outTakasa2;		// 第2荷重高さ
var outKumiJiyutyou	// 組合せ自由長

//計算用変数
var L4;			// 組合せ高さ(自由時)
var E6;			// 単体タワミ(第一荷重)
var E7;			// 単体タワミ(第二荷重)
var E8;			// h:単体タワミ(密着)
var B20;		// 面取り
var B28;		// JIS補正
var B23;		// α
var B25;		// β
var B26;		// γ
var B24;		// C
var B27;		// Α

//エクセルの右上計算部分
var H = new Array(3);	//標準荷重配列(第一荷重/第二荷重/密着)
var I = new Array(3);	//JIS荷重配列(第一荷重/第二荷重/密着)
var J = new Array(3);	//単体高さ配列(第一荷重/第二荷重/密着)
var L = new Array(3);	//組合せタワミ配列(第一荷重/第二荷重/密着)
var M = new Array(3);	//組合せ高さ配列(第一荷重/第二荷重/密着)
var N = new Array(3);	//標準応力σｃ配列(第一荷重/第二荷重/密着)
var O = new Array(3);	//標準応力σt1配列(第一荷重/第二荷重/密着)
var P = new Array(3);	//標準応力σt2配列(第一荷重/第二荷重/密着)
var Q = new Array(3);	//δ%配列(第一荷重/第二荷重/密着)

//寿命計算変数
var Katamuki;		//傾き
var Setten50 = new Array(2);		//接点(50)
var Setten200 = new Array(2);		//接点(200)
var Setten1;		//接点σt1
var Setten2;		//接点σt2
var KatamukiLog;	//傾き対数関数値
var SettenLog;		//接点対数関数値
var NLife1;		//n条寿命σt1
var NLife2;		//n条寿命σt2
var SLife1;		//正味寿命σt1
var SLife2;		//正味寿命σt2
var MLife1;		//万回寿命σt1
var MLife2;		//万回寿命σt2
var KLife1;		//切捨て寿命σt1
var KLife2;		//切捨て寿命σt2
var RLife;		//寿命計算結果

//定数
var POASON = 0.3;	//ポアソン比
var DANSEI = 206000;	//弾性係数

//---------------------------------------------------------------------------------
//[関数名]CalcMain
//[機　能]メイン関数
//---------------------------------------------------------------------------------
function CalcMain(){
	
	var res = true;	
	// 入力文字のチェック	
	res = InputCheckMain();

	// チェックをパスしたら、通常計算
	if(res){
		
		//↓↓↓ ここで計算式を行う関数を呼び出して、計算を行う。---------------------
		CalcSara();
		//↑↑↑ ---------------------------------------------------------------------
		// 計算結果出力
		OutputCalc();
	}
}

//---------------------------------------------------------------------------------
//[関数名]InputCheckMain
//[機　能]チェックしたオブジェクトをチェックの結果を返す
//[戻り値]False：エラー　True：ＯＫ
//---------------------------------------------------------------------------------
function InputCheckMain(){
	
	if(!InputCheckValue(document.s_banet.itaatu.value)){
		alert ("入力された板厚の値が異常です！")
		return false;
	}
	if(!InputCheckValue(document.s_banet.gaikei.value)){
		alert ("入力された外経の値が異常です！")
		return false;
	}
	if(!InputCheckValue(document.s_banet.naikei.value)){
		alert ("入力された内径の値が異常です！")
		return false;
	}
	if(!InputCheckValue(document.s_banet.jiyuu.value)){
		alert ("入力された自由高さの値が異常です！")
		return false;
	}
	if(!InputCheckValue(document.s_banet.heiretu.value)){
		alert ("入力された並列枚数の値が異常です！")
		return false;
	}
	if(!InputCheckValue(document.s_banet.tyokuretu.value)){
		alert ("入力された直列枚数の値が異常です！")
		return false;
	}
	if(!InputCheckValue(document.s_banet.jiyuu_1_tawami.value)){
		alert ("入力された自由〜第１荷重間タワミの値が異常です！")
		return false;
	}
	if(!InputCheckValue(document.s_banet.jiyuu_2_tawami.value)){
		alert ("入力された第１〜第２荷重間タワミの値が異常です！")
		return false;
	}
	
	return true;
}
//---------------------------------------------------------------------------------
//[関数名]InputCheckValue
//[機　能]フォームに値が入力されていて、かつ、０以上の数値の場合、Trueを返す
//---------------------------------------------------------------------------------
function InputCheckValue(param){
	
	var value = param;
	var i=0;
	
	// 空白チェック
	if(value == "")
		return false;
	
	// 入力内容チェック
	for(i=0;i<value.length;i++){
		if(value.charAt(i) < "0" || value.charAt(i) > "9"){
			if(value.charAt(i) != ".")
				return false;
		}
	}
	// 数値として成立するかどうかチェック
	if(isNaN(param)){
		return false;
	}
	return true;
}
//---------------------------------------------------------------------------------
//[関数名]InputImgStrCopy
//[機　能]フォームの値を、画像埋め込みフォームにコピーする
//---------------------------------------------------------------------------------
function InputImgStrCopy(mode){
	
	switch(mode){
		case 0:
			document.s_banet.ita_img.value = document.s_banet.itaatu.value;
			document.s_banet.gai_img.value = document.s_banet.gaikei.value;
			document.s_banet.nai_img.value = document.s_banet.naikei.value;
			document.s_banet.jiyu_img.value = document.s_banet.jiyuu.value;
			break;
		case 1:
			document.s_banet.itaatu.value = document.s_banet.ita_img.value;
			document.s_banet.gaikei.value =document.s_banet.gai_img.value;
			document.s_banet.naikei.value =document.s_banet.nai_img.value;
			document.s_banet.jiyuu.value = document.s_banet.jiyu_img.value;
			break;
	}
}

//---------------------------------------------------------------------------------
//[関数名]MM_findObj
//[機　能]オブジェクト番号を返す
//---------------------------------------------------------------------------------
function MM_findObj(n, d) { //v4.01
  var p,i,x;  if(!d) d=document; if((p=n.indexOf("?"))>0&&parent.frames.length) {
    d=parent.frames[n.substring(p+1)].document; n=n.substring(0,p);}
  if(!(x=d[n])&&d.all) x=d.all[n]; for (i=0;!x&&i<d.forms.length;i++) x=d.forms[i][n];
  for(i=0;!x&&d.layers&&i<d.layers.length;i++) x=MM_findObj(n,d.layers[i].document);
  if(!x && d.getElementById) x=d.getElementById(n); return x;
}

//---------------------------------------------------------------------------------
//[関数名]OutputCalc
//[機　能]計算結果を、フォームに返す
//---------------------------------------------------------------------------------
function OutputCalc(){

	document.s_banet.dai1_kaju.value 	= out1Kajuu;	// 第一荷重
	document.s_banet.dai1_kaju_ou.value	= out1Ouryoku;	// 第一荷重応力
	document.s_banet.dai2_kaju.value 	= out2Kajuu;	// 第二荷重
	document.s_banet.dai2_kaju_ou.value	= out2Ouryoku;	// 第ニ荷重応力
//	document.s_banet.max_tawami.value 	= outMaxTawami;	// 最大タワミ
	document.s_banet.jumyou.value 		= outJumyou;	// 推定寿命
	document.s_banet.tantai.value 		= outTantai;	// 単体
	document.s_banet.ht.value 		= outht;	// h/t
	document.s_banet.kumi.value 		= outKumi;	// 組
	document.s_banet.dd.value 		= outDd;	// D/d
	document.s_banet.adv_1.value 		= outAdv1;	// 入力支援アドバイス１
	document.s_banet.adv_2.value 		= outAdv2;	// 入力支援アドバイス２
	document.s_banet.adv_3.value 		= outAdv3;	// 入力支援アドバイス３
	document.s_banet.adv_4.value 		= outAdv4;	// 入力支援アドバイス４

// 2005/11/30 add
	document.s_banet.dai1_kaju_takasa.value = outTakasa1;	// 第1荷重高さ
	document.s_banet.dai2_kaju_takasa.value = outTakasa2;	// 第2荷重高さ
	document.s_banet.kumi_nagasa.value = outKumiJiyutyou;	// 組合せ自由長
}

//---------------------------------------------------------------------------------
//[関数名]MM_showHideLayers
//[機　能]フォーカスの有無でレイヤーの表示非表示を切り替える
//---------------------------------------------------------------------------------
function MM_showHideLayers() { //v6.0
  var i,p,v,obj,args=MM_showHideLayers.arguments;
  for (i=0; i<(args.length-2); i+=3) if ((obj=MM_findObj(args[i]))!=null) { v=args[i+2];
    if (obj.style) { obj=obj.style; v=(v=='show')?'visible':(v=='hide')?'hidden':v; }
    obj.visibility=v; }
}

//---------------------------------------------------------------------------------
//[関数名]CalcSara
//[機　能]サラバネ計算
//---------------------------------------------------------------------------------
function CalcSara() {

	//計算正常フラグ初期化
	var CalcOK = false;

	//入力値の取得
	inItaatu = parseFloat(document.s_banet.itaatu.value);			// 板厚		
	inGaikei = parseFloat(document.s_banet.gaikei.value);			// 外経
	inNaikei = parseFloat(document.s_banet.naikei.value);			// 内径
	inJiyuu = parseFloat(document.s_banet.jiyuu.value);				// 自由高さ
	inHeiretu = parseFloat(document.s_banet.heiretu.value);			// 並列枚数
	inTyokuretu = parseFloat(document.s_banet.tyokuretu.value);		// 直列枚数
	inTawami1 = parseFloat(document.s_banet.jiyuu_1_tawami.value);	// 自由〜第１荷重間タワミ
	inTawami2 = parseFloat(document.s_banet.jiyuu_2_tawami.value);	// 第１〜第２荷重間タワミ
// 2005/11/30 add----------------
	inInputType1 = parseInt(document.s_banet.type1.value);			// 荷重１入力方法
	inInputType2 = parseInt(document.s_banet.type2.value);			// 荷重２入力方法
//-------------------------------
//2005/11/29 add 
// 入力形式チェック
	//係数計算
	if(CalcKeisu())
	{	
		//係数計算でエラーが発生しなければ荷重計算
		if(CalcKajyu())
		{
			//荷重計算でエラーが発生しなければ寿命計算
			if(CalcJyumyo())
			{
				CalcOK = true;
			}
		}
	}

	//結果格納
	Result(CalcOK);

}

//---------------------------------------------------------------------------------
//[関数名]CalcKeisu
//[機　能]計算に必要な係数を算出する
//[戻り値]True/False 計算完了/計算不可な箇所が存在
//---------------------------------------------------------------------------------
function CalcKeisu()
{

	var tmpTawami;
	
	//出力用変数初期化
	outDd = "";
	outht = "";

	//単体質量算出
	outTantai = parseFloat((Math.pow(inGaikei,2) - Math.pow(inNaikei,2)) / 4 * Math.PI * inItaatu * 7.85 * 0.000001);

	//組質量算出
	outKumi = parseFloat(outTantai * inTyokuretu * inHeiretu);

	//0割りでなければ、D/d算出
	if(inNaikei != 0)
	{
		outDd = (inGaikei / inNaikei);
		//outDd = outDd.toFixed(2);		//小数2桁まで表示
	}
	else
	{
		alert("計算に失敗しました(0で除算)");
		return false;
	}

	E8 = inJiyuu - inItaatu;			//密着
	//組合せ高さ(自由時)算出
	L4 = ((inItaatu * inHeiretu) + E8) * inTyokuretu;
	//L4 = L4.toFixed(2);				//小数第二位まで有効


	//0割りでなければ、単体タワミ(第一荷重/第二荷重/密着時)算出
	if(inTyokuretu != 0)
	{
//		alert("inTawami1:"+inTawami1 + "\n" + "inTawami2:" + inTawami2 + "\n"+"inTyokuretu:"+inTyokuretu);
// 2005/11/30 change ---------------------
		switch(inInputType1){
			case 0:
				E6 = parseFloat(inTawami1 / inTyokuretu);			// 自由〜第1荷重間たわみ　から第1単体たわみを求める
				tmpTawami = inTawami1;
				break;
			case 1:
				E6 = parseFloat(inTawami1);							// 第1単体たわみ直接入力
				tmpTawami = parseFloat(E6 * inTyokuretu);
				break;
			case 2:
				E6 = parseFloat((L4 - inTawami1) / inTyokuretu)		// 高さから第1単体たわみを求める
				tmpTawami = parseFloat(L4 - inTawami1);
				break;
			default:
				break;
		}
		switch(inInputType2){
			case 0:
				E7 = parseFloat((tmpTawami + inTawami2 ) / inTyokuretu);	// 第1〜第2荷重間たわみ　から　第2単体たわみを求める
				break;
			case 1:
				E7 = parseFloat(inTawami2);									// 第2単体たわみ直接入力
				break;
			case 2:
				E7 = parseFloat(( L4 - inTawami2) / inTyokuretu);			// 高さから第2単体たわみを求める
				break;
			default:
				break;
		}
	}
	else
	{
		alert("計算に失敗しました(0で除算)");
		return false;
	}

	//0割りでなければ、h/t算出
	if(inItaatu != 0)
	{
		outht = parseFloat(E8 / inItaatu);
		//outht = outht.toFixed(2);		//小数2桁まで表示
	}
	else
	{
		alert("計算に失敗しました(0で除算)");
		return false;
	}


	//面取り取得
	B20 = ChoiseMentori();
	if(B20 < 0)		//面取り取得失敗ならfalse
	{
		alert("計算に失敗しました(0で除算)");
		return false;
	}

	//0割りでなければ、JIS補正算出
	if(inGaikei- inNaikei - (3 * B20) != 0)
	{
		B28 = (inGaikei - inNaikei) / (inGaikei- inNaikei - (3 * B20));
		//B28 = B28.toFixed(4);			//小数4桁に丸める
	}
	else
	{
		alert("計算に失敗しました(0で除算)");
		return false;
	}

	//0割りでなければ、α算出
	if(inNaikei != 0)
	{
		B23 = inGaikei / inNaikei;
	}
	else
	{
		alert("計算に失敗しました(0で除算)");
		return false;
	}

	//0割りでなければ、β、γを算出
	if(Math.log(B23) != 0)
	{
		B25 = 1 / Math.PI * 6 / Math.log(B23) * ((B23 - 1) / Math.log(B23) - 1);	//β算出
		B26 = 1 / Math.PI * 6 / Math.log(B23) * (B23 - 1) / 2;				//γ算出
	}
	else
	{
		alert("計算に失敗しました(0で除算)");
		return false;
	}

	//0割りでなければ、C算出
	if(B23 -1 != 0)
	{
		B24 = ((B23 + 1) / (B23 - 1) - 2 / Math.log(B23)) * Math.PI * Math.pow( B23 / (B23-1), 2);
	}
	else
	{
		alert("計算に失敗しました(0で除算)");
		return false;
	}

	//0割りでなければ、Α算出(外径以外は定数なので0割りが起こるとすれば外径のみ)
	if(inGaikei != 0)
	{
		B27 = 4 * DANSEI * B24 / (1 - Math.pow(POASON, 2)) / Math.pow(inGaikei, 2);
	}
	else
	{
		alert("計算に失敗しました(0で除算)");
		return false;
	}

//------------------
/*/Debug
alert("単体質量=" + outTantai + " : 組質量=" + outKumi);
alert("E6(タワミσ1)= " + E6 + " : E7(タワミσ2)=" + E7 + " : E8(h)=" + E8);
alert("h/t=" + outht + " :　D/d =" + outDd);
alert("L4(組み合わせたかさ)=" + L4);
alert("B20(面取り)=" + B20);
alert("B23(α)= " + B23 + " : B25(β)=" + B25 + " : B26(γ)=" + B26);
alert("B24(C)= " + B24 + " : B27(Α)=" + B27);
/*/
//------------------
	return true;

}

//---------------------------------------------------------------------------------
//[関数名]CalcKajyu
//[機　能]荷重計算
//[戻り値]True/False 計算完了/計算不可な箇所が存在
//---------------------------------------------------------------------------------
function CalcKajyu()
{

	//標準荷重算出
	H[0] = CalcHKajyu(E6);		//第一荷重
	H[1] = CalcHKajyu(E7);		//第二荷重
	H[2] = CalcHKajyu(E8);		//密着
//------------------
//Debug
//alert("H[0]/H[1]/H[2](標準荷重1/2/密)=" + H[0] + "/" + H[1] + "/" + H[2] );
//------------------
	//JIS補正荷重算出
	I[0] = CalcJKajyu(H[0]);	//第一荷重
	I[1] = CalcJKajyu(H[1]);	//第二荷重
	I[2] = CalcJKajyu(H[2]);	//密着
//------------------
//Debug
//alert("I6/I7/I8(JIS補正荷重1/2/密)=" + I[0] + "/" + I[1] + "/" + I[2] );
//------------------
	//組合せタワミ算出
	L[0] = CalcKTawami(E6);		//第一荷重
	L[1] = CalcKTawami(E7);		//第二荷重
	L[2] = CalcKTawami(E8);		//密着
//------------------
//Debug
//alert("L6/L7/L8(組合せタワミ1/2/密)=" + L[0] + "/" + L[1] + "/" + L[2] );
//------------------
	//単体高さ算出
	J[0] = CalcTTakasa(E6);		//第一荷重
	J[1] = CalcTTakasa(E7);		//第二荷重
	J[2] = CalcTTakasa(E8);		//密着
//------------------
//Debug
//alert("J6/J7/J8(単体高さ1/2/密)=" + J[0] + "/" + J[1] + "/" + J[2] );
//------------------
	//組合せ高さ算出
	M[0] = CalcKTakasa(L[0]);	//第一荷重
	M[1] = CalcKTakasa(L[1]);	//第二荷重
	M[2] = CalcKTakasa(L[2]);	//密着
//------------------
//Debug
//alert("M6/M7/M8(組合せ高さ1/2/密)=" + M[0] + "/" + M[1] + "/" + M[2] );
//------------------
	//標準応力σc算出
	N[0] = CalcSigmaC(E6);		//第一荷重
	N[1] = CalcSigmaC(E7);		//第二荷重
	N[2] = CalcSigmaC(E8);		//密着
//------------------
//Debug
//alert("N6/N7/N8(標準応力σc1/2/密)=" + N[0] + "/" + N[1] + "/" + N[2] );
//------------------
	//標準応力σt1算出
	O[0] = CalcSigmat1(E6);		//第一荷重
	O[1] = CalcSigmat1(E7);		//第二荷重
	O[2] = CalcSigmat1(E8);		//密着
//------------------
//Debug
//alert("O6/O7/O8(標準応力σt1 1/2/密)=" + O[0] + "/" + O[1] + "/" + O[2] );
//------------------
	//標準応力σt2算出
	P[0] = CalcSigmat2(E6);		//第一荷重
	P[1] = CalcSigmat2(E7);		//第二荷重
	P[2] = CalcSigmat2(E8);		//密着
	//計算に失敗した場合、falseを返す
	if(P[0] == "" || P[1] == "" || P[2] == "")
	{
		alert("計算に失敗しました(0で除算)");
		return false;
	}
//------------------
//Debug
//alert("P6/P7/P8(標準応力σt2 1/2/密)=" + P[0] + "/" + P[1] + "/" + P[2] );
//------------------

	//δ%算出
	Q[0] = CalcDelta(E6);		//第一荷重
	Q[1] = CalcDelta(E7);		//第二荷重
	Q[2] = CalcDelta(E8);		//密着
	//計算に失敗した場合、falseを返す
	if(Q[0] == "" || Q[1] == "" || Q[2] == "")
	{
		alert("計算に失敗しました(0で除算)");
		return false;
	}

//------------------
//Debug
//alert("Q6/Q7/Q8(δ% 1/2/密)=" + Q[0] + "/" + Q[1] + "/" + Q[2] );
//------------------

	return true;

}

//---------------------------------------------------------------------------------
//[関数名]CalcJyumyo
//[機　能]寿命計算
//[戻り値]True/False 計算完了/計算不可な箇所が存在
//---------------------------------------------------------------------------------
function CalcJyumyo()
{
	//ローカル変数定義
	var i;		//寿命算出用カウンタ
	var localSetten1 = new Array(4);	//接点σt1
	var localSetten2 = new Array(4);	//接点σt2
	var localNLife1 = new Array(4);		//n条寿命1
	var localNLife2 = new Array(4);		//n条寿命2
	var localSLife1 = new Array(4);		//正味寿命1
	var localSLife2 = new Array(4);		//正味寿命2
	var localMLife1 = new Array(4);		//万回寿命1
	var localMLife2 = new Array(4);		//万回寿命2
	var localKLife1 = new Array(4);		//切捨寿命1
	var localKLife2 = new Array(4);		//切捨寿命2
	var localRLife = new Array(4);

	//4パターン全ての寿命算出
	for(i = 0 ; i < 4 ; i++)	//start for
	{
		//計算用定数決定(板厚で分岐)取得失敗したらfalseを返す
		if(ChoiseKeisu(i, Katamuki, Setten50[1], Setten200[1]) == false)
		{
			alert("計算に失敗しました");
			return false;
		}

		//接点σ(t1,t2)算出
		localSetten1[i] = CalcSettenSigma(1);	//t1
		localSetten2[i] = CalcSettenSigma(2);	//t2
//-----------
//Debug
//alert("接点σ(t1)=" + localSetten1[i]);
//alert("接点σ(t2)=" + localSetten2[i]);
//-----------
		//0割りでなければ、傾き対数関数値算出
		if( Setten200[0] - Setten50[0] != 0)
		{
			KatamukiLog = (Setten200[1] - Setten50[1]) / (Setten200[0] - Setten50[0]);
		}
		else
		{
			alert("計算に失敗しました(0で除算)");
			return false;
		}

		//接点対数関数値算出
		SettenLog = Setten50[1] - Setten50[0] * KatamukiLog;
//-----------
//Debug
//alert("傾き対数関数値=" + KatamukiLog);
//alert("接点対数関数値=" + SettenLog);
//-----------
		//n条件寿命算出
		localNLife1[i] = CalcNLife(localSetten1[i]);
		localNLife2[i] = CalcNLife(localSetten2[i]);
		//寿命計算に失敗したら、falseを返す
		if(localNLife1[i] == "" || localNLife2[i] == "")
		{
			alert("計算に失敗しました(0で除算)");
			return false;
		}
//-----------
//Debug
//alert("n条寿命1=" + localNLife1[i]);
//alert("n条寿命2=" + localNLife2[i]);
//-----------
		//正味寿命算出
		localSLife1[i] = CalcSLife(localNLife1[i]);
		localSLife2[i] = CalcSLife(localNLife2[i]);
//-----------
//Debug
//alert("正味寿命1=" + localSLife1[i]);
//alert("正味寿命2=" + localSLife2[i]);
//-----------
		//万回寿命算出
		localMLife1[i] = CalcMLife(localSLife1[i]);
		localMLife2[i] = CalcMLife(localSLife2[i]);
//-----------
//Debug
//alert("万回寿命1=" + localSLife1[i]);
//alert("万回寿命2=" + localSLife2[i]);
//-----------
		//切捨て寿命算出
		localKLife1[i] = CalcKLife(localMLife1[i]);
		localKLife2[i] = CalcKLife(localMLife2[i]);
//-----------
//Debug
//alert("切捨て1=" + localKLife1[i]);
//alert("切捨て2=" + localKLife2[i]);
//-----------
/*/excel本来の式
	//寿命(RLife)判断
	if(O[1] > 1300 || P[1] > 1300)		//寿命推定不可判定
	{
		RLife = "推定不可";
	}
	else
	{
		if(Math.min(KLife1, KLife2) >= 200)	//200以上
		{
			RLife = 200;
		}
		else					//その他
		{
			RLife = Math.min(KLife1, KLife2);
		}
	}
/*/

		//寿命(RLife)判断
		if(O[1] > 1225 || P[1] > 1225)		//寿命推定不可判定(応力σt1(荷重2)or応力σt2(荷重2)>1225)
		{
			localRLife[i] = "推定不可";
		}
		else
		{
			if(Math.min(localKLife1[i], localKLife2[i]) >= 200)	//寿命上限判定
			{
				localRLife[i] = 200;
			}
			else if(Math.min(localKLife1[i], localKLife2[i]) >= 150)
			{
				localRLife[i] = 150;
			}
			else if(Math.min(localKLife1[i], localKLife2[i]) >= 100)
			{
				localRLife[i] = 100;
			}
			else if(Math.min(localKLife1[i], localKLife2[i]) >= 50)
			{
				localRLife[i] = 50;
			}
			else if(Math.min(localKLife1[i], localKLife2[i]) >= 10)
			{
				localRLife[i] = 10;
			}
			else
			{	//どのパターンにも当てはまらない→10万以下
				localRLife[i] = "10以下";
			}
		}
	}	//end for

	//寿命決定(板圧により選択)
	if(inItaatu < 1.2)				//1.2未満の寿命を採用
	{
		NLife1 = localNLife1[0];
		NLife2 = localNLife2[0];
		MLife1 = localMLife1[0];
		MLife2 = localMLife2[0];
		KLife1 = localKLife1[0];
		KLife2 = localKLife2[0];
		RLife = localRLife[0];

	}
	else if(inItaatu >= 1.2 && 6 > inItaatu)	//1.2〜6の寿命を採用
	{
		NLife1 = localNLife1[1];
		NLife2 = localNLife2[1];
		MLife1 = localMLife1[1];
		MLife2 = localMLife2[1];
		KLife1 = localKLife1[1];
		KLife2 = localKLife2[1];
		RLife = localRLife[1];
	}
	else if(inItaatu >= 6 && 15 > inItaatu)		//6〜15の寿命を採用
	{
		NLife1 = localNLife1[2];
		NLife2 = localNLife2[2];
		MLife1 = localMLife1[2];
		MLife2 = localMLife2[2];
		KLife1 = localKLife1[2];
		KLife2 = localKLife2[2];
		RLife = localRLife[2];

	}
	else						//15以降の寿命を採用
	{
		NLife1 = localNLife1[3];
		NLife2 = localNLife2[3];
		MLife1 = localMLife1[3];
		MLife2 = localMLife2[3];
		KLife1 = localKLife1[3];
		KLife2 = localKLife2[3];
		RLife = localRLife[3];

	} 

	//寿命決定後の寿命が0の場合"10以下"とする(excelでは50以下)
	if(RLife == 0)			//寿命下限判定
	{
		//RLife = "50以下";
		RLife = "10以下";
	}

	return true;

}

//---------------------------------------------------------------------------------
//[関数名]Result
//[機　能]計算結果格納(計算が不能な箇所があった場合、全て""を格納)
//[引　数]flg　計算不能になった箇所が一箇所でもあったかを示す
//	 (True=計算不能箇所無し/false=計算不能箇所あり)
//---------------------------------------------------------------------------------
function Result(flg)
{
	
	//計算不能な箇所があった場合、出力変数を全てクリアし、終了
	if(flg == false)
	{
		alert("aa");
		out1Kajuu = "";	// 第一荷重
		out1Ouryoku = "";	// 第一荷重応力
		out2Kajuu = "";	// 第二荷重
		out2Ouryoku = "";	// 第ニ荷重応力
		outMaxTawami = "";	// 最大タワミ
		outJumyou = "";	// 推定寿命
		outTantai = "";	// 単体
		outht = "";	// h/t
		outKumi = "";	// 組
		outDd = "";	// D/d
		outAdv1 = "";	// 入力支援アドバイス１
		outAdv2 = "";	// 入力支援アドバイス２
		outAdv3 = "";	// 入力支援アドバイス３
		outAdv4 = "";	// 入力支援アドバイス４
		outTakasa1 = "";	// 第１荷重高さ
		outTakasa2 = "";	// 第２荷重高さ
		outKumiJiyuutyo = "";	// 組合せ自由長
		return;
	}

	//結果変数初期化
	out1Ouryoku = "";
	out2Ouryoku = "";
	out1Kajuu = "";
	out2Kajuu = "";
	outAdv1 = "";
	outAdv2 = "";
	outAdv3 = "";
	outAdv4 = "";
	outMaxTawami;
	outJumyou;

	//第一/第二荷重時応力(整数部まで表示)
	if((MLife1 - MLife2) < 0)		//万回寿命(σt1)<万回寿命(σt2)
	{					//標準応力σt1を使用
		out1Ouryoku = RoundEx(O[0], 0);
		out2Ouryoku = RoundEx(O[1], 0);
	}
	else if((MLife1 - MLife2) > 0)		//万回寿命(σt1)>万回寿命(σt2)
	{					//標準応力σt2を使用
		out1Ouryoku = RoundEx(P[0], 0);
		out2Ouryoku = RoundEx(P[1], 0);
	}
	else					//万回寿命(σt1)=万回寿命(σt2)
	{					//エクセル上で、どちらも使用していないため、空欄
		out1Ouryoku = "";
		out2Ouryoku = "";
	}

	//第一/第二荷重(1の位を丸める)
	if(document.s_banet.syurui.selectedIndex == 0)
	{	//バネ種 = 規格・一般 → JIS荷重使用
		out1Kajuu = RoundEx(I[0], -1);
		out2Kajuu = RoundEx(I[1], -1);
	}
	else
	{	//バネ種 = MC → 標準荷重使用
		out1Kajuu = RoundEx(H[0], -1);
		out2Kajuu = RoundEx(H[1], -1);
	}

	//最大タワミ = 組合せタワミ(密着) (整数部まで表示)
	outMaxTawami = RoundEx(L[2], 0);

	//推定寿命
	outJumyou = RLife;

	// h/t D/d(小数第3位まで表示)
	outht = RoundEx(parseFloat(outht), 3);
	outDd = RoundEx(parseFloat(outDd), 3);

	//単体/組質量(小数第3位まで表示)
	outTantai = RoundEx(outTantai, 3);	//単体
	outKumi = RoundEx(outKumi, 3);		//組

	//入力支援アドバイス(入力値が0の場合表示しない)
	if(inItaatu * inGaikei * inNaikei * inJiyuu * inHeiretu * inTyokuretu * inTawami1 * inTawami2 != 0)
	{
		if(N[2] < -2942)		//支援メッセージ1
		{
			outAdv1 = "この仕様は密着まで圧縮する事が出来ません。";
		}
		//if(Math.round(Math.round(Q[1] * 10)/10) < 75)			//支援メッセージ2
		//if(parseInt(Q[1] + 0.00005) < 75)
		if(RoundEx(Q[1],5) < 75)
		{
		}
		else
		{
			outAdv2 = "第2荷重が最大タワミの75％を超えています。タワミを減らすか、直列段数を増やして下さい。";
		}
		if( 0 < outht && outht < 1)	//支援メッセージ3
		{
		}
		else
		{
			outAdv3 = "板厚と単体時自由高さのバランスが不適合です。";
		}
		if(1.7 < outDd && outDd < 2.5)	//支援メッセージ4
		{
		}
		else
		{
			outAdv4 = "内外径のバランスが悪いです。";
		}
	}
	
// 2005/11/30 add 
	outTakasa1 = RoundEx(M[0],3);
	outTakasa2 = RoundEx(M[1],3);
	outKumiJiyutyou = RoundEx(L4,3);
}

//---------------------------------------------------------------------------------
//[関数名]CalcHKajyu
//[機　能]標準荷重計算
//---------------------------------------------------------------------------------
function CalcHKajyu(Tawami)
{
//	alert("単体タワミ=" +Tawami+":h"+E8+":板厚"+inItaatu+":並列"+inHeiretu);
	if(E6 != 0)
	{
		return (B27 * Tawami * ((E8 - Tawami) * (E8 - Tawami / 2) * inItaatu + Math.pow(inItaatu, 3)) * inHeiretu);
	}
}

//---------------------------------------------------------------------------------
//[関数名]CalcJKajyu
//[機　能]JIS荷重計算
//---------------------------------------------------------------------------------
function CalcJKajyu(HKajyu)
{
	return (B28 * HKajyu);
}

//---------------------------------------------------------------------------------
//[関数名]CalcKTawami
//[機　能]組合せタワミ計算
//---------------------------------------------------------------------------------
function CalcKTawami(Tawami)
{
	return (Tawami * inTyokuretu);
}

//---------------------------------------------------------------------------------
//[関数名]CalcTTakasa
//[機　能]単体高さ計算
//---------------------------------------------------------------------------------
function CalcTTakasa(KTawami)
{
	return (inJiyuu - KTawami);
}

//---------------------------------------------------------------------------------
//[関数名]CalcKTakasa
//[機　能]組合せ高さ計算
//---------------------------------------------------------------------------------
function CalcKTakasa(KTawami)
{
	return (L4 - KTawami);
}

//---------------------------------------------------------------------------------
//[関数名]CalcSigmaC
//[機　能σｃ計算
//---------------------------------------------------------------------------------
function CalcSigmaC(Tawami)
{
	return (B27 * Tawami * ( (-1) * B25 * (E8 - Tawami / 2) - B26 * inItaatu));
}

//---------------------------------------------------------------------------------
//[関数名]CalcSigmat1
//[機　能]σt1計算
//[戻り値]σt1
//---------------------------------------------------------------------------------
function CalcSigmat1(Tawami)
{
	return (B27 * Tawami * ( (-1) * B25 * (E8 - Tawami / 2) + B26 * inItaatu));
}

//---------------------------------------------------------------------------------
//[関数名]CalcSigmat2
//[機　能]σt2計算
//[戻り値]σt2(計算不能の時は"")
//---------------------------------------------------------------------------------
function CalcSigmat2(Tawami)
{
	if(B23 != 0)
	{
		return (B27 * Tawami / B23 * ((2 * B26 - B25) * (E8 - Tawami / 2) + B26 * inItaatu));
	}
	else
	{
		return "";
	}
}

//---------------------------------------------------------------------------------
//[関数名]CalcDelta
//[機　能]δ%計算
//[戻り値]δ%(計算不能の時は"")
//---------------------------------------------------------------------------------
function CalcDelta(Tawami)
{	
	if(E8 != 0)
	{
		return (Tawami / E8 * 100);
	}
	else
	{
		return "";
	}
}

//---------------------------------------------------------------------------------
//[関数名]CalcSettenSigma
//[機　能]接点σ計算
//[戻り値]接点σ
//---------------------------------------------------------------------------------
function CalcSettenSigma(Index)
{
	//Indexによって接点σの計算に使用する応力を変更する
	switch(Index)
	{
   		case 1:
			return (O[1] - O[0] * Math.tan(Katamuki));
			break;
		case 2:
			return (P[1] - P[0] * Math.tan(Katamuki));
			break;
		default:
			break;
	}

}

//---------------------------------------------------------------------------------
//[関数名]CalcNLife
//[機　能]n条寿命計算
//[引　数]接点σ値(t1/t2)
//[戻り値]n条寿命(計算不能の場合"")
//---------------------------------------------------------------------------------
function CalcNLife(SettenSigma)
{
	if(KatamukiLog != 0)
	{
		return ((SettenSigma - SettenLog) / KatamukiLog);
	}
	else
	{
		return "";
	}

}

//---------------------------------------------------------------------------------
//[関数名]CalcSLife
//[機　能]正味寿命計算
//[戻り値]正味寿命
//---------------------------------------------------------------------------------
function CalcSLife(NLife)
{
	return ( Math.pow(10, NLife) );
}

//---------------------------------------------------------------------------------
//[関数名]CalcMLife
//[機　能]万回寿命計算
//[戻り値]万回寿命
//---------------------------------------------------------------------------------
function CalcMLife(SLife)
{
	return ( SLife / 10000 );
}

//---------------------------------------------------------------------------------
//[関数名]CalcKLife
//[機　能]切捨寿命計算
//[戻り値]切捨寿命
//---------------------------------------------------------------------------------
function CalcKLife(MLife)
{
	//return (Math.floor(MLife / 50) * 50);	//50万単位で切り捨て(本来のexcelの式)
	return (Math.floor(MLife / 10) * 10);	//10万単位で切り捨て
}

//---------------------------------------------------------------------------------
//[関数名]ChoiseMentori
//[機　能]板圧から面取りを選択し、取得する
//[戻り値]面取り値(Float) -1は面取り選択不可(板圧が負)
//---------------------------------------------------------------------------------
function ChoiseMentori()
{
	//板圧による分岐
	if(inItaatu < 1.5)		// t < 1.5
	{
		return 0.1;
	}
	else if(inItaatu < 2.5)		// 1.5 <= t < 2.5
	{
		return 0.2;
	}
	else if(inItaatu < 4)		// 2.5 <= t< 4
	{
		return 0.3;
	}
	else if(inItaatu < 8)		// 4 <= t < 8
	{
		return 0.5;
	}
	else if(inItaatu < 14)		// 8 <= t < 14
	{
		return 1;
	}
	else if(inItaatu < 20)		// 14 <= t < 20
	{
		return 1.5;
	}
	else if( 20 <= inItaatu)	// 20 <= t
	{
		return 2;
	}
	else				// t < 0
	{
		return -1;
	}
}

//---------------------------------------------------------------------------------
//[関数名]ChoiseKeisu
//[機　能]寿命計算用定数を取得する(引数にて取得する板圧帯を決定する)
//[戻り値]True/False　取得成功/取得失敗(板厚が負)
//---------------------------------------------------------------------------------
function ChoiseKeisu(inCount, outKatamuki, outSetten50, outSetten200 )
{
	var Log2 = 0.301	//底が10のLog2の値
	var Log5 = 0.699	//底が10のLog5の値
	Setten50[0] = Log5 + 5;
	Setten200[0] = Log2 + 6;
	//0〜3の引数で分岐
	switch (inCount)
	{
		case 0:		//板厚 < 1.2
			Katamuki = 0.47561;
			//Katamuki = Math.atan((1300-735) / 1097 );
			Setten50[1] = 839;
			Setten200[1] = 735;
			break;
		case 1:		// 1.2 <= 板厚 < 6
			Katamuki = 0.4538;
			//Katamuki = 26 / 180 * Math.PI;
			Setten50[1] = 809;
			Setten200[1] = 700;
			break;
		case 2:		// 6<= 板厚 < 15
			Katamuki = 0.473;
			//Katamuki = 26 / 180 * Math.PI;
			Setten50[1] = 688;
			Setten200[1] = 617;
			break;
		case 3:		// 15 <= 板厚
			Katamuki = 0.483456;
			//Katamuki = 26 / 180 * Math.PI;
			Setten50[1] = 618;
			Setten200[1] = 559;
			break;
		default:		//板厚
			Katamuki = "";
			Setten50[1] = "";
			Setten200[1] = "";
			return false;
			break;
	}
	return true;

}

//---------------------------------------------------------------------------------
//[関数名]RoundEx
//[機　能]桁数を指定して四捨五入を行う
//[戻り値]成功/四捨五入後の値、失敗/引数そのまま
//---------------------------------------------------------------------------------
function RoundEx(inVal, Keta)
{
	//桁数倍して、round()　さらに桁数で割る
	var Temp;
	if(isNaN(inVal))
	{
		return inVal;
	}
	if(Keta < 0)
	{
		Keta = -Keta;
		Temp = inVal / Math.pow(10, Keta);
		Temp = Math.round(Temp);
		return (Temp * Math.pow(10, Keta));
	}
	else if(Keta > 0)
	{
		Temp = inVal * Math.pow(10, Keta);
		Temp = Math.round(Temp);
		return (Temp / Math.pow(10, Keta));
	}
	else if(Keta == 0)
	{
		return (Math.round(inVal));
	}
}

//---------------------------------------------------------------------------------
//[関数名]JiyuutyouCalc
//[機　能]必要項目が入力された時点で、組合せ自由長を計算して出力する
//[戻り値]成功/四捨五入後の値、失敗/引数そのまま
//---------------------------------------------------------------------------------
function JiyuutyouCalc()
{
	var tmpYuukou;
	var tmpKumi;

	var tmpItaatu;
	var tmpJiyuu;
	var tmpHeiretu;
	var tmpTyokuretu;
	if(document.s_banet.itaatu.value=="") return;
	if(document.s_banet.heiretu.value=="") return;
	if(document.s_banet.jiyuu.value=="") return;
	if(document.s_banet.tyokuretu.value=="") return;

	//入力値の取得
	tmpItaatu = parseFloat(document.s_banet.itaatu.value);				// 板厚		
	tmpJiyuu = parseFloat(document.s_banet.jiyuu.value);				// 自由高さ
	tmpHeiretu = parseFloat(document.s_banet.heiretu.value);			// 並列枚数
	tmpTyokuretu = parseFloat(document.s_banet.tyokuretu.value);		// 直列枚数

	// 有効高さ算出
	tmpYuukou = parseFloat(tmpJiyuu - tmpItaatu);

	//組合せ自由長算出
	tmpKumi = parseFloat((tmpItaatu * tmpHeiretu + tmpYuukou) * tmpTyokuretu);
//	alert(tmpKumi);
	tmpKumi = RoundEx(tmpKumi,3);
	
	document.s_banet.kumi_nagasa.value = tmpKumi;

}