;; Constructors



(defun make-constant (num)

  num)



(defun make-variable (sym)

  sym)



;;(defun p+ (poly1 poly2)

 ;; (list '+ poly1 poly2))



(defmacro p+ (poly1 poly2)

`(list '+ ',poly1 ',poly2))



(defmacro p* (poly1 poly2)

`(list '* ',poly1 ',poly2))





;;(defun p* (poly1 poly2)

;;  (list '* poly1 poly2))



(defun make-power (poly num)

  (list '** poly num))



;;

;; Recognizers for polynomials

;;



(defun constant-p (poly)

  (numberp poly))



(defun variable-p (poly)

  (symbolp poly))



(defun sum-p (poly)

  (and (listp poly) (eq (first poly) '+)))



(defun product-p (poly)

  (and (listp poly) (eq (first poly) '*)))



(defun power-p (poly)

  (and (listp poly) (eq (first poly) '**)))



;;

;; Selectors for polynomials

;;



(defun constant-numeric (const)

  const)



(defun variable-symbol (var)

  var)



(defun sum-arg1 (sum)

  (second sum))



(defun sum-arg2 (sum)

  (third sum))



(defun product-arg1 (prod)

  (second prod))



(defun product-arg2 (prod)

  (third prod))



(defun power-base (pow)

  (second pow))



(defun power-exponent (pow)

  (third pow))







;;

;; Simplification function

;;



(defun simplify (poly)

  "Simplify polynomial POLY."

  (cond

   ((constant-p poly) poly)

   ((variable-p poly) poly)

   ((sum-p poly)

    (let ((arg1 (simplify (sum-arg1 poly)))

          (arg2 (simplify (sum-arg2 poly))))

      (make-simplified-sum arg1 arg2)))

   ((product-p poly)

    (let ((arg1 (simplify (product-arg1 poly)))

          (arg2 (simplify (product-arg2 poly))))

      (make-simplified-product arg1 arg2)))

   ((power-p poly)

    (let ((base (simplify (power-base poly)))

          (exponent (simplify (power-exponent poly))))

      (make-simplified-power base exponent)))

   ((derivative-p poly) poly)))



(defun make-simplified-sum (arg1 arg2)

  "Given simplified polynomials ARG1 and ARG2, construct a simplified sum of ARG1 and ARG2."

  (cond

   ((and (constant-p arg1) (zerop arg1)) arg2)

   ((and (constant-p arg2) (zerop arg2)) arg1)

   (t                                    (p+ arg1 arg2))))



(defun make-simplified-product (arg1 arg2)

  "Given simplified polynomials ARG1 and ARG2, construct a simplified product of ARG1 and ARG2."

  (cond

   ((and (constant-p arg1) (zerop arg1)) (make-constant 0))

   ((and (constant-p arg2) (zerop arg2)) (make-constant 0))

   ((and (constant-p arg1) (= arg1 1))   arg2)

   ((and (constant-p arg2) (= arg2 1))   arg1)

   (t                                    (p* arg1 arg2))))



(defun make-simplified-power (base exponent)

  "Given simplified polynomials BASE and EXPONENT, construct a simplified power with base BASE and exponent EXPONENT."

  (cond

   ((and (constant-p exponent) (= exponent 1))   base)

   ((and (constant-p exponent) (zerop exponent)) (make-constant 1))

   (t                          (make-power base exponent))))

count = 1;

while(computer has not found false line)

{
if (first Line of serverFile == false)

{

then set the first line to 'true' and set the account to "account+count"

}

else

{

increment count

}
}

REM This file holds true false statements if accounts are in use if they are true they are in use.

false //this line represents account one

false //this line represents account two

 TAKEHOME.COB                            Wed Dec 03 17:08:51 2008    Page   1

 line number source line   Microsoft COBOL                       Version 2.20



   1          IDENTIFICATION DIVISION.

   2          PROGRAM-ID.  Iteration-If.

   3          AUTHOR.  Michael Coughlan.

   4    

   5          ENVIRONMENT DIVISION.

   6    

   7          DATA DIVISION.

   8    

   9          WORKING-STORAGE SECTION.

  10          01  Num1           PIC 99  VALUE ZEROS.

  11          01  Num2           PIC 99  VALUE ZEROS.

  12          01  Result         PIC 999 VALUE ZEROS.

  13          01  Sum-Nos        PIC 999 VALUE ZEROS.

  14          01  Prod-Nos       PIC 999 VALUE 1.

  15          01  Ave-Nos        PIC 99.99 VALUE ZEROS.

  16          01  Counter        PIC 99  VALUE ZEROS.

  17          01  Operator       PIC X  VALUE SPACE.

  18          01  Answer         PIC X  VALUE SPACE.

  19          01  CHECKEVEN     PIC 99   VALUE ZEROS.

  20          01  CHECKODD      PIC 99   VALUE ZEROS.

  21    

  22          PROCEDURE DIVISION.

  23    

  24          Main.

  25             DISPLAY "Enter First Integer: ".

  26             ACCEPT Num1.

  27             DISPLAY "Enter Second Integer: ".

  28             ACCEPT Num2.

  29             DISPLAY "Choose 0/E/A: ".

  30             ACCEPT Answer.

  31             IF Answer = "O"

  32              PERFORM Odd

  33             ELSE

  34             IF Answer = "E"

  35              PERFORM Even

  36             ELSE

  37             IF Answer = "A"

  38              PERFORM Gabos

  39             ELSE

  40              DISPLAY "Invalid Input!".

  41    

  42          Gabos.

  43             PERFORM Get-Values

  44                  VARYING Num1 FROM Num1 BY 1

  45                  UNTIL Num1 > Num2.

  46             DISPLAY "The Sum is: ", Sum-Nos.

  47             DISPLAY "The Product is: ", Prod-Nos.

  48             COMPUTE Ave-Nos = Sum-Nos / Num2.

  49             DISPLAY "The Average is: ", Ave-Nos.

  50             STOP RUN.

  51    

  52          Even.

  53             COMPUTE CHECKEVEN = Num1 / Num1.

  54             IF CHECKEVEN = 1

  55              PERFORM Get-Values

  56                   VARYING Num1 FROM Num1 BY 2

  57                   UNTIL Num1 > Num2

  58             ELSE

  59              COMPUTE Num1 = Num1 + 1

  60              PERFORM Get-Values

  61                   VARYING Num1 FROM Num1 BY 2

  62                   UNTIL Num1 > Num2.

  63             DISPLAY "The Sum is: ", Sum-Nos.

  64             DISPLAY "The Product is: ", Prod-Nos.

  65             COMPUTE Counter = Num2 - Num1 + 0.5.

  66             COMPUTE Ave-Nos = Sum-Nos / Counter.

  67             DISPLAY "The Average is: ", Ave-Nos.

  68             STOP RUN.

  69    

  70          Odd.

  71             COMPUTE CHECKODD = Num1 / Num1.

  72             IF CHECKODD = 1

  73              PERFORM Get-Values

  74                   VARYING Num1 FROM Num1 BY 2

  75                   UNTIL Num1 > Num2

  76             ELSE

  77              COMPUTE Num1 = Num1 + 1

  78              PERFORM Get-Values

  79                   VARYING Num1 FROM Num1 BY 2

  80                   UNTIL Num1 > Num2.

  81             DISPLAY "The Sum is: ", Sum-Nos.

  82             DISPLAY "The Product is: ", Prod-Nos.

  83             COMPUTE Counter = Num2 - Num1 + 0.5.

  84             COMPUTE Ave-Nos = Sum-Nos / Counter.

  85             DISPLAY "The Average is: ", Ave-Nos.

  86             STOP RUN.

  87    

  88          Get-Values.

  89             COMPUTE Sum-Nos = Sum-Nos + Num1.

  90             COMPUTE Prod-Nos = Prod-Nos * Num1.

  91