(in-package :common-lisp-user)
(defpackage "WORD"
(:use :clim :clim-lisp)
(:export "WORD-MAIN"))
(in-package :word)
(define-application-frame word		;name
    ()					;superclasses
  ()					;slots
  ;; options
  (:panes				;panes option
   (title				;pane name 
    :title)	;pane type, такое, :title "bla bla", не пролезит
   (document				;pane name
    :application))			;pane type
  (:layouts				;layouts option
   (default				;layout name
       (vertically ()			;layout macros
	 (1/8 title)
	 (7/8 document)))))
(defun word-main ()
(run-frame-top-level (make-application-frame 'word :height 300 :width 300)))

(defgeneric dishes (obj)

(:method-combination progn)
;;;^^^^ option is available at http://www.lispworks.com/documentation/lw70/CLHS/Body/m_defgen.htm#defgeneric


(:method progn (obj)
;;;^^^ а эта опция где описана. 


(format t "- clean and dry.~&"))
(:method progn ((obj person))
(format t "- bring a person's dishes~&"))
(:method progn ((obj child))
(format t "- bring the baby dishes~&")))

(defclass coloured ()
  (colour))

(defclass coloured-circle (circle coloured)
  ())

(defclass rectangle ()
  (height width))

(defclass circle ()
  (radius))

(defvar r)
(defmethod area-r ((r rectangle))
  (* (slot-value r 'height)
     (slot-value r 'width)))

(defvar c)
(defmethod area-c ((c circle))
  (* pi (expt (slot-value c 'radius) 2)))

(let ((r (make-instance 'rectangle)))
  (setf (slot-value r 'height) 2
	(slot-value r 'width) 3)
  (area-r r))

(let ((c (make-instance 'circle)))
	(setf (slot-value c 'radius) 4)
  (area-c c))

(defvar cc)
(let ((cc (make-instance 'coloured-circle)))
  (setf (slot-value cc 'radius) 9)
  (area-c cc))

CL-USER> (defvar cc)
CC
CL-USER> (let ((cc (make-instance 'coloured-circle)))
  (setf (slot-value cc 'radius) 9)
  (area-c cc))

254.46900494077323d0
CL-USER> (type-of cc)
; Evaluation aborted on #<UNBOUND-VARIABLE CC {100460B1B3}>. ->

 какова техника поиска, что я проморгал? 

(defpackage "APP"
  (:use :clim :clim-lisp)
  (:export "BUTTONS-MAIN"))

(in-package :APP)
(defvar arg)
(defun press (button)
  (accepting-values (*query-io* :own-window t)
    (format *query-io* "~A" arg)))
(defun squeeze (button)
  (accepting-values (*query-io* :own-window t)
    (format *query-io* "~A" arg)))

(define-application-frame buttons	;name
    ()					;superclasses
  ()					;slots
  ;; options
  (:panes (button 
	   (horizontally ()
	     (make-pane 'push-button
			:label "squeeze"
			:activate-callback #'squeeze)
	     (make-pane 'push-button
			:label "press"
			:activate-callback #'press))) 
	  (application			;pane name 
	   :application))		;pane type ... :application is an extended-stream-pane
  (:layouts (default			;layout name
	     (vertically ()		;layout macros
	       (1/8 button) (7/8 application)))
	    (alternate			;layout name
	     (horizontally ()		;layout macros
	       (1/8 button) (7/8 application)))))

(defun buttons-main ()
  (run-frame-top-level
   (make-application-frame 'buttons :height 10 :width 10)))

; file: ~/Documents/using-panes-layouts.lisp
; in: DEFUN PRESS
;     (DEFUN APP::PRESS (APP::BUTTON)
;       (CLIM:ACCEPTING-VALUES (*QUERY-IO* :OWN-WINDOW T)
;         (FORMAT *QUERY-IO* "~A" APP::ARG)))
; 
; caught STYLE-WARNING:
;   The variable BUTTON is defined but never used.<- BUTTON ;     используется в BUTTONS !!!!!!!!!!!!!
; 
; compilation unit finished
;   caught 1 STYLE-WARNING condition

; file: ~/Documents/using-panes-layouts.lisp
; in: DEFUN SQUEEZE
;     (DEFUN APP::SQUEEZE (APP::BUTTON)
;       (CLIM:ACCEPTING-VALUES (*QUERY-IO* :OWN-WINDOW T)
;         (FORMAT *QUERY-IO* "~A" APP::ARG)))
; 
; caught STYLE-WARNING:
;   The variable BUTTON is defined but never used. <- BUTTON ;     используется в BUTTONS !!!!!!!!!!!!!
; 
; compilation unit finished
;   caught 1 STYLE-WARNING condition
T

$ ./lx86cl64 --version
Version 1.12 (v1.12) LinuxX8664

(ql:quickload "scigraph")
(in-package :graph)
(setq raw-data '((0 0) (1 -1.5) (2 3) (3 22) (4 8) (5 22)))
(setq dataset (make-instance 'graph-data
:symbologies '(:line-symbol)
:data raw-data))
(setq graph
(make-instance 'annotated-graph
:title "Some Data"
:x-label "Fortnights"
:y-label "Furlongs"))
(add-dataset graph dataset)
(view-graphs (list graph))

Stream #<BASIC-FILE-BINARY-INPUT-STREAM ("/usr/share/fonts/truetype/dejavu/DejaVuSansMono.ttf"/7 ISO-8859-1) #x302005C8D58D> is private to #<PROCESS Frame Top Level(14) [Reset] #x302005C73FED>
   [Condition of type SIMPLE-ERROR]

(defun rad-to-decimal-deg (alpha-rad)
  (/ (* alpha-rad 180) pi))

(rad-to-decimal-deg 0.0116) => 0.664631042351755
(rad-to-decimal-deg 0.0233) => 1.3349916626548182

(defun decimal-deg-to-dms (n)
  (setq d (round n))
  (setq m (* (- n d) 60))
  (setq s (- (* 3600 (- n d)) (* 60 m)))
  (format "%d° %d' %d''" d m s))

(decimal-deg-to-dms 0.664631042351755) => "1° -20' 0''"
(decimal-deg-to-dms 1.3349916626548182) => "1° 20' 0''"

(defun dms-to-rad (d m s)
  (+ (* d (/ pi 180))
     (* m (/ pi (* 180 60)))
     (* s (/ pi (* 180 60 60)))
     ))

            0˚8’0’’
(dms-to-rad 0 8 0) => 0.0023271056693257726
(rad-to-decimal-deg 0.0023271056693257726) => 0.13333333333333333
(decimal-deg-to-dms 0.13333333333333333) => "0° 8' 0''"

здесь всё как по Running Open Genera 2.0 on Linux
Standalone Site: Yes No
The local site is not the distribution site

  
Возможно ли из этого          
                                   Кс
  -------------------------------------------------------------------  
                           m
                   [1 + p  Σ  Ki τi / (1 – Ki)]  -  (1 – Кс) (1 – рτ)
                         i = 1    

получить вот это

                                                        1
                   ------------------------------------------------------   
                           m
                   1 + p  [Σ  Ki τi / (1 – Ki)  -  (1 – Кс) τ] / Кс   
                         i = 1   

(defun mappend (fn &rest lsts)
  "maps elements in list and finally appends all resulted lists."
  (apply #'append (apply #'mapcar fn lsts)))

(require 'debug)
(setq debug-on-quit t)
(setq x 2)
(setq n 3)
(setq r 1)
(while (< 0 n)
  (setq n (- n 1))
  (setq r (* r x)))   ;; такая версия нравится


(defun power (x n)
  (if (= 0 n)
      1
    (if (= 1 n)
	x
      (if (< 1 n)
	(setq r (* r (power x (- n 1))))))))
(trace-function 'power) ;; Lisp nesting exceeds ‘max-lisp-eval-depth’ не понятно где я накосячил аж Emacs виснет.
(power 2 3)

;;Этот алгоритм, просто супер, но результат, зараза, 7.9999999998
(defun pow (x n)
  (exp (* n (log x))))
(pow 2 3)

;; (defun fact (n)
;;    (if (= n 0) 1
;;      (* n (fact (1- n)))))
;;  fact
;;
;;  (trace-function 'fact)
;;  fact
;;
;;  Now, evaluating this...
;;
;;  (fact 4)
;;  24=============>   это да
;;
;;  ...will generate the following in *trace-buffer*: ==>ничего подобного
;;
;;  1 -> fact: n=4
;;  | 2 -> fact: n=3
;;  | | 3 -> fact: n=2
;;  | | | 4 -> fact: n=1
;;  | | | | 5 -> fact: n=0
;;  | | | | 5 <- fact: 1
;;  | | | 4 <- fact: 1
;;  | | 3 <- fact: 2
;;  | 2 <- fact: 6
;;  1 <- fact: 24
;;