###  Prompts the user for an angle in degrees, converts it into radians
###  Calculates the Cosine using Series Convergence
###  Cos(x) = 1 - x2/2! + x4/4! - x6/6!


# 1 - x2/2! + x4/4! - x6/6!
#  Xold f0 f1
#  Xnew f2 f3
#  Angle f4 f5
#  Threshold f6 f7
#  Term index = $t1


	.data

Angle:	.double  0.0 	#the angle in radians to compute 45degrees
THold:	.double  0.000001	#accuracy threshold
Neg1:	.double  -1.0		#-1,0 used to change the Sign of Sign
Sign:	.double  -1.0		#Sign of the term
PI:	.double 3.141592653
_180:	.double 180.0
Prompt: .asciiz "Enter the angle in Degrees: "

	.text

	jal GetAngle  #get the angle in degrees


	li $t0, 1			#Initialize Xold to 1
	mtc1 $t0, $f2			#move 1 to $f0 and convert it into a double
	cvt.d.w $f2,$f2			#f0 and f1 contain the double rep of 1

	move $t0, $0			#initialize Xnew to 0.0
	mtc1  $t0, $f0
	cvt.d.w  $f0, $f0


	ldc1 $f4, Angle		#load the Angle 
	ldc1 $f6, THold  	#load the Threshold
	li $t1, 2		# term index value used for power and factorial

	


loop0:	#while (abs(Xold -Xnew) > Threshold
	c.lt.d 1,$f0, $f2       #if f0<f2 then set condition flag 1 to true
        bc1t 1, loop1		#compute the abs of f0-f2
		sub.d $f10, $f0, $f2
		b loop2	
	loop1:
		sub.d $f10, $f2, $f0
	loop2:

	c.lt.d 1, $f10,$f6     #check if threshold is reached loopend
	bc1t 1, loopEnd
		mov.d $f0, $f2 #Xold = Xnew
		
		move $t3, $t1   #calc the pow (angle, termindex
		subi $t3,$t3,1	 #we multiply Angle*Angle,  termIndex - 1 times
		mov.d $f10, $f4  #store the result in $f10
		loop3:
		beqz $t3, loop4			#calc pow(angle, termIndex)
			mul.d $f10, $f10, $f4
			subi $t3, $t3, 1
			b loop3
		loop4:
		move  $a0, $t1			#find factorial(termIndex)
		jal Fact
		mtc1  $v0, $f12			#convert factorial to a double
		cvt.d.w $f12,$f12		# store it in $f12
		
		div.d $f2, $f10, $f12		#divide pow(angle,index)/fact(index)
		
		ldc1 $f12, Sign			#apply the correct sign to the term
		mul.d $f2,$f2,$f12
		ldc1 $f10,Neg1			#flip the sign ready for next term
		mul.d $f12,$f12,$f10
		sdc1 $f12, Sign			#store the new sign
		
		addi $t1, $t1, 2		#increment the term index
		
		add.d $f2, $f2, $f0             #Add the new term to the old terms together
						#store this a Xnew
	b loop0


loopEnd:    #finished the while loop

	li $v0, 3   #print out result Xnew
	mov.d  $f12, $f2
	syscall

	li $v0, 10   #done
	syscall


# Prompt and enter an angle in degrees, then convert it
# into Radians and store it in Angle
GetAngle:
	li $v0 ,4
	la $a0 ,Prompt
	syscall
	
	li $v0, 7
	syscall
	
	ldc1 $f2, _180		#put 180 into $f2
	ldc1 $f4, PI           #Load constant PI
	mul.d $f0,$f0,$f4     #calculate angle* PI /180
	div.d $f0, $f0, $f2
	sdc1  $f0, Angle	        #Store result into memory

	jr $ra


Fact:	# Factorial procedure, put N in a0, get result from v0
	move $fp,$sp		#create the initial AR dummy frame
	addi $sp,$sp,-8		#won't save old fp because there isn't one
	move $s7, $ra
	
	jal Fact_0

	jr $s7

Fact_0:
	sw $ra, ($fp)		#save ra in the AR
	
	beqz $a0, Fact_1
	
	sw $a0, ($sp)		#save a0 onto stack
	addi $sp, $sp, -12	#create space for ra and old fp
	sw $fp, 4($sp)		#store previous fp
	move $fp,$sp   		#set fp to point to stored ra
	addi $fp,$fp,8		
	
	subi $a0,$a0,1       	#setup parameter n-1
	jal Fact_0

	
	lw $a0,4($fp) 		#restore a0
	move $sp,$fp		#set sp to fp
	lw $fp, -4($fp)		#restore old fp 
	addi $sp,$sp,12		#set sp to TOP of previous AR													
	b Fact_2																								
Fact_1:
	li $v0, 1																																					
	b Fact_3
Fact_2: 																																																	
	mul $v0,$v0,$a0
Fact_3:	lw $ra, ($fp)		#restore ra from AR
	jr $ra