1D vector: Vec[T] #

import org.saddle._
import org.saddle.order._

Factories #

import org.saddle._
Vec(1, 2, 3)  
// res0: Vec[Int] = [3 x 1]
// 1
// 2
// 3
//   
Vec(1 to 3 : _*)    
// res1: Vec[Int] = [3 x 1]
// 1
// 2
// 3
//     
Vec(Array(1,2,3))
// res2: Vec[Int] = [3 x 1]
// 1
// 2
// 3
// 
Vec.empty[Double] 
// res3: Vec[Double] = Empty Vec 

vec.ones(2)
// res4: Vec[Double] = [2 x 1]
// 1.0000
// 1.0000
// 
vec.zeros(3)
// res5: Vec[Double] = [3 x 1]
// 0.0000
// 0.0000
// 0.0000
// 
vec.rand(20)
// res6: Vec[Double] = [20 x 1]
// 0.4156
// 0.7939
// 0.7203
// 0.9872
// 0.3947
//  ... 
// 0.6707
// 0.9865
// 0.8451
// 0.0182
// 0.4917
//

Operations #

import org.saddle.ops.BinOps._

Vec(1,2,3) + Vec(4,5,6)
// res7: Vec[Int] = [3 x 1]
// 5
// 7
// 9
// 
Vec(1,2,3) * Vec(4,5,6)
// res8: Vec[Int] = [3 x 1]
//  4
// 10
// 18
// 
Vec(1,2,3) ** Vec(4,5,6)
// res9: Vec[Int] = [3 x 1]
//   1
//  32
// 729
//

Note above, that you have to import that BinOp instances.

An alternative set of instances are also available which inline the innermost in Mat and Vec operations:

// The macros package contains instances where the innermost loop is inlined.
import org.saddle._
import org.saddle.macros.BinOps._  
Vec(1,2,3) + Vec(4,5,6)
// res11: Vec[Int] = [3 x 1]
// 5
// 7
// 9
// 
Vec(1,2,3) * Vec(4,5,6)
// res12: Vec[Int] = [3 x 1]
//  4
// 10
// 18
// 
Vec(1,2,3) ** Vec(4,5,6)
// res13: Vec[Int] = [3 x 1]
//   1
//  32
// 729
//

Slicing #

import org.saddle._
import org.saddle.ops.BinOps._
Vec(1,2,3).at(2) // Boxes and keeps NA
// res15: scalar.Scalar[Int] = Value(el = 3) // Boxes and keeps NA
Vec(1,2,3).raw(2)  
// res16: Int = 3  
Vec(1,2,3).apply(2) // same as raw
// res17: Int = 3 // same as raw
Vec(1,2,3).take(0,2)
// res18: Vec[Int] = [2 x 1]
// 1
// 3
// 
Vec(1,2,3).take(1 -> *)
// res19: Vec[Int] = [2 x 1]
// 2
// 3
// 
Vec(1,2,3).take(* -> 1)
// res20: Vec[Int] = [2 x 1]
// 1
// 2
//