###  Modular Programming Components; If-Else and While Loops.

# Now that we've learned how to write boolean expressions, we can
# use them to form if statements, if-else statements, and while loops.

x = eval(input("Enter a number: "))

if x<0: print("x is negative")
if x>0: print("x is positive")
if x==0: print("x is zero")

# The statement after the : will only be executed if the boolean expression
# evaluates to True.  Each if statement will be tested and executed in turn.

# A if statement can also optionally have an else part:

if x!=0: print( 1/x )
else: print("can't divide by zero")

# The else part will be executed if the boolean condition is false: thus in
# an if-else statement something will always be executed.

# What does the following print?

x, y = 4,2  # simultaneously assigns x to 4 and y to 2

if x>y: print("x is bigger")
if x<y: print("y is bigger")
else: print("x and y are the same")

# answer: it prints "x is bigger" AND THEN it also prints "x and y are the
# same".  Why?  because the two if statements are executed in turn, but
# something will ALWAYS be executed by the second if-else statement
# regardless of what happened with the first statement.  Think about this
# to make sure you understand.

### if statements that does more than one thing:

if x==0:
    print("A")
    print("B")

# if x is indeed 0, it will print both A and B, otherwise it prints nothing.
# The indentation determines the SCOPE of the if statment.  One should think
# of any set of code that's properly aligned (indented the same way) as
# forming a program module, a coherent piece of code.


### nested if statements.

# The body or scope of an if statement can contain any number of other
# statements as long as they're aligned.  This naturally means that
# if statements can contain other if statements.

if x>y: print("x is bigger")
else:
    if x<y: print("y is bigger")
    else: print("x and y are the same")

# Assuming that x,y are still 4,2, this time it will just print x is bigger,
# because the entire second if-else will be skipped, because it's inside
# the scode of the first if-else.

# the following code tries to test if a and b are equal and that both are
# positive.
a,b = eval(input("Enter two numbers:"))

if a==b:
    if a>0:
        if b>0: print("ok")

# This is equivalent to:

if (a==b and a>0 and b>0): print("ok")

# As general practice, do not nest more if statements than necessary.

# QUIZ: what does the following print?

a,b = 2,2
if a != b:   # same as if not(a==b):
    if a>b:
        print("a is bigger")
    else: print("a is not bigger")
print("a and b are the same")

# ???????

# anwer: it prints "a and b are the same", because a!=b is False.
# else clause is associated with the inner if, not the outer if.


#### elif.

if a==0: print("zero")
else:
    if a==1: print("one")
    else:
        if a==2: print("two")
        else: print("bigger than two")

# This sequence can be conveniently replaced by:

if a==0: print("zero")
elif a==1: print("one")
elif a==2: print("two")
else: print("bigger than two")

# elif is just a convenient form of else: if ... without  needing a
# new level of indentation.

# if combined with elifs tests a series of conditions and executes the
# statements associated with the first true condition that it encounters,
# all other statements are ignored.


########## While Loops.

# A while loop is like an if statement (with no else: part), except it
# retests the boolean condition after each execution of its body, until
# the boolean condition becomes false, which is possible because we can
# change the value of variables.

x = 1
while x<10:
    print(x*x)
    x = x+1
# end while x

# While loops will usually contain more than one statement, properly aligned.
# The comment at the end is REQUIRED, otherwise your code will become
# unreadable when it gets large.

# If the boolean condition is true, it will execute the body, then retest
# the condition, jumping out of the loop when it becomes false.  It
# always executes the entire body of the while loop before retesting the
# boolean condition: it does not terminate in the middle.  The following
# prints something slightly different.

x = 1
while x<10:
    x = x+1
    print(x*x)
# end while x

# count the number of lines printed: you should notice that it still
# printed 9 numbers, but the numbers it printed are different. Why?
# Understanding such details is crucially important.  The trickiest
# part of writing while loops is to understand HOW IT STARTS and WHEN
# IT ENDS.  The beginning and the end are usually where mistakes are
# made.

# The following prints 1, 4, 9, etc.. up to 100.
x = 0
while x<10:
    x = x+1
    print(x*x)
# end while x

# The Fibonacci sequence is 1 1 2 3 5 8 13 21 ...  The following prints the
# the first 30 Fibonacci numbers:

n = 30  # counts downward how many numbers are left to be printed.
a,b = 0,1
while n>0:
    print (b, " ", end="")  # printing with end="" means no line break
    a,b = b,a+b
    n -= 1    # this is shorthand for n = n-1
# while n
print("")      # prints line break AFTER the while loop.

# In this program, I also used print in a way that does not automatically
# generate a line break at the end, with the end="" option when calling print.

## The body of while loops can be arbitrarily large and complex.  It can
# contain if statements, as well as nested while loops.
print("----------------------")
x = 1
while x<10:
    y = 1
    while y<10:
        print (x*y, "\t", end="")    # \t is the tab character
        y = y+1             
    # inner while
    print("")          # prints blank, then line break
    x = x+1
# outer while

# This prints a multiplication table.

### At this point, it is important for you to realize that a program is much
# more complex than just a sequence of commands.  The program must be
# STRUCTURED correctly.  It's not just one line followed by another: how
# these lines relate to eachother is crucially important.

# To better understand a nested while loop such as above, you can't just
# read the code line-by line.  It is important to be able to identify the
# *five principal components* that makes up a while loop:

#  1. preamble: sets up initial conditions before loop begins
#  2. boolean expression: determines whether loop continues or ends
#  3. update: condition must be updated for loop to stop eventually
#  4. main body of the while loop
#  5. postamble: final or clean-up action after the loop stops.
#     The postamble is sometimes empty, but conceptually we should still
#     think that it's present.

# Exercise: take any of the sample loops below, and identify the component
# that each line belongs to.

### More sample while loops:

# The following loop computes the greatest common divisor of a and b
# by implementing Euclid's algorithm, which can be described as follows.
# Given two numbers:
# 1. divide the larger number by the smaller number and find the remainder.
# 2. replace the larger number by the remainder found above.
# 3. repeat steps 1 and 2 until one of the two numbers is zero
# 4. the gcd is the remaining, non-zero number.

# Clarification: the above implies that if the two numbers are equal, 
# divide any one by the other, and if one number is zero to begin with, 
# the other number is the gcd.

a,b = eval(input("enter two numbers: "))
while (a!=0 and b!=0):
  if a>b: a = a%b
  else: b = b%a
# while
gcd = a+b  # one of a or b will be zero and automatically canceled
print("the gcd is",gcd)
  

# The following while loop checks if a number is a prime number.  A number
# is prime if it is evenly divisible (does not leave remainder) only by
# one and itself.

n = int(input("enter a number: "))  # number to test for primality
testcase = 2                   # first number to test against
answer = True
while testcase<n and answer:
    if (n % testcase == 0): answer = False
    testcase = testcase +1
# while
if (answer):
    print (n,"is prime")
else:
    print (n,"is not prime")

# Question, what will happen if n is 2?
# In that case the loop will never run, and it will print correctly that
# 2 is prime.

# note that the "and answer" clause in the boolean condition means that
# the loop will stop as soon as answer becomes false.
# saying "answer" here is the same as "answer==true" because what does
# answer==true evaluate to?

## EXERCISE: improve the prime testing algorithm by skipping even numbers.
# That is, once we confirm that n is not divisible by 2, then we know it's 
# not divisible by 4, 6, 8, ...  It is also possible to stop as soon as
# testcase becomes >= n/2, or even sqrt(n).