Module: Tensorflow::Math

Defined in:
lib/tensorflow/ops/math.rb

Class Method Summary collapse

Class Method Details

.abs(x, dtype: nil) ⇒ Object 



4
5
6
 
# File 'lib/tensorflow/ops/math.rb', line 4

def abs(x, dtype: nil)
  RawOps.abs(x, typeT: dtype)
end

.acos(x, dtype: nil) ⇒ Object

def accumulate_n end



11
12
13
 
# File 'lib/tensorflow/ops/math.rb', line 11

def acos(x, dtype: nil)
  RawOps.acos(x, typeT: dtype)
end

.acosh(x, dtype: nil) ⇒ Object 



15
16
17
 
# File 'lib/tensorflow/ops/math.rb', line 15

def acosh(x, dtype: nil)
  RawOps.acosh(x, typeT: dtype)
end

.add(x, y, dtype: nil) ⇒ Object 



19
20
21
 
# File 'lib/tensorflow/ops/math.rb', line 19

def add(x, y, dtype: nil)
  RawOps.add(x, y, typeT: dtype)
end

.add_n(inputs, dtype: nil) ⇒ Object 



23
24
25
 
# File 'lib/tensorflow/ops/math.rb', line 23

def add_n(inputs, dtype: nil)
  RawOps.add_n(inputs, n: inputs.length, typeT: dtype)
end

.angle(input, dtype: nil) ⇒ Object 



27
28
29
 
# File 'lib/tensorflow/ops/math.rb', line 27

def angle(input, dtype: nil)
  RawOps.angle(input, typeT: dtype)
end

.asin(x, dtype: nil) ⇒ Object

def argmin end



37
38
39
 
# File 'lib/tensorflow/ops/math.rb', line 37

def asin(x, dtype: nil)
  RawOps.asin(x, typeT: dtype)
end

.asinh(x, dtype: nil) ⇒ Object 



41
42
43
 
# File 'lib/tensorflow/ops/math.rb', line 41

def asinh(x, dtype: nil)
  RawOps.asinh(x, typeT: dtype)
end

.atan(x, dtype: nil) ⇒ Object 



45
46
47
 
# File 'lib/tensorflow/ops/math.rb', line 45

def atan(x, dtype: nil)
  RawOps.atan(x, typeT: dtype)
end

.atan2(y, x, dtype: nil) ⇒ Object 



49
50
51
 
# File 'lib/tensorflow/ops/math.rb', line 49

def atan2(y, x, dtype: nil)
  RawOps.atan2(y, x, typeT: dtype)
end

.atanh(x, dtype: nil) ⇒ Object 



53
54
55
 
# File 'lib/tensorflow/ops/math.rb', line 53

def atanh(x, dtype: nil)
  RawOps.atanh(x, typeT: dtype)
end

.bessel_i0e(x, dtype: nil) ⇒ Object

def bessel_i0 end



60
61
62
 
# File 'lib/tensorflow/ops/math.rb', line 60

def bessel_i0e(x, dtype: nil)
  RawOps.bessel_i0e(x, typeT: dtype)
end

.bessel_i1e(x, dtype: nil) ⇒ Object

def bessel_i1 end



67
68
69
 
# File 'lib/tensorflow/ops/math.rb', line 67

def bessel_i1e(x, dtype: nil)
  RawOps.bessel_i1e(x, typeT: dtype)
end

.betainc(a, b, x, dtype: nil) ⇒ Object 



71
72
73
 
# File 'lib/tensorflow/ops/math.rb', line 71

def betainc(a, b, x, dtype: nil)
  RawOps.betainc(a, b, x, typeT: dtype)
end

.bincount(arr, size, weights, dtype: nil) ⇒ Object 



75
76
77
 
# File 'lib/tensorflow/ops/math.rb', line 75

def bincount(arr, size, weights, dtype: nil)
  RawOps.bincount(arr, size, weights, typeT: dtype)
end

.ceil(x, dtype: nil) ⇒ Object 



79
80
81
 
# File 'lib/tensorflow/ops/math.rb', line 79

def ceil(x, dtype: nil)
  RawOps.ceil(x, typeT: dtype)
end

.conj(input, dtype: nil) ⇒ Object

def confusion_matrix end



86
87
88
 
# File 'lib/tensorflow/ops/math.rb', line 86

def conj(input, dtype: nil)
  RawOps.conj(input, typeT: dtype)
end

.cos(x, dtype: nil) ⇒ Object 



90
91
92
 
# File 'lib/tensorflow/ops/math.rb', line 90

def cos(x, dtype: nil)
  RawOps.cos(x, typeT: dtype)
end

.cosh(x, dtype: nil) ⇒ Object 



94
95
96
 
# File 'lib/tensorflow/ops/math.rb', line 94

def cosh(x, dtype: nil)
  RawOps.cosh(x, typeT: dtype)
end

.cumprod(x, axis, exclusive: nil, reverse: nil, dtype: nil) ⇒ Object

def count_nonzero end



101
102
103
 
# File 'lib/tensorflow/ops/math.rb', line 101

def cumprod(x, axis, exclusive: nil, reverse: nil, dtype: nil)
  RawOps.cumprod(x, axis, exclusive: exclusive, reverse: reverse, typeT: dtype)
end

.cumsum(x, axis, exclusive: nil, reverse: nil, dtype: nil) ⇒ Object 



105
106
107
 
# File 'lib/tensorflow/ops/math.rb', line 105

def cumsum(x, axis, exclusive: nil, reverse: nil, dtype: nil)
  RawOps.cumsum(x, axis, exclusive: exclusive, reverse: reverse, typeT: dtype)
end

.digamma(x, dtype: nil) ⇒ Object

def cumulative_logsumexp end



112
113
114
 
# File 'lib/tensorflow/ops/math.rb', line 112

def digamma(x, dtype: nil)
  RawOps.digamma(x, typeT: dtype)
end

.divide(x, y, dtype: nil) ⇒ Object 



116
117
118
 
# File 'lib/tensorflow/ops/math.rb', line 116

def divide(x, y, dtype: nil)
  RawOps.div(x, y, typeT: dtype)
end

.equal(x, y, dtype: nil) ⇒ Object

def divide_no_nan end



123
124
125
 
# File 'lib/tensorflow/ops/math.rb', line 123

def equal(x, y, dtype: nil)
  RawOps.equal(x, y, typeT: dtype)
end

.erf(x, dtype: nil) ⇒ Object 



127
128
129
 
# File 'lib/tensorflow/ops/math.rb', line 127

def erf(x, dtype: nil)
  RawOps.erf(x, typeT: dtype)
end

.erfc(x, dtype: nil) ⇒ Object 



131
132
133
 
# File 'lib/tensorflow/ops/math.rb', line 131

def erfc(x, dtype: nil)
  RawOps.erfc(x, typeT: dtype)
end

.exp(x, dtype: nil) ⇒ Object 



135
136
137
 
# File 'lib/tensorflow/ops/math.rb', line 135

def exp(x, dtype: nil)
  RawOps.exp(x, typeT: dtype)
end

.expm1(x, dtype: nil) ⇒ Object 



139
140
141
 
# File 'lib/tensorflow/ops/math.rb', line 139

def expm1(x, dtype: nil)
  RawOps.expm1(x, typeT: dtype)
end

.floor(x, dtype: nil) ⇒ Object 



143
144
145
 
# File 'lib/tensorflow/ops/math.rb', line 143

def floor(x, dtype: nil)
  RawOps.floor(x, typeT: dtype)
end

.floordiv(x, y, dtype: nil) ⇒ Object 



147
148
149
 
# File 'lib/tensorflow/ops/math.rb', line 147

def floordiv(x, y, dtype: nil)
  RawOps.floor_div(x, y, typeT: dtype)
end

.floormod(x, y, dtype: nil) ⇒ Object 



151
152
153
 
# File 'lib/tensorflow/ops/math.rb', line 151

def floormod(x, y, dtype: nil)
  RawOps.floor_mod(x, y, typeT: dtype)
end

.greater(x, y, dtype: nil) ⇒ Object 



155
156
157
 
# File 'lib/tensorflow/ops/math.rb', line 155

def greater(x, y, dtype: nil)
  RawOps.greater(x, y, typeT: dtype)
end

.greater_equal(x, y, dtype: nil) ⇒ Object 



159
160
161
 
# File 'lib/tensorflow/ops/math.rb', line 159

def greater_equal(x, y, dtype: nil)
  RawOps.greater_equal(x, y, typeT: dtype)
end

.igamma(a, x, dtype: nil) ⇒ Object 



163
164
165
 
# File 'lib/tensorflow/ops/math.rb', line 163

def igamma(a, x, dtype: nil)
  RawOps.igamma(a, x, typeT: dtype)
end

.igammac(a, x, dtype: nil) ⇒ Object 



167
168
169
 
# File 'lib/tensorflow/ops/math.rb', line 167

def igammac(a, x, dtype: nil)
  RawOps.igammac(a, x, typeT: dtype)
end

.imag(input, dtype: nil) ⇒ Object 



171
172
173
 
# File 'lib/tensorflow/ops/math.rb', line 171

def imag(input, dtype: nil)
  RawOps.imag(input, typeT: dtype)
end

.in_top_k(predictions, targets, k = nil, dtype: nil) ⇒ Object 



175
176
177
 
# File 'lib/tensorflow/ops/math.rb', line 175

def in_top_k(predictions, targets, k=nil, dtype: nil)
  RawOps.in_top_kv2(predictions, targets, k, typeT: dtype)
end

.invert_permutation(x, dtype: nil) ⇒ Object 



179
180
181
 
# File 'lib/tensorflow/ops/math.rb', line 179

def invert_permutation(x, dtype: nil)
  RawOps.invert_permutation(x, typeT: dtype)
end

.is_finite(x, dtype: nil) ⇒ Object 



183
184
185
 
# File 'lib/tensorflow/ops/math.rb', line 183

def is_finite(x, dtype: nil)
  RawOps.is_finite(x, typeT: dtype)
end

.is_inf(x, dtype: nil) ⇒ Object 



187
188
189
 
# File 'lib/tensorflow/ops/math.rb', line 187

def is_inf(x, dtype: nil)
  RawOps.is_inf(x, typeT: dtype)
end

.is_nan(x, dtype: nil) ⇒ Object 



191
192
193
 
# File 'lib/tensorflow/ops/math.rb', line 191

def is_nan(x, dtype: nil)
  RawOps.is_nan(x, typeT: dtype)
end

.less(x, y, dtype: nil) ⇒ Object

def lbeta end



207
208
209
 
# File 'lib/tensorflow/ops/math.rb', line 207

def less(x, y, dtype: nil)
  RawOps.less(x, y, typeT: dtype)
end

.less_equal(x, y, dtype: nil) ⇒ Object 



211
212
213
 
# File 'lib/tensorflow/ops/math.rb', line 211

def less_equal(x, y, dtype: nil)
  RawOps.less_equal(x, y, typeT: dtype)
end

.lgamma(x, dtype: nil) ⇒ Object 



215
216
217
 
# File 'lib/tensorflow/ops/math.rb', line 215

def lgamma(x, dtype: nil)
  RawOps.lgamma(x, typeT: dtype)
end

.log(x, dtype: nil) ⇒ Object 



219
220
221
 
# File 'lib/tensorflow/ops/math.rb', line 219

def log(x, dtype: nil)
  RawOps.log(x, typeT: dtype)
end

.log1p(x, dtype: nil) ⇒ Object 



223
224
225
 
# File 'lib/tensorflow/ops/math.rb', line 223

def log1p(x, dtype: nil)
  RawOps.log1p(x, typeT: dtype)
end

.log_sigmoid(x, dtype: nil) ⇒ Object 



227
228
229
 
# File 'lib/tensorflow/ops/math.rb', line 227

def log_sigmoid(x, dtype: nil)
  negative(RawOps.softplus(-x, typeT: nil), dtype: dtype)
end

.log_softmax(logits, dtype: nil) ⇒ Object 



231
232
233
 
# File 'lib/tensorflow/ops/math.rb', line 231

def log_softmax(logits, dtype: nil)
  RawOps.log_softmax(logits: logits, typeT: dtype)
end

.logical_and(x, y, dtype: nil) ⇒ Object 



235
236
237
 
# File 'lib/tensorflow/ops/math.rb', line 235

def logical_and(x, y, dtype: nil)
  RawOps.logical_and(x, y)
end

.logical_not(x, dtype: nil) ⇒ Object 



239
240
241
 
# File 'lib/tensorflow/ops/math.rb', line 239

def logical_not(x, dtype: nil)
  RawOps.logical_not(x)
end

.logical_or(x, y, dtype: nil) ⇒ Object 



243
244
245
 
# File 'lib/tensorflow/ops/math.rb', line 243

def logical_or(x, y, dtype: nil)
  RawOps.logical_or(x, y)
end

.logical_xor(x, y, dtype: nil) ⇒ Object 



247
248
249
 
# File 'lib/tensorflow/ops/math.rb', line 247

def logical_xor(x, y, dtype: nil)
  logical_and(logical_or(x, y, dtype: nil), logical_not(logical_and(x, y, dtype: nil), dtype: nil))
end

.maximum(x, y, dtype: nil) ⇒ Object 



251
252
253
 
# File 'lib/tensorflow/ops/math.rb', line 251

def maximum(x, y, dtype: nil)
  RawOps.maximum(x, y, typeT: dtype)
end

.minimum(x, y, dtype: nil) ⇒ Object 



255
256
257
 
# File 'lib/tensorflow/ops/math.rb', line 255

def minimum(x, y, dtype: nil)
  RawOps.minimum(x, y, typeT: dtype)
end

.mod(x, y, dtype: nil) ⇒ Object 



259
260
261
 
# File 'lib/tensorflow/ops/math.rb', line 259

def mod(x, y, dtype: nil)
  RawOps.mod(x, y, typeT: dtype)
end

.multiply(x, y, dtype: nil) ⇒ Object 



263
264
265
 
# File 'lib/tensorflow/ops/math.rb', line 263

def multiply(x, y, dtype: nil)
  RawOps.mul(x, y, typeT: dtype)
end

.multiply_no_nan(x, y, dtype: nil) ⇒ Object 



267
268
269
 
# File 'lib/tensorflow/ops/math.rb', line 267

def multiply_no_nan(x, y, dtype: nil)
  RawOps.mul_no_nan(x, y, typeT: dtype)
end

.negative(x, dtype: nil) ⇒ Object 



271
272
273
 
# File 'lib/tensorflow/ops/math.rb', line 271

def negative(x, dtype: nil)
  RawOps.neg(x, typeT: dtype)
end

.not_equal(x, y, dtype: nil) ⇒ Object

def nextafter end



278
279
280
 
# File 'lib/tensorflow/ops/math.rb', line 278

def not_equal(x, y, dtype: nil)
  RawOps.not_equal(x, y, typeT: dtype)
end

.polygamma(a, x, dtype: nil) ⇒ Object 



282
283
284
 
# File 'lib/tensorflow/ops/math.rb', line 282

def polygamma(a, x, dtype: nil)
  RawOps.polygamma(a, x, typeT: dtype)
end

.pow(x, y, dtype: nil) ⇒ Object

def polyval end



289
290
291
 
# File 'lib/tensorflow/ops/math.rb', line 289

def pow(x, y, dtype: nil)
  RawOps.pow(x, y, typeT: dtype)
end

.real(input, dtype: nil) ⇒ Object 



293
294
295
 
# File 'lib/tensorflow/ops/math.rb', line 293

def real(input, dtype: nil)
  RawOps.real(input, typeT: dtype)
end

.reciprocal(x, dtype: nil) ⇒ Object 



297
298
299
 
# File 'lib/tensorflow/ops/math.rb', line 297

def reciprocal(x, dtype: nil)
  RawOps.reciprocal(x, typeT: dtype)
end

.reduce_any(input, axis: nil, keepdims: false, dtype: nil) ⇒ Object

def reduce_all end



307
308
309
310
 
# File 'lib/tensorflow/ops/math.rb', line 307

def reduce_any(input, axis: nil, keepdims: false, dtype: nil)
  axis ||= reduction_dims(input, dtype: dtype)
  RawOps.any(input, axis, keep_dims: keepdims)
end

.reduce_max(input, axis: nil, keepdims: false, dtype: nil) ⇒ Object

def reduce_logsumexp end



318
319
320
321
 
# File 'lib/tensorflow/ops/math.rb', line 318

def reduce_max(input, axis: nil, keepdims: false, dtype: nil)
  axis ||= reduction_dims(input, dtype: dtype)
  RawOps.max(input, axis, keep_dims: keepdims, typeT: dtype)
end

.reduce_mean(input, axis: nil, keepdims: false, dtype: nil) ⇒ Object 



323
324
325
326
 
# File 'lib/tensorflow/ops/math.rb', line 323

def reduce_mean(input, axis: nil, keepdims: false, dtype: nil)
  axis ||= reduction_dims(input, dtype: dtype)
  RawOps.mean(input, axis, keep_dims: keepdims, typeT: dtype)
end

.reduce_min(input, axis: nil, keepdims: false, dtype: nil) ⇒ Object 



328
329
330
331
 
# File 'lib/tensorflow/ops/math.rb', line 328

def reduce_min(input, axis: nil, keepdims: false, dtype: nil)
  axis ||= reduction_dims(input, dtype: dtype)
  RawOps.min(input, axis, keep_dims: keepdims, typeT: dtype)
end

.reduce_prod(input, axis: nil, keepdims: false, dtype: nil) ⇒ Object 



333
334
335
336
 
# File 'lib/tensorflow/ops/math.rb', line 333

def reduce_prod(input, axis: nil, keepdims: false, dtype: nil)
  axis ||= reduction_dims(input, dtype: dtype)
  RawOps.prod(input, axis, keep_dims: keepdims, typeT: dtype)
end

.reduce_std(input, axis: nil, keepdims: false, dtype: nil) ⇒ Object 



338
339
340
341
 
# File 'lib/tensorflow/ops/math.rb', line 338

def reduce_std(input, axis: nil, keepdims: false, dtype: nil)
  variance = reduce_variance(input, axis: axis, keepdims: keepdims, dtype: dtype)
  sqrt(variance, dtype: dtype)
end

.reduce_sum(input, axis: nil, keepdims: false, dtype: nil) ⇒ Object 



343
344
345
346
 
# File 'lib/tensorflow/ops/math.rb', line 343

def reduce_sum(input, axis: nil, keepdims: false, dtype: nil)
  axis ||= reduction_dims(input, dtype: dtype)
  RawOps.sum(input, axis, keep_dims: keepdims, typeT: dtype)
end

.reduce_variance(input, axis: nil, keepdims: false, dtype: nil) ⇒ Object 



348
349
350
351
352
 
# File 'lib/tensorflow/ops/math.rb', line 348

def reduce_variance(input, axis: nil, keepdims: false, dtype: nil)
  means = reduce_mean(input, axis: axis, keepdims: true, dtype: dtype)
  squared_deviations = RawOps.square(input - means, typeT: dtype)
  reduce_mean(squared_deviations, axis: axis, keepdims: keepdims, dtype: dtype)
end

.rint(x, dtype: nil) ⇒ Object 



354
355
356
 
# File 'lib/tensorflow/ops/math.rb', line 354

def rint(x, dtype: nil)
  RawOps.rint(x, typeT: dtype)
end

.round(x, dtype: nil) ⇒ Object 



358
359
360
 
# File 'lib/tensorflow/ops/math.rb', line 358

def round(x, dtype: nil)
  RawOps.round(x, typeT: dtype)
end

.rsqrt(x, dtype: nil) ⇒ Object 



362
363
364
 
# File 'lib/tensorflow/ops/math.rb', line 362

def rsqrt(x, dtype: nil)
  RawOps.rsqrt(x, typeT: dtype)
end

.segment_max(data, segment_ids, dtype: nil) ⇒ Object

def scalar_mul end



369
370
371
 
# File 'lib/tensorflow/ops/math.rb', line 369

def segment_max(data, segment_ids, dtype: nil)
  RawOps.segment_max(data, segment_ids, typeT: dtype)
end

.segment_mean(data, segment_ids, dtype: nil) ⇒ Object 



373
374
375
 
# File 'lib/tensorflow/ops/math.rb', line 373

def segment_mean(data, segment_ids, dtype: nil)
  RawOps.segment_mean(data, segment_ids, typeT: dtype)
end

.segment_min(data, segment_ids, dtype: nil) ⇒ Object 



377
378
379
 
# File 'lib/tensorflow/ops/math.rb', line 377

def segment_min(data, segment_ids, dtype: nil)
  RawOps.segment_min(data, segment_ids, typeT: dtype)
end

.segment_prod(data, segment_ids, dtype: nil) ⇒ Object 



381
382
383
 
# File 'lib/tensorflow/ops/math.rb', line 381

def segment_prod(data, segment_ids, dtype: nil)
  RawOps.segment_prod(data, segment_ids, typeT: dtype)
end

.segment_sum(data, segment_ids, dtype: nil) ⇒ Object 



385
386
387
 
# File 'lib/tensorflow/ops/math.rb', line 385

def segment_sum(data, segment_ids, dtype: nil)
  RawOps.segment_sum(data, segment_ids, typeT: dtype)
end

.sigmoid(x, dtype: nil) ⇒ Object 



389
390
391
 
# File 'lib/tensorflow/ops/math.rb', line 389

def sigmoid(x, dtype: nil)
  RawOps.sigmoid(x, typeT: dtype)
end

.sign(x, dtype: nil) ⇒ Object 



393
394
395
 
# File 'lib/tensorflow/ops/math.rb', line 393

def sign(x, dtype: nil)
  RawOps.sign(x, typeT: dtype)
end

.sin(x, dtype: nil) ⇒ Object 



397
398
399
 
# File 'lib/tensorflow/ops/math.rb', line 397

def sin(x, dtype: nil)
  RawOps.sin(x, typeT: dtype)
end

.sinh(x, dtype: nil) ⇒ Object 



401
402
403
 
# File 'lib/tensorflow/ops/math.rb', line 401

def sinh(x, dtype: nil)
  RawOps.sinh(x, typeT: dtype)
end

.softmax(logits, dtype: nil) ⇒ Object 



405
406
407
 
# File 'lib/tensorflow/ops/math.rb', line 405

def softmax(logits, dtype: nil)
  RawOps.softmax(logits: logits, typeT: dtype)
end

.softplus(features, dtype: nil) ⇒ Object 



409
410
411
 
# File 'lib/tensorflow/ops/math.rb', line 409

def softplus(features, dtype: nil)
  RawOps.softplus(features: features, typeT: dtype)
end

.softsign(features, dtype: nil) ⇒ Object 



413
414
415
 
# File 'lib/tensorflow/ops/math.rb', line 413

def softsign(features, dtype: nil)
  RawOps.softsign(features: features, typeT: dtype)
end

.sqrt(x, dtype: nil) ⇒ Object 



417
418
419
 
# File 'lib/tensorflow/ops/math.rb', line 417

def sqrt(x, dtype: nil)
  RawOps.sqrt(x, typeT: dtype)
end

.square(x, dtype: nil) ⇒ Object 



421
422
423
 
# File 'lib/tensorflow/ops/math.rb', line 421

def square(x, dtype: nil)
  RawOps.square(x, typeT: dtype)
end

.squared_difference(x, y, dtype: nil) ⇒ Object 



425
426
427
 
# File 'lib/tensorflow/ops/math.rb', line 425

def squared_difference(x, y, dtype: nil)
  RawOps.squared_difference(x, y, typeT: dtype)
end

.subtract(x, y, dtype: nil) ⇒ Object 



429
430
431
 
# File 'lib/tensorflow/ops/math.rb', line 429

def subtract(x, y, dtype: nil)
  RawOps.sub(x, y, typeT: dtype)
end

.tan(x, dtype: nil) ⇒ Object 



433
434
435
 
# File 'lib/tensorflow/ops/math.rb', line 433

def tan(x, dtype: nil)
  RawOps.tan(x, typeT: dtype)
end

.tanh(x, dtype: nil) ⇒ Object 



437
438
439
 
# File 'lib/tensorflow/ops/math.rb', line 437

def tanh(x, dtype: nil)
  RawOps.tanh(x, typeT: dtype)
end

.top_k(input, k: nil, sorted: nil, dtype: nil) ⇒ Object 



441
442
443
 
# File 'lib/tensorflow/ops/math.rb', line 441

def top_k(input, k: nil, sorted: nil, dtype: nil)
  RawOps.top_k(input, k: k, sorted: sorted, typeT: dtype)
end

.unsorted_segment_max(data, segment_ids, num_segments, dtype: nil) ⇒ Object

def truediv end



448
449
450
 
# File 'lib/tensorflow/ops/math.rb', line 448

def unsorted_segment_max(data, segment_ids, num_segments, dtype: nil)
  RawOps.unsorted_segment_max(data, segment_ids, num_segments: num_segments, typeT: dtype)
end

.unsorted_segment_min(data, segment_ids, num_segments, dtype: nil) ⇒ Object

def unsorted_segment_mean end



455
456
457
 
# File 'lib/tensorflow/ops/math.rb', line 455

def unsorted_segment_min(data, segment_ids, num_segments, dtype: nil)
  RawOps.unsorted_segment_min(data, segment_ids, num_segments: num_segments, typeT: dtype)
end

.unsorted_segment_prod(data, segment_ids, num_segments, dtype: nil) ⇒ Object 



459
460
461
 
# File 'lib/tensorflow/ops/math.rb', line 459

def unsorted_segment_prod(data, segment_ids, num_segments, dtype: nil)
  RawOps.unsorted_segment_prod(data, segment_ids, num_segments: num_segments, typeT: dtype)
end

.unsorted_segment_sum(data, segment_ids, num_segments, dtype: nil) ⇒ Object

def unsorted_segment_sqrt_n end



466
467
468
 
# File 'lib/tensorflow/ops/math.rb', line 466

def unsorted_segment_sum(data, segment_ids, num_segments, dtype: nil)
  RawOps.unsorted_segment_sum(data, segment_ids, num_segments: num_segments, typeT: dtype)
end

.xdivy(x, y, dtype: nil) ⇒ Object 



470
471
472
 
# File 'lib/tensorflow/ops/math.rb', line 470

def xdivy(x, y, dtype: nil)
  RawOps.xdivy(x, y, typeT: dtype)
end

.xlogy(x, y, dtype: nil) ⇒ Object 



474
475
476
 
# File 'lib/tensorflow/ops/math.rb', line 474

def xlogy(x, y, dtype: nil)
  RawOps.xlogy(x, y, typeT: dtype)
end

.zeta(x, q, dtype: nil) ⇒ Object

def zero_fraction end



481
482
483
 
# File 'lib/tensorflow/ops/math.rb', line 481

def zeta(x, q, dtype: nil)
  RawOps.zeta(x, q, typeT: dtype)
end