/ snuggs Public

Snuggs are s-expressions for Numpy

# mapbox/snuggs

Switch branches/tags
Nothing to show

A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior. Are you sure you want to create this branch?

## Latest commit

`e985263`

## Files

Failed to load latest commit information.
Type
Name
Commit time

# snuggs

Snuggs are s-expressions for Numpy

```>>> snuggs.eval("(+ (asarray 1 1) (asarray 2 2))")
array([3, 3])```

## Syntax

Snuggs wraps Numpy in expressions with the following syntax:

```expression = "(" (operator | function) *arg ")"
arg = expression | name | number | string
```

## Examples

```import snuggs
snuggs.eval('(+ 1 2)')
# 3```

### Multiplication of a number and an array

Arrays can be created using `asarray`.

```snuggs.eval("(* 3.5 (asarray 1 1))")
# array([ 3.5,  3.5])```

### Evaluation context

Expressions can also refer by name to arrays in a local context.

```snuggs.eval("(+ (asarray 1 1) b)", b=np.array([2, 2]))
# array([3, 3])```

This local context may be provided using keyword arguments (e.g., `b=np.array([2, 2])`), or by passing a dictionary that stores the keys and associated array values. Passing a dictionary, specifically an `OrderedDict`, is important when using a function or operator that references the order in which values have been provided. For example, the `read` function will lookup the i-th value passed:

```ctx = OrderedDict((
('a', np.array([5, 5])),
('b', np.array([2, 2]))
))
# array([3, 3])```

## Functions and operators

Arithmetic (`* + / -`) and logical (`< <= == != >= > & |`) operators are available. Members of the `numpy` module such as `asarray()`, `mean()`, and `where()` are also available.

```snuggs.eval("(mean (asarray 1 2 4))")
# 2.3333333333333335```
```snuggs.eval("(where (& tt tf) 1 0)",
tt=numpy.array([True, True]),
tf=numpy.array([True, False]))
# array([1, 0])```

## Higher-order functions

New in snuggs 1.1 are higher-order functions `map` and `partial`.

```snuggs.eval("((partial * 2) 2)")
# 4

snuggs.eval('(asarray (map (partial * 2) (asarray 1 2 3)))')
# array([2, 4, 6])```

## Performance notes

Snuggs makes simple calculator programs possible. None of the optimizations of, e.g., numexpr (multithreading, elimination of temporary data, etc) are currently available.

If you're looking to combine Numpy with a more complete Lisp, see Hy:

```=> (import numpy)
=> (* 2 (.asarray numpy [1 2 3]))
array([2, 4, 6])```

Snuggs are s-expressions for Numpy

13 tags

## Packages 0

No packages published