Skip to content

Commit

Permalink
fixes to reduce functions
Browse files Browse the repository at this point in the history
  • Loading branch information
@jcanny
jcanny committed Jun 25, 2014
1 parent d25625d commit 1c1e4d4
Show file tree
Hide file tree
Showing 6 changed files with 74 additions and 73 deletions.
4 changes: 2 additions & 2 deletions src/main/scala/BIDMat/CMat.scala
View file
Original file line number Diff line number Diff line change
Expand Up @@ -732,8 +732,8 @@ case class CMat(nr:Int, nc:Int, data0:Array[Float]) extends DenseMat[Float](nr,
def ffReduceOp(n:Int, f1:(Float) => Float, f2:(Float, Float) => Float, out:Mat) =
CMat(ggReduceOp(n, f1, f2, out))

def ffReduceOpv(n:Int, f:(Array[Float],Int,Int,Array[Float],Int,Int,Array[Float],Int,Int,Int) => Float, out:Mat) =
CMat(ggReduceOpv(n, f, out))
def ffReduceOpv(n:Int, f1:(Float) => Float, f2:(Array[Float],Int,Int,Array[Float],Int,Int,Array[Float],Int,Int,Int) => Float, out:Mat) =
CMat(ggReduceOpv(n, f1, f2, out))

def ccReduceOpv(dim0:Int, opv:(Array[Float],Int,Int,Array[Float],Int,Int,Array[Float],Int,Int,Int) => Float, oldmat:Mat):CMat = {
var dim = if (nrows == 1 && dim0 == 0) 2 else math.max(1, dim0)
Expand Down
22 changes: 11 additions & 11 deletions src/main/scala/BIDMat/DMat.scala
View file
Original file line number Diff line number Diff line change
Expand Up @@ -161,8 +161,8 @@ case class DMat(nr:Int, nc:Int, data0:Array[Double]) extends DenseMat[Double](nr

def ddReduceOp(n:Int, f1:(Double) => Double, f2:(Double, Double) => Double, out:Mat) = DMat(ggReduceOp(n, f1, f2, out))

def ddReduceOpv(n:Int, f:(Array[Double],Int,Int,Array[Double],Int,Int,Array[Double],Int,Int,Int) => Double, out:Mat) =
DMat(ggReduceOpv(n, f, out))
def ddReduceOpv(n:Int, f1:(Double) => Double, f2:(Array[Double],Int,Int,Array[Double],Int,Int,Array[Double],Int,Int,Int) => Double, out:Mat) =
DMat(ggReduceOpv(n, f1, f2, out))

def ddReduceAll(n:Int, f1:(Double) => Double, f2:(Double, Double) => Double, out:Mat) =
DMat(ggReduceAll(n, f1, f2, out))
Expand Down Expand Up @@ -1049,9 +1049,9 @@ object DMat {
}

def vecAdd(a:Array[Double], a0:Int, ainc:Int, b:Array[Double], b0:Int, binc:Int, c:Array[Double], c0:Int, cinc:Int, n:Int):Double = {
var ai = a0; var bi = b0; var ci = c0; var cend = c0 + n
while (ci < cend) {
c(ci) = a(ai) + b(bi); ai += ainc; bi += binc; ci += cinc
var ai = a0; var bi = b0; var ci = c0; var i = 0
while (i < n) {
c(ci) = a(ai) + b(bi); ai += ainc; bi += binc; ci += cinc; i += 1
}
0
}
Expand All @@ -1073,17 +1073,17 @@ object DMat {
}

def vecMax(a:Array[Double], a0:Int, ainc:Int, b:Array[Double], b0:Int, binc:Int, c:Array[Double], c0:Int, cinc:Int, n:Int):Double = {
var ai = a0; var bi = b0; var ci = c0; var cend = c0 + n
while (ci < cend) {
c(ci) = math.max(a(ai), b(bi)); ai += ainc; bi += binc; ci += cinc
var ai = a0; var bi = b0; var ci = c0; var i = 0
while (i < n) {
c(ci) = math.max(a(ai), b(bi)); ai += ainc; bi += binc; ci += cinc; i += 1
}
0
}

def vecMin(a:Array[Double], a0:Int, ainc:Int, b:Array[Double], b0:Int, binc:Int, c:Array[Double], c0:Int, cinc:Int, n:Int):Double = {
var ai = a0; var bi = b0; var ci = c0; var cend = c0 + n
while (ci < cend) {
c(ci) = math.min(a(ai), b(bi)); ai += ainc; bi += binc; ci += cinc
var ai = a0; var bi = b0; var ci = c0; var i = 0
while (i < n) {
c(ci) = math.min(a(ai), b(bi)); ai += ainc; bi += binc; ci += cinc; i += 1
}
0
}
Expand Down
6 changes: 3 additions & 3 deletions src/main/scala/BIDMat/DenseMat.scala
View file
Original file line number Diff line number Diff line change
Expand Up @@ -987,14 +987,14 @@ class DenseMat[@specialized(Double,Float,Int,Byte) T]
throw new RuntimeException("index must 1 or 2");
}

def ggReduceOpv(dim0:Int, opv:(Array[T],Int,Int,Array[T],Int,Int,Array[T],Int,Int,Int) => T, oldmat:Mat):DenseMat[T] = {
def ggReduceOpv(dim0:Int, op1:(T) => T, opv:(Array[T],Int,Int,Array[T],Int,Int,Array[T],Int,Int,Int) => T, oldmat:Mat):DenseMat[T] = {
var dim = if (nrows == 1 && dim0 == 0) 2 else math.max(1, dim0)
if (dim == 1) {
val out = DenseMat.newOrCheck[T](1, ncols, oldmat, GUID, 1, opv.hashCode)
Mat.nflops += length
var i = 0
while (i < ncols) {
out.data(i) = data(i*nrows)
out.data(i) = op1(data(i*nrows))
opv(data, i*nrows+1, 1, out.data, i, 0, out.data, i, 0, nrows-1)
i += 1
}
Expand All @@ -1004,7 +1004,7 @@ class DenseMat[@specialized(Double,Float,Int,Byte) T]
Mat.nflops += length
var j = 0
while (j < nrows) {
out.data(j) = data(j)
out.data(j) = op1(data(j))
j += 1
}
var i = 1
Expand Down
22 changes: 11 additions & 11 deletions src/main/scala/BIDMat/FMat.scala
View file
Original file line number Diff line number Diff line change
Expand Up @@ -148,8 +148,8 @@ case class FMat(nr:Int, nc:Int, data0:Array[Float]) extends DenseMat[Float](nr,
def ffReduceOp(n:Int, f1:(Float) => Float, f2:(Float, Float) => Float, out:Mat) =
FMat(ggReduceOp(n, f1, f2, out))

def ffReduceOpv(n:Int, f:(Array[Float],Int,Int,Array[Float],Int,Int,Array[Float],Int,Int,Int) => Float, out:Mat) =
FMat(ggReduceOpv(n, f, out))
def ffReduceOpv(n:Int, f1:(Float) => Float, f2:(Array[Float],Int,Int,Array[Float],Int,Int,Array[Float],Int,Int,Int) => Float, out:Mat) =
FMat(ggReduceOpv(n, f1, f2, out))

def ffReduceAll(n:Int, f1:(Float) => Float, f2:(Float, Float) => Float, out:Mat) =
FMat(ggReduceAll(n, f1, f2, out))
Expand Down Expand Up @@ -1297,9 +1297,9 @@ object FMat {
}

def vecAdd(a:Array[Float], a0:Int, ainc:Int, b:Array[Float], b0:Int, binc:Int, c:Array[Float], c0:Int, cinc:Int, n:Int):Float = {
var ai = a0; var bi = b0; var ci = c0; var cend = c0 + n
while (ci < cend) {
c(ci) = a(ai) + b(bi); ai += ainc; bi += binc; ci += cinc
var ai = a0; var bi = b0; var ci = c0; var i = 0
while (i < n) {
c(ci) = a(ai) + b(bi); ai += ainc; bi += binc; ci += cinc; i += 1
}
0
}
Expand Down Expand Up @@ -1329,17 +1329,17 @@ object FMat {
}

def vecMax(a:Array[Float], a0:Int, ainc:Int, b:Array[Float], b0:Int, binc:Int, c:Array[Float], c0:Int, cinc:Int, n:Int):Float = {
var ai = a0; var bi = b0; var ci = c0; var cend = c0 + n
while (ci < cend) {
c(ci) = math.max(a(ai), b(bi)); ai += ainc; bi += binc; ci += cinc
var ai = a0; var bi = b0; var ci = c0; var i = 0
while (i < n) {
c(ci) = math.max(a(ai), b(bi)); ai += ainc; bi += binc; ci += cinc; i += 1
}
0
}

def vecMin(a:Array[Float], a0:Int, ainc:Int, b:Array[Float], b0:Int, binc:Int, c:Array[Float], c0:Int, cinc:Int, n:Int):Float = {
var ai = a0; var bi = b0; var ci = c0; var cend = c0 + n
while (ci < cend) {
c(ci) = math.min(a(ai), b(bi)); ai += ainc; bi += binc; ci += cinc
var ai = a0; var bi = b0; var ci = c0; var i = 0
while (i < n) {
c(ci) = math.min(a(ai), b(bi)); ai += ainc; bi += binc; ci += cinc; i += 1
}
0
}
Expand Down
21 changes: 11 additions & 10 deletions src/main/scala/BIDMat/IMat.scala
View file
Original file line number Diff line number Diff line change
Expand Up @@ -119,7 +119,8 @@ case class IMat(nr:Int, nc:Int, data0:Array[Int]) extends DenseMat[Int](nr, nc,

def iiReduceOp(n:Int, f1:(Int) => Int, f2:(Int, Int) => Int, old:Mat) = IMat(ggReduceOp(n, f1, f2, old))

def iiReduceOpv(n:Int, f:(Array[Int],Int,Int,Array[Int],Int,Int,Array[Int],Int,Int,Int) => Int, old:Mat) = IMat(ggReduceOpv(n, f, old))
def iiReduceOpv(n:Int, f1:(Int) => Int, f2:(Array[Int],Int,Int,Array[Int],Int,Int,Array[Int],Int,Int,Int) => Int, old:Mat) =
IMat(ggReduceOpv(n, f1, f2, old))

def iiReduceAll(n:Int, f1:(Int) => Int, f2:(Int, Int) => Int, old:Mat) = IMat(ggReduceAll(n, f1, f2, old))

Expand Down Expand Up @@ -747,9 +748,9 @@ object IMat {
}

def vecAdd(a:Array[Int], a0:Int, ainc:Int, b:Array[Int], b0:Int, binc:Int, c:Array[Int], c0:Int, cinc:Int, n:Int):Int = {
var ai = a0; var bi = b0; var ci = c0; var cend = c0 + n
while (ci < cend) {
c(ci) = a(ai) + b(bi); ai += ainc; bi += binc; ci += cinc
var ai = a0; var bi = b0; var ci = c0; var i = 0
while (i < n) {
c(ci) = a(ai) + b(bi); ai += ainc; bi += binc; ci += cinc; i += 1
}
0
}
Expand Down Expand Up @@ -779,17 +780,17 @@ object IMat {
}

def vecMax(a:Array[Int], a0:Int, ainc:Int, b:Array[Int], b0:Int, binc:Int, c:Array[Int], c0:Int, cinc:Int, n:Int):Int = {
var ai = a0; var bi = b0; var ci = c0; var cend = c0 + n
while (ci < cend) {
c(ci) = math.max(a(ai), b(bi)); ai += ainc; bi += binc; ci += cinc
var ai = a0; var bi = b0; var ci = c0; var i = 0
while (i < n) {
c(ci) = math.max(a(ai), b(bi)); ai += ainc; bi += binc; ci += cinc; i += 1
}
0
}

def vecMin(a:Array[Int], a0:Int, ainc:Int, b:Array[Int], b0:Int, binc:Int, c:Array[Int], c0:Int, cinc:Int, n:Int):Int = {
var ai = a0; var bi = b0; var ci = c0; var cend = c0 + n
while (ci < cend) {
c(ci) = math.min(a(ai), b(bi)); ai += ainc; bi += binc; ci += cinc
var ai = a0; var bi = b0; var ci = c0; var i = 0
while (i < n) {
c(ci) = math.min(a(ai), b(bi)); ai += ainc; bi += binc; ci += cinc; i += 1
}
0
}
Expand Down
72 changes: 36 additions & 36 deletions src/main/scala/BIDMat/SciFunctions.scala
View file
Original file line number Diff line number Diff line change
Expand Up @@ -459,81 +459,81 @@ object SciFunctions {

def min(a:DMat, b:DMat) = a.ddMatOpv(b, DMat.vecMinFun, null)
def max(a:DMat, b:DMat) = a.ddMatOpv(b, DMat.vecMaxFun, null)
def sum(a:DMat, n:Int) = a.ddReduceOp(n, DMat.idFun, DMat.sumFun, null)
def sum(a:DMat, n:Int) = a.ddReduceOpv(n, DMat.idFun, DMat.vecAddFun, null)
def cumsum(a:DMat, n:Int) = a.ddReduceAll(n, DMat.idFun, DMat.sumFun, null)
def maxi(a:DMat, n:Int) = a.ddReduceOp(n, DMat.idFun, DMat.maxFun, null)
def mini(a:DMat, n:Int):DMat = a.ddReduceOp(n, DMat.idFun, DMat.minFun, null)
def sum(a:DMat) = a.ddReduceOp(0, DMat.idFun, DMat.sumFun, null)
def maxi(a:DMat, n:Int) = a.ddReduceOpv(n, DMat.idFun, DMat.vecMaxFun, null)
def mini(a:DMat, n:Int):DMat = a.ddReduceOpv(n, DMat.idFun, DMat.vecMinFun, null)
def sum(a:DMat) = a.ddReduceOpv(0, DMat.idFun, DMat.vecAddFun, null)
def cumsum(a:DMat) = a.ddReduceAll(0, DMat.idFun, DMat.sumFun, null)
def maxi(a:DMat) = a.ddReduceOp(0, DMat.idFun, DMat.maxFun, null)
def mini(a:DMat):DMat = a.ddReduceOp(0, DMat.idFun, DMat.minFun, null)
def maxi(a:DMat) = a.ddReduceOpv(0, DMat.idFun, DMat.vecMaxFun, null)
def mini(a:DMat):DMat = a.ddReduceOpv(0, DMat.idFun, DMat.vecMinFun, null)
def maxi2(a:DMat,d:Int):(DMat,IMat) = {val (m,ii)=a.ggOpt2(d,DMat.gtPred); (DMat(m), ii)}
def mini2(a:DMat,d:Int):(DMat,IMat) = {val (m,ii)=a.ggOpt2(d,DMat.ltPred); (DMat(m), ii)}
def maxi2(a:DMat):(DMat,IMat) = {val (m,ii)=a.ggOpt2(0,DMat.gtPred); (DMat(m), ii)}
def mini2(a:DMat):(DMat,IMat) = {val (m,ii)=a.ggOpt2(0,DMat.ltPred); (DMat(m), ii)}

def min(a:DMat, b:DMat, out:Mat) = a.ddMatOpv(b, DMat.vecMinFun, out)
def max(a:DMat, b:DMat, out:Mat) = a.ddMatOpv(b, DMat.vecMaxFun, out)
def sum(a:DMat, n:Int, out:Mat) = a.ddReduceOp(n, DMat.idFun, DMat.sumFun, out)
def sum(a:DMat, n:Int, out:Mat) = a.ddReduceOpv(n, DMat.idFun, DMat.vecAddFun, out)
def cumsum(a:DMat, n:Int, out:Mat) = a.ddReduceAll(n, DMat.idFun, DMat.sumFun, out)
def maxi(a:DMat, n:Int, out:Mat) = a.ddReduceOp(n, DMat.idFun, DMat.maxFun, out)
def mini(a:DMat, n:Int, out:Mat):DMat = a.ddReduceOp(n, DMat.idFun, DMat.minFun, out)
def sum(a:DMat, out:Mat) = a.ddReduceOp(0, DMat.idFun, DMat.sumFun, out)
def maxi(a:DMat, n:Int, out:Mat) = a.ddReduceOpv(n, DMat.idFun, DMat.vecMaxFun, out)
def mini(a:DMat, n:Int, out:Mat):DMat = a.ddReduceOpv(n, DMat.idFun, DMat.vecMinFun, out)
def sum(a:DMat, out:Mat) = a.ddReduceOpv(0, DMat.idFun, DMat.vecAddFun, out)
def cumsum(a:DMat, out:Mat) = a.ddReduceAll(0, DMat.idFun, DMat.sumFun, out)
def maxi(a:DMat, out:Mat) = a.ddReduceOp(0, DMat.idFun, DMat.maxFun, out)
def mini(a:DMat, out:Mat):DMat = a.ddReduceOp(0, DMat.idFun, DMat.minFun, out)
def maxi(a:DMat, out:Mat) = a.ddReduceOpv(0, DMat.idFun, DMat.vecMaxFun, out)
def mini(a:DMat, out:Mat):DMat = a.ddReduceOpv(0, DMat.idFun, DMat.vecMinFun, out)

def min(a:FMat, b:FMat) = a.ffMatOpv(b, FMat.vecMinFun, null)
def max(a:FMat, b:FMat) = a.ffMatOpv(b, FMat.vecMaxFun, null)
def sum(a:FMat, n:Int) = a.ffReduceOp(n, FMat.idFun, FMat.sumFun, null)
def sum(a:FMat, n:Int) = a.ffReduceOpv(n, FMat.idFun, FMat.vecAddFun, null)
def cumsum(a:FMat, n:Int) = a.ffReduceAll(n, FMat.idFun, FMat.sumFun, null)
def maxi(a:FMat, n:Int) = a.ffReduceOp(n, FMat.idFun, FMat.maxFun, null)
def mini(a:FMat, n:Int):FMat = a.ffReduceOp(n, FMat.idFun, FMat.minFun, null)
def sum(a:FMat) = a.ffReduceOp(0, FMat.idFun, FMat.sumFun, null)
def maxi(a:FMat, n:Int) = a.ffReduceOpv(n, FMat.idFun, FMat.vecMaxFun, null)
def mini(a:FMat, n:Int):FMat = a.ffReduceOpv(n, FMat.idFun, FMat.vecMinFun, null)
def sum(a:FMat) = a.ffReduceOpv(0, FMat.idFun, FMat.vecAddFun, null)
def cumsum(a:FMat) = a.ffReduceAll(0, FMat.idFun, FMat.sumFun, null)
def maxi(a:FMat) = a.ffReduceOp(0, FMat.idFun, FMat.maxFun, null)
def mini(a:FMat):FMat = a.ffReduceOp(0, FMat.idFun, FMat.minFun, null)
def maxi(a:FMat) = a.ffReduceOpv(0, FMat.idFun, FMat.vecMaxFun, null)
def mini(a:FMat):FMat = a.ffReduceOpv(0, FMat.idFun, FMat.vecMinFun, null)
def maxi2(a:FMat,d:Int):(FMat,IMat) = {val (m,ii)=a.ggOpt2(d,FMat.gtPred); (FMat(m), ii)}
def mini2(a:FMat,d:Int):(FMat,IMat) = {val (m,ii)=a.ggOpt2(d,FMat.ltPred); (FMat(m), ii)}
def maxi2(a:FMat):(FMat,IMat) = {val (m,ii)=a.ggOpt2(0,FMat.gtPred); (FMat(m), ii)}
def mini2(a:FMat):(FMat,IMat) = {val (m,ii)=a.ggOpt2(0,FMat.ltPred); (FMat(m), ii)}

def min(a:FMat, b:FMat, out:Mat) = a.ffMatOpv(b, FMat.vecMinFun, out)
def max(a:FMat, b:FMat, out:Mat) = a.ffMatOpv(b, FMat.vecMaxFun, out)
def sum(a:FMat, n:Int, out:Mat) = a.ffReduceOp(n, FMat.idFun, FMat.sumFun, out)
def sum(a:FMat, n:Int, out:Mat) = a.ffReduceOpv(n, FMat.idFun, FMat.vecAddFun, out)
def cumsum(a:FMat, n:Int, out:Mat) = a.ffReduceAll(n, FMat.idFun, FMat.sumFun, out)
def maxi(a:FMat, n:Int, out:Mat) = a.ffReduceOp(n, FMat.idFun, FMat.maxFun, out)
def mini(a:FMat, n:Int, out:Mat):FMat = a.ffReduceOp(n, FMat.idFun, FMat.minFun, out)
def sum(a:FMat, out:Mat) = a.ffReduceOp(0, FMat.idFun, FMat.sumFun, out)
def maxi(a:FMat, n:Int, out:Mat) = a.ffReduceOpv(n, FMat.idFun, FMat.vecMaxFun, out)
def mini(a:FMat, n:Int, out:Mat):FMat = a.ffReduceOpv(n, FMat.idFun, FMat.vecMinFun, out)
def sum(a:FMat, out:Mat) = a.ffReduceOpv(0, FMat.idFun, FMat.vecAddFun, out)
def cumsum(a:FMat, out:Mat) = a.ffReduceAll(0, FMat.idFun, FMat.sumFun, out)
def maxi(a:FMat, out:Mat) = a.ffReduceOp(0, FMat.idFun, FMat.maxFun, out)
def mini(a:FMat, out:Mat):FMat = a.ffReduceOp(0, FMat.idFun, FMat.minFun, out)
def maxi(a:FMat, out:Mat) = a.ffReduceOpv(0, FMat.idFun, FMat.vecMaxFun, out)
def mini(a:FMat, out:Mat):FMat = a.ffReduceOpv(0, FMat.idFun, FMat.vecMinFun, out)

def min (a:IMat, b:IMat) = a.iiMatOpv(b, IMat.vecMinFun, null)
def max (a:IMat, b:IMat) = a.iiMatOpv(b, IMat.vecMaxFun, null)
def sum(a:IMat, n:Int) = a.iiReduceOp(n, IMat.idFun, IMat.sumFun, null)
def sum(a:IMat, n:Int) = a.iiReduceOpv(n, IMat.idFun, IMat.vecAddFun, null)
def cumsum(a:IMat, n:Int) = a.iiReduceAll(n, IMat.idFun, IMat.sumFun, null)
def maxi(a:IMat, n:Int) = a.iiReduceOp(n, IMat.idFun, IMat.maxFun, null)
def mini(a:IMat, n:Int):IMat = a.iiReduceOp(n, IMat.idFun, IMat.minFun, null)
def sum(a:IMat) = a.iiReduceOp(0, IMat.idFun, IMat.sumFun, null)
def maxi(a:IMat, n:Int) = a.iiReduceOpv(n, IMat.idFun, IMat.vecMaxFun, null)
def mini(a:IMat, n:Int):IMat = a.iiReduceOpv(n, IMat.idFun, IMat.vecMinFun, null)
def sum(a:IMat) = a.iiReduceOpv(0, IMat.idFun, IMat.vecAddFun, null)
def cumsum(a:IMat) = a.iiReduceAll(0, IMat.idFun, IMat.sumFun, null)
def maxi(a:IMat) = a.iiReduceOp(0, IMat.idFun, IMat.maxFun, null)
def mini(a:IMat):IMat = a.iiReduceOp(0, IMat.idFun, IMat.minFun, null)
def maxi(a:IMat) = a.iiReduceOpv(0, IMat.idFun, IMat.vecMaxFun, null)
def mini(a:IMat):IMat = a.iiReduceOpv(0, IMat.idFun, IMat.vecMinFun, null)
def maxi2(a:IMat,d:Int):(IMat,IMat) = {val (m,ii)=a.ggOpt2(d,IMat.gtPred); (IMat(m), ii)}
def mini2(a:IMat,d:Int):(IMat,IMat) = {val (m,ii)=a.ggOpt2(d,IMat.ltPred); (IMat(m), ii)}
def maxi2(a:IMat):(IMat,IMat) = {val (m,ii)=a.ggOpt2(0,IMat.gtPred); (IMat(m), ii)}
def mini2(a:IMat):(IMat,IMat) = {val (m,ii)=a.ggOpt2(0,IMat.ltPred); (IMat(m), ii)}

def min (a:IMat, b:IMat, out:Mat) = a.iiMatOpv(b, IMat.vecMinFun, out)
def max (a:IMat, b:IMat, out:Mat) = a.iiMatOpv(b, IMat.vecMaxFun, out)
def sum(a:IMat, n:Int, out:Mat) = a.iiReduceOp(n, IMat.idFun, IMat.sumFun, out)
def sum(a:IMat, n:Int, out:Mat) = a.iiReduceOpv(n, IMat.idFun, IMat.vecAddFun, out)
def cumsum(a:IMat, n:Int, out:Mat) = a.iiReduceAll(n, IMat.idFun, IMat.sumFun, out)
def maxi(a:IMat, n:Int, out:Mat) = a.iiReduceOp(n, IMat.idFun, IMat.maxFun, out)
def mini(a:IMat, n:Int, out:Mat):IMat = a.iiReduceOp(n, IMat.idFun, IMat.minFun, out)
def sum(a:IMat, out:Mat) = a.iiReduceOp(0, IMat.idFun, IMat.sumFun, out)
def maxi(a:IMat, n:Int, out:Mat) = a.iiReduceOpv(n, IMat.idFun, IMat.vecMaxFun, out)
def mini(a:IMat, n:Int, out:Mat):IMat = a.iiReduceOpv(n, IMat.idFun, IMat.vecMinFun, out)
def sum(a:IMat, out:Mat) = a.iiReduceOpv(0, IMat.idFun, IMat.vecAddFun, out)
def cumsum(a:IMat, out:Mat) = a.iiReduceAll(0, IMat.idFun, IMat.sumFun, out)
def maxi(a:IMat, out:Mat) = a.iiReduceOp(0, IMat.idFun, IMat.maxFun, out)
def mini(a:IMat, out:Mat):IMat = a.iiReduceOp(0, IMat.idFun, IMat.minFun, out)
def maxi(a:IMat, out:Mat) = a.iiReduceOpv(0, IMat.idFun, IMat.vecMaxFun, out)
def mini(a:IMat, out:Mat):IMat = a.iiReduceOpv(0, IMat.idFun, IMat.vecMinFun, out)

def min(a:SDMat, b:SDMat) = a.ssMatOp(b, DMat.minFun, null)
def max(a:SDMat, b:SDMat) = a.ssMatOp(b, DMat.maxFun, null)
Expand Down

0 comments on commit 1c1e4d4

Please sign in to comment.