主页 / coding / 问题 / 78749382
Accepted
nemo nemo
Asked: 2024-07-15 18:38:39 +0800 CST

如何使用一个函数产生的符号表达式来定义另一个函数？

  • 772

我正在尝试在 Chez 方案中创建一个符号派生函数。它运行良好（尚未进行简化）：

(define (derive var expr)
;; var is the direction in which you would like to derive
  (if (list? expr)
      (case (car expr)
        ('+    (sum-rule var expr))
        ('-    (sub-rule var expr))
        ('*    (prod-rule var expr))
        ;; other rules
        (else  (atomic-rule var expr )))
      (atomic-rule var expr)))

(define (atomic-rule var expr)
  (if (list? expr)
      expr
      (if (eqv? var expr)
          1
          0)))

(define (sum-rule var expr)
  (let ((args (cdr expr)))
    `(+ ,@(map (lambda (e) (derive var e)) args))))

(define (sub-rule var expr)
  (let ((args (cdr expr)))
    `(- ,@(map (lambda (e) (derive var e)) args))))

(define (prod-rule var  expr)
  (let* ((args (cdr expr))
         (f (car args))
         (g (cadr args)))
    `(+ (* ,f ,(derive var g))
        (* ,g ,(derive var f)))))

我可以执行(derive 'x '(+ (* x x) (* x y)))并得到(+ (+ (* x 1) (* x 1)) (+ (* x 0) (* y 1)))正确的结果。但我还想以编程方式创建从这些表达式返回数值的函数。

我的尝试失败了：

(define (lambda-derive var expr)
  (let ([derivative (derive var expr)])
    (lambda (var) derivative)))

((lambda-derive 'x '(* x x)) 2) => (+ (* x 1) (* x 1)) ;; should be 4

(define-syntax lbd-macro
  (lambda (context)
    (syntax-case context ()
      [(k expr var )
       (with-syntax ([new-var (datum->syntax #'k (syntax->datum #'var))])
         #'(lambda (new-var) expr))])))


((lbd-macro (derive 'x '(* x x)) x) 2) => (+ (* x 1) (* x 1)) ;; should be 4

我感觉我忽略了一些非常明显的东西。有人能提供一些启示吗？（是的，我知道这些尝试没有涵盖多变量情况）

==编辑==

我睡了一个坏觉并决定继续工作，我找到了与 @ignis volens 描述的类似的解决方案，尽管使用了哈希表并且更加黑客化：

(define (lambda-aux variables vals expr)
  (let ((ht (make-eqv-hashtable (length variables))))
    (for-each (lambda (k v) (hashtable-set! ht k v)) variables vals)
    (let loop ((expr expr))
      (if (list? expr)
          (let ((op (car expr))
                (args (map loop (cdr expr))))
            (cons op args))
          (let ((variable (hashtable-ref ht expr #f)))
            (if variable
                variable
                (if (number? expr)
                    expr
                    (error "variable not found"))))))))

(define-syntax lambda-derive
  (syntax-rules ()
    [(_ expr var var* ...)
     (lambda (var var* ...) (eval (lambda-aux '(var var* ...) (list var var* ...) (derive 'var 'expr) )))]))

可以像这样使用：

(define my-test-derivative
  ;;f(x,y) = x^2 + x * y
  ;;df/dx (x,y) = 2*x + y
  (lambda-derive (+ (* x y) (* x x)) x y))
(my-test-derivative 2 2) => 6
(my-test-derivative 8 2) => 18
;; ...
scheme

1 个回答

  1. Best Answer

    在这种情况下，您要么咬紧牙关，要么使用eval：

    (eval `(lambda (x) ,(derive 'x '(* x x))) (scheme-report-environment 5))

    将返回一个带有一个参数的函数，该函数(* x x)将对给定的值求导x（我在这里假设是 R5RS，因为我没有 Chez Scheme）：

    > (let ((d (eval `(lambda (x) ,(derive 'x '(* x x))) (scheme-report-environment 5))))
    (d 1))
2

    或者，可以说更好（当然也更安全）的是，你可以编写一个符号表达式求值器。这也是 R5RS：

    (define (evaluate-symbolic-expression expression bindings)
  ;; Evaluate a symbolic expression in the presence of bindings
  (cond
    ((number? expression)
     expression)
    ((symbol? expression)
     (let ((found (assq expression bindings)))
       (if found
           (evaluate-symbolic-expression (cadr found) bindings)
           expression)))
    ((pair? expression)
     (apply-symbolic-operator
      (car expression)
      (map (lambda (e) (evaluate-symbolic-expression e bindings))
           (cdr expression))
      bindings))
    (else
     expression)))

(define (all-numbers? l)
  (cond
    ((null? l)
     #t)
    ((number? (car l))
     (all-numbers? (cdr l)))
    (else
     #f)))

(define (apply-symbolic-operator op args bindings)
  (if (all-numbers? args)
      (let ((f (assq op bindings)))
        (if f
         (apply (cadr f) args)
         `(,op ,@args)))
      `(,op ,@args)))

(define arithmetic-operator-bindings
  `((+ ,+)
    (- ,-)
    (* ,*)
    (/ ,/)))

    现在

    > (evaluate-symbolic-expression
   (derive 'x '(* x x))
   (append '((x 4)) arithmetic-operator-bindings))
8

    evaluate-symbolic-expression可以写得更清楚些：它开始为本质上很小的 Lisp-2 实现一个评估器，但是我改变了它，而且懒得重做这一切。

    • 2

相关问题