Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Common Lisp Statistics -- based on LispStat (Tierney) but updated for Common Lisp and incorporating lessons from R (http://www.r-project.org/). See the google group for lisp stat / common lisp statistics for a mailing list.
Common Lisp TeX Other
tree: 1bf9aeb8ba

Fetching latest commit…

Cannot retrieve the latest commit at this time

Failed to load latest commit information.
ASDF
Data
Doc
bin
bugs
examples
lib
src
.gitignore
.gitmodules
Externals.org
LICENSE.mit
Makefile
README.org
TODO.org
cls-system.mbd
cls.asd
lib-deps.txt
lift-standard.config
ls-demo-ls1.lisp
ls-demo.lisp
sysdef.mbd
test-style.css
version.lisp-expr

README.org

Time-stamp: <2012-07-01 10:56:30 tony>

Fast Start

You probably did (preferred)

git clone git://github.com/blindglobe/common-lisp-stat.git

or (coming soon!) from within a Lisp instance,

(ql:quickload :cls)

set up git submodules to do the right thing.

  • State “TODO” from “” [2010-10-10 Sun 23:30]
git submodules init
git submodules update

to get the whole package.

Build shared library

_Obsolete_: Make the shared library liblispstat with an ANSI C compiler (only gcc tested at this point). This is used for numerical support which might be more robust to obtain from GSLL or similar other systems. It would be done via.

cd lib && make && cd

run a common lisp (SBCL, CMUCL, CLISP, CLOZURE-CL) starting in the current directory. Recent versions of CFFI and LIFT can be found in the external/ subdirectory, and should be autoload-able, assuming that you are using a Lisp implementation supporting ASDF. (AJR-FIXME: need to upload my GIT mirrors to repo.or.cz or similar, and have them potentially available as submodules if needed)

(on Debian or similar systems: can use CLC (Common Lisp Controller) or SBCL approaches, i.e. ~/.clc/systems or ~/.sbcl/systems should contain softlinks to the cls, cffi, and lift ASDF files (i.e. cls.asd, cffi.asd, and lift.asd). AJR-FIXME: There is probably a similar incantation for other CL’s, need to record that here!).

Step through ls-demo.lisp for a range of examples of activities.

Example Usage steps

change directory into the CommonLispStat working directory.

start your lisp

follow the commands in the ls-demo.lisp (need to add link) file, i.e.

(asdf:oos ‘asdf:load-op :cls)

use ASDF to load lispstat

(in-package :ls-user)

work in the scratch user package. Normally, one would create a special package to work in.

(normal-rand 20)

(setf mytest (normal-rand 20))

… (and so on) …

and see if they work (basic CFFI functionality for external C library, LIFT package for unit-testing framework to ensure run time stability).

Inform moi of problems or successes

mailto:blindglobe@gmail.com if there is anything wrong, or even if something happens to work.

Current beliefs:

  • CMUCL and SBCL seem to work just fine at this stage.
  • CLISP is finicky regarding the problems that we have with CFFI conversation. In particular that we can not really do typing that we need to take care of. I think this is my problem, not someone elses.
  • Need to test ECL. Clozure-CL seems to work.

History

See Doc/README* for history and design considerations See Doc/INSTALL for getting this to work and run

Working on your own modifications

git clone git://repo.or.cz/CommonLispStat.git 
cd CommonLispStat
git submodules init
git submodules update

will pull the whole repository, and create a “master” branch to work on. If you are making edits, which I’d like, you don’t want to use the master branch, but more to use a topic-centric branch, so you might:

git checkout -b myTopicBranch

and then work on myTopicBranch, pulling back to the master branch when needed by

git checkout master
git pull . myTopicBranch

(or

git rebase myTopicBranch

)

of course, perhaps you want to contribute to the mob branch. For that, after cloning the repository as above, you would:

git checkout -b mob remotes/origin/mob

(work, work, work… through a cycle of

       <edit>
	 git add <files just edited>
	 git commit -m "what I just did"

ad-nauseum. When ready to commit, then just:

git push git+ssh://mob@repo.or.cz/srv/git/CommonLispStat.git mob:mob

)

and it’ll be put on the mob branch, as a proposal for merging.

Another approach would be to pull from the topic branch into the mob branch before uploading. Will work on a formal example soon.

(the basic principle is that instead of the edit cycle on mob, do something like:

git checkout mob
git pull . myTopicBranch   
git push git+ssh://mob@repo.or.cz/srv/git/CommonLispStat.git mob:mob

)

Alternatively, one can work on the github repositories as well. They are a bit differently organized, and require one to get a github account and work from there. In that case, you’d need to D/L the libraries.

That gets a bit tricky, but see ./bin/GetRepos.sh for an example.

Documentation and examples

I’ve started putting examples of use in function documentation. If you are a lisp’er, you’ll find this pendantic and insulting. Many of the uses are trivial. However, this has been tested out on a number of research statisticians (the primary user audience) and found useful.

Still need to write the (run-doc-ex ‘function-name) function, which would print out the example and run it live. Hopefully with the same results. I’ve used XML markup for this, but for no particular reason, we could have used SEXPs as well. This is currently done by using an <example> tag set, as in

<example>
(progn
  (example-code-for-function))
</example>

Footnotes

[fn:1] I´m not including instructions for Emacs or git, as the former is dealt with other places and the latter was required for you to get this. Since disk space is cheap, I´m intentionally forcing git to be part of this system. Sorry if you hate it. Org-mode, org-babel, and org-babel-lisp, and hypo are useful for making this file a literate and interactively executable piece of work.

Something went wrong with that request. Please try again.