# Clojure Programming/Examples/API Examples/Data Structures

## Numbers

### Computation

##### +

Returns the sum of nums. (+) returns 0.

``` (+ [] [x] [x y] [x y & more]) ```

```user=> (+ 1 2 3) 6 user=> (map + [1 2 3] [1 1 2]) (2 3 5) ```
##### -

If no ys are supplied, returns the negation of x, else subtracts the ys from x and returns the result.

``` (- [x] [x y] [x y & more]) ```

```user=> (- 1 2 3) -4 user=> (- -1) 1 ```
##### *

Returns the product of nums. (*) returns 1.

``` (* [] [x] [x y] [x y & more]) ```

```user=> (* 1 2 3 4) 24 ```
##### /

If no denominators are supplied, returns 1/numerator, else returns numerator divided by all of the denominators.

``` (/ [x] [x y] [x y & more]) ```

```user=> (/ 1 4) 1/4 ```

#### inc

Returns a number one greater than num.

``` (inc [x]) ```

```user=> (inc 41) 42 user=> (inc 1/4) 5/4 ```

#### dec

Returns a number one less than num.

``` (dec [x]) ```

```user=> (dec 99) 98 user=> (map dec [2 3 4]) (1 2 3) ```

#### min

Returns the least of the nums.

``` (min [x] [x y] [x y & more]) ```

```user=> (min 2 -1 3) -1 ```

#### max

Returns the greatest of the nums.

``` (max [x] [x y] [x y & more]) ```

```user=> (max 2 -1 3) 3 ```

#### quot

Quotient of dividing numerator by denominator.

``` (quot [num div]) ```

```user=> (quot 4 2) 2 user=> (quot 5 2) 2 user=> (quot 6 2) 3 ```

#### rem

Remainder of dividing numerator by denominator.

``` (rem [num div]) ```

```user=> (rem 5 2) 1 user=> (rem 4 2) 0 ```

#### rationalize

Returns the rational value of num.

``` (rationalize [num]) ```

```user=> (rationalize 1.33) 133/100 user=> (rationalize 3.14159265) 62831853/20000000 user=> (rationalize (Math/sqrt 2)) 14142135623730951/10000000000000000 ```

### Comparison

#### ==

Returns non-nil if nums all have the same value, otherwise false.

`(== [x] [x y] [x y & more])`

```user=> (== (+ 1 2) 3) true user=> (== (+ 1 2) 3 2.999) false user=> (if (== 2 (+ 1 1)) (println "So easy!")) So easy! user=> (== true true) ;Be careful! Works only for nums. false user=> (= true true) ;= works like Java x.equals(y) true ```

#### <

Returns non-nil if nums are in monotonically increasing order, otherwise false.

`(< [x] [x y] [x y & more])`

```user=> (< 1 (Math/sqrt 2) (+ 1 1)) true user=> (< 5 5) false user=> (< 5) true ```

#### >

Returns non-nil if nums are in monotonically decreasing order, otherwise false.

`(> [x] [x y] [x y & more])`

```user=> (> 7 6 4 2) true user=> (> 2 4) false ```

#### <=

Returns non-nil if nums are in monotonically non-decreasing order, otherwise false.

`(<= [x] [x y] [x y & more])`

```user=> (<= 0 1 1) true ```

#### >=

Returns non-nil if nums are in monotonically non-increasing order, otherwise false.

`(>= [x] [x y] [x y & more])`

```user=> (>= 3 2 1) true ```

### Predicates

#### zero?

Returns true if num is zero, else false.

`(zero? [x])`

```user=> (zero? 0.01) false user=> (zero? 0) true ```

#### pos?

Returns true if num is greater than zero, else false.

`(pos? [x])`

```user=> (pos? 0) false user=> (pos? (Math/PI)) true user=> (filter pos? [-1 1 0 -1 5 2]) (1 5 2) ```

#### neg?

Returns true if num is less than zero, else false.

`(neg? [x])`

```user=> (neg? -1) true user=> (neg? 0) false ```

## Strings

#### str

```user=> (str "a" :b \c 3 4.5 6/7) "a:bc34.56/7" user=> (str [1 2]) "[1 2]" user=> (str 1 2) "12" user=> (str #(1)) "user\$eval__1289\$fn__1291@4f53dd" ```

## Characters

```user=> \a \a user=> (seq "a") \a user=> (seq " ") (\space) user=> (char 13) \return user=> (str \a \b \c) "abc" user=> (char? \z) true ```