QUIZ 1 Due Thursday September 28, 2017, but extended three days to Sunday evenin

Question

QUIZ 1 Due Thursday September 28, 2017, but extended three days to Sunday evening at 5PNM (1) write a general program which computes the constitutive matrix, Aij- (A11,A12, A16, A22, A26, A66) Bij- (811, 812, B16, B22, 826, B66) Dij- (D11, D12, D16, D22, D26, D66) Base on input parameter, Given N-total number of layers Given fiber orientations (theta1,theta2, theta 3,.,.hetaN-1, ThetaN) Given E1/E2=10, given poisson12 0.25 Therefore poisson21 poison 12 (E2/E1) (1a) we all know for each layer, we have Q matrix for the kth layer (QnQa.a QuAwad we define Qnon-dime (1rEJ) (QnQnQiLQn,Qual For example, use equation 2.66, Q/E (E1/E2)/(1-poisson12 Computer Q non-dim The above Q is assume we are referring to theta 0 poisson 21) We now specialize the above to arbitrary value of the fiber angle, see equation 2.85, page 77 albar (1/E2)s (1/E2) [ Q11 cos* + 2(Q12+2066) sineos, Q22 sin Au non-dim A22 non-dim Au/KEt) A22/(Ezt) Auz non-dim Aas non-dim Az/(Et) Aas / (Ert) As non-dim Ad (E4) A“ non-dime Am/ (Et)

Explanation / Answer

#lang racket

(require racket/match)

;; Evaluation toggles between eval and apply.

; eval dispatches on the type of expression:
(define (eval exp env)
(match exp
    [(? symbol?)          (env-lookup env exp)]
    [(? number?)          exp]
    [(? boolean?)         exp]
    [`(if ,ec ,et ,ef)    (if (eval ec env)
                              (eval et env)
                              (eval ef env))]
    [`(letrec ,binds ,eb) (eval-letrec binds eb env)]
    [`(let    ,binds ,eb) (eval-let binds eb env)]
    [`(lambda ,vs ,e)    `(closure ,exp ,env)]
    [`(set! ,v ,e)        (env-set! env v e)]
    [`(begin ,e1 ,e2)     (begin (eval e1 env)
                                 (eval e2 env))]
    [`(,f . ,args)        (apply-proc
                           (eval f env)
                           (map (eval-with env) args))]))

; a handy wrapper for Currying eval:
(define (eval-with env)
(lambda (exp) (eval exp env)))

; eval for letrec:
(define (eval-letrec bindings body env)
(let* ((vars (map car bindings))
         (exps (map cadr bindings))
         (fs   (map (lambda _ #f) bindings))
         (env* (env-extend* env vars fs))
         (vals (map (eval-with env*) exps)))
    (env-set!* env* vars vals)
    (eval body env*)))

; eval for let:
(define (eval-let bindings body env)
(let* ((vars (map car bindings))
         (exps (map cadr bindings))
         (vals (map (eval-with env) exps))
         (env* (env-extend* env vars vals)))
    (eval body env*)))
  
; applies a procedure to arguments:
(define (apply-proc f values)
(match f
    [`(closure (lambda ,vs ,body) ,env)
     ; =>
     (eval body (env-extend* env vs values))]
  
    [`(primitive ,p)
     ; =>
     (apply p values)]))

;; Environments map variables to mutable cells
;; containing values.

(define-struct cell ([value #:mutable]))

; empty environment:
(define (env-empty) (hash))

; initial environment, with bindings for primitives:
(define (env-initial)
(env-extend*
   (env-empty)
   '(+ - / * <= void display newline)
   (map (lambda (s) (list 'primitive s))
   `(,+ ,- ,/ ,* ,<= ,void ,display ,newline))))

; looks up a value:
(define (env-lookup env var)
(cell-value (hash-ref env var)))

; sets a value in an environment:
(define (env-set! env var value)
(set-cell-value! (hash-ref env var) value))

; extends an environment with several bindings:
(define (env-extend* env vars values)
(match `(,vars ,values)
    [`((,v . ,vars) (,val . ,values))
     ; =>
     (env-extend* (hash-set env v (make-cell val)) vars values)]
  
    [`(() ())
     ; =>
     env]))

; mutates an environment with several assignments:
(define (env-set!* env vars values)
(match `(,vars ,values)
    [`((,v . ,vars) (,val . ,values))
     ; =>
     (begin
       (env-set! env v val)
       (env-set!* env vars values))]
  
    [`(() ())
     ; =>
     (void)]))

;; Evaluation tests.

; define new syntax to make tests look prettier:
(define-syntax
test-eval
(syntax-rules (====)
    [(_ program ==== value)
     (let ((result (eval (quote program) (env-initial))))
       (when (not (equal? program value))
         (error "test failed!")))]))

(test-eval
((lambda (x) (+ 3 4)) 20)
====
7)

(test-eval
(letrec ((f (lambda (n)
                 (if (<= n 1)
                     1
                     (* n (f (- n 1)))))))
    (f 5))
====
120)

(test-eval
(let ((x 100))
    (begin
      (set! x 20)
      x))
====
20)

(test-eval
(let ((x 1000))
    (begin (let ((x 10))
             20)
           x))
====
1000)

;; Programs are translated into a single letrec expression.

(define (define->binding define)
(match define
    [`(define (,f . ,formals) ,body)
     ; =>
     `(,f (lambda ,formals ,body))]
  
    [`(define ,v ,value)
     ; =>
     `(,v ,value)]
  
    [else
     ; =>
     `(,(gensym) ,define)]))

(define (transform-top-level defines)
`(letrec ,(map define->binding defines)
     (void)))

(define (eval-program program)
(eval (transform-top-level program) (env-initial)))

(define (read-all)
(let ((next (read)))
    (if (eof-object? next)
        '()
        (cons next (read-all)))))

; read in a program, and evaluate:
(eval-program (read-all))

Related Questions

Navigate

• Browse (All)
• Browse Q
• Subjects

---