Module: TensorFlow::Math

Defined in:
lib/tensorflow/math.rb

Class Method Summary collapse

Class Method Details

.abs(x) ⇒ Object 



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

def abs(x)
  RawOps.abs(x: x)
end

.acos(x) ⇒ Object

def accumulate_n end



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

def acos(x)
  RawOps.acos(x: x)
end

.acosh(x) ⇒ Object 



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

def acosh(x)
  RawOps.acosh(x: x)
end

.add(x, y) ⇒ Object 



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

def add(x, y)
  RawOps.add(x: x, y: y)
end

.add_n(inputs) ⇒ Object 



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

def add_n(inputs)
  RawOps.add_n(inputs: inputs)
end

.angle(input) ⇒ Object 



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

def angle(input)
  RawOps.angle(input: input)
end

.asin(x) ⇒ Object

def argmin end



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

def asin(x)
  RawOps.asin(x: x)
end

.asinh(x) ⇒ Object 



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

def asinh(x)
  RawOps.asinh(x: x)
end

.atan(x) ⇒ Object 



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

def atan(x)
  RawOps.atan(x: x)
end

.atan2(y, x) ⇒ Object 



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

def atan2(y, x)
  RawOps.atan2(y: y, x: x)
end

.atanh(x) ⇒ Object 



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

def atanh(x)
  RawOps.atanh(x: x)
end

.bessel_i0e(x) ⇒ Object

def bessel_i0 end



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

def bessel_i0e(x)
  RawOps.bessel_i0e(x: x)
end

.bessel_i1e(x) ⇒ Object

def bessel_i1 end



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

def bessel_i1e(x)
  RawOps.bessel_i1e(x: x)
end

.betainc(a, b, x) ⇒ Object 



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

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

.bincount(arr, size, weights) ⇒ Object 



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

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

.ceil(x) ⇒ Object 



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

def ceil(x)
  RawOps.ceil(x: x)
end

.conj(input) ⇒ Object

def confusion_matrix end



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

def conj(input)
  RawOps.conj(input: input)
end

.cos(x) ⇒ Object 



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

def cos(x)
  RawOps.cos(x: x)
end

.cosh(x) ⇒ Object 



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

def cosh(x)
  RawOps.cosh(x: x)
end

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

def count_nonzero end



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

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

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



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

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

.digamma(x) ⇒ Object

def cumulative_logsumexp end



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

def digamma(x)
  RawOps.digamma(x: x)
end

.divide(x, y) ⇒ Object 



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

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

.equal(x, y) ⇒ Object

def divide_no_nan end



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

def equal(x, y)
  RawOps.equal(x: x, y: y)
end

.erf(x) ⇒ Object 



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

def erf(x)
  RawOps.erf(x: x)
end

.erfc(x) ⇒ Object 



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

def erfc(x)
  RawOps.erfc(x: x)
end

.exp(x) ⇒ Object 



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

def exp(x)
  RawOps.exp(x: x)
end

.expm1(x) ⇒ Object 



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

def expm1(x)
  RawOps.expm1(x: x)
end

.floor(x) ⇒ Object 



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

def floor(x)
  RawOps.floor(x: x)
end

.floordiv(x, y) ⇒ Object 



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

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

.floormod(x, y) ⇒ Object 



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

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

.greater(x, y) ⇒ Object 



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

def greater(x, y)
  RawOps.greater(x: x, y: y)
end

.greater_equal(x, y) ⇒ Object 



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

def greater_equal(x, y)
  RawOps.greater_equal(x: x, y: y)
end

.igamma(a, x) ⇒ Object 



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

def igamma(a, x)
  RawOps.igamma(a: a, x: x)
end

.igammac(a, x) ⇒ Object 



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

def igammac(a, x)
  RawOps.igammac(a: a, x: x)
end

.imag(input) ⇒ Object 



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

def imag(input)
  RawOps.imag(input: input)
end

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



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

def in_top_k(predictions, targets, k: nil)
  RawOps.in_top_k(predictions: predictions, targets: targets, k: k)
end

.invert_permutation(x) ⇒ Object 



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

def invert_permutation(x)
  RawOps.invert_permutation(x: x)
end

.is_finite(x) ⇒ Object 



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

def is_finite(x)
  RawOps.is_finite(x: x)
end

.is_inf(x) ⇒ Object 



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

def is_inf(x)
  RawOps.is_inf(x: x)
end

.is_nan(x) ⇒ Object 



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

def is_nan(x)
  RawOps.is_nan(x: x)
end

.less(x, y) ⇒ Object

def lbeta end



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

def less(x, y)
  RawOps.less(x: x, y: y)
end

.less_equal(x, y) ⇒ Object 



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

def less_equal(x, y)
  RawOps.less_equal(x: x, y: y)
end

.lgamma(x) ⇒ Object 



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

def lgamma(x)
  RawOps.lgamma(x: x)
end

.log(x) ⇒ Object 



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

def log(x)
  RawOps.log(x: x)
end

.log1p(x) ⇒ Object 



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

def log1p(x)
  RawOps.log1p(x: x)
end

.log_softmax(logits) ⇒ Object

def log_sigmoid end



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

def log_softmax(logits)
  RawOps.log_softmax(logits: logits)
end

.logical_and(x, y) ⇒ Object 



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

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

.logical_not(x) ⇒ Object 



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

def logical_not(x)
  RawOps.logical_not(x: x)
end

.logical_or(x, y) ⇒ Object 



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

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

.maximum(x, y) ⇒ Object

def logical_xor end



249
250
251
 
# File 'lib/tensorflow/math.rb', line 249

def maximum(x, y)
  RawOps.maximum(x: x, y: y)
end

.minimum(x, y) ⇒ Object 



253
254
255
 
# File 'lib/tensorflow/math.rb', line 253

def minimum(x, y)
  RawOps.minimum(x: x, y: y)
end

.mod(x, y) ⇒ Object 



257
258
259
 
# File 'lib/tensorflow/math.rb', line 257

def mod(x, y)
  RawOps.mod(x: x, y: y)
end

.multiply(x, y) ⇒ Object 



261
262
263
 
# File 'lib/tensorflow/math.rb', line 261

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

.not_equal(x, y) ⇒ Object

def nextafter end



274
275
276
 
# File 'lib/tensorflow/math.rb', line 274

def not_equal(x, y)
  RawOps.not_equal(x: x, y: y)
end

.polygamma(a, x) ⇒ Object 



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

def polygamma(a, x)
  RawOps.polygamma(a: a, x: x)
end

.pow(x, y) ⇒ Object

def polyval end



285
286
287
 
# File 'lib/tensorflow/math.rb', line 285

def pow(x, y)
  RawOps.pow(x: x, y: y)
end

.real(input) ⇒ Object 



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

def real(input)
  RawOps.real(input: input)
end

.reciprocal(x) ⇒ Object 



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

def reciprocal(x)
  RawOps.reciprocal(x: x)
end

.rint(x) ⇒ Object

def reduce_variance end



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

def rint(x)
  RawOps.rint(x: x)
end

.round(x) ⇒ Object 



337
338
339
 
# File 'lib/tensorflow/math.rb', line 337

def round(x)
  RawOps.round(x: x)
end

.rsqrt(x) ⇒ Object 



341
342
343
 
# File 'lib/tensorflow/math.rb', line 341

def rsqrt(x)
  RawOps.rsqrt(x: x)
end

.segment_max(data, segment_ids) ⇒ Object

def scalar_mul end



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

def segment_max(data, segment_ids)
  RawOps.segment_max(data: data, segment_ids: segment_ids)
end

.segment_mean(data, segment_ids) ⇒ Object 



352
353
354
 
# File 'lib/tensorflow/math.rb', line 352

def segment_mean(data, segment_ids)
  RawOps.segment_mean(data: data, segment_ids: segment_ids)
end

.segment_min(data, segment_ids) ⇒ Object 



356
357
358
 
# File 'lib/tensorflow/math.rb', line 356

def segment_min(data, segment_ids)
  RawOps.segment_min(data: data, segment_ids: segment_ids)
end

.segment_prod(data, segment_ids) ⇒ Object 



360
361
362
 
# File 'lib/tensorflow/math.rb', line 360

def segment_prod(data, segment_ids)
  RawOps.segment_prod(data: data, segment_ids: segment_ids)
end

.segment_sum(data, segment_ids) ⇒ Object 



364
365
366
 
# File 'lib/tensorflow/math.rb', line 364

def segment_sum(data, segment_ids)
  RawOps.segment_sum(data: data, segment_ids: segment_ids)
end

.sigmoid(x) ⇒ Object 



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

def sigmoid(x)
  RawOps.sigmoid(x: x)
end

.sign(x) ⇒ Object 



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

def sign(x)
  RawOps.sign(x: x)
end

.sin(x) ⇒ Object 



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

def sin(x)
  RawOps.sin(x: x)
end

.sinh(x) ⇒ Object 



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

def sinh(x)
  RawOps.sinh(x: x)
end

.softmax(logits) ⇒ Object 



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

def softmax(logits)
  RawOps.softmax(logits: logits)
end

.softplus(features) ⇒ Object 



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

def softplus(features)
  RawOps.softplus(features: features)
end

.softsign(features) ⇒ Object 



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

def softsign(features)
  RawOps.softsign(features: features)
end

.sqrt(x) ⇒ Object 



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

def sqrt(x)
  RawOps.sqrt(x: x)
end

.square(x) ⇒ Object 



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

def square(x)
  RawOps.square(x: x)
end

.squared_difference(x, y) ⇒ Object 



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

def squared_difference(x, y)
  RawOps.squared_difference(x: x, y: y)
end

.subtract(x, y) ⇒ Object 



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

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

.tan(x) ⇒ Object 



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

def tan(x)
  RawOps.tan(x: x)
end

.tanh(x) ⇒ Object 



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

def tanh(x)
  RawOps.tanh(x: x)
end

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



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

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

.unsorted_segment_max(data, segment_ids, num_segments) ⇒ Object

def truediv end



427
428
429
 
# File 'lib/tensorflow/math.rb', line 427

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

.unsorted_segment_min(data, segment_ids, num_segments) ⇒ Object

def unsorted_segment_mean end



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

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

.unsorted_segment_prod(data, segment_ids, num_segments) ⇒ Object 



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

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

.unsorted_segment_sum(data, segment_ids, num_segments) ⇒ Object

def unsorted_segment_sqrt_n end



445
446
447
 
# File 'lib/tensorflow/math.rb', line 445

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

.xdivy(x, y) ⇒ Object 



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

def xdivy(x, y)
  RawOps.xdivy(x: x, y: y)
end

.xlogy(x, y) ⇒ Object 



453
454
455
 
# File 'lib/tensorflow/math.rb', line 453

def xlogy(x, y)
  RawOps.xlogy(x: x, y: y)
end

.zeta(x, q) ⇒ Object

def zero_fraction end



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

def zeta(x, q)
  RawOps.zeta(x: x, q: q)
end