Liam Healy

three

typedef struct
  {
    double dat[2];
  }
gsl_complex;

gsl_complex gsl_complex_conjugate (gsl_complex z);

(fsbv:defcstruct (complex :constructor complex :deconstructor (realpart imagpart))
  (dat :double :count 2))
(defun complex-conjugate (complex-number)
  (fsbv:with-foreign-objects ((gslin 'complex complex-number))
    (object
     (fsbv:foreign-funcall "gsl_complex_conjugate" complex gslin complex)
     'complex)))

(complex-conjugate #c(3.0d0 4.0d0))
#C(3.0 -4.0)

typedef struct
  {
    double dat[2];
  }
gsl_complex;

typedef struct
  {
    float dat[2];
  }
gsl_complex_float;

(FOREIGN-FUNCALL "gsl_blas_caxpy" 
		 :DOUBLE (PACK-COMPLEX-AS-DOUBLE ALPHA) 
		 :POINTER (MPOINTER X) :POINTER (MPOINTER Y)
		 :INT)

(FOREIGN-FUNCALL "gsl_blas_zaxpy" 
		 :DOUBLE (REALPART ALPHA) 
		 :DOUBLE (IMAGPART ALPHA) 
		 :POINTER (MPOINTER X) :POINTER (MPOINTER Y) 
		 :INT)

> lx86cl64
Welcome to Clozure Common Lisp Version 1.2-r10552  (LinuxX8664)!
? (load "/usr/share/common-lisp/source/common-lisp-controller/common-lisp-controller.lisp")
? (common-lisp-controller:compile-common-lisp-controller-v5 "ccl")
(#P"/var/cache/common-lisp-controller/0/ccl/common-lisp-controller/common-lisp-controller.lx64fsl"
 #P"/var/cache/common-lisp-controller/0/ccl/cl-asdf/asdf.lx64fsl"
 #P"/var/cache/common-lisp-controller/0/ccl/cl-asdf/wild-modules.lx64fsl"
 #P"/var/cache/common-lisp-controller/0/ccl/common-lisp-controller/post-sysdef-install.lx64fsl")

? (load "/var/cache/common-lisp-controller/0/ccl/common-lisp-controller/common-lisp-controller.lx64fsl")
? (load "/var/cache/common-lisp-controller/0/ccl/cl-asdf/asdf.lx64fsl")
? (load "/var/cache/common-lisp-controller/0/ccl/cl-asdf/wild-modules.lx64fsl")
? (load "/var/cache/common-lisp-controller/0/ccl/common-lisp-controller/post-sysdef-install.lx64fsl")
? (common-lisp-controller:init-common-lisp-controller-v5 "ccl")
? (ccl:save-application "ccl-deb")

(clc:clc-require :asdf-system-connections)
(clc:clc-require :cl-base64)
(clc:clc-require :cl-ppcre)
(clc:clc-require :md5)
(clc:clc-require :port)
(clc:clc-require :iterate)
(clc:clc-require :cl-utilities)
(clc:clc-require :uffi)
(clc:clc-require :clsql-uffi)
(clc:clc-require :clsql-sqlite3)
(clc:clc-require :cffi)
(clc:clc-require :drakma)
(clc:clc-require :cl-html-parse)

(clc:clc-require :memoization)
 Error: The function CCL:ARGLIST is predefined in OpenMCL.
(use-package :iterate :cl-user)
> Error: Using #<Package "ITERATE"> in #<Package "COMMON-LISP-USER">
>        would cause name conflicts with symbols inherited by that package: 
>        ITERATE:TERMINATE  TERMINATE
 (clc:clc-require :trivial-http)
> Error: Module TRIVIAL-HTTP was not provided by any function on *MODULE-PROVIDER-FUNCTIONS*.

 aptitude install module-assistant build-essential
 aptitude install krb5-user krb5-clients
 aptitude install openafs-client openafs-modules-source openafs-krb5
 m-a prepare
 m-a a-i openafs
 invoke-rc.d openafs-client start

 kinit
 aklog

kinit user@OTHER.REALM
aklog -cell other.afs.server -k OTHER.REALM

  dd if=/dev/zero of=/some/local/dir count=nnnn bs=1M 
  mkfs.ext3 /some/local/dir
  mount /some/local/dir /var/cache/openafs -o loop

 git svn clone --stdlayout svn+ssh://public/repo/ /tmp/clnetsvn
 cd /tmp/clnetsvn
 git checkout -b trunk trunk
 git checkout -b ffa ffa

 git svn clone --stdlayout svn+ssh://private/repo/ /tmp/localsvn
 cd /tmp/localsvn
 git checkout -b trunk trunk
 git checkout -b pre-iospec tags/pre-iospec

 mkdir ~/staging; cd ~/staging; git init
 git remote add localsvn /tmp/localsvn
 git remote add clnetsvn /tmp/clnetsvn
 git fetch localsvn
 git fetch clnetsvn
 git checkout --no-track -b old localsvn/trunk
 git checkout --no-track -b pre-ffa clnetsvn/trunk
 git checkout --no-track -b master clnetsvn/ffa

 git diff old..6ed4d0626

 git rebase old master

 0069b7f5af9a90dde26de14c7c19ae92e4d9f38b eef416b5cb25797ae266cda2f28e0c56c1675437

 git checkout pre-ffa
 git filter-branch 646c623c193139ba491c3bccc6ff6dd26bfa4bdc..HEAD

 git remote add origin ssh://remote/repository
 git push --all origin
 git push --tags

=== sbcl:
= Missing build(s) on alpha,sparc
 This might need manual action from your side.
 See http://buildd.debian.org/pkg.cgi?pkg=sbcl
= No migration to testing for 585 days.
 See <http://release.debian.org/migration/testing.pl?package=sbcl>

#include <fenv.h>
trapfpe () {
  feenableexcept(FE_INVALID|FE_DIVBYZERO|FE_OVERFLOW);
}

#ifndef _TRAPFPE_H_
#define _TRAPFPE_H_

#include <sys/cdefs.h>

__BEGIN_DECLS
void trapfpe(void);
__END_DECLS

#endif /* _TRAPFPE_H_ */

(float-as-integer most-negative-single-float)
-2139095039
(float-as-integer least-negative-single-float)
-1
(float-as-integer -0.0f0)
0
(float-as-integer 0.0f0)
0
(float-as-integer least-positive-single-float)
1
(float-as-integer (- 1.0f0 single-float-negative-epsilon))
1065353215
(float-as-integer 1.0f0)
1065353216
(float-as-integer (+ 1.0f0 single-float-epsilon))
1065353217
(float-as-integer most-positive-single-float)
2139095039

(job 1)
(job 2)
(job 3)
...

(defparameter *job-lock* (sb-thread:make-mutex :name "job lock"))
(defparameter *results* (list nil))
(defvar *end-of-jobs* (make-symbol "EOJ"))
(defvar *jobs* nil)

(defun worker (job)
  (let ((my-job nil)
	(more-jobs t))
    (loop while more-jobs
       do
       (sb-thread:with-mutex (*job-lock*)
	 (setf more-jobs (or *jobs*))
	 (setf my-job (when more-jobs (pop *jobs*))))
       (when my-job			; there is a job to be done
	 (if (eq my-job *end-of-jobs*)
	     (setf more-jobs nil)
	     (let ((my-results (apply job my-job))) ; call the job outside the mutex
	       (sb-thread:with-mutex (*job-lock*)   ; save results
		 (push my-results *results*))))))))

(defun run-tasks (job dataset number-of-workers)
  "The job is a function that takes one non-null argument.
   The dataset is a list of arglist sets for the job.
   The number-of-workers is the number of workers desired, 
   presumably the number of processors available."
  (setf *jobs* (make-list number-of-workers :initial-element *end-of-jobs*)
	*results* (list nil))
  (dolist (ds dataset) (push ds *jobs*))
  (let ((threads (list nil)))
    (loop repeat number-of-workers
       do (push (sb-thread:make-thread (lambda () (worker job))) threads))
    (dolist (thread (butlast threads)) (sb-thread:join-thread thread))
    (butlast *results*)))

(defun job (x) (list x (+ (loop for i from 1 to 2000000 sum (let ((p (* i x))) (1- (expt p (/ p))))))))
(run-tasks #'job '((1) (2) (3) (4) (5) (6) (7) (8) (9) (10)) 2)
((1 105.73587) (2 58.11023) (3 41.245914) (4 31.676012) (5 26.053244)
 (6 22.305136) (7 19.607342) (8 17.642727) (9 15.433696) (10 14.060191))

M-x slime-toggle-profile-fdefinition
M-x slime-profile-reset
M-x slime-profile-report
sudo aptitude install libpcsclite1 pcsc-tools libccid coolkey

(in-package :sqlite3)

;;; Add mathematical and string functions to SQL queries using
;;; libsqlitefunctions from
;;; http://www.sqlite.org/contrib/download/extension-functions.c?get=22

(def-sqlite3-function
    "sqlite3_enable_load_extension"
    ((db sqlite3-db) (onoff :int))
 :returning :int)

(def-sqlite3-function
    "sqlite3_load_extension"
    ((db sqlite3-db)
     (filename :cstring)
     (entrypoint :int)
     (errmsg :int))
  :returning :int)

(eval-when  (:compile-toplevel :load-toplevel :execute)
  (export 'enable-sqlite3-extension-functions))

(defun enable-sqlite3-extension-functions (database)
  "Set up the SQLite3 mathematical extension functions.  This
   must be called every time the database is connected
   before any extension function is used."
  (let ((db-ptr (clsql-sqlite3::sqlite3-db database)))
    (sqlite3-enable-load-extension db-ptr 1)
    (unless (zerop
	     (sqlite3-load-extension db-ptr "libsqlitefunctions.so" 0 0))
      (error "Can't load libsqlitefunctions.so."))))

Liam Healy

GSLL using FSBV

Foreign structures by value

Regression (unit) test in Lisp, including float tests

Passing a complex number to a foreign function

GSLL new version

Clozure CL on Debian

AFS rides again

Using git to stitch together a broken subversion repository

SBCL in Debian testing (lenny): good news

SBCL in Debian testing (lenny)

Cairo for Lisp

Never a NaN or Inf

SBCL, libc6, and GCC

GNU Scientific Library for Lisp

Comparison of floating point numbers in Common Lisp

Multiprocessing lisp evaluations

lhealy @ 2008-01-05T12:45:00

Profiling in SLIME

DoD authentication in Iceweasel/Icedove

Extension functions in sqlite3, again

cl-mcclim out of date in Debian unstable

GMAT on Debian amd64

DRAKMA

Parsing HTML and memory fault from cl-curl

Math and string extension functions for SQLite