Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.8/site-packages/tensorflow/python/ops/gen_special_math_ops.py: 11%

1"""Python wrappers around TensorFlow ops. 

2 

3This file is MACHINE GENERATED! Do not edit. 

4""" 

5 

6import collections 

7 

8from tensorflow.python import pywrap_tfe as pywrap_tfe 

9from tensorflow.python.eager import context as _context 

10from tensorflow.python.eager import core as _core 

11from tensorflow.python.eager import execute as _execute 

12from tensorflow.python.framework import dtypes as _dtypes 

13from tensorflow.security.fuzzing.py import annotation_types as _atypes 

14 

15from tensorflow.python.framework import op_def_registry as _op_def_registry 

16from tensorflow.python.framework import ops as _ops 

17from tensorflow.python.framework import op_def_library as _op_def_library 

18from tensorflow.python.util.deprecation import deprecated_endpoints 

19from tensorflow.python.util import dispatch as _dispatch 

20from tensorflow.python.util.tf_export import tf_export 

21 

22from typing import TypeVar 

23 

24def bessel_i0(x, name=None): 

25 r"""TODO: add doc. 

26 

27 Args: 

28 x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`. 

29 name: A name for the operation (optional). 

30 

31 Returns: 

32 A `Tensor`. Has the same type as `x`. 

33 """ 

34 _ctx = _context._context or _context.context() 

35 tld = _ctx._thread_local_data 

36 if tld.is_eager: 

37 try: 

38 _result = pywrap_tfe.TFE_Py_FastPathExecute( 

39 _ctx, "BesselI0", name, x) 

40 return _result 

41 except _core._NotOkStatusException as e: 

42 _ops.raise_from_not_ok_status(e, name) 

43 except _core._FallbackException: 

44 pass 

45 try: 

46 return bessel_i0_eager_fallback( 

47 x, name=name, ctx=_ctx) 

48 except _core._SymbolicException: 

49 pass # Add nodes to the TensorFlow graph. 

50 # Add nodes to the TensorFlow graph. 

51 _, _, _op, _outputs = _op_def_library._apply_op_helper( 

52 "BesselI0", x=x, name=name) 

53 _result = _outputs[:] 

54 if _execute.must_record_gradient(): 

55 _attrs = ("T", _op._get_attr_type("T")) 

56 _inputs_flat = _op.inputs 

57 _execute.record_gradient( 

58 "BesselI0", _inputs_flat, _attrs, _result) 

59 _result, = _result 

60 return _result 

61 

62BesselI0 = tf_export("raw_ops.BesselI0")(_ops.to_raw_op(bessel_i0)) 

63 

64 

65def bessel_i0_eager_fallback(x, name, ctx): 

66 _attr_T, (x,) = _execute.args_to_matching_eager([x], ctx, [_dtypes.bfloat16, _dtypes.half, _dtypes.float32, _dtypes.float64, ]) 

67 _inputs_flat = [x] 

68 _attrs = ("T", _attr_T) 

69 _result = _execute.execute(b"BesselI0", 1, inputs=_inputs_flat, 

70 attrs=_attrs, ctx=ctx, name=name) 

71 if _execute.must_record_gradient(): 

72 _execute.record_gradient( 

73 "BesselI0", _inputs_flat, _attrs, _result) 

74 _result, = _result 

75 return _result 

76 

77 

78def bessel_i0e(x, name=None): 

79 r"""TODO: add doc. 

80 

81 Args: 

82 x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`. 

83 name: A name for the operation (optional). 

84 

85 Returns: 

86 A `Tensor`. Has the same type as `x`. 

87 """ 

88 _ctx = _context._context or _context.context() 

89 tld = _ctx._thread_local_data 

90 if tld.is_eager: 

91 try: 

92 _result = pywrap_tfe.TFE_Py_FastPathExecute( 

93 _ctx, "BesselI0e", name, x) 

94 return _result 

95 except _core._NotOkStatusException as e: 

96 _ops.raise_from_not_ok_status(e, name) 

97 except _core._FallbackException: 

98 pass 

99 try: 

100 return bessel_i0e_eager_fallback( 

101 x, name=name, ctx=_ctx) 

102 except _core._SymbolicException: 

103 pass # Add nodes to the TensorFlow graph. 

104 # Add nodes to the TensorFlow graph. 

105 _, _, _op, _outputs = _op_def_library._apply_op_helper( 

106 "BesselI0e", x=x, name=name) 

107 _result = _outputs[:] 

108 if _execute.must_record_gradient(): 

109 _attrs = ("T", _op._get_attr_type("T")) 

110 _inputs_flat = _op.inputs 

111 _execute.record_gradient( 

112 "BesselI0e", _inputs_flat, _attrs, _result) 

113 _result, = _result 

114 return _result 

115 

116BesselI0e = tf_export("raw_ops.BesselI0e")(_ops.to_raw_op(bessel_i0e)) 

117 

118 

119def bessel_i0e_eager_fallback(x, name, ctx): 

120 _attr_T, (x,) = _execute.args_to_matching_eager([x], ctx, [_dtypes.bfloat16, _dtypes.half, _dtypes.float32, _dtypes.float64, ]) 

121 _inputs_flat = [x] 

122 _attrs = ("T", _attr_T) 

123 _result = _execute.execute(b"BesselI0e", 1, inputs=_inputs_flat, 

124 attrs=_attrs, ctx=ctx, name=name) 

125 if _execute.must_record_gradient(): 

126 _execute.record_gradient( 

127 "BesselI0e", _inputs_flat, _attrs, _result) 

128 _result, = _result 

129 return _result 

130 

131 

132def bessel_i1(x, name=None): 

133 r"""TODO: add doc. 

134 

135 Args: 

136 x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`. 

137 name: A name for the operation (optional). 

138 

139 Returns: 

140 A `Tensor`. Has the same type as `x`. 

141 """ 

142 _ctx = _context._context or _context.context() 

143 tld = _ctx._thread_local_data 

144 if tld.is_eager: 

145 try: 

146 _result = pywrap_tfe.TFE_Py_FastPathExecute( 

147 _ctx, "BesselI1", name, x) 

148 return _result 

149 except _core._NotOkStatusException as e: 

150 _ops.raise_from_not_ok_status(e, name) 

151 except _core._FallbackException: 

152 pass 

153 try: 

154 return bessel_i1_eager_fallback( 

155 x, name=name, ctx=_ctx) 

156 except _core._SymbolicException: 

157 pass # Add nodes to the TensorFlow graph. 

158 # Add nodes to the TensorFlow graph. 

159 _, _, _op, _outputs = _op_def_library._apply_op_helper( 

160 "BesselI1", x=x, name=name) 

161 _result = _outputs[:] 

162 if _execute.must_record_gradient(): 

163 _attrs = ("T", _op._get_attr_type("T")) 

164 _inputs_flat = _op.inputs 

165 _execute.record_gradient( 

166 "BesselI1", _inputs_flat, _attrs, _result) 

167 _result, = _result 

168 return _result 

169 

170BesselI1 = tf_export("raw_ops.BesselI1")(_ops.to_raw_op(bessel_i1)) 

171 

172 

173def bessel_i1_eager_fallback(x, name, ctx): 

174 _attr_T, (x,) = _execute.args_to_matching_eager([x], ctx, [_dtypes.bfloat16, _dtypes.half, _dtypes.float32, _dtypes.float64, ]) 

175 _inputs_flat = [x] 

176 _attrs = ("T", _attr_T) 

177 _result = _execute.execute(b"BesselI1", 1, inputs=_inputs_flat, 

178 attrs=_attrs, ctx=ctx, name=name) 

179 if _execute.must_record_gradient(): 

180 _execute.record_gradient( 

181 "BesselI1", _inputs_flat, _attrs, _result) 

182 _result, = _result 

183 return _result 

184 

185 

186def bessel_i1e(x, name=None): 

187 r"""TODO: add doc. 

188 

189 Args: 

190 x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`. 

191 name: A name for the operation (optional). 

192 

193 Returns: 

194 A `Tensor`. Has the same type as `x`. 

195 """ 

196 _ctx = _context._context or _context.context() 

197 tld = _ctx._thread_local_data 

198 if tld.is_eager: 

199 try: 

200 _result = pywrap_tfe.TFE_Py_FastPathExecute( 

201 _ctx, "BesselI1e", name, x) 

202 return _result 

203 except _core._NotOkStatusException as e: 

204 _ops.raise_from_not_ok_status(e, name) 

205 except _core._FallbackException: 

206 pass 

207 try: 

208 return bessel_i1e_eager_fallback( 

209 x, name=name, ctx=_ctx) 

210 except _core._SymbolicException: 

211 pass # Add nodes to the TensorFlow graph. 

212 # Add nodes to the TensorFlow graph. 

213 _, _, _op, _outputs = _op_def_library._apply_op_helper( 

214 "BesselI1e", x=x, name=name) 

215 _result = _outputs[:] 

216 if _execute.must_record_gradient(): 

217 _attrs = ("T", _op._get_attr_type("T")) 

218 _inputs_flat = _op.inputs 

219 _execute.record_gradient( 

220 "BesselI1e", _inputs_flat, _attrs, _result) 

221 _result, = _result 

222 return _result 

223 

224BesselI1e = tf_export("raw_ops.BesselI1e")(_ops.to_raw_op(bessel_i1e)) 

225 

226 

227def bessel_i1e_eager_fallback(x, name, ctx): 

228 _attr_T, (x,) = _execute.args_to_matching_eager([x], ctx, [_dtypes.bfloat16, _dtypes.half, _dtypes.float32, _dtypes.float64, ]) 

229 _inputs_flat = [x] 

230 _attrs = ("T", _attr_T) 

231 _result = _execute.execute(b"BesselI1e", 1, inputs=_inputs_flat, 

232 attrs=_attrs, ctx=ctx, name=name) 

233 if _execute.must_record_gradient(): 

234 _execute.record_gradient( 

235 "BesselI1e", _inputs_flat, _attrs, _result) 

236 _result, = _result 

237 return _result 

238 

239 

240def bessel_j0(x, name=None): 

241 r"""TODO: add doc. 

242 

243 Args: 

244 x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`. 

245 name: A name for the operation (optional). 

246 

247 Returns: 

248 A `Tensor`. Has the same type as `x`. 

249 """ 

250 _ctx = _context._context or _context.context() 

251 tld = _ctx._thread_local_data 

252 if tld.is_eager: 

253 try: 

254 _result = pywrap_tfe.TFE_Py_FastPathExecute( 

255 _ctx, "BesselJ0", name, x) 

256 return _result 

257 except _core._NotOkStatusException as e: 

258 _ops.raise_from_not_ok_status(e, name) 

259 except _core._FallbackException: 

260 pass 

261 try: 

262 return bessel_j0_eager_fallback( 

263 x, name=name, ctx=_ctx) 

264 except _core._SymbolicException: 

265 pass # Add nodes to the TensorFlow graph. 

266 # Add nodes to the TensorFlow graph. 

267 _, _, _op, _outputs = _op_def_library._apply_op_helper( 

268 "BesselJ0", x=x, name=name) 

269 _result = _outputs[:] 

270 if _execute.must_record_gradient(): 

271 _attrs = ("T", _op._get_attr_type("T")) 

272 _inputs_flat = _op.inputs 

273 _execute.record_gradient( 

274 "BesselJ0", _inputs_flat, _attrs, _result) 

275 _result, = _result 

276 return _result 

277 

278BesselJ0 = tf_export("raw_ops.BesselJ0")(_ops.to_raw_op(bessel_j0)) 

279 

280 

281def bessel_j0_eager_fallback(x, name, ctx): 

282 _attr_T, (x,) = _execute.args_to_matching_eager([x], ctx, [_dtypes.bfloat16, _dtypes.half, _dtypes.float32, _dtypes.float64, ]) 

283 _inputs_flat = [x] 

284 _attrs = ("T", _attr_T) 

285 _result = _execute.execute(b"BesselJ0", 1, inputs=_inputs_flat, 

286 attrs=_attrs, ctx=ctx, name=name) 

287 if _execute.must_record_gradient(): 

288 _execute.record_gradient( 

289 "BesselJ0", _inputs_flat, _attrs, _result) 

290 _result, = _result 

291 return _result 

292 

293 

294def bessel_j1(x, name=None): 

295 r"""TODO: add doc. 

296 

297 Args: 

298 x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`. 

299 name: A name for the operation (optional). 

300 

301 Returns: 

302 A `Tensor`. Has the same type as `x`. 

303 """ 

304 _ctx = _context._context or _context.context() 

305 tld = _ctx._thread_local_data 

306 if tld.is_eager: 

307 try: 

308 _result = pywrap_tfe.TFE_Py_FastPathExecute( 

309 _ctx, "BesselJ1", name, x) 

310 return _result 

311 except _core._NotOkStatusException as e: 

312 _ops.raise_from_not_ok_status(e, name) 

313 except _core._FallbackException: 

314 pass 

315 try: 

316 return bessel_j1_eager_fallback( 

317 x, name=name, ctx=_ctx) 

318 except _core._SymbolicException: 

319 pass # Add nodes to the TensorFlow graph. 

320 # Add nodes to the TensorFlow graph. 

321 _, _, _op, _outputs = _op_def_library._apply_op_helper( 

322 "BesselJ1", x=x, name=name) 

323 _result = _outputs[:] 

324 if _execute.must_record_gradient(): 

325 _attrs = ("T", _op._get_attr_type("T")) 

326 _inputs_flat = _op.inputs 

327 _execute.record_gradient( 

328 "BesselJ1", _inputs_flat, _attrs, _result) 

329 _result, = _result 

330 return _result 

331 

332BesselJ1 = tf_export("raw_ops.BesselJ1")(_ops.to_raw_op(bessel_j1)) 

333 

334 

335def bessel_j1_eager_fallback(x, name, ctx): 

336 _attr_T, (x,) = _execute.args_to_matching_eager([x], ctx, [_dtypes.bfloat16, _dtypes.half, _dtypes.float32, _dtypes.float64, ]) 

337 _inputs_flat = [x] 

338 _attrs = ("T", _attr_T) 

339 _result = _execute.execute(b"BesselJ1", 1, inputs=_inputs_flat, 

340 attrs=_attrs, ctx=ctx, name=name) 

341 if _execute.must_record_gradient(): 

342 _execute.record_gradient( 

343 "BesselJ1", _inputs_flat, _attrs, _result) 

344 _result, = _result 

345 return _result 

346 

347 

348def bessel_k0(x, name=None): 

349 r"""TODO: add doc. 

350 

351 Args: 

352 x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`. 

353 name: A name for the operation (optional). 

354 

355 Returns: 

356 A `Tensor`. Has the same type as `x`. 

357 """ 

358 _ctx = _context._context or _context.context() 

359 tld = _ctx._thread_local_data 

360 if tld.is_eager: 

361 try: 

362 _result = pywrap_tfe.TFE_Py_FastPathExecute( 

363 _ctx, "BesselK0", name, x) 

364 return _result 

365 except _core._NotOkStatusException as e: 

366 _ops.raise_from_not_ok_status(e, name) 

367 except _core._FallbackException: 

368 pass 

369 try: 

370 return bessel_k0_eager_fallback( 

371 x, name=name, ctx=_ctx) 

372 except _core._SymbolicException: 

373 pass # Add nodes to the TensorFlow graph. 

374 # Add nodes to the TensorFlow graph. 

375 _, _, _op, _outputs = _op_def_library._apply_op_helper( 

376 "BesselK0", x=x, name=name) 

377 _result = _outputs[:] 

378 if _execute.must_record_gradient(): 

379 _attrs = ("T", _op._get_attr_type("T")) 

380 _inputs_flat = _op.inputs 

381 _execute.record_gradient( 

382 "BesselK0", _inputs_flat, _attrs, _result) 

383 _result, = _result 

384 return _result 

385 

386BesselK0 = tf_export("raw_ops.BesselK0")(_ops.to_raw_op(bessel_k0)) 

387 

388 

389def bessel_k0_eager_fallback(x, name, ctx): 

390 _attr_T, (x,) = _execute.args_to_matching_eager([x], ctx, [_dtypes.bfloat16, _dtypes.half, _dtypes.float32, _dtypes.float64, ]) 

391 _inputs_flat = [x] 

392 _attrs = ("T", _attr_T) 

393 _result = _execute.execute(b"BesselK0", 1, inputs=_inputs_flat, 

394 attrs=_attrs, ctx=ctx, name=name) 

395 if _execute.must_record_gradient(): 

396 _execute.record_gradient( 

397 "BesselK0", _inputs_flat, _attrs, _result) 

398 _result, = _result 

399 return _result 

400 

401 

402def bessel_k0e(x, name=None): 

403 r"""TODO: add doc. 

404 

405 Args: 

406 x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`. 

407 name: A name for the operation (optional). 

408 

409 Returns: 

410 A `Tensor`. Has the same type as `x`. 

411 """ 

412 _ctx = _context._context or _context.context() 

413 tld = _ctx._thread_local_data 

414 if tld.is_eager: 

415 try: 

416 _result = pywrap_tfe.TFE_Py_FastPathExecute( 

417 _ctx, "BesselK0e", name, x) 

418 return _result 

419 except _core._NotOkStatusException as e: 

420 _ops.raise_from_not_ok_status(e, name) 

421 except _core._FallbackException: 

422 pass 

423 try: 

424 return bessel_k0e_eager_fallback( 

425 x, name=name, ctx=_ctx) 

426 except _core._SymbolicException: 

427 pass # Add nodes to the TensorFlow graph. 

428 # Add nodes to the TensorFlow graph. 

429 _, _, _op, _outputs = _op_def_library._apply_op_helper( 

430 "BesselK0e", x=x, name=name) 

431 _result = _outputs[:] 

432 if _execute.must_record_gradient(): 

433 _attrs = ("T", _op._get_attr_type("T")) 

434 _inputs_flat = _op.inputs 

435 _execute.record_gradient( 

436 "BesselK0e", _inputs_flat, _attrs, _result) 

437 _result, = _result 

438 return _result 

439 

440BesselK0e = tf_export("raw_ops.BesselK0e")(_ops.to_raw_op(bessel_k0e)) 

441 

442 

443def bessel_k0e_eager_fallback(x, name, ctx): 

444 _attr_T, (x,) = _execute.args_to_matching_eager([x], ctx, [_dtypes.bfloat16, _dtypes.half, _dtypes.float32, _dtypes.float64, ]) 

445 _inputs_flat = [x] 

446 _attrs = ("T", _attr_T) 

447 _result = _execute.execute(b"BesselK0e", 1, inputs=_inputs_flat, 

448 attrs=_attrs, ctx=ctx, name=name) 

449 if _execute.must_record_gradient(): 

450 _execute.record_gradient( 

451 "BesselK0e", _inputs_flat, _attrs, _result) 

452 _result, = _result 

453 return _result 

454 

455 

456def bessel_k1(x, name=None): 

457 r"""TODO: add doc. 

458 

459 Args: 

460 x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`. 

461 name: A name for the operation (optional). 

462 

463 Returns: 

464 A `Tensor`. Has the same type as `x`. 

465 """ 

466 _ctx = _context._context or _context.context() 

467 tld = _ctx._thread_local_data 

468 if tld.is_eager: 

469 try: 

470 _result = pywrap_tfe.TFE_Py_FastPathExecute( 

471 _ctx, "BesselK1", name, x) 

472 return _result 

473 except _core._NotOkStatusException as e: 

474 _ops.raise_from_not_ok_status(e, name) 

475 except _core._FallbackException: 

476 pass 

477 try: 

478 return bessel_k1_eager_fallback( 

479 x, name=name, ctx=_ctx) 

480 except _core._SymbolicException: 

481 pass # Add nodes to the TensorFlow graph. 

482 # Add nodes to the TensorFlow graph. 

483 _, _, _op, _outputs = _op_def_library._apply_op_helper( 

484 "BesselK1", x=x, name=name) 

485 _result = _outputs[:] 

486 if _execute.must_record_gradient(): 

487 _attrs = ("T", _op._get_attr_type("T")) 

488 _inputs_flat = _op.inputs 

489 _execute.record_gradient( 

490 "BesselK1", _inputs_flat, _attrs, _result) 

491 _result, = _result 

492 return _result 

493 

494BesselK1 = tf_export("raw_ops.BesselK1")(_ops.to_raw_op(bessel_k1)) 

495 

496 

497def bessel_k1_eager_fallback(x, name, ctx): 

498 _attr_T, (x,) = _execute.args_to_matching_eager([x], ctx, [_dtypes.bfloat16, _dtypes.half, _dtypes.float32, _dtypes.float64, ]) 

499 _inputs_flat = [x] 

500 _attrs = ("T", _attr_T) 

501 _result = _execute.execute(b"BesselK1", 1, inputs=_inputs_flat, 

502 attrs=_attrs, ctx=ctx, name=name) 

503 if _execute.must_record_gradient(): 

504 _execute.record_gradient( 

505 "BesselK1", _inputs_flat, _attrs, _result) 

506 _result, = _result 

507 return _result 

508 

509 

510def bessel_k1e(x, name=None): 

511 r"""TODO: add doc. 

512 

513 Args: 

514 x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`. 

515 name: A name for the operation (optional). 

516 

517 Returns: 

518 A `Tensor`. Has the same type as `x`. 

519 """ 

520 _ctx = _context._context or _context.context() 

521 tld = _ctx._thread_local_data 

522 if tld.is_eager: 

523 try: 

524 _result = pywrap_tfe.TFE_Py_FastPathExecute( 

525 _ctx, "BesselK1e", name, x) 

526 return _result 

527 except _core._NotOkStatusException as e: 

528 _ops.raise_from_not_ok_status(e, name) 

529 except _core._FallbackException: 

530 pass 

531 try: 

532 return bessel_k1e_eager_fallback( 

533 x, name=name, ctx=_ctx) 

534 except _core._SymbolicException: 

535 pass # Add nodes to the TensorFlow graph. 

536 # Add nodes to the TensorFlow graph. 

537 _, _, _op, _outputs = _op_def_library._apply_op_helper( 

538 "BesselK1e", x=x, name=name) 

539 _result = _outputs[:] 

540 if _execute.must_record_gradient(): 

541 _attrs = ("T", _op._get_attr_type("T")) 

542 _inputs_flat = _op.inputs 

543 _execute.record_gradient( 

544 "BesselK1e", _inputs_flat, _attrs, _result) 

545 _result, = _result 

546 return _result 

547 

548BesselK1e = tf_export("raw_ops.BesselK1e")(_ops.to_raw_op(bessel_k1e)) 

549 

550 

551def bessel_k1e_eager_fallback(x, name, ctx): 

552 _attr_T, (x,) = _execute.args_to_matching_eager([x], ctx, [_dtypes.bfloat16, _dtypes.half, _dtypes.float32, _dtypes.float64, ]) 

553 _inputs_flat = [x] 

554 _attrs = ("T", _attr_T) 

555 _result = _execute.execute(b"BesselK1e", 1, inputs=_inputs_flat, 

556 attrs=_attrs, ctx=ctx, name=name) 

557 if _execute.must_record_gradient(): 

558 _execute.record_gradient( 

559 "BesselK1e", _inputs_flat, _attrs, _result) 

560 _result, = _result 

561 return _result 

562 

563 

564def bessel_y0(x, name=None): 

565 r"""TODO: add doc. 

566 

567 Args: 

568 x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`. 

569 name: A name for the operation (optional). 

570 

571 Returns: 

572 A `Tensor`. Has the same type as `x`. 

573 """ 

574 _ctx = _context._context or _context.context() 

575 tld = _ctx._thread_local_data 

576 if tld.is_eager: 

577 try: 

578 _result = pywrap_tfe.TFE_Py_FastPathExecute( 

579 _ctx, "BesselY0", name, x) 

580 return _result 

581 except _core._NotOkStatusException as e: 

582 _ops.raise_from_not_ok_status(e, name) 

583 except _core._FallbackException: 

584 pass 

585 try: 

586 return bessel_y0_eager_fallback( 

587 x, name=name, ctx=_ctx) 

588 except _core._SymbolicException: 

589 pass # Add nodes to the TensorFlow graph. 

590 # Add nodes to the TensorFlow graph. 

591 _, _, _op, _outputs = _op_def_library._apply_op_helper( 

592 "BesselY0", x=x, name=name) 

593 _result = _outputs[:] 

594 if _execute.must_record_gradient(): 

595 _attrs = ("T", _op._get_attr_type("T")) 

596 _inputs_flat = _op.inputs 

597 _execute.record_gradient( 

598 "BesselY0", _inputs_flat, _attrs, _result) 

599 _result, = _result 

600 return _result 

601 

602BesselY0 = tf_export("raw_ops.BesselY0")(_ops.to_raw_op(bessel_y0)) 

603 

604 

605def bessel_y0_eager_fallback(x, name, ctx): 

606 _attr_T, (x,) = _execute.args_to_matching_eager([x], ctx, [_dtypes.bfloat16, _dtypes.half, _dtypes.float32, _dtypes.float64, ]) 

607 _inputs_flat = [x] 

608 _attrs = ("T", _attr_T) 

609 _result = _execute.execute(b"BesselY0", 1, inputs=_inputs_flat, 

610 attrs=_attrs, ctx=ctx, name=name) 

611 if _execute.must_record_gradient(): 

612 _execute.record_gradient( 

613 "BesselY0", _inputs_flat, _attrs, _result) 

614 _result, = _result 

615 return _result 

616 

617 

618def bessel_y1(x, name=None): 

619 r"""TODO: add doc. 

620 

621 Args: 

622 x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`. 

623 name: A name for the operation (optional). 

624 

625 Returns: 

626 A `Tensor`. Has the same type as `x`. 

627 """ 

628 _ctx = _context._context or _context.context() 

629 tld = _ctx._thread_local_data 

630 if tld.is_eager: 

631 try: 

632 _result = pywrap_tfe.TFE_Py_FastPathExecute( 

633 _ctx, "BesselY1", name, x) 

634 return _result 

635 except _core._NotOkStatusException as e: 

636 _ops.raise_from_not_ok_status(e, name) 

637 except _core._FallbackException: 

638 pass 

639 try: 

640 return bessel_y1_eager_fallback( 

641 x, name=name, ctx=_ctx) 

642 except _core._SymbolicException: 

643 pass # Add nodes to the TensorFlow graph. 

644 # Add nodes to the TensorFlow graph. 

645 _, _, _op, _outputs = _op_def_library._apply_op_helper( 

646 "BesselY1", x=x, name=name) 

647 _result = _outputs[:] 

648 if _execute.must_record_gradient(): 

649 _attrs = ("T", _op._get_attr_type("T")) 

650 _inputs_flat = _op.inputs 

651 _execute.record_gradient( 

652 "BesselY1", _inputs_flat, _attrs, _result) 

653 _result, = _result 

654 return _result 

655 

656BesselY1 = tf_export("raw_ops.BesselY1")(_ops.to_raw_op(bessel_y1)) 

657 

658 

659def bessel_y1_eager_fallback(x, name, ctx): 

660 _attr_T, (x,) = _execute.args_to_matching_eager([x], ctx, [_dtypes.bfloat16, _dtypes.half, _dtypes.float32, _dtypes.float64, ]) 

661 _inputs_flat = [x] 

662 _attrs = ("T", _attr_T) 

663 _result = _execute.execute(b"BesselY1", 1, inputs=_inputs_flat, 

664 attrs=_attrs, ctx=ctx, name=name) 

665 if _execute.must_record_gradient(): 

666 _execute.record_gradient( 

667 "BesselY1", _inputs_flat, _attrs, _result) 

668 _result, = _result 

669 return _result 

670 

671 

672def dawsn(x, name=None): 

673 r"""TODO: add doc. 

674 

675 Args: 

676 x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`. 

677 name: A name for the operation (optional). 

678 

679 Returns: 

680 A `Tensor`. Has the same type as `x`. 

681 """ 

682 _ctx = _context._context or _context.context() 

683 tld = _ctx._thread_local_data 

684 if tld.is_eager: 

685 try: 

686 _result = pywrap_tfe.TFE_Py_FastPathExecute( 

687 _ctx, "Dawsn", name, x) 

688 return _result 

689 except _core._NotOkStatusException as e: 

690 _ops.raise_from_not_ok_status(e, name) 

691 except _core._FallbackException: 

692 pass 

693 try: 

694 return dawsn_eager_fallback( 

695 x, name=name, ctx=_ctx) 

696 except _core._SymbolicException: 

697 pass # Add nodes to the TensorFlow graph. 

698 # Add nodes to the TensorFlow graph. 

699 _, _, _op, _outputs = _op_def_library._apply_op_helper( 

700 "Dawsn", x=x, name=name) 

701 _result = _outputs[:] 

702 if _execute.must_record_gradient(): 

703 _attrs = ("T", _op._get_attr_type("T")) 

704 _inputs_flat = _op.inputs 

705 _execute.record_gradient( 

706 "Dawsn", _inputs_flat, _attrs, _result) 

707 _result, = _result 

708 return _result 

709 

710Dawsn = tf_export("raw_ops.Dawsn")(_ops.to_raw_op(dawsn)) 

711 

712 

713def dawsn_eager_fallback(x, name, ctx): 

714 _attr_T, (x,) = _execute.args_to_matching_eager([x], ctx, [_dtypes.bfloat16, _dtypes.half, _dtypes.float32, _dtypes.float64, ]) 

715 _inputs_flat = [x] 

716 _attrs = ("T", _attr_T) 

717 _result = _execute.execute(b"Dawsn", 1, inputs=_inputs_flat, attrs=_attrs, 

718 ctx=ctx, name=name) 

719 if _execute.must_record_gradient(): 

720 _execute.record_gradient( 

721 "Dawsn", _inputs_flat, _attrs, _result) 

722 _result, = _result 

723 return _result 

724 

725 

726def expint(x, name=None): 

727 r"""TODO: add doc. 

728 

729 Args: 

730 x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`. 

731 name: A name for the operation (optional). 

732 

733 Returns: 

734 A `Tensor`. Has the same type as `x`. 

735 """ 

736 _ctx = _context._context or _context.context() 

737 tld = _ctx._thread_local_data 

738 if tld.is_eager: 

739 try: 

740 _result = pywrap_tfe.TFE_Py_FastPathExecute( 

741 _ctx, "Expint", name, x) 

742 return _result 

743 except _core._NotOkStatusException as e: 

744 _ops.raise_from_not_ok_status(e, name) 

745 except _core._FallbackException: 

746 pass 

747 try: 

748 return expint_eager_fallback( 

749 x, name=name, ctx=_ctx) 

750 except _core._SymbolicException: 

751 pass # Add nodes to the TensorFlow graph. 

752 # Add nodes to the TensorFlow graph. 

753 _, _, _op, _outputs = _op_def_library._apply_op_helper( 

754 "Expint", x=x, name=name) 

755 _result = _outputs[:] 

756 if _execute.must_record_gradient(): 

757 _attrs = ("T", _op._get_attr_type("T")) 

758 _inputs_flat = _op.inputs 

759 _execute.record_gradient( 

760 "Expint", _inputs_flat, _attrs, _result) 

761 _result, = _result 

762 return _result 

763 

764Expint = tf_export("raw_ops.Expint")(_ops.to_raw_op(expint)) 

765 

766 

767def expint_eager_fallback(x, name, ctx): 

768 _attr_T, (x,) = _execute.args_to_matching_eager([x], ctx, [_dtypes.bfloat16, _dtypes.half, _dtypes.float32, _dtypes.float64, ])