 
 
 
-
-func invGrad(scope:Scope,x: tf.Output, y: tf.OutputT :type)  ->(z: tf.Output){
-    if scope.error() != nil {
-        return
-    }
-    let opspec = tf.OpSpec(
-        Type: "InvGrad",
-        Input: [ x, y]
+func invGrad(scope:Scope,x: tf.Output, y: tf.Output, t :type  )  ->(z: tf.Output){
+    if scope.error() != nil {
+        return
+    }
+
+    var attrs:Dictionary<String,Tensorflow_AttrValue> = [:]
+    attr.append("T":t)
+
+    let opspec = tf.OpSpec(
+        OpType: "InvGrad",
+        Input: [ x, y],
         Attrs: attrs
     )
     let op = scope.AddOperation(opspec)





func ifft2D(scope:Scope,input: tf.Output)  ->(output: tf.Output){
    if scope.error() != nil {
        return
    }
    let opspec = tf.OpSpec(
        Type: "IFFT2D",
        Input: [ input]
        Attrs: attrs
    )
    let op = scope.AddOperation(opspec)




func batchMatMul(scope:Scope,x: tf.Output, y: tf.Output, t :type  , adjX :bool  , adjY :bool  )  ->(output: tf.Output){
    if scope.error() != nil {
        return
    }

    var attrs:Dictionary<String,Tensorflow_AttrValue> = [:]
    attr.append("T":t)
    attr.append("adj_x":adjX)
    attr.append("adj_y":adjY)

    let opspec = tf.OpSpec(
        OpType: "BatchMatMul",
        Input: [ x, y],
        Attrs: attrs
    )
    let op = scope.AddOperation(opspec)
    return (op.Output(1 -1))
}

/*


*/




func batchMatrixBandPart(scope:Scope,input: tf.Output, numLower: tf.Output, numUpper: tf.Output, t :type  )  ->(band: tf.Output){
    if scope.error() != nil {
        return
    }

    var attrs:Dictionary<String,Tensorflow_AttrValue> = [:]
    attr.append("T":t)

    let opspec = tf.OpSpec(
        OpType: "BatchMatrixBandPart",
        Input: [ input, numLower, numUpper],
        Attrs: attrs
    )
    let op = scope.AddOperation(opspec)
    return (op.Output(1 -1))
}

/*


*/




func batchMatrixDeterminant(scope:Scope,input: tf.Output, t :type  )  ->(output: tf.Output){
    if scope.error() != nil {
        return
    }

    var attrs:Dictionary<String,Tensorflow_AttrValue> = [:]
    attr.append("T":t)

    let opspec = tf.OpSpec(
        OpType: "BatchMatrixDeterminant",
        Input: [ input],
        Attrs: attrs
    )
    let op = scope.AddOperation(opspec)
    return (op.Output(1 -1))
}

/*


*/




func batchMatrixDiag(scope:Scope,diagonal: tf.Output, t :type  )  ->(output: tf.Output){
    if scope.error() != nil {
        return
    }

    var attrs:Dictionary<String,Tensorflow_AttrValue> = [:]
    attr.append("T":t)

    let opspec = tf.OpSpec(
        OpType: "BatchMatrixDiag",
        Input: [ diagonal],
        Attrs: attrs
    )
    let op = scope.AddOperation(opspec)
    return (op.Output(1 -1))
}

/*


*/




func batchMatrixDiagPart(scope:Scope,input: tf.Output, t :type  )  ->(diagonal: tf.Output){
    if scope.error() != nil {
        return
    }

    var attrs:Dictionary<String,Tensorflow_AttrValue> = [:]
    attr.append("T":t)

    let opspec = tf.OpSpec(
        OpType: "BatchMatrixDiagPart",
        Input: [ input],
        Attrs: attrs
    )
    let op = scope.AddOperation(opspec)
    return (op.Output(1 -1))
}

/*


*/




func batchMatrixInverse(scope:Scope,input: tf.Output, adjoint :bool  , t :type  )  ->(output: tf.Output){
    if scope.error() != nil {
        return
    }

    var attrs:Dictionary<String,Tensorflow_AttrValue> = [:]
    attr.append("adjoint":adjoint)
    attr.append("T":t)

    let opspec = tf.OpSpec(
        OpType: "BatchMatrixInverse",
        Input: [ input],
        Attrs: attrs
    )
    let op = scope.AddOperation(opspec)
    return (op.Output(1 -1))
}

/*


*/




func batchMatrixSetDiag(scope:Scope,input: tf.Output, diagonal: tf.Output, t :type  )  ->(output: tf.Output){
    if scope.error() != nil {
        return
    }

    var attrs:Dictionary<String,Tensorflow_AttrValue> = [:]
    attr.append("T":t)

    let opspec = tf.OpSpec(
        OpType: "BatchMatrixSetDiag",
        Input: [ input, diagonal],
        Attrs: attrs
    )
    let op = scope.AddOperation(opspec)
    return (op.Output(1 -1))
}

/*


*/




func batchMatrixSolve(scope:Scope,matrix: tf.Output, rhs: tf.Output, adjoint :bool  , t :type  )  ->(output: tf.Output){
    if scope.error() != nil {
        return
    }

    var attrs:Dictionary<String,Tensorflow_AttrValue> = [:]
    attr.append("adjoint":adjoint)
    attr.append("T":t)

    let opspec = tf.OpSpec(
        OpType: "BatchMatrixSolve",
        Input: [ matrix, rhs],
        Attrs: attrs
    )
    let op = scope.AddOperation(opspec)
    return (op.Output(1 -1))
}

/*


*/




func batchMatrixSolveLs(scope:Scope,matrix: tf.Output, rhs: tf.Output, l2Regularizer: tf.Output, t :type  , fast :bool  )  ->(output: tf.Output){
    if scope.error() != nil {
        return
    }

    var attrs:Dictionary<String,Tensorflow_AttrValue> = [:]
    attr.append("T":t)
    attr.append("fast":fast)

    let opspec = tf.OpSpec(
        OpType: "BatchMatrixSolveLs",
        Input: [ matrix, rhs, l2Regularizer],
        Attrs: attrs
    )
    let op = scope.AddOperation(opspec)
    return (op.Output(1 -1))
}

/*


*/




func batchMatrixTriangularSolve(scope:Scope,matrix: tf.Output, rhs: tf.Output, lower :bool  , adjoint :bool  , t :type  )  ->(output: tf.Output){
    if scope.error() != nil {
        return
    }

    var attrs:Dictionary<String,Tensorflow_AttrValue> = [:]
    attr.append("lower":lower)
    attr.append("adjoint":adjoint)
    attr.append("T":t)

    let opspec = tf.OpSpec(
        OpType: "BatchMatrixTriangularSolve",
        Input: [ matrix, rhs],
        Attrs: attrs
    )
    let op = scope.AddOperation(opspec)
