# Clojure Programming/Examples/API Examples/Data Structures

## NumbersEdit

### ComputationEdit

##### +Edit

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)
```
```
##### -Edit

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
```
```
##### *Edit

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

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

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

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
```
```

#### incEdit

Returns a number one greater than num.

`(inc [x])`

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

#### decEdit

Returns a number one less than num.

`(dec [x])`

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

#### minEdit

Returns the least of the nums.

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

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

#### maxEdit

Returns the greatest of the nums.

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

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

#### quotEdit

Quotient of dividing numerator by denominator.

`(quot [num div])`

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

#### remEdit

Remainder of dividing numerator by denominator.

`(rem [num div])`

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

#### rationalizeEdit

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
```
```

### ComparisonEdit

#### ==Edit

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
```
```

#### <Edit

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
```
```

#### >Edit

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
```
```

#### <=Edit

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

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

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

#### >=Edit

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

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

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

### PredicatesEdit

#### zero?Edit

Returns true if num is zero, else false.

`(zero? [x])`

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

#### pos?Edit

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?Edit

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

`(neg? [x])`

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

## StringsEdit

#### strEdit

``````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"
```
```

## CharactersEdit

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