""" define target function from fdFunc-module

"""

funcObj = func.fdFunc(no)

x = funcObj.x

y = funcObj.getFunc()

""" initialize List by I

"""

List = []

List.append(I)

""" function of all solution

"""

""" step-1 """

#print "step-1:"

# リストList の初期化

List = initList(I)

# 唯一解を持つリスト

solI = []

# 分割回数の保持

numSplit = 0

flag = None

# 対象funcの設定

if x is None or y is None:

x, y = fdFunc(no)

""" step-2 """

#print "step-2"

#print "=========================== START ============================="

#print "List of intervals: ",

while List != []:

if numSplit%50 == 0:

#print numSplit, ": ", str(len(List))

pass

#print List

# リストList の先頭要素を取り出しI とする

I = List.pop(0)

""" step-3 """

#print "step-3:"

# F(I) によりI に解が存在するか判定(弱い非存在判定)

if solex.checkNoSolExist(no, I, x, y, method = 1) == True:

# I を初期化してstep 2 へ戻る

#I = []

#continue

flag = 3

break

else:

pass

""" step-4 """

#print "step-4:"

# Krawczyk 法による唯一解の判定

krawObj = kraw.data(no, I)

if not krawObj.KI is False:

if solex.checkOnlySolExist(no, krawObj, x, y, method = 4) == True:

#print I

solI.append(I)

#continue

flag = 4

break

else:

pass

""" step-5 """

#print "step-5:"

# 区間I, K(I) が空集合であればI に解は存在しない(強い非存在判定)

if not krawObj.KI is False:

# the krawczyk-method

if solex.checkNoSolExist(no, krawObj, x, y, method = 2) == True:

#I = []

#continue

flag = 5

break

else:

# the mean-value-form

if solex.checkNoSolExist(no, I, x, y, method = 3) == True:

#I = []

#continue

flag = 5

break

""" step-6 """

#print "step-6:"

# 区間の分割

splitI = []

for i in range(len(split(I))):

#List.append(split(I)[i])

splitI.append(split(I)[i])

numSplit += 1

#continue

flag = 6

return (no, flag, splitI)

# 唯一解を持つ区間を返す

# 分割回数の表示

#print '\n\r'

#print "The number of split-I: "+str(numSplit)

#return solI

""" higher numerical verification

"""

if x is None or y is None:

x, y = fdFunc(no)

# number counting improved-solI

countImprovedSolI = 0

# max-loop of improve soilI

maxLoop = 100

#if len(solIList) == 0:

if len(solI) == 0:

msg = 'Assigned equation has no-solution in the interval-list.'

print "============================ END =============================="

return msg

#improvedSolIList = []

#countImprovedSolI += 1

#solI = solIList.pop(0)

# 区間反復法

#solIList.append(kraw.krawczyk(no, solI))

flag = None

if evaluateImproveVerification(solI) == True:

flag = True

else:

flag = False

return (no, flag, [kraw.krawczyk(no, solI, x, y)])

#print "The number of improving verification: "+str(countImprovedSolI)

#print "============================ END =============================="

""" splitting List

"""

# Deep-copy による区間の複製

Isucc = np.mat(I.copy())

Ipred = np.mat(I.copy())

# 区間幅の最も大きいものを分割

Isucc[maxElementInMatrix(I)] = interval(I.item(maxElementInMatrix(I)).inf, interval.medsucc(I.item(maxElementInMatrix(I))))

Ipred[maxElementInMatrix(I)] = interval(interval.medpred(I.item(maxElementInMatrix(I))), I.item(maxElementInMatrix(I)).sup)

""" return list-index of max element in one matrix

"""

width = []

for i in range(len(I)):

width.append(interval.width(I.item(i)))

""" evaluate calcurating-error and check whether its allowable-value

If error is under allowable-value, return True.

"""

# criteria of allowable-error

#allowableError = 1e-7

allowableError = 1e-1

for i in range(len(solI)):

# calcurate width-error of interval

widthError = interval.width(solI.item(i))

if widthError >= allowableError:

return False

"""

"""

import json

data = {}

list = {}

cnt = 0

data['no'] = no

data['flag'] = flag

for I in IList:

val = []

for i in xrange(len(I)):

val.append((I.item(i).inf, I.item(i).sup))

#list.append(val)

list[cnt] = val

cnt = cnt + 1

data['I'] = list

#return json.dumps(data, indent=4)