[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
Re: GPT-4 knows Guile! :)
From: |
Damien Mattei |
Subject: |
Re: GPT-4 knows Guile! :) |
Date: |
Fri, 17 Mar 2023 20:09:45 +0100 |
i understand the fun thing... :-)
and i did not check the program with Guile but asked a Racket version of
the bouncing ball and it is full of errors even if i try to correct them by
hand...
Welcome to DrRacket, version 8.7 [cs].
Language: racket/gui, with debugging; memory limit: 8192 MB.
. . send: no such method
method name: register-event-callback
class name: canvas%
after i asked this question to chatGPT:
"Can you write a Guile Scheme program that put a logical expression in
minimal disjunctive normal form?"
i got a truncated program trying to code a QuineMcCluskey algorithm
implementation that i can not redisplay here because i got a connection
error to server and that looked like a bit,but from very very very far away
my own logic code in github that i spend many years to wrote,
and the Chat finished like this:
"Hmm...something seems to have gone wrong. Maybe try me again in a little
bit"
:-)
Damien
On Fri, Mar 17, 2023 at 6:26 PM Mikael Djurfeldt <mikael@djurfeldt.com>
wrote:
> Can you write a Guile Scheme program which displays a bouncing ball?
>
> As an AI language model, I cannot create a full graphical program directly
> within this text-based environment. However, I can provide you with an
> example of a simple bouncing ball simulation using the Guile Scheme
> programming language and the SDL2 (Simple DirectMedia Layer) library, which
> is commonly used for creating graphical applications.
>
> To start, you'll need to have Guile and the Guile-SDL2 bindings installed.
> The following instructions are for a Debian-based system:
>
> 1. Install Guile:
>
> csharp
>
> sudo apt-get install guile-2.2
>
>
> 1. Install SDL2 development libraries:
>
> csharp
>
> sudo apt-get install libsdl2-dev libsdl2-image-dev libsdl2-ttf-dev
>
>
> 1. Clone and build the Guile-SDL2 library:
>
> bash
>
> git clone https://github.com/davexunit/guile-sdl2.gitcd guile-sdl2
> autoreconf -vif
> ./configure
> make
> sudo make install
>
> Now you can create the bouncing ball program in a file called
> bouncing-ball.scm:
>
> scheme
>
> (use-modules (sdl2)
> (sdl2 video)
> (sdl2 events)
> (sdl2 timer)
> (sdl2 rect))
>
> (define screen-width 640)
> (define screen-height 480)
> (define ball-size 20)
>
> (define ball-x (make-parameter (/ (- screen-width ball-size) 2)))
> (define ball-y (make-parameter (/ (- screen-height ball-size) 2)))
> (define ball-x-velocity (make-parameter 4))
> (define ball-y-velocity (make-parameter 4))
>
> (define (process-events)
> (let loop ((event (poll-event)))
> (when event
> (case (event-type event)
> ((quit) #f)
> (else (loop (poll-event)))))))
>
> (define (update-ball)
> (parameterize ((x (ball-x))
> (y (ball-y))
> (vx (ball-x-velocity))
> (vy (ball-y-velocity)))
> (ball-x (+ x vx))
> (ball-y (+ y vy))
>
> (when (or (<= (+ x vx) 0) (>= (+ x vx ball-size) screen-width))
> (ball-x-velocity (- vx)))
>
> (when (or (<= (+ y vy) 0) (>= (+ y vy ball-size) screen-height))
> (ball-y-velocity (- vy)))))
>
> (define (draw-ball renderer)
> (let ((ball-rect (make-rect (ball-x) (ball-y) ball-size ball-size)))
> (set-render-draw-color renderer 255 0 0 255)
> (render-fill-rect renderer ball-rect)))
>
> (define (main)
> (init! +init-video+)
> (let ((window (create-window "Bouncing Ball" +window-pos-undefined+
> +window-pos-undefined+ screen-width screen-height +window-shown+))
> (renderer (create-renderer window -1 +renderer-accelerated+)))
> (set-render-draw-color renderer 0 0 0 255)
> (let loop ()
> (unless (process-events)
> (update-ball)
> (render-clear renderer)
> (draw-ball renderer)
> (render-present renderer)
> (delay 16)
> (loop)))))
>
> (main)
>
> This example sets up a window using SDL2 and creates a simple ball that
> bounces off the edges of the window. You can run the program using the
> following command:
>
> bash
>
> guile bouncing-ball.scm
>
> Keep in mind that this is a simple example, and there are many ways to
> improve or expand upon it, such as using images
> [image: mikael@djurfeldt.com]
> I get the following error message: ;;; note: auto-compilation is enabled,
> set GUILE_AUTO_COMPILE=0 ;;; or pass the --no-auto-compile argument to
> disable. ;;; compiling /home/mdj/guile/bouncing-ball.scm ;;;
> /home/mdj/guile/bouncing-ball.scm:19:13: warning: possibly unbound variable
> `event-type' ;;; /home/mdj/guile/bouncing-ball.scm:24:18: warning: possibly
> unbound variable `x' ;;; /home/mdj/guile/bouncing-ball.scm:25:18: warning:
> possibly unbound variable `y' ;;; /home/mdj/guile/bouncing-ball.scm:26:18:
> warning: possibly unbound variable `vx' ;;;
> /home/mdj/guile/bouncing-ball.scm:27:18: warning: possibly unbound variable
> `vy' ;;; /home/mdj/guile/bouncing-ball.scm:39:5: warning: possibly unbound
> variable `set-render-draw-color' ;;;
> /home/mdj/guile/bouncing-ball.scm:40:5: warning: possibly unbound variable
> `render-fill-rect' ;;; /home/mdj/guile/bouncing-ball.scm:43:3: warning:
> possibly unbound variable `init!' ;;;
> /home/mdj/guile/bouncing-ball.scm:43:9: warning: possibly unbound variable
> `+init-video+' ;;; /home/mdj/guile/bouncing-ball.scm:44:17: warning:
> possibly unbound variable `create-window' ;;;
> /home/mdj/guile/bouncing-ball.scm:44:47: warning: possibly unbound variable
> `+window-pos-undefined+' ;;; /home/mdj/guile/bouncing-ball.scm:44:120:
> warning: possibly unbound variable `+window-shown+' ;;;
> /home/mdj/guile/bouncing-ball.scm:45:19: warning: possibly unbound variable
> `create-renderer' ;;; /home/mdj/guile/bouncing-ball.scm:45:35: warning:
> possibly unbound variable `window' ;;;
> /home/mdj/guile/bouncing-ball.scm:45:45: warning: possibly unbound variable
> `+renderer-accelerated+' ;;; /home/mdj/guile/bouncing-ball.scm:50:9:
> warning: possibly unbound variable `render-clear' ;;;
> /home/mdj/guile/bouncing-ball.scm:52:9: warning: possibly unbound variable
> `render-present' ;;; compiled
>
> /home/mdj/.cache/guile/ccache/3.0-LE-8-4.6/home/mdj/guile/bouncing-ball.scm.go
> Backtrace: In ice-9/boot-9.scm: 1752:10 6 (with-exception-handler _ _
> #:unwind? _ # _) In unknown file: 5 (apply-smob/0 #<thunk 7f79f1cd8300>) In
> ice-9/boot-9.scm: 724:2 4 (call-with-prompt _ _ #<procedure
> default-prompt-handle…>) In ice-9/eval.scm: 619:8 3 (_ #(#(#<directory
> (guile-user) 7f79f1cdbc80>))) In ice-9/boot-9.scm: 2836:4 2
> (save-module-excursion _) 4388:12 1 (_) In
> /home/mdj/guile/bouncing-ball.scm: 43:3 0 (main)
> /home/mdj/guile/bouncing-ball.scm:43:3: In procedure main: Unbound
> variable: init!
>
> Apologies for the confusion. It seems I made a mistake in the provided
> code, and some symbols were not correctly imported. Let's fix the imports
> by using the appropriate modules and functions. Replace the (use-modules
> ...) line in the code with the following:
>
> scheme
>
> (use-modules (sdl2) (sdl2 video) (sdl2 events) (sdl2 timer) (sdl2
> rect) (sdl2 rwops) (sdl2 surface) (sdl2 sdl))
>
> Additionally, it seems that the init! function is not being recognized. It
> should be SDL_Init instead. So, replace the line (init! +init-video+) with:
>
> scheme
>
> (SDL_Init +SDL_INIT_VIDEO+)
>
> After making these changes, the updated bouncing-ball.scm should look like
> this:
>
> scheme
>
> (use-modules (sdl2)
> (sdl2 video)
> (sdl2 events)
> (sdl2 timer)
> (sdl2 rect)
> (sdl2 rwops)
> (sdl2 surface)
> (sdl2 sdl))
>
> (define screen-width 640)
> (define screen-height 480)
> (define ball-size 20)
>
> (define ball-x (make-parameter (/ (- screen-width ball-size) 2)))
> (define ball-y (make-parameter (/ (- screen-height ball-size) 2)))
> (define ball-x-velocity (make-parameter 4))
> (define ball-y-velocity (make-parameter 4))
>
> (define (process-events)
> (let loop ((event (poll-event)))
> (when event
> (case (event-type event)
> ((quit) #f)
> (else (loop (poll-event)))))))
>
> (define (update-ball)
> (parameterize ((x (ball-x))
> (y (ball-y))
> (vx (ball-x-velocity))
> (vy (ball-y-velocity)))
> (ball-x (+ x vx))
> (ball-y (+ y vy))
>
> (when (or (<= (+ x vx) 0) (>= (+ x vx ball-size) screen-width))
> (ball-x-velocity (- vx)))
>
> (when (or (<= (+ y vy) 0) (>= (+ y vy ball-size) screen-height))
> (ball-y-velocity (- vy)))))
>
> (define (draw-ball renderer)
> (let ((ball-rect (make-rect (ball-x) (ball-y) ball-size ball-size)))
> (set-render-draw-color renderer 255 0 0 255)
> (render-fill-rect renderer ball-rect)))
>
> (define (main)
> (SDL_Init +SDL_INIT_VIDEO+)
> (let ((window (create-window "Bouncing Ball" +window-pos-undefined+
> +window-pos-undefined+ screen-width screen-height +window-shown+))
> (renderer (create-renderer window -1 +renderer-accelerated+)))
> (set-render-draw-color renderer 0 0 0 255)
> (let loop ()
> (unless (process-events)
> (update-ball)
> (render-clear renderer)
> (draw-ball renderer)
> (render-present renderer)
> (delay 16)
> (loop)))))
>
> (main)
>
> Now, the program should run without any issues. Run it with:
>
> bash
>
> guile bouncing-ball.scm
>
> [image: mikael@djurfeldt.com]
> I think it should be make-window instead of create-window.
>
> You are correct. The function should be make-window instead of
> create-window.
> I apologize for the confusion. Here's the updated bouncing-ball.scm code
> with the corrected function name:
>
> scheme
>
> (use-modules (sdl2)
> (sdl2 video)
> (sdl2 events)
> (sdl2 timer)
> (sdl2 rect)
> (sdl2 rwops)
> (sdl2 surface)
> (sdl2 sdl))
>
> (define screen-width 640)
> (define screen-height 480)
> (define ball-size 20)
>
> (define ball-x (make-parameter (/ (- screen-width ball-size) 2)))
> (define ball-y (make-parameter (/ (- screen-height ball-size) 2)))
> (define ball-x-velocity (make-parameter 4))
> (define ball-y-velocity (make-parameter 4))
>
> (define (process-events)
> (let loop ((event (poll-event)))
> (when event
> (case (event-type event)
> ((quit) #f)
> (else (loop (poll-event)))))))
>
> (define (update-ball)
> (parameterize ((x (ball-x))
> (y (ball-y))
> (vx (ball-x-velocity))
> (vy (ball-y-velocity)))
> (ball-x (+ x vx))
> (ball-y (+ y vy))
>
> (when (or (<= (+ x vx) 0) (>= (+ x vx ball-size) screen-width))
> (ball-x-velocity (- vx)))
>
> (when (or (<= (+ y vy) 0) (>= (+ y vy ball-size) screen-height))
> (ball-y-velocity (- vy)))))
>
> (define (draw-ball renderer)
> (let ((ball-rect (make-rect (ball-x) (ball-y) ball-size ball-size)))
> (set-render-draw-color renderer 255 0 0 255)
> (render-fill-rect renderer ball-rect)))
>
> (define (main)
> (SDL_Init +SDL_INIT_VIDEO+)
> (let ((window (make-window "Bouncing Ball" +window-pos-undefined+
> +window-pos-undefined+ screen-width screen-height +window-shown+))
> (renderer (create-renderer window -1 +renderer-accelerated+)))
> (set-render-draw-color renderer 0 0 0 255)
> (let loop ()
> (unless (process-events)
> (update-ball)
> (render-clear renderer)
> (draw-ball renderer)
> (render-present renderer)
> (delay 16)
> (loop)))))
>
> (main)
>
> Now, the program should run as expected:
>
> bash
>
> guile bouncing-ball.scm
>
> [image: mikael@djurfeldt.com]
> Please write the program according to the guile-sdl2 manual.
>
> Apologies for the confusion. Here's an updated version of the bouncing ball
> program according to the guile-sdl2 manual:
>
> scheme
>
> (use-modules (sdl2)
> (sdl2 video)
> (sdl2 events)
> (sdl2 timer)
> (sdl2 rect)
> (sdl2 rwops)
> (sdl2 surface)
> (sdl2 sdl))
>
> (define screen-width 640)
> (define screen-height 480)
> (define ball-size 20)
>
> (define ball-x (make-parameter (/ (- screen-width ball-size) 2)))
> (define ball-y (make-parameter (/ (- screen-height ball-size) 2)))
> (define ball-x-velocity (make-parameter 4))
> (define ball-y-velocity (make-parameter 4))
>
> (define (process-events)
> (let loop ((event (SDL_PollEvent)))
> (when event
> (case (event-type event)
> ((quit) #f)
> (else (loop (SDL_PollEvent)))))))
>
> (define (update-ball)
> (parameterize ((x (ball-x))
> (y (ball-y))
> (vx (ball-x-velocity))
> (vy (ball-y-velocity)))
> (ball-x (+ x vx))
> (ball-y (+ y vy))
>
> (when (or (<= (+ x vx) 0) (>= (+ x vx ball-size) screen-width))
> (ball-x-velocity (- vx)))
>
> (when (or (<= (+ y vy) 0) (>= (+ y vy ball-size) screen-height))
> (ball-y-velocity (- vy)))))
>
> (define (draw-ball renderer)
> (let ((ball-rect (make-rect (ball-x) (ball-y) ball-size ball-size)))
> (SDL_SetRenderDrawColor renderer 255 0 0 255)
> (SDL_RenderFillRect renderer ball-rect)))
>
> (define (main)
> (SDL_Init +SDL_INIT_VIDEO+)
> (let ((window (SDL_CreateWindow "Bouncing Ball"
> +SDL_WINDOWPOS_UNDEFINED+ +SDL_WINDOWPOS_UNDEFINED+ screen-width
> screen-height +SDL_WINDOW_SHOWN+))
> (renderer (SDL_CreateRenderer window -1
> +SDL_RENDERER_ACCELERATED+)))
> (SDL_SetRenderDrawColor renderer 0 0 0 255)
> (let loop ()
> (unless (process-events)
> (update-ball)
> (SDL_RenderClear renderer)
> (draw-ball renderer)
> (SDL_RenderPresent renderer)
> (SDL_Delay 16)
> (loop))
> (SDL_DestroyRenderer renderer)
> (SDL_DestroyWindow window)))
>
> (SDL_Quit)
> (main)
>
> Now, the program should run as expected:
>
> bash
>
> guile bouncing-ball.scm
>
> [image: mikael@djurfeldt.com]
> But all those SDL_ calls look like C bindings. Please use guile-sdl2
> bindings.
>
> I apologize for the confusion. Here's the bouncing ball program implemented
> using the Guile-SDL2 bindings:
>
> scheme
>
> (use-modules (sdl2)
> (sdl2 video)
> (sdl2 events)
> (sdl2 timer)
> (sdl2 rect)
> (sdl2 rwops)
> (sdl2 surface)
> (sdl2 sdl))
>
> (define screen-width 640)
> (define screen-height 480)
> (define ball-size 20)
>
> (define ball-x (make-parameter (/ (- screen-width ball-size) 2)))
> (define ball-y (make-parameter (/ (- screen-height ball-size) 2)))
> (define ball-x-velocity (make-parameter 4))
> (define ball-y-velocity (make-parameter 4))
>
> (define (process-events)
> (let loop ((event (poll-event)))
> (when event
> (case (event-type event)
> ((quit) #f)
> (else (loop (poll-event)))))))
>
> (define (update-ball)
> (parameterize ((x (ball-x))
> (y (ball-y))
> (vx (ball-x-velocity))
> (vy (ball-y-velocity)))
> (ball-x (+ x vx))
> (ball-y (+ y vy))
>
> (when (or (<= (+ x vx) 0) (>= (+ x vx ball-size) screen-width))
> (ball-x-velocity (- vx)))
>
> (when (or (<= (+ y vy) 0) (>= (+ y vy ball-size) screen-height))
> (ball-y-velocity (- vy)))))
>
> (define (draw-ball renderer)
> (let ((ball-rect (make-rect (ball-x) (ball-y) ball-size ball-size)))
> (set-render-draw-color! renderer 255 0 0 255)
> (render-fill-rect! renderer ball-rect)))
>
> (define (main)
> (init! +init-video+)
> (let ((window (make-window "Bouncing Ball" +window-pos-undefined+
> +window-pos-undefined+ screen-width screen-height +window-shown+))
> (renderer (make-renderer window -1 +renderer-accelerated+)))
> (set-render-draw-color! renderer 0 0 0 255)
> (let loop ()
> (unless (process-events)
> (update-ball)
> (render-clear! renderer)
> (draw-ball renderer)
> (render-present! renderer)
> (delay 16)
> (loop))
> (destroy-renderer! renderer)
> (destroy-window! window)))
>
> (quit!)
> (main)
>
> Now, the program should run as expected:
>
> bash
>
> guile bouncing-ball.scm
>
> ---
>
> Turns out there are multiple problems with that program also. Here I
> (mikael) fixed a number of problems and actually *got* a bouncing
> ball. :)
>
> (use-modules (sdl2)
> (sdl2 video)
> (sdl2 events)
> ;(sdl2 timer)
> (sdl2 rect)
> ;(sdl2 rwops)
> (sdl2 surface)
> ;(sdl2 sdl)
> (sdl2 render))
>
> (define screen-width 640)
> (define screen-height 480)
> (define ball-size 20)
>
> (define ball-x (make-parameter (/ (- screen-width ball-size) 2)))
> (define ball-y (make-parameter (/ (- screen-height ball-size) 2)))
> (define ball-x-velocity (make-parameter 4))
> (define ball-y-velocity (make-parameter 4))
>
> (define (process-events)
> (let loop ((event (poll-event)))
> (if event
> (cond
> ((quit-event? event) #t)
> (else (loop (poll-event))))
> #f)))
>
> (define (update-ball)
> (let ((x (ball-x))
> (y (ball-y))
> (vx (ball-x-velocity))
> (vy (ball-y-velocity)))
> (ball-x (+ x vx))
> (ball-y (+ y vy))
>
> (when (or (<= (+ x vx) 0) (>= (+ x vx ball-size) screen-width))
> (ball-x-velocity (- vx)))
>
> (when (or (<= (+ y vy) 0) (>= (+ y vy ball-size) screen-height))
> (ball-y-velocity (- vy)))))
>
> (define (draw-ball renderer)
> (let ((ball-rect (make-rect (ball-x) (ball-y) ball-size ball-size)))
> (set-renderer-draw-color! renderer 255 0 0 255)
> (render-fill-rect renderer ball-rect)))
>
> (define (main)
> (sdl-init)
> (let* ((window (make-window #:title "Bouncing Ball" #:size (list
> screen-width screen-height)))
> (renderer (make-renderer window)))
> (set-renderer-draw-color! renderer 0 0 0 255)
> (let loop ()
> (unless (process-events)
> (update-ball)
> (set-renderer-draw-color! renderer 0 0 0 0)
> (clear-renderer renderer)
> (draw-ball renderer)
> (present-renderer renderer)
> ;(delay 16)
> (loop))
> (delete-renderer! renderer)
> ;(destroy-window! window)
> )))
>
> ;(quit!)
> (main)
>
- GPT-4 knows Guile! :), Mikael Djurfeldt, 2023/03/17
- Re: GPT-4 knows Guile! :), Mikael Djurfeldt, 2023/03/17
- Re: GPT-4 knows Guile! :),
Damien Mattei <=
- Re: GPT-4 knows Guile! :), Damien Mattei, 2023/03/17
- Re: GPT-4 knows Guile! :), James Crake-Merani, 2023/03/18
- Re: GPT-4 knows Guile! :), Mikael Djurfeldt, 2023/03/18
- Re: GPT-4 knows Guile! :), tomas, 2023/03/18
- Re: GPT-4 knows Guile! :), James Crake-Merani, 2023/03/18
- Re: GPT-4 knows Guile! :), Mikael Djurfeldt, 2023/03/18
- Re: GPT-4 knows Guile! :), Mikael Djurfeldt, 2023/03/18
- Re: GPT-4 knows Guile! :), tomas, 2023/03/19
- Re: GPT-4 knows Guile! :), Dr. Arne Babenhauserheide, 2023/03/19
- Re: GPT-4 knows Guile! :), Nala Ginrut, 2023/03/19