def thermodynamic_integration(x,y,yerr,N=1000):
    """ Performs the integration using Simpson's rule after bootstrapping the y values.
    """
    Q=np.zeros(N)

    y_bstrap=eh.resampling(y,yerr,N)
    for i in xrange(N):
        Q[i]=simps(y_bstrap[:,i],x,even='avg')

    return Q
parser.add_argument('--magnsusc','-m',action='store_true')
parser.add_argument('--verbose','-v',action='store_true')
args=parser.parse_args()

def energy_flucs(e, e2, beta):
    return (e2 - e**2 ) * beta**2 

def magn_flucs(e, e2, beta):
    return (e2 - e**2 ) * beta

path=os.path.dirname(args.infile)
prefix=os.path.basename(args.infile)

N=args.N

dataG = eh.read_results_from_file(path, prefix, args.X, args.quantity)
if args.verbose:
    print dataG

if args.specheat:
    dataG2 = eh.read_results_from_file(path, prefix, args.X, args.quantity+'2')
    b, e, eerr = eh.convert_alps_dataset(dataG[0])
    b, e2, e2err= eh.convert_alps_dataset(dataG2[0])
    
    L = dataG[0].props['L']

    for beta,en,enerr,en2,en2err in zip(b,e,eerr,e2,e2err):
        cv, cverr = eh.bootstrap(energy_flucs, [en, en2, beta] , [enerr, en2err, 0.0], N=N)
        print beta, cv, cverr

elif args.magnsusc:
if W!=L:
    dofs = 2*factor[args.System] *L** (dim[args.System]-1) * W

if args.full:
    dofs = 1

#print dofs


x=np.zeros((NIncSteps,NValues))
y=np.zeros((NIncSteps,NValues))
y_err=np.zeros((NIncSteps,NValues))

for schemes in renyi_dataG:
    scheme=int(schemes.props['IncNo'])
    x[scheme],y[scheme],y_err[scheme] = eh.convert_alps_dataset(schemes)


for k in range(3,NValues+1,args.Step):
    for schemes in renyi_dataG:
        scheme=int(schemes.props['IncNo'])
        S[scheme]=thermodynamic_integration(x[scheme,:k],y[scheme,:k],y_err[scheme,:k]+1e-15,N)

    if args.alternate:
        gamma=np.array([args.Const-dofs * (S[0,l]-S[1,l]-S[2,l]+S[3,l]) for l in range(N)])
    elif args.simple:
        gamma=np.array([args.Const-dofs * (S[args.simple,l]-S[0,l]) for l in range(N)])
    else:
        gamma=1./(n-1)*np.array([args.Const-(n*factor[args.System] * L ** dim[args.System]) * (S[0,l]-2*S[1,l]+S[2,l]) for l in range(N)])