This library contains a collection of machine learning algorithms for online linear classification written in Common Lisp.

clingon is a command-line option parsing library for Common Lisp. Its features include:

• Support for subcommands

• Support for command aliases

• Support for short and long options

• Related options may be grouped into categories

• Short options may be collapsed into a single argument, as in -xyz

• Long options support the notations --long-opt arg and --long-opt=arg

• Automatic generation of help/usage information for commands and subcommands

• Out-of-the-box support for --version and --help

• Support for various kinds of options including string, integer, boolean, switch, enum, list, counter, filepath, etc.

• Subcommands can look up global options defined in parent commands

• Support for required options

• Options can be initialized via environment variables

• Single interface for creating options using CLINGON:MAKE-OPTION

• Generate documentation for your command-line application

• Support for pre-hook and post-hook actions for commands, which allow invoking functions before and after the respective handler of the command is executed

• Support for Bash and Zsh completions

• Extensibility, so if you don't find something you need you can extend it by developing a new option kind, or even a new mechanism for initializing options, e.g., by looking up an external key/value store

The purpose of this library is to provide a collection of implementations of trees.

In contrast to existing libraries such as cl-containers, it does not impose a particular use for the trees. Instead, it aims for a stratified design, allowing client code to choose between different levels of abstraction.

As a consequence of this policy, low-level interfaces are provided where the concrete representation is exposed, but also high level interfaces where the trees can be used as search trees or as trees that represent sequences of objects.

cl-inotify uses cl-cffi to provide a Common Lisp interface to the Linux inotify API.

ORG-SAMPLER allows using Lisp docstrings and reflection to make org-mode text for inclusion into a larger document.

Inquisitor is a cross-implementation library providing encoding/end-of-line detection and external-format abstraction for Common Lisp.

cl-num-utils implements simple numerical functions for Common Lisp, including:

• num=, a comparison operator for floats

• simple arithmeric functions, like sum and l2norm

• elementwise operations for arrays

• intervals

• special matrices and shorthand for their input

• sample statistics

• Chebyshev polynomials

• univariate rootfinding

MAP-BIND is a macro that allows visual grouping of variables with their corresponding values in calls to mapping operators when using an inline LAMBDA.

This library allows you to implement and enforce proper finalization of compile-time constructs while building Lisp source files.

It produces two systems: asdf-finalizers and list-of.

Alloy is a user interface toolkit. It is defined through a set of protocols that allow for a clear interface, as well as a standardised way to integrate Alloy into a target backend.

This package provides a safer variant of READ secure against internbombing, excessive input and macro characters.

CL-Ledger is a Common Lisp port of the Ledger double-entry accounting system.

This is a Common Lisp utilities library originating from the Zombie Raptor game engine project.

Funds provides portable, purely functional data structures in Common Lisp. It includes tree based implementations for Array, Hash, Queue, Stack, and Heap.

Utility library for handling bit vectors, bit vector arithmetic, and universal integer type conversions between bit-vectors, byte-vectors, octals, decimals, and hexadecimal notation.

This package provides a grab bag of miscellaneous Common Lisp utilities.

A client for the Stripe payment API.

This library provides a tiny Common Lisp wrapper around setlocale(3) and can be used in conjunction with other FFI wrappers like cl-charms.

Antik provides a foundation for scientific and engineering computation in Common Lisp. It is designed not only to facilitate numerical computations, but to permit the use of numerical computation libraries and the interchange of data and procedures, whether foreign (non-Lisp) or Lisp libraries. It is named after the Antikythera mechanism, one of the oldest examples of a scientific computer known.

cl-random is a library for generating random draws from various commonly used distributions, and for calculating statistical functions, such as density, distribution and quantiles for these distributions.

This package provides a PEM (Privacy-Enhanced Mail) parser for Common Lisp.

Py4CL is a bridge between Common Lisp and Python, which enables Common Lisp to interact with Python code. It uses streams to communicate with a separate python process, the approach taken by cl4py. This is different to the CFFI approach used by burgled-batteries, but has the same goal.

This lisp library handles physical quantities which consist of

• value / magnitude

• uncertainty / error

• unit

where the type of the value can be any subtype of real. For the uncertainty, both absolute and relative values are possible. Combinations of lisp symbols or strings are used to describe units. User defined units including abbreviations and prefixes are supported. Error propagation and unit checking is performed for all defined operations.

This Common Lisp library provides a series data structure much like a sequence, with similar kinds of operations. The difference is that in many situations, operations on series may be composed functionally and yet execute iteratively, without the need to construct intermediate series values explicitly. In this manner, series provide both the clarity of a functional programming style and the efficiency of an iterative programming style.