#!/usr/local/other/Python-2.5.4/bin/python

import numpy
import sys
import time
import math
import solverOrder4

# number of grid points
numPoints = int(sys.argv[1])

j=numpy.complex(0,1)
pi_c = 4.0*math.atan(1.0)

##################################
# Setting of the initial condition
##################################

u=numpy.zeros((numPoints,numPoints),dtype=float)

################################
# Setting the boundary condition
################################

x=numpy.r_[0.0:pi_c:numPoints*j]
u[0,:]=numpy.sin(x)
u[numPoints-1,:]=numpy.sin(x)*numpy.exp(-pi_c)

def regularSolver(u):
   iter =0
   err = 2
   while(iter <100000 and err>1e-6):
      (u,err)=solverOrder4.slowTimeStep(u)
      iter+=1
   return (u,err,iter)

begTime1 = time.time()

(u,err,iter) = regularSolver(u)

endTime1 = time.time()
print "Regular Python solver 4th-order scheme: "
print "       Elapsed time: ", endTime1 - begTime1,"(s)"
print "       Number of iterations: ", iter
print "       Error:", err

# Fast Solver

v=numpy.zeros((numPoints,numPoints),dtype=float)

x=numpy.r_[0.0:pi_c:numPoints*j]
v[0,:]=numpy.sin(x)
v[numPoints-1,:]=numpy.sin(x)*numpy.exp(-pi_c)


def fastSolver(v):
   iter =0
   err = 2
   while(iter <100000 and err>1e-6):
      (v,err)=solverOrder4.numpyTimeStep(v)
      iter+=1
   return (v,err,iter)

begTime2 = time.time()

(v,err,iter) = fastSolver(v)

endTime2 = time.time()
print " "
print "Fast Numpy solver 4th-order scheme: "
print "       Elapsed time: ", endTime2 - begTime2,"(s)"
print "       Number of iterations: ", iter
print "       Error:", err

######### Fortran Solver  #############
#import numpy.f2py as f2py
#fid = open('timeStep4.f90')
#source = fid.read()
#fid.close()
#f2py.compile(source, modulename='timeStep4')
#import timeStep4
#
#w=numpy.zeros((numPoints,numPoints),dtype=float)
#
#x=numpy.r_[0.0:pi_c:numPoints*j]
#w[0,:]=numpy.sin(x)
#w[numPoints-1,:]=numpy.sin(x)*numpy.exp(-pi_c)
#
#def fortranSolver(w):
#   iter =0
#   err = 2
#   n, m = w.shape
#   while(iter <10000 and err>1e-6):
#      (w,err)=timeStep(w,n,err)
#      iter+=1
#   return (w,err,iter)

#begTime3 = time.time()
#
#(w,err,iter) = fortranSolver(w)
#
#endTime3 = time.time()
#print " "
#print "Fortran solver: "
#print "       Elapsed time: ", endTime3 - begTime3,"(s)"
#print "       Number of iterations: ", iter
#print "       Error:", err