Pytest Pytorch Scipy Tensorflow
Mon 30 June 2025
# Cell 1 - Pytest Example
def add_1(a, b):
return a + b + 1
def test_add_1():
assert add_1(1, 2) == 4
test_add_1()
print("Pytest Cell 1 Passed")
Pytest Cell 1 Passed
# Cell 2 - Pytest Example
def add_2(a, b):
return a + b + 2
def test_add_2():
assert add_2(2, 3) == 7
test_add_2()
print("Pytest Cell 2 Passed")
Pytest Cell 2 Passed
# Cell 3 - Pytest Example
def add_3(a, b):
return a + b + 3
def test_add_3():
assert add_3(3, 4) == 10
test_add_3()
print("Pytest Cell 3 Passed")
Pytest Cell 3 Passed
# Cell 4 - Pytest Example
def add_4(a, b):
return a + b + 4
def test_add_4():
assert add_4(4, 5) == 13
test_add_4()
print("Pytest Cell 4 Passed")
Pytest Cell 4 Passed
# Cell 5 - Pytest Example
def add_5(a, b):
return a + b + 5
def test_add_5():
assert add_5(5, 6) == 16
test_add_5()
print("Pytest Cell 5 Passed")
Pytest Cell 5 Passed
# Cell 6 - Pytest Example
def add_6(a, b):
return a + b + 6
def test_add_6():
assert add_6(6, 7) == 19
test_add_6()
print("Pytest Cell 6 Passed")
Pytest Cell 6 Passed
# Cell 7 - Pytest Example
def add_7(a, b):
return a + b + 7
def test_add_7():
assert add_7(7, 8) == 22
test_add_7()
print("Pytest Cell 7 Passed")
Pytest Cell 7 Passed
# Cell 8 - Pytest Example
def add_8(a, b):
return a + b + 8
def test_add_8():
assert add_8(8, 9) == 25
test_add_8()
print("Pytest Cell 8 Passed")
Pytest Cell 8 Passed
# Cell 9 - Pytest Example
def add_9(a, b):
return a + b + 9
def test_add_9():
assert add_9(9, 10) == 28
test_add_9()
print("Pytest Cell 9 Passed")
Pytest Cell 9 Passed
# Cell 10 - Pytest Example
def add_10(a, b):
return a + b + 10
def test_add_10():
assert add_10(10, 11) == 31
test_add_10()
print("Pytest Cell 10 Passed")
Pytest Cell 10 Passed
# Cell 11 - Pytest Example
def add_11(a, b):
return a + b + 11
def test_add_11():
assert add_11(11, 12) == 34
test_add_11()
print("Pytest Cell 11 Passed")
Pytest Cell 11 Passed
# Cell 12 - Pytest Example
def add_12(a, b):
return a + b + 12
def test_add_12():
assert add_12(12, 13) == 37
test_add_12()
print("Pytest Cell 12 Passed")
Pytest Cell 12 Passed
# Cell 13 - Pytest Example
def add_13(a, b):
return a + b + 13
def test_add_13():
assert add_13(13, 14) == 40
test_add_13()
print("Pytest Cell 13 Passed")
Pytest Cell 13 Passed
# Cell 14 - Pytest Example
def add_14(a, b):
return a + b + 14
def test_add_14():
assert add_14(14, 15) == 43
test_add_14()
print("Pytest Cell 14 Passed")
Pytest Cell 14 Passed
# Cell 15 - Pytest Example
def add_15(a, b):
return a + b + 15
def test_add_15():
assert add_15(15, 16) == 46
test_add_15()
print("Pytest Cell 15 Passed")
Pytest Cell 15 Passed
# Cell 16 - Pytest Example
def add_16(a, b):
return a + b + 16
def test_add_16():
assert add_16(16, 17) == 49
test_add_16()
print("Pytest Cell 16 Passed")
Pytest Cell 16 Passed
# Cell 17 - Pytest Example
def add_17(a, b):
return a + b + 17
def test_add_17():
assert add_17(17, 18) == 52
test_add_17()
print("Pytest Cell 17 Passed")
Pytest Cell 17 Passed
# Cell 18 - Pytest Example
def add_18(a, b):
return a + b + 18
def test_add_18():
assert add_18(18, 19) == 55
test_add_18()
print("Pytest Cell 18 Passed")
Pytest Cell 18 Passed
# Cell 19 - Pytest Example
def add_19(a, b):
return a + b + 19
def test_add_19():
assert add_19(19, 20) == 58
test_add_19()
print("Pytest Cell 19 Passed")
Pytest Cell 19 Passed
# Cell 20 - Pytest Example
def add_20(a, b):
return a + b + 20
def test_add_20():
assert add_20(20, 21) == 61
test_add_20()
print("Pytest Cell 20 Passed")
Pytest Cell 20 Passed
# Cell 21 - Pytest Example
def add_21(a, b):
return a + b + 21
def test_add_21():
assert add_21(21, 22) == 64
test_add_21()
print("Pytest Cell 21 Passed")
Pytest Cell 21 Passed
# Cell 22 - Pytest Example
def add_22(a, b):
return a + b + 22
def test_add_22():
assert add_22(22, 23) == 67
test_add_22()
print("Pytest Cell 22 Passed")
Pytest Cell 22 Passed
# Cell 23 - Pytest Example
def add_23(a, b):
return a + b + 23
def test_add_23():
assert add_23(23, 24) == 70
test_add_23()
print("Pytest Cell 23 Passed")
Pytest Cell 23 Passed
# Cell 24 - Pytest Example
def add_24(a, b):
return a + b + 24
def test_add_24():
assert add_24(24, 25) == 73
test_add_24()
print("Pytest Cell 24 Passed")
Pytest Cell 24 Passed
# Cell 25 - Pytest Example
def add_25(a, b):
return a + b + 25
def test_add_25():
assert add_25(25, 26) == 76
test_add_25()
print("Pytest Cell 25 Passed")
Pytest Cell 25 Passed
# Cell 26 - Pytest Example
def add_26(a, b):
return a + b + 26
def test_add_26():
assert add_26(26, 27) == 79
test_add_26()
print("Pytest Cell 26 Passed")
Pytest Cell 26 Passed
# Cell 27 - Pytest Example
def add_27(a, b):
return a + b + 27
def test_add_27():
assert add_27(27, 28) == 82
test_add_27()
print("Pytest Cell 27 Passed")
Pytest Cell 27 Passed
# Cell 28 - Pytest Example
def add_28(a, b):
return a + b + 28
def test_add_28():
assert add_28(28, 29) == 85
test_add_28()
print("Pytest Cell 28 Passed")
Pytest Cell 28 Passed
# Cell 29 - Pytest Example
def add_29(a, b):
return a + b + 29
def test_add_29():
assert add_29(29, 30) == 88
test_add_29()
print("Pytest Cell 29 Passed")
Pytest Cell 29 Passed
# Cell 30 - Pytest Example
def add_30(a, b):
return a + b + 30
def test_add_30():
assert add_30(30, 31) == 91
test_add_30()
print("Pytest Cell 30 Passed")
Pytest Cell 30 Passed
# Cell 31 - Pytest Example
def add_31(a, b):
return a + b + 31
def test_add_31():
assert add_31(31, 32) == 94
test_add_31()
print("Pytest Cell 31 Passed")
Pytest Cell 31 Passed
# Cell 32 - Pytest Example
def add_32(a, b):
return a + b + 32
def test_add_32():
assert add_32(32, 33) == 97
test_add_32()
print("Pytest Cell 32 Passed")
Pytest Cell 32 Passed
# Cell 33 - Pytest Example
def add_33(a, b):
return a + b + 33
def test_add_33():
assert add_33(33, 34) == 100
test_add_33()
print("Pytest Cell 33 Passed")
Pytest Cell 33 Passed
# Cell 34 - Pytest Example
def add_34(a, b):
return a + b + 34
def test_add_34():
assert add_34(34, 35) == 103
test_add_34()
print("Pytest Cell 34 Passed")
Pytest Cell 34 Passed
# Cell 35 - Pytest Example
def add_35(a, b):
return a + b + 35
def test_add_35():
assert add_35(35, 36) == 106
test_add_35()
print("Pytest Cell 35 Passed")
Pytest Cell 35 Passed
# Cell 36 - Pytest Example
def add_36(a, b):
return a + b + 36
def test_add_36():
assert add_36(36, 37) == 109
test_add_36()
print("Pytest Cell 36 Passed")
Pytest Cell 36 Passed
# Cell 37 - Pytest Example
def add_37(a, b):
return a + b + 37
def test_add_37():
assert add_37(37, 38) == 112
test_add_37()
print("Pytest Cell 37 Passed")
Pytest Cell 37 Passed
# Cell 38 - Pytest Example
def add_38(a, b):
return a + b + 38
def test_add_38():
assert add_38(38, 39) == 115
test_add_38()
print("Pytest Cell 38 Passed")
Pytest Cell 38 Passed
# Cell 39 - Pytest Example
def add_39(a, b):
return a + b + 39
def test_add_39():
assert add_39(39, 40) == 118
test_add_39()
print("Pytest Cell 39 Passed")
Pytest Cell 39 Passed
# Cell 40 - Pytest Example
def add_40(a, b):
return a + b + 40
def test_add_40():
assert add_40(40, 41) == 121
test_add_40()
print("Pytest Cell 40 Passed")
Pytest Cell 40 Passed
# Cell 41 - Pytest Example
def add_41(a, b):
return a + b + 41
def test_add_41():
assert add_41(41, 42) == 124
test_add_41()
print("Pytest Cell 41 Passed")
Pytest Cell 41 Passed
# Cell 42 - Pytest Example
def add_42(a, b):
return a + b + 42
def test_add_42():
assert add_42(42, 43) == 127
test_add_42()
print("Pytest Cell 42 Passed")
Pytest Cell 42 Passed
# Cell 43 - Pytest Example
def add_43(a, b):
return a + b + 43
def test_add_43():
assert add_43(43, 44) == 130
test_add_43()
print("Pytest Cell 43 Passed")
Pytest Cell 43 Passed
# Cell 44 - Pytest Example
def add_44(a, b):
return a + b + 44
def test_add_44():
assert add_44(44, 45) == 133
test_add_44()
print("Pytest Cell 44 Passed")
Pytest Cell 44 Passed
# Cell 45 - Pytest Example
def add_45(a, b):
return a + b + 45
def test_add_45():
assert add_45(45, 46) == 136
test_add_45()
print("Pytest Cell 45 Passed")
Pytest Cell 45 Passed
# Cell 46 - Pytest Example
def add_46(a, b):
return a + b + 46
def test_add_46():
assert add_46(46, 47) == 139
test_add_46()
print("Pytest Cell 46 Passed")
Pytest Cell 46 Passed
# Cell 47 - Pytest Example
def add_47(a, b):
return a + b + 47
def test_add_47():
assert add_47(47, 48) == 142
test_add_47()
print("Pytest Cell 47 Passed")
Pytest Cell 47 Passed
# Cell 48 - Pytest Example
def add_48(a, b):
return a + b + 48
def test_add_48():
assert add_48(48, 49) == 145
test_add_48()
print("Pytest Cell 48 Passed")
Pytest Cell 48 Passed
# Cell 49 - Pytest Example
def add_49(a, b):
return a + b + 49
def test_add_49():
assert add_49(49, 50) == 148
test_add_49()
print("Pytest Cell 49 Passed")
Pytest Cell 49 Passed
# Cell 50 - Pytest Example
def add_50(a, b):
return a + b + 50
def test_add_50():
assert add_50(50, 51) == 151
test_add_50()
print("Pytest Cell 50 Passed")
Pytest Cell 50 Passed
# Cell 51 - Pytest Example
def add_51(a, b):
return a + b + 51
def test_add_51():
assert add_51(51, 52) == 154
test_add_51()
print("Pytest Cell 51 Passed")
Pytest Cell 51 Passed
# Cell 52 - Pytest Example
def add_52(a, b):
return a + b + 52
def test_add_52():
assert add_52(52, 53) == 157
test_add_52()
print("Pytest Cell 52 Passed")
Pytest Cell 52 Passed
# Cell 53 - Pytest Example
def add_53(a, b):
return a + b + 53
def test_add_53():
assert add_53(53, 54) == 160
test_add_53()
print("Pytest Cell 53 Passed")
Pytest Cell 53 Passed
# Cell 54 - Pytest Example
def add_54(a, b):
return a + b + 54
def test_add_54():
assert add_54(54, 55) == 163
test_add_54()
print("Pytest Cell 54 Passed")
Pytest Cell 54 Passed
# Cell 55 - Pytest Example
def add_55(a, b):
return a + b + 55
def test_add_55():
assert add_55(55, 56) == 166
test_add_55()
print("Pytest Cell 55 Passed")
Pytest Cell 55 Passed
# Cell 56 - Pytest Example
def add_56(a, b):
return a + b + 56
def test_add_56():
assert add_56(56, 57) == 169
test_add_56()
print("Pytest Cell 56 Passed")
Pytest Cell 56 Passed
# Cell 57 - Pytest Example
def add_57(a, b):
return a + b + 57
def test_add_57():
assert add_57(57, 58) == 172
test_add_57()
print("Pytest Cell 57 Passed")
Pytest Cell 57 Passed
# Cell 58 - Pytest Example
def add_58(a, b):
return a + b + 58
def test_add_58():
assert add_58(58, 59) == 175
test_add_58()
print("Pytest Cell 58 Passed")
Pytest Cell 58 Passed
# Cell 59 - Pytest Example
def add_59(a, b):
return a + b + 59
def test_add_59():
assert add_59(59, 60) == 178
test_add_59()
print("Pytest Cell 59 Passed")
Pytest Cell 59 Passed
# Cell 60 - Pytest Example
def add_60(a, b):
return a + b + 60
def test_add_60():
assert add_60(60, 61) == 181
test_add_60()
print("Pytest Cell 60 Passed")
Pytest Cell 60 Passed
# Cell 61 - Pytest Example
def add_61(a, b):
return a + b + 61
def test_add_61():
assert add_61(61, 62) == 184
test_add_61()
print("Pytest Cell 61 Passed")
Pytest Cell 61 Passed
# Cell 62 - Pytest Example
def add_62(a, b):
return a + b + 62
def test_add_62():
assert add_62(62, 63) == 187
test_add_62()
print("Pytest Cell 62 Passed")
Pytest Cell 62 Passed
# Cell 63 - Pytest Example
def add_63(a, b):
return a + b + 63
def test_add_63():
assert add_63(63, 64) == 190
test_add_63()
print("Pytest Cell 63 Passed")
Pytest Cell 63 Passed
# Cell 64 - Pytest Example
def add_64(a, b):
return a + b + 64
def test_add_64():
assert add_64(64, 65) == 193
test_add_64()
print("Pytest Cell 64 Passed")
Pytest Cell 64 Passed
# Cell 65 - Pytest Example
def add_65(a, b):
return a + b + 65
def test_add_65():
assert add_65(65, 66) == 196
test_add_65()
print("Pytest Cell 65 Passed")
Pytest Cell 65 Passed
# Cell 66 - Pytest Example
def add_66(a, b):
return a + b + 66
def test_add_66():
assert add_66(66, 67) == 199
test_add_66()
print("Pytest Cell 66 Passed")
Pytest Cell 66 Passed
# Cell 67 - Pytest Example
def add_67(a, b):
return a + b + 67
def test_add_67():
assert add_67(67, 68) == 202
test_add_67()
print("Pytest Cell 67 Passed")
Pytest Cell 67 Passed
# Cell 68 - Pytest Example
def add_68(a, b):
return a + b + 68
def test_add_68():
assert add_68(68, 69) == 205
test_add_68()
print("Pytest Cell 68 Passed")
Pytest Cell 68 Passed
# Cell 69 - Pytest Example
def add_69(a, b):
return a + b + 69
def test_add_69():
assert add_69(69, 70) == 208
test_add_69()
print("Pytest Cell 69 Passed")
Pytest Cell 69 Passed
# Cell 70 - Pytest Example
def add_70(a, b):
return a + b + 70
def test_add_70():
assert add_70(70, 71) == 211
test_add_70()
print("Pytest Cell 70 Passed")
Pytest Cell 70 Passed
# Cell 71 - Pytest Example
def add_71(a, b):
return a + b + 71
def test_add_71():
assert add_71(71, 72) == 214
test_add_71()
print("Pytest Cell 71 Passed")
Pytest Cell 71 Passed
# Cell 72 - Pytest Example
def add_72(a, b):
return a + b + 72
def test_add_72():
assert add_72(72, 73) == 217
test_add_72()
print("Pytest Cell 72 Passed")
Pytest Cell 72 Passed
# Cell 73 - Pytest Example
def add_73(a, b):
return a + b + 73
def test_add_73():
assert add_73(73, 74) == 220
test_add_73()
print("Pytest Cell 73 Passed")
Pytest Cell 73 Passed
# Cell 74 - Pytest Example
def add_74(a, b):
return a + b + 74
def test_add_74():
assert add_74(74, 75) == 223
test_add_74()
print("Pytest Cell 74 Passed")
Pytest Cell 74 Passed
# Cell 75 - Pytest Example
def add_75(a, b):
return a + b + 75
def test_add_75():
assert add_75(75, 76) == 226
test_add_75()
print("Pytest Cell 75 Passed")
Pytest Cell 75 Passed
# Cell 76 - Pytest Example
def add_76(a, b):
return a + b + 76
def test_add_76():
assert add_76(76, 77) == 229
test_add_76()
print("Pytest Cell 76 Passed")
Pytest Cell 76 Passed
# Cell 77 - Pytest Example
def add_77(a, b):
return a + b + 77
def test_add_77():
assert add_77(77, 78) == 232
test_add_77()
print("Pytest Cell 77 Passed")
Pytest Cell 77 Passed
# Cell 78 - Pytest Example
def add_78(a, b):
return a + b + 78
def test_add_78():
assert add_78(78, 79) == 235
test_add_78()
print("Pytest Cell 78 Passed")
Pytest Cell 78 Passed
# Cell 79 - Pytest Example
def add_79(a, b):
return a + b + 79
def test_add_79():
assert add_79(79, 80) == 238
test_add_79()
print("Pytest Cell 79 Passed")
Pytest Cell 79 Passed
# Cell 80 - Pytest Example
def add_80(a, b):
return a + b + 80
def test_add_80():
assert add_80(80, 81) == 241
test_add_80()
print("Pytest Cell 80 Passed")
Pytest Cell 80 Passed
# Cell 81 - Pytest Example
def add_81(a, b):
return a + b + 81
def test_add_81():
assert add_81(81, 82) == 244
test_add_81()
print("Pytest Cell 81 Passed")
Pytest Cell 81 Passed
# Cell 82 - Pytest Example
def add_82(a, b):
return a + b + 82
def test_add_82():
assert add_82(82, 83) == 247
test_add_82()
print("Pytest Cell 82 Passed")
Pytest Cell 82 Passed
# Cell 83 - Pytest Example
def add_83(a, b):
return a + b + 83
def test_add_83():
assert add_83(83, 84) == 250
test_add_83()
print("Pytest Cell 83 Passed")
Pytest Cell 83 Passed
# Cell 84 - Pytest Example
def add_84(a, b):
return a + b + 84
def test_add_84():
assert add_84(84, 85) == 253
test_add_84()
print("Pytest Cell 84 Passed")
Pytest Cell 84 Passed
# Cell 85 - Pytest Example
def add_85(a, b):
return a + b + 85
def test_add_85():
assert add_85(85, 86) == 256
test_add_85()
print("Pytest Cell 85 Passed")
Pytest Cell 85 Passed
# Cell 86 - Pytest Example
def add_86(a, b):
return a + b + 86
def test_add_86():
assert add_86(86, 87) == 259
test_add_86()
print("Pytest Cell 86 Passed")
Pytest Cell 86 Passed
# Cell 87 - Pytest Example
def add_87(a, b):
return a + b + 87
def test_add_87():
assert add_87(87, 88) == 262
test_add_87()
print("Pytest Cell 87 Passed")
Pytest Cell 87 Passed
# Cell 88 - Pytest Example
def add_88(a, b):
return a + b + 88
def test_add_88():
assert add_88(88, 89) == 265
test_add_88()
print("Pytest Cell 88 Passed")
Pytest Cell 88 Passed
# Cell 89 - Pytest Example
def add_89(a, b):
return a + b + 89
def test_add_89():
assert add_89(89, 90) == 268
test_add_89()
print("Pytest Cell 89 Passed")
Pytest Cell 89 Passed
# Cell 90 - Pytest Example
def add_90(a, b):
return a + b + 90
def test_add_90():
assert add_90(90, 91) == 271
test_add_90()
print("Pytest Cell 90 Passed")
Pytest Cell 90 Passed
# Cell 91 - Pytest Example
def add_91(a, b):
return a + b + 91
def test_add_91():
assert add_91(91, 92) == 274
test_add_91()
print("Pytest Cell 91 Passed")
Pytest Cell 91 Passed
# Cell 92 - Pytest Example
def add_92(a, b):
return a + b + 92
def test_add_92():
assert add_92(92, 93) == 277
test_add_92()
print("Pytest Cell 92 Passed")
Pytest Cell 92 Passed
# Cell 93 - Pytest Example
def add_93(a, b):
return a + b + 93
def test_add_93():
assert add_93(93, 94) == 280
test_add_93()
print("Pytest Cell 93 Passed")
Pytest Cell 93 Passed
# Cell 94 - Pytest Example
def add_94(a, b):
return a + b + 94
def test_add_94():
assert add_94(94, 95) == 283
test_add_94()
print("Pytest Cell 94 Passed")
Pytest Cell 94 Passed
# Cell 95 - Pytest Example
def add_95(a, b):
return a + b + 95
def test_add_95():
assert add_95(95, 96) == 286
test_add_95()
print("Pytest Cell 95 Passed")
Pytest Cell 95 Passed
# Cell 96 - Pytest Example
def add_96(a, b):
return a + b + 96
def test_add_96():
assert add_96(96, 97) == 289
test_add_96()
print("Pytest Cell 96 Passed")
Pytest Cell 96 Passed
# Cell 97 - Pytest Example
def add_97(a, b):
return a + b + 97
def test_add_97():
assert add_97(97, 98) == 292
test_add_97()
print("Pytest Cell 97 Passed")
Pytest Cell 97 Passed
# Cell 98 - Pytest Example
def add_98(a, b):
return a + b + 98
def test_add_98():
assert add_98(98, 99) == 295
test_add_98()
print("Pytest Cell 98 Passed")
Pytest Cell 98 Passed
# Cell 99 - Pytest Example
def add_99(a, b):
return a + b + 99
def test_add_99():
assert add_99(99, 100) == 298
test_add_99()
print("Pytest Cell 99 Passed")
Pytest Cell 99 Passed
# Cell 100 - Pytest Example
def add_100(a, b):
return a + b + 100
def test_add_100():
assert add_100(100, 101) == 301
test_add_100()
print("Pytest Cell 100 Passed")
Pytest Cell 100 Passed
# Cell 101 - Pytest Example
def add_101(a, b):
return a + b + 101
def test_add_101():
assert add_101(101, 102) == 304
test_add_101()
print("Pytest Cell 101 Passed")
Pytest Cell 101 Passed
# Cell 102 - Pytest Example
def add_102(a, b):
return a + b + 102
def test_add_102():
assert add_102(102, 103) == 307
test_add_102()
print("Pytest Cell 102 Passed")
Pytest Cell 102 Passed
# Cell 103 - Pytest Example
def add_103(a, b):
return a + b + 103
def test_add_103():
assert add_103(103, 104) == 310
test_add_103()
print("Pytest Cell 103 Passed")
Pytest Cell 103 Passed
# Cell 104 - Pytest Example
def add_104(a, b):
return a + b + 104
def test_add_104():
assert add_104(104, 105) == 313
test_add_104()
print("Pytest Cell 104 Passed")
Pytest Cell 104 Passed
# Cell 105 - Pytest Example
def add_105(a, b):
return a + b + 105
def test_add_105():
assert add_105(105, 106) == 316
test_add_105()
print("Pytest Cell 105 Passed")
Pytest Cell 105 Passed
# Cell 106 - Pytest Example
def add_106(a, b):
return a + b + 106
def test_add_106():
assert add_106(106, 107) == 319
test_add_106()
print("Pytest Cell 106 Passed")
Pytest Cell 106 Passed
# Cell 107 - Pytest Example
def add_107(a, b):
return a + b + 107
def test_add_107():
assert add_107(107, 108) == 322
test_add_107()
print("Pytest Cell 107 Passed")
Pytest Cell 107 Passed
# Cell 108 - Pytest Example
def add_108(a, b):
return a + b + 108
def test_add_108():
assert add_108(108, 109) == 325
test_add_108()
print("Pytest Cell 108 Passed")
Pytest Cell 108 Passed
# Cell 109 - Pytest Example
def add_109(a, b):
return a + b + 109
def test_add_109():
assert add_109(109, 110) == 328
test_add_109()
print("Pytest Cell 109 Passed")
Pytest Cell 109 Passed
# Cell 110 - Pytest Example
def add_110(a, b):
return a + b + 110
def test_add_110():
assert add_110(110, 111) == 331
test_add_110()
print("Pytest Cell 110 Passed")
Pytest Cell 110 Passed
# Cell 111 - Pytest Example
def add_111(a, b):
return a + b + 111
def test_add_111():
assert add_111(111, 112) == 334
test_add_111()
print("Pytest Cell 111 Passed")
Pytest Cell 111 Passed
# Cell 112 - Pytest Example
def add_112(a, b):
return a + b + 112
def test_add_112():
assert add_112(112, 113) == 337
test_add_112()
print("Pytest Cell 112 Passed")
Pytest Cell 112 Passed
# Cell 113 - Pytest Example
def add_113(a, b):
return a + b + 113
def test_add_113():
assert add_113(113, 114) == 340
test_add_113()
print("Pytest Cell 113 Passed")
Pytest Cell 113 Passed
# Cell 114 - Pytest Example
def add_114(a, b):
return a + b + 114
def test_add_114():
assert add_114(114, 115) == 343
test_add_114()
print("Pytest Cell 114 Passed")
Pytest Cell 114 Passed
# Cell 115 - Pytest Example
def add_115(a, b):
return a + b + 115
def test_add_115():
assert add_115(115, 116) == 346
test_add_115()
print("Pytest Cell 115 Passed")
Pytest Cell 115 Passed
# Cell 116 - Pytest Example
def add_116(a, b):
return a + b + 116
def test_add_116():
assert add_116(116, 117) == 349
test_add_116()
print("Pytest Cell 116 Passed")
Pytest Cell 116 Passed
# Cell 117 - Pytest Example
def add_117(a, b):
return a + b + 117
def test_add_117():
assert add_117(117, 118) == 352
test_add_117()
print("Pytest Cell 117 Passed")
Pytest Cell 117 Passed
# Cell 118 - Pytest Example
def add_118(a, b):
return a + b + 118
def test_add_118():
assert add_118(118, 119) == 355
test_add_118()
print("Pytest Cell 118 Passed")
Pytest Cell 118 Passed
# Cell 119 - Pytest Example
def add_119(a, b):
return a + b + 119
def test_add_119():
assert add_119(119, 120) == 358
test_add_119()
print("Pytest Cell 119 Passed")
Pytest Cell 119 Passed
# Cell 120 - Pytest Example
def add_120(a, b):
return a + b + 120
def test_add_120():
assert add_120(120, 121) == 361
test_add_120()
print("Pytest Cell 120 Passed")
Pytest Cell 120 Passed
# Cell 121 - Pytest Example
def add_121(a, b):
return a + b + 121
def test_add_121():
assert add_121(121, 122) == 364
test_add_121()
print("Pytest Cell 121 Passed")
Pytest Cell 121 Passed
# Cell 122 - Pytest Example
def add_122(a, b):
return a + b + 122
def test_add_122():
assert add_122(122, 123) == 367
test_add_122()
print("Pytest Cell 122 Passed")
Pytest Cell 122 Passed
# Cell 123 - Pytest Example
def add_123(a, b):
return a + b + 123
def test_add_123():
assert add_123(123, 124) == 370
test_add_123()
print("Pytest Cell 123 Passed")
Pytest Cell 123 Passed
# Cell 124 - Pytest Example
def add_124(a, b):
return a + b + 124
def test_add_124():
assert add_124(124, 125) == 373
test_add_124()
print("Pytest Cell 124 Passed")
Pytest Cell 124 Passed
# Cell 125 - Pytest Example
def add_125(a, b):
return a + b + 125
def test_add_125():
assert add_125(125, 126) == 376
test_add_125()
print("Pytest Cell 125 Passed")
Pytest Cell 125 Passed
# Cell 126 - Pytest Example
def add_126(a, b):
return a + b + 126
def test_add_126():
assert add_126(126, 127) == 379
test_add_126()
print("Pytest Cell 126 Passed")
Pytest Cell 126 Passed
# Cell 127 - Pytest Example
def add_127(a, b):
return a + b + 127
def test_add_127():
assert add_127(127, 128) == 382
test_add_127()
print("Pytest Cell 127 Passed")
Pytest Cell 127 Passed
# Cell 128 - Pytest Example
def add_128(a, b):
return a + b + 128
def test_add_128():
assert add_128(128, 129) == 385
test_add_128()
print("Pytest Cell 128 Passed")
Pytest Cell 128 Passed
# Cell 129 - Pytest Example
def add_129(a, b):
return a + b + 129
def test_add_129():
assert add_129(129, 130) == 388
test_add_129()
print("Pytest Cell 129 Passed")
Pytest Cell 129 Passed
# Cell 130 - Pytest Example
def add_130(a, b):
return a + b + 130
def test_add_130():
assert add_130(130, 131) == 391
test_add_130()
print("Pytest Cell 130 Passed")
Pytest Cell 130 Passed
# Cell 131 - Pytest Example
def add_131(a, b):
return a + b + 131
def test_add_131():
assert add_131(131, 132) == 394
test_add_131()
print("Pytest Cell 131 Passed")
Pytest Cell 131 Passed
# Cell 132 - Pytest Example
def add_132(a, b):
return a + b + 132
def test_add_132():
assert add_132(132, 133) == 397
test_add_132()
print("Pytest Cell 132 Passed")
Pytest Cell 132 Passed
# Cell 133 - Pytest Example
def add_133(a, b):
return a + b + 133
def test_add_133():
assert add_133(133, 134) == 400
test_add_133()
print("Pytest Cell 133 Passed")
Pytest Cell 133 Passed
# Cell 134 - Pytest Example
def add_134(a, b):
return a + b + 134
def test_add_134():
assert add_134(134, 135) == 403
test_add_134()
print("Pytest Cell 134 Passed")
Pytest Cell 134 Passed
# Cell 135 - Pytest Example
def add_135(a, b):
return a + b + 135
def test_add_135():
assert add_135(135, 136) == 406
test_add_135()
print("Pytest Cell 135 Passed")
Pytest Cell 135 Passed
# Cell 136 - Pytest Example
def add_136(a, b):
return a + b + 136
def test_add_136():
assert add_136(136, 137) == 409
test_add_136()
print("Pytest Cell 136 Passed")
Pytest Cell 136 Passed
# Cell 137 - Pytest Example
def add_137(a, b):
return a + b + 137
def test_add_137():
assert add_137(137, 138) == 412
test_add_137()
print("Pytest Cell 137 Passed")
Pytest Cell 137 Passed
# Cell 138 - Pytest Example
def add_138(a, b):
return a + b + 138
def test_add_138():
assert add_138(138, 139) == 415
test_add_138()
print("Pytest Cell 138 Passed")
Pytest Cell 138 Passed
# Cell 139 - Pytest Example
def add_139(a, b):
return a + b + 139
def test_add_139():
assert add_139(139, 140) == 418
test_add_139()
print("Pytest Cell 139 Passed")
Pytest Cell 139 Passed
# Cell 140 - Pytest Example
def add_140(a, b):
return a + b + 140
def test_add_140():
assert add_140(140, 141) == 421
test_add_140()
print("Pytest Cell 140 Passed")
Pytest Cell 140 Passed
# Cell 141 - Pytest Example
def add_141(a, b):
return a + b + 141
def test_add_141():
assert add_141(141, 142) == 424
test_add_141()
print("Pytest Cell 141 Passed")
Pytest Cell 141 Passed
# Cell 142 - Pytest Example
def add_142(a, b):
return a + b + 142
def test_add_142():
assert add_142(142, 143) == 427
test_add_142()
print("Pytest Cell 142 Passed")
Pytest Cell 142 Passed
# Cell 143 - Pytest Example
def add_143(a, b):
return a + b + 143
def test_add_143():
assert add_143(143, 144) == 430
test_add_143()
print("Pytest Cell 143 Passed")
Pytest Cell 143 Passed
# Cell 144 - Pytest Example
def add_144(a, b):
return a + b + 144
def test_add_144():
assert add_144(144, 145) == 433
test_add_144()
print("Pytest Cell 144 Passed")
Pytest Cell 144 Passed
# Cell 145 - Pytest Example
def add_145(a, b):
return a + b + 145
def test_add_145():
assert add_145(145, 146) == 436
test_add_145()
print("Pytest Cell 145 Passed")
Pytest Cell 145 Passed
# Cell 146 - Pytest Example
def add_146(a, b):
return a + b + 146
def test_add_146():
assert add_146(146, 147) == 439
test_add_146()
print("Pytest Cell 146 Passed")
Pytest Cell 146 Passed
# Cell 147 - Pytest Example
def add_147(a, b):
return a + b + 147
def test_add_147():
assert add_147(147, 148) == 442
test_add_147()
print("Pytest Cell 147 Passed")
Pytest Cell 147 Passed
# Cell 148 - Pytest Example
def add_148(a, b):
return a + b + 148
def test_add_148():
assert add_148(148, 149) == 445
test_add_148()
print("Pytest Cell 148 Passed")
Pytest Cell 148 Passed
# Cell 149 - Pytest Example
def add_149(a, b):
return a + b + 149
def test_add_149():
assert add_149(149, 150) == 448
test_add_149()
print("Pytest Cell 149 Passed")
Pytest Cell 149 Passed
# Cell 150 - Pytest Example
def add_150(a, b):
return a + b + 150
def test_add_150():
assert add_150(150, 151) == 451
test_add_150()
print("Pytest Cell 150 Passed")
Pytest Cell 150 Passed
# Cell 151 - PyTorch Example
import torch
x151 = torch.tensor([151.0, 152.0])
y151 = torch.tensor([153.0, 154.0])
z151 = x151 + y151
print(f"PyTorch Cell 151: ", z151)
---------------------------------------------------------------------------
ModuleNotFoundError Traceback (most recent call last)
Cell In[454], line 2
1 # Cell 151 - PyTorch Example
----> 2 import torch
4 x151 = torch.tensor([151.0, 152.0])
5 y151 = torch.tensor([153.0, 154.0])
ModuleNotFoundError: No module named 'torch'
# Cell 152 - PyTorch Example
import torch
x152 = torch.tensor([152.0, 153.0])
y152 = torch.tensor([154.0, 155.0])
z152 = x152 + y152
print(f"PyTorch Cell 152: ", z152)
# Cell 153 - PyTorch Example
import torch
x153 = torch.tensor([153.0, 154.0])
y153 = torch.tensor([155.0, 156.0])
z153 = x153 + y153
print(f"PyTorch Cell 153: ", z153)
# Cell 154 - PyTorch Example
import torch
x154 = torch.tensor([154.0, 155.0])
y154 = torch.tensor([156.0, 157.0])
z154 = x154 + y154
print(f"PyTorch Cell 154: ", z154)
# Cell 155 - PyTorch Example
import torch
x155 = torch.tensor([155.0, 156.0])
y155 = torch.tensor([157.0, 158.0])
z155 = x155 + y155
print(f"PyTorch Cell 155: ", z155)
# Cell 156 - PyTorch Example
import torch
x156 = torch.tensor([156.0, 157.0])
y156 = torch.tensor([158.0, 159.0])
z156 = x156 + y156
print(f"PyTorch Cell 156: ", z156)
# Cell 157 - PyTorch Example
import torch
x157 = torch.tensor([157.0, 158.0])
y157 = torch.tensor([159.0, 160.0])
z157 = x157 + y157
print(f"PyTorch Cell 157: ", z157)
# Cell 158 - PyTorch Example
import torch
x158 = torch.tensor([158.0, 159.0])
y158 = torch.tensor([160.0, 161.0])
z158 = x158 + y158
print(f"PyTorch Cell 158: ", z158)
# Cell 159 - PyTorch Example
import torch
x159 = torch.tensor([159.0, 160.0])
y159 = torch.tensor([161.0, 162.0])
z159 = x159 + y159
print(f"PyTorch Cell 159: ", z159)
# Cell 160 - PyTorch Example
import torch
x160 = torch.tensor([160.0, 161.0])
y160 = torch.tensor([162.0, 163.0])
z160 = x160 + y160
print(f"PyTorch Cell 160: ", z160)
# Cell 161 - PyTorch Example
import torch
x161 = torch.tensor([161.0, 162.0])
y161 = torch.tensor([163.0, 164.0])
z161 = x161 + y161
print(f"PyTorch Cell 161: ", z161)
# Cell 162 - PyTorch Example
import torch
x162 = torch.tensor([162.0, 163.0])
y162 = torch.tensor([164.0, 165.0])
z162 = x162 + y162
print(f"PyTorch Cell 162: ", z162)
# Cell 163 - PyTorch Example
import torch
x163 = torch.tensor([163.0, 164.0])
y163 = torch.tensor([165.0, 166.0])
z163 = x163 + y163
print(f"PyTorch Cell 163: ", z163)
# Cell 164 - PyTorch Example
import torch
x164 = torch.tensor([164.0, 165.0])
y164 = torch.tensor([166.0, 167.0])
z164 = x164 + y164
print(f"PyTorch Cell 164: ", z164)
# Cell 165 - PyTorch Example
import torch
x165 = torch.tensor([165.0, 166.0])
y165 = torch.tensor([167.0, 168.0])
z165 = x165 + y165
print(f"PyTorch Cell 165: ", z165)
# Cell 166 - PyTorch Example
import torch
x166 = torch.tensor([166.0, 167.0])
y166 = torch.tensor([168.0, 169.0])
z166 = x166 + y166
print(f"PyTorch Cell 166: ", z166)
# Cell 167 - PyTorch Example
import torch
x167 = torch.tensor([167.0, 168.0])
y167 = torch.tensor([169.0, 170.0])
z167 = x167 + y167
print(f"PyTorch Cell 167: ", z167)
# Cell 168 - PyTorch Example
import torch
x168 = torch.tensor([168.0, 169.0])
y168 = torch.tensor([170.0, 171.0])
z168 = x168 + y168
print(f"PyTorch Cell 168: ", z168)
# Cell 169 - PyTorch Example
import torch
x169 = torch.tensor([169.0, 170.0])
y169 = torch.tensor([171.0, 172.0])
z169 = x169 + y169
print(f"PyTorch Cell 169: ", z169)
# Cell 170 - PyTorch Example
import torch
x170 = torch.tensor([170.0, 171.0])
y170 = torch.tensor([172.0, 173.0])
z170 = x170 + y170
print(f"PyTorch Cell 170: ", z170)
# Cell 171 - PyTorch Example
import torch
x171 = torch.tensor([171.0, 172.0])
y171 = torch.tensor([173.0, 174.0])
z171 = x171 + y171
print(f"PyTorch Cell 171: ", z171)
# Cell 172 - PyTorch Example
import torch
x172 = torch.tensor([172.0, 173.0])
y172 = torch.tensor([174.0, 175.0])
z172 = x172 + y172
print(f"PyTorch Cell 172: ", z172)
# Cell 173 - PyTorch Example
import torch
x173 = torch.tensor([173.0, 174.0])
y173 = torch.tensor([175.0, 176.0])
z173 = x173 + y173
print(f"PyTorch Cell 173: ", z173)
# Cell 174 - PyTorch Example
import torch
x174 = torch.tensor([174.0, 175.0])
y174 = torch.tensor([176.0, 177.0])
z174 = x174 + y174
print(f"PyTorch Cell 174: ", z174)
# Cell 175 - PyTorch Example
import torch
x175 = torch.tensor([175.0, 176.0])
y175 = torch.tensor([177.0, 178.0])
z175 = x175 + y175
print(f"PyTorch Cell 175: ", z175)
# Cell 176 - PyTorch Example
import torch
x176 = torch.tensor([176.0, 177.0])
y176 = torch.tensor([178.0, 179.0])
z176 = x176 + y176
print(f"PyTorch Cell 176: ", z176)
# Cell 177 - PyTorch Example
import torch
x177 = torch.tensor([177.0, 178.0])
y177 = torch.tensor([179.0, 180.0])
z177 = x177 + y177
print(f"PyTorch Cell 177: ", z177)
# Cell 178 - PyTorch Example
import torch
x178 = torch.tensor([178.0, 179.0])
y178 = torch.tensor([180.0, 181.0])
z178 = x178 + y178
print(f"PyTorch Cell 178: ", z178)
# Cell 179 - PyTorch Example
import torch
x179 = torch.tensor([179.0, 180.0])
y179 = torch.tensor([181.0, 182.0])
z179 = x179 + y179
print(f"PyTorch Cell 179: ", z179)
# Cell 180 - PyTorch Example
import torch
x180 = torch.tensor([180.0, 181.0])
y180 = torch.tensor([182.0, 183.0])
z180 = x180 + y180
print(f"PyTorch Cell 180: ", z180)
# Cell 181 - PyTorch Example
import torch
x181 = torch.tensor([181.0, 182.0])
y181 = torch.tensor([183.0, 184.0])
z181 = x181 + y181
print(f"PyTorch Cell 181: ", z181)
# Cell 182 - PyTorch Example
import torch
x182 = torch.tensor([182.0, 183.0])
y182 = torch.tensor([184.0, 185.0])
z182 = x182 + y182
print(f"PyTorch Cell 182: ", z182)
# Cell 183 - PyTorch Example
import torch
x183 = torch.tensor([183.0, 184.0])
y183 = torch.tensor([185.0, 186.0])
z183 = x183 + y183
print(f"PyTorch Cell 183: ", z183)
# Cell 184 - PyTorch Example
import torch
x184 = torch.tensor([184.0, 185.0])
y184 = torch.tensor([186.0, 187.0])
z184 = x184 + y184
print(f"PyTorch Cell 184: ", z184)
# Cell 185 - PyTorch Example
import torch
x185 = torch.tensor([185.0, 186.0])
y185 = torch.tensor([187.0, 188.0])
z185 = x185 + y185
print(f"PyTorch Cell 185: ", z185)
# Cell 186 - PyTorch Example
import torch
x186 = torch.tensor([186.0, 187.0])
y186 = torch.tensor([188.0, 189.0])
z186 = x186 + y186
print(f"PyTorch Cell 186: ", z186)
# Cell 187 - PyTorch Example
import torch
x187 = torch.tensor([187.0, 188.0])
y187 = torch.tensor([189.0, 190.0])
z187 = x187 + y187
print(f"PyTorch Cell 187: ", z187)
# Cell 188 - PyTorch Example
import torch
x188 = torch.tensor([188.0, 189.0])
y188 = torch.tensor([190.0, 191.0])
z188 = x188 + y188
print(f"PyTorch Cell 188: ", z188)
# Cell 189 - PyTorch Example
import torch
x189 = torch.tensor([189.0, 190.0])
y189 = torch.tensor([191.0, 192.0])
z189 = x189 + y189
print(f"PyTorch Cell 189: ", z189)
# Cell 190 - PyTorch Example
import torch
x190 = torch.tensor([190.0, 191.0])
y190 = torch.tensor([192.0, 193.0])
z190 = x190 + y190
print(f"PyTorch Cell 190: ", z190)
# Cell 191 - PyTorch Example
import torch
x191 = torch.tensor([191.0, 192.0])
y191 = torch.tensor([193.0, 194.0])
z191 = x191 + y191
print(f"PyTorch Cell 191: ", z191)
# Cell 192 - PyTorch Example
import torch
x192 = torch.tensor([192.0, 193.0])
y192 = torch.tensor([194.0, 195.0])
z192 = x192 + y192
print(f"PyTorch Cell 192: ", z192)
# Cell 193 - PyTorch Example
import torch
x193 = torch.tensor([193.0, 194.0])
y193 = torch.tensor([195.0, 196.0])
z193 = x193 + y193
print(f"PyTorch Cell 193: ", z193)
# Cell 194 - PyTorch Example
import torch
x194 = torch.tensor([194.0, 195.0])
y194 = torch.tensor([196.0, 197.0])
z194 = x194 + y194
print(f"PyTorch Cell 194: ", z194)
# Cell 195 - PyTorch Example
import torch
x195 = torch.tensor([195.0, 196.0])
y195 = torch.tensor([197.0, 198.0])
z195 = x195 + y195
print(f"PyTorch Cell 195: ", z195)
# Cell 196 - PyTorch Example
import torch
x196 = torch.tensor([196.0, 197.0])
y196 = torch.tensor([198.0, 199.0])
z196 = x196 + y196
print(f"PyTorch Cell 196: ", z196)
# Cell 197 - PyTorch Example
import torch
x197 = torch.tensor([197.0, 198.0])
y197 = torch.tensor([199.0, 200.0])
z197 = x197 + y197
print(f"PyTorch Cell 197: ", z197)
# Cell 198 - PyTorch Example
import torch
x198 = torch.tensor([198.0, 199.0])
y198 = torch.tensor([200.0, 201.0])
z198 = x198 + y198
print(f"PyTorch Cell 198: ", z198)
# Cell 199 - PyTorch Example
import torch
x199 = torch.tensor([199.0, 200.0])
y199 = torch.tensor([201.0, 202.0])
z199 = x199 + y199
print(f"PyTorch Cell 199: ", z199)
# Cell 200 - PyTorch Example
import torch
x200 = torch.tensor([200.0, 201.0])
y200 = torch.tensor([202.0, 203.0])
z200 = x200 + y200
print(f"PyTorch Cell 200: ", z200)
# Cell 201 - PyTorch Example
import torch
x201 = torch.tensor([201.0, 202.0])
y201 = torch.tensor([203.0, 204.0])
z201 = x201 + y201
print(f"PyTorch Cell 201: ", z201)
# Cell 202 - PyTorch Example
import torch
x202 = torch.tensor([202.0, 203.0])
y202 = torch.tensor([204.0, 205.0])
z202 = x202 + y202
print(f"PyTorch Cell 202: ", z202)
# Cell 203 - PyTorch Example
import torch
x203 = torch.tensor([203.0, 204.0])
y203 = torch.tensor([205.0, 206.0])
z203 = x203 + y203
print(f"PyTorch Cell 203: ", z203)
# Cell 204 - PyTorch Example
import torch
x204 = torch.tensor([204.0, 205.0])
y204 = torch.tensor([206.0, 207.0])
z204 = x204 + y204
print(f"PyTorch Cell 204: ", z204)
# Cell 205 - PyTorch Example
import torch
x205 = torch.tensor([205.0, 206.0])
y205 = torch.tensor([207.0, 208.0])
z205 = x205 + y205
print(f"PyTorch Cell 205: ", z205)
# Cell 206 - PyTorch Example
import torch
x206 = torch.tensor([206.0, 207.0])
y206 = torch.tensor([208.0, 209.0])
z206 = x206 + y206
print(f"PyTorch Cell 206: ", z206)
# Cell 207 - PyTorch Example
import torch
x207 = torch.tensor([207.0, 208.0])
y207 = torch.tensor([209.0, 210.0])
z207 = x207 + y207
print(f"PyTorch Cell 207: ", z207)
# Cell 208 - PyTorch Example
import torch
x208 = torch.tensor([208.0, 209.0])
y208 = torch.tensor([210.0, 211.0])
z208 = x208 + y208
print(f"PyTorch Cell 208: ", z208)
# Cell 209 - PyTorch Example
import torch
x209 = torch.tensor([209.0, 210.0])
y209 = torch.tensor([211.0, 212.0])
z209 = x209 + y209
print(f"PyTorch Cell 209: ", z209)
# Cell 210 - PyTorch Example
import torch
x210 = torch.tensor([210.0, 211.0])
y210 = torch.tensor([212.0, 213.0])
z210 = x210 + y210
print(f"PyTorch Cell 210: ", z210)
# Cell 211 - PyTorch Example
import torch
x211 = torch.tensor([211.0, 212.0])
y211 = torch.tensor([213.0, 214.0])
z211 = x211 + y211
print(f"PyTorch Cell 211: ", z211)
# Cell 212 - PyTorch Example
import torch
x212 = torch.tensor([212.0, 213.0])
y212 = torch.tensor([214.0, 215.0])
z212 = x212 + y212
print(f"PyTorch Cell 212: ", z212)
# Cell 213 - PyTorch Example
import torch
x213 = torch.tensor([213.0, 214.0])
y213 = torch.tensor([215.0, 216.0])
z213 = x213 + y213
print(f"PyTorch Cell 213: ", z213)
# Cell 214 - PyTorch Example
import torch
x214 = torch.tensor([214.0, 215.0])
y214 = torch.tensor([216.0, 217.0])
z214 = x214 + y214
print(f"PyTorch Cell 214: ", z214)
# Cell 215 - PyTorch Example
import torch
x215 = torch.tensor([215.0, 216.0])
y215 = torch.tensor([217.0, 218.0])
z215 = x215 + y215
print(f"PyTorch Cell 215: ", z215)
# Cell 216 - PyTorch Example
import torch
x216 = torch.tensor([216.0, 217.0])
y216 = torch.tensor([218.0, 219.0])
z216 = x216 + y216
print(f"PyTorch Cell 216: ", z216)
# Cell 217 - PyTorch Example
import torch
x217 = torch.tensor([217.0, 218.0])
y217 = torch.tensor([219.0, 220.0])
z217 = x217 + y217
print(f"PyTorch Cell 217: ", z217)
# Cell 218 - PyTorch Example
import torch
x218 = torch.tensor([218.0, 219.0])
y218 = torch.tensor([220.0, 221.0])
z218 = x218 + y218
print(f"PyTorch Cell 218: ", z218)
# Cell 219 - PyTorch Example
import torch
x219 = torch.tensor([219.0, 220.0])
y219 = torch.tensor([221.0, 222.0])
z219 = x219 + y219
print(f"PyTorch Cell 219: ", z219)
# Cell 220 - PyTorch Example
import torch
x220 = torch.tensor([220.0, 221.0])
y220 = torch.tensor([222.0, 223.0])
z220 = x220 + y220
print(f"PyTorch Cell 220: ", z220)
# Cell 221 - PyTorch Example
import torch
x221 = torch.tensor([221.0, 222.0])
y221 = torch.tensor([223.0, 224.0])
z221 = x221 + y221
print(f"PyTorch Cell 221: ", z221)
# Cell 222 - PyTorch Example
import torch
x222 = torch.tensor([222.0, 223.0])
y222 = torch.tensor([224.0, 225.0])
z222 = x222 + y222
print(f"PyTorch Cell 222: ", z222)
# Cell 223 - PyTorch Example
import torch
x223 = torch.tensor([223.0, 224.0])
y223 = torch.tensor([225.0, 226.0])
z223 = x223 + y223
print(f"PyTorch Cell 223: ", z223)
# Cell 224 - PyTorch Example
import torch
x224 = torch.tensor([224.0, 225.0])
y224 = torch.tensor([226.0, 227.0])
z224 = x224 + y224
print(f"PyTorch Cell 224: ", z224)
# Cell 225 - PyTorch Example
import torch
x225 = torch.tensor([225.0, 226.0])
y225 = torch.tensor([227.0, 228.0])
z225 = x225 + y225
print(f"PyTorch Cell 225: ", z225)
# Cell 226 - PyTorch Example
import torch
x226 = torch.tensor([226.0, 227.0])
y226 = torch.tensor([228.0, 229.0])
z226 = x226 + y226
print(f"PyTorch Cell 226: ", z226)
# Cell 227 - PyTorch Example
import torch
x227 = torch.tensor([227.0, 228.0])
y227 = torch.tensor([229.0, 230.0])
z227 = x227 + y227
print(f"PyTorch Cell 227: ", z227)
# Cell 228 - PyTorch Example
import torch
x228 = torch.tensor([228.0, 229.0])
y228 = torch.tensor([230.0, 231.0])
z228 = x228 + y228
print(f"PyTorch Cell 228: ", z228)
# Cell 229 - PyTorch Example
import torch
x229 = torch.tensor([229.0, 230.0])
y229 = torch.tensor([231.0, 232.0])
z229 = x229 + y229
print(f"PyTorch Cell 229: ", z229)
# Cell 230 - PyTorch Example
import torch
x230 = torch.tensor([230.0, 231.0])
y230 = torch.tensor([232.0, 233.0])
z230 = x230 + y230
print(f"PyTorch Cell 230: ", z230)
# Cell 231 - PyTorch Example
import torch
x231 = torch.tensor([231.0, 232.0])
y231 = torch.tensor([233.0, 234.0])
z231 = x231 + y231
print(f"PyTorch Cell 231: ", z231)
# Cell 232 - PyTorch Example
import torch
x232 = torch.tensor([232.0, 233.0])
y232 = torch.tensor([234.0, 235.0])
z232 = x232 + y232
print(f"PyTorch Cell 232: ", z232)
# Cell 233 - PyTorch Example
import torch
x233 = torch.tensor([233.0, 234.0])
y233 = torch.tensor([235.0, 236.0])
z233 = x233 + y233
print(f"PyTorch Cell 233: ", z233)
# Cell 234 - PyTorch Example
import torch
x234 = torch.tensor([234.0, 235.0])
y234 = torch.tensor([236.0, 237.0])
z234 = x234 + y234
print(f"PyTorch Cell 234: ", z234)
# Cell 235 - PyTorch Example
import torch
x235 = torch.tensor([235.0, 236.0])
y235 = torch.tensor([237.0, 238.0])
z235 = x235 + y235
print(f"PyTorch Cell 235: ", z235)
# Cell 236 - PyTorch Example
import torch
x236 = torch.tensor([236.0, 237.0])
y236 = torch.tensor([238.0, 239.0])
z236 = x236 + y236
print(f"PyTorch Cell 236: ", z236)
# Cell 237 - PyTorch Example
import torch
x237 = torch.tensor([237.0, 238.0])
y237 = torch.tensor([239.0, 240.0])
z237 = x237 + y237
print(f"PyTorch Cell 237: ", z237)
# Cell 238 - PyTorch Example
import torch
x238 = torch.tensor([238.0, 239.0])
y238 = torch.tensor([240.0, 241.0])
z238 = x238 + y238
print(f"PyTorch Cell 238: ", z238)
# Cell 239 - PyTorch Example
import torch
x239 = torch.tensor([239.0, 240.0])
y239 = torch.tensor([241.0, 242.0])
z239 = x239 + y239
print(f"PyTorch Cell 239: ", z239)
# Cell 240 - PyTorch Example
import torch
x240 = torch.tensor([240.0, 241.0])
y240 = torch.tensor([242.0, 243.0])
z240 = x240 + y240
print(f"PyTorch Cell 240: ", z240)
# Cell 241 - PyTorch Example
import torch
x241 = torch.tensor([241.0, 242.0])
y241 = torch.tensor([243.0, 244.0])
z241 = x241 + y241
print(f"PyTorch Cell 241: ", z241)
# Cell 242 - PyTorch Example
import torch
x242 = torch.tensor([242.0, 243.0])
y242 = torch.tensor([244.0, 245.0])
z242 = x242 + y242
print(f"PyTorch Cell 242: ", z242)
# Cell 243 - PyTorch Example
import torch
x243 = torch.tensor([243.0, 244.0])
y243 = torch.tensor([245.0, 246.0])
z243 = x243 + y243
print(f"PyTorch Cell 243: ", z243)
# Cell 244 - PyTorch Example
import torch
x244 = torch.tensor([244.0, 245.0])
y244 = torch.tensor([246.0, 247.0])
z244 = x244 + y244
print(f"PyTorch Cell 244: ", z244)
# Cell 245 - PyTorch Example
import torch
x245 = torch.tensor([245.0, 246.0])
y245 = torch.tensor([247.0, 248.0])
z245 = x245 + y245
print(f"PyTorch Cell 245: ", z245)
# Cell 246 - PyTorch Example
import torch
x246 = torch.tensor([246.0, 247.0])
y246 = torch.tensor([248.0, 249.0])
z246 = x246 + y246
print(f"PyTorch Cell 246: ", z246)
# Cell 247 - PyTorch Example
import torch
x247 = torch.tensor([247.0, 248.0])
y247 = torch.tensor([249.0, 250.0])
z247 = x247 + y247
print(f"PyTorch Cell 247: ", z247)
# Cell 248 - PyTorch Example
import torch
x248 = torch.tensor([248.0, 249.0])
y248 = torch.tensor([250.0, 251.0])
z248 = x248 + y248
print(f"PyTorch Cell 248: ", z248)
# Cell 249 - PyTorch Example
import torch
x249 = torch.tensor([249.0, 250.0])
y249 = torch.tensor([251.0, 252.0])
z249 = x249 + y249
print(f"PyTorch Cell 249: ", z249)
# Cell 250 - PyTorch Example
import torch
x250 = torch.tensor([250.0, 251.0])
y250 = torch.tensor([252.0, 253.0])
z250 = x250 + y250
print(f"PyTorch Cell 250: ", z250)
# Cell 251 - PyTorch Example
import torch
x251 = torch.tensor([251.0, 252.0])
y251 = torch.tensor([253.0, 254.0])
z251 = x251 + y251
print(f"PyTorch Cell 251: ", z251)
# Cell 252 - PyTorch Example
import torch
x252 = torch.tensor([252.0, 253.0])
y252 = torch.tensor([254.0, 255.0])
z252 = x252 + y252
print(f"PyTorch Cell 252: ", z252)
# Cell 253 - PyTorch Example
import torch
x253 = torch.tensor([253.0, 254.0])
y253 = torch.tensor([255.0, 256.0])
z253 = x253 + y253
print(f"PyTorch Cell 253: ", z253)
# Cell 254 - PyTorch Example
import torch
x254 = torch.tensor([254.0, 255.0])
y254 = torch.tensor([256.0, 257.0])
z254 = x254 + y254
print(f"PyTorch Cell 254: ", z254)
# Cell 255 - PyTorch Example
import torch
x255 = torch.tensor([255.0, 256.0])
y255 = torch.tensor([257.0, 258.0])
z255 = x255 + y255
print(f"PyTorch Cell 255: ", z255)
# Cell 256 - PyTorch Example
import torch
x256 = torch.tensor([256.0, 257.0])
y256 = torch.tensor([258.0, 259.0])
z256 = x256 + y256
print(f"PyTorch Cell 256: ", z256)
# Cell 257 - PyTorch Example
import torch
x257 = torch.tensor([257.0, 258.0])
y257 = torch.tensor([259.0, 260.0])
z257 = x257 + y257
print(f"PyTorch Cell 257: ", z257)
# Cell 258 - PyTorch Example
import torch
x258 = torch.tensor([258.0, 259.0])
y258 = torch.tensor([260.0, 261.0])
z258 = x258 + y258
print(f"PyTorch Cell 258: ", z258)
# Cell 259 - PyTorch Example
import torch
x259 = torch.tensor([259.0, 260.0])
y259 = torch.tensor([261.0, 262.0])
z259 = x259 + y259
print(f"PyTorch Cell 259: ", z259)
# Cell 260 - PyTorch Example
import torch
x260 = torch.tensor([260.0, 261.0])
y260 = torch.tensor([262.0, 263.0])
z260 = x260 + y260
print(f"PyTorch Cell 260: ", z260)
# Cell 261 - PyTorch Example
import torch
x261 = torch.tensor([261.0, 262.0])
y261 = torch.tensor([263.0, 264.0])
z261 = x261 + y261
print(f"PyTorch Cell 261: ", z261)
# Cell 262 - PyTorch Example
import torch
x262 = torch.tensor([262.0, 263.0])
y262 = torch.tensor([264.0, 265.0])
z262 = x262 + y262
print(f"PyTorch Cell 262: ", z262)
# Cell 263 - PyTorch Example
import torch
x263 = torch.tensor([263.0, 264.0])
y263 = torch.tensor([265.0, 266.0])
z263 = x263 + y263
print(f"PyTorch Cell 263: ", z263)
# Cell 264 - PyTorch Example
import torch
x264 = torch.tensor([264.0, 265.0])
y264 = torch.tensor([266.0, 267.0])
z264 = x264 + y264
print(f"PyTorch Cell 264: ", z264)
# Cell 265 - PyTorch Example
import torch
x265 = torch.tensor([265.0, 266.0])
y265 = torch.tensor([267.0, 268.0])
z265 = x265 + y265
print(f"PyTorch Cell 265: ", z265)
# Cell 266 - PyTorch Example
import torch
x266 = torch.tensor([266.0, 267.0])
y266 = torch.tensor([268.0, 269.0])
z266 = x266 + y266
print(f"PyTorch Cell 266: ", z266)
# Cell 267 - PyTorch Example
import torch
x267 = torch.tensor([267.0, 268.0])
y267 = torch.tensor([269.0, 270.0])
z267 = x267 + y267
print(f"PyTorch Cell 267: ", z267)
# Cell 268 - PyTorch Example
import torch
x268 = torch.tensor([268.0, 269.0])
y268 = torch.tensor([270.0, 271.0])
z268 = x268 + y268
print(f"PyTorch Cell 268: ", z268)
# Cell 269 - PyTorch Example
import torch
x269 = torch.tensor([269.0, 270.0])
y269 = torch.tensor([271.0, 272.0])
z269 = x269 + y269
print(f"PyTorch Cell 269: ", z269)
# Cell 270 - PyTorch Example
import torch
x270 = torch.tensor([270.0, 271.0])
y270 = torch.tensor([272.0, 273.0])
z270 = x270 + y270
print(f"PyTorch Cell 270: ", z270)
# Cell 271 - PyTorch Example
import torch
x271 = torch.tensor([271.0, 272.0])
y271 = torch.tensor([273.0, 274.0])
z271 = x271 + y271
print(f"PyTorch Cell 271: ", z271)
# Cell 272 - PyTorch Example
import torch
x272 = torch.tensor([272.0, 273.0])
y272 = torch.tensor([274.0, 275.0])
z272 = x272 + y272
print(f"PyTorch Cell 272: ", z272)
# Cell 273 - PyTorch Example
import torch
x273 = torch.tensor([273.0, 274.0])
y273 = torch.tensor([275.0, 276.0])
z273 = x273 + y273
print(f"PyTorch Cell 273: ", z273)
# Cell 274 - PyTorch Example
import torch
x274 = torch.tensor([274.0, 275.0])
y274 = torch.tensor([276.0, 277.0])
z274 = x274 + y274
print(f"PyTorch Cell 274: ", z274)
# Cell 275 - PyTorch Example
import torch
x275 = torch.tensor([275.0, 276.0])
y275 = torch.tensor([277.0, 278.0])
z275 = x275 + y275
print(f"PyTorch Cell 275: ", z275)
# Cell 276 - PyTorch Example
import torch
x276 = torch.tensor([276.0, 277.0])
y276 = torch.tensor([278.0, 279.0])
z276 = x276 + y276
print(f"PyTorch Cell 276: ", z276)
# Cell 277 - PyTorch Example
import torch
x277 = torch.tensor([277.0, 278.0])
y277 = torch.tensor([279.0, 280.0])
z277 = x277 + y277
print(f"PyTorch Cell 277: ", z277)
# Cell 278 - PyTorch Example
import torch
x278 = torch.tensor([278.0, 279.0])
y278 = torch.tensor([280.0, 281.0])
z278 = x278 + y278
print(f"PyTorch Cell 278: ", z278)
# Cell 279 - PyTorch Example
import torch
x279 = torch.tensor([279.0, 280.0])
y279 = torch.tensor([281.0, 282.0])
z279 = x279 + y279
print(f"PyTorch Cell 279: ", z279)
# Cell 280 - PyTorch Example
import torch
x280 = torch.tensor([280.0, 281.0])
y280 = torch.tensor([282.0, 283.0])
z280 = x280 + y280
print(f"PyTorch Cell 280: ", z280)
# Cell 281 - PyTorch Example
import torch
x281 = torch.tensor([281.0, 282.0])
y281 = torch.tensor([283.0, 284.0])
z281 = x281 + y281
print(f"PyTorch Cell 281: ", z281)
# Cell 282 - PyTorch Example
import torch
x282 = torch.tensor([282.0, 283.0])
y282 = torch.tensor([284.0, 285.0])
z282 = x282 + y282
print(f"PyTorch Cell 282: ", z282)
# Cell 283 - PyTorch Example
import torch
x283 = torch.tensor([283.0, 284.0])
y283 = torch.tensor([285.0, 286.0])
z283 = x283 + y283
print(f"PyTorch Cell 283: ", z283)
# Cell 284 - PyTorch Example
import torch
x284 = torch.tensor([284.0, 285.0])
y284 = torch.tensor([286.0, 287.0])
z284 = x284 + y284
print(f"PyTorch Cell 284: ", z284)
# Cell 285 - PyTorch Example
import torch
x285 = torch.tensor([285.0, 286.0])
y285 = torch.tensor([287.0, 288.0])
z285 = x285 + y285
print(f"PyTorch Cell 285: ", z285)
# Cell 286 - PyTorch Example
import torch
x286 = torch.tensor([286.0, 287.0])
y286 = torch.tensor([288.0, 289.0])
z286 = x286 + y286
print(f"PyTorch Cell 286: ", z286)
# Cell 287 - PyTorch Example
import torch
x287 = torch.tensor([287.0, 288.0])
y287 = torch.tensor([289.0, 290.0])
z287 = x287 + y287
print(f"PyTorch Cell 287: ", z287)
# Cell 288 - PyTorch Example
import torch
x288 = torch.tensor([288.0, 289.0])
y288 = torch.tensor([290.0, 291.0])
z288 = x288 + y288
print(f"PyTorch Cell 288: ", z288)
# Cell 289 - PyTorch Example
import torch
x289 = torch.tensor([289.0, 290.0])
y289 = torch.tensor([291.0, 292.0])
z289 = x289 + y289
print(f"PyTorch Cell 289: ", z289)
# Cell 290 - PyTorch Example
import torch
x290 = torch.tensor([290.0, 291.0])
y290 = torch.tensor([292.0, 293.0])
z290 = x290 + y290
print(f"PyTorch Cell 290: ", z290)
# Cell 291 - PyTorch Example
import torch
x291 = torch.tensor([291.0, 292.0])
y291 = torch.tensor([293.0, 294.0])
z291 = x291 + y291
print(f"PyTorch Cell 291: ", z291)
# Cell 292 - PyTorch Example
import torch
x292 = torch.tensor([292.0, 293.0])
y292 = torch.tensor([294.0, 295.0])
z292 = x292 + y292
print(f"PyTorch Cell 292: ", z292)
# Cell 293 - PyTorch Example
import torch
x293 = torch.tensor([293.0, 294.0])
y293 = torch.tensor([295.0, 296.0])
z293 = x293 + y293
print(f"PyTorch Cell 293: ", z293)
# Cell 294 - PyTorch Example
import torch
x294 = torch.tensor([294.0, 295.0])
y294 = torch.tensor([296.0, 297.0])
z294 = x294 + y294
print(f"PyTorch Cell 294: ", z294)
# Cell 295 - PyTorch Example
import torch
x295 = torch.tensor([295.0, 296.0])
y295 = torch.tensor([297.0, 298.0])
z295 = x295 + y295
print(f"PyTorch Cell 295: ", z295)
# Cell 296 - PyTorch Example
import torch
x296 = torch.tensor([296.0, 297.0])
y296 = torch.tensor([298.0, 299.0])
z296 = x296 + y296
print(f"PyTorch Cell 296: ", z296)
# Cell 297 - PyTorch Example
import torch
x297 = torch.tensor([297.0, 298.0])
y297 = torch.tensor([299.0, 300.0])
z297 = x297 + y297
print(f"PyTorch Cell 297: ", z297)
# Cell 298 - PyTorch Example
import torch
x298 = torch.tensor([298.0, 299.0])
y298 = torch.tensor([300.0, 301.0])
z298 = x298 + y298
print(f"PyTorch Cell 298: ", z298)
# Cell 299 - PyTorch Example
import torch
x299 = torch.tensor([299.0, 300.0])
y299 = torch.tensor([301.0, 302.0])
z299 = x299 + y299
print(f"PyTorch Cell 299: ", z299)
# Cell 300 - PyTorch Example
import torch
x300 = torch.tensor([300.0, 301.0])
y300 = torch.tensor([302.0, 303.0])
z300 = x300 + y300
print(f"PyTorch Cell 300: ", z300)
# Cell 301 - SciPy Example
from scipy.integrate import quad
def func_301(x):
return x**2 + 301
result_301, _ = quad(func_301, 0, 2)
print(f"SciPy Cell 301: ", result_301)
# Cell 302 - SciPy Example
from scipy.integrate import quad
def func_302(x):
return x**2 + 302
result_302, _ = quad(func_302, 0, 3)
print(f"SciPy Cell 302: ", result_302)
# Cell 303 - SciPy Example
from scipy.integrate import quad
def func_303(x):
return x**2 + 303
result_303, _ = quad(func_303, 0, 4)
print(f"SciPy Cell 303: ", result_303)
# Cell 304 - SciPy Example
from scipy.integrate import quad
def func_304(x):
return x**2 + 304
result_304, _ = quad(func_304, 0, 5)
print(f"SciPy Cell 304: ", result_304)
# Cell 305 - SciPy Example
from scipy.integrate import quad
def func_305(x):
return x**2 + 305
result_305, _ = quad(func_305, 0, 6)
print(f"SciPy Cell 305: ", result_305)
# Cell 306 - SciPy Example
from scipy.integrate import quad
def func_306(x):
return x**2 + 306
result_306, _ = quad(func_306, 0, 7)
print(f"SciPy Cell 306: ", result_306)
# Cell 307 - SciPy Example
from scipy.integrate import quad
def func_307(x):
return x**2 + 307
result_307, _ = quad(func_307, 0, 8)
print(f"SciPy Cell 307: ", result_307)
# Cell 308 - SciPy Example
from scipy.integrate import quad
def func_308(x):
return x**2 + 308
result_308, _ = quad(func_308, 0, 9)
print(f"SciPy Cell 308: ", result_308)
# Cell 309 - SciPy Example
from scipy.integrate import quad
def func_309(x):
return x**2 + 309
result_309, _ = quad(func_309, 0, 10)
print(f"SciPy Cell 309: ", result_309)
# Cell 310 - SciPy Example
from scipy.integrate import quad
def func_310(x):
return x**2 + 310
result_310, _ = quad(func_310, 0, 1)
print(f"SciPy Cell 310: ", result_310)
# Cell 311 - SciPy Example
from scipy.integrate import quad
def func_311(x):
return x**2 + 311
result_311, _ = quad(func_311, 0, 2)
print(f"SciPy Cell 311: ", result_311)
# Cell 312 - SciPy Example
from scipy.integrate import quad
def func_312(x):
return x**2 + 312
result_312, _ = quad(func_312, 0, 3)
print(f"SciPy Cell 312: ", result_312)
# Cell 313 - SciPy Example
from scipy.integrate import quad
def func_313(x):
return x**2 + 313
result_313, _ = quad(func_313, 0, 4)
print(f"SciPy Cell 313: ", result_313)
# Cell 314 - SciPy Example
from scipy.integrate import quad
def func_314(x):
return x**2 + 314
result_314, _ = quad(func_314, 0, 5)
print(f"SciPy Cell 314: ", result_314)
# Cell 315 - SciPy Example
from scipy.integrate import quad
def func_315(x):
return x**2 + 315
result_315, _ = quad(func_315, 0, 6)
print(f"SciPy Cell 315: ", result_315)
# Cell 316 - SciPy Example
from scipy.integrate import quad
def func_316(x):
return x**2 + 316
result_316, _ = quad(func_316, 0, 7)
print(f"SciPy Cell 316: ", result_316)
# Cell 317 - SciPy Example
from scipy.integrate import quad
def func_317(x):
return x**2 + 317
result_317, _ = quad(func_317, 0, 8)
print(f"SciPy Cell 317: ", result_317)
# Cell 318 - SciPy Example
from scipy.integrate import quad
def func_318(x):
return x**2 + 318
result_318, _ = quad(func_318, 0, 9)
print(f"SciPy Cell 318: ", result_318)
# Cell 319 - SciPy Example
from scipy.integrate import quad
def func_319(x):
return x**2 + 319
result_319, _ = quad(func_319, 0, 10)
print(f"SciPy Cell 319: ", result_319)
# Cell 320 - SciPy Example
from scipy.integrate import quad
def func_320(x):
return x**2 + 320
result_320, _ = quad(func_320, 0, 1)
print(f"SciPy Cell 320: ", result_320)
# Cell 321 - SciPy Example
from scipy.integrate import quad
def func_321(x):
return x**2 + 321
result_321, _ = quad(func_321, 0, 2)
print(f"SciPy Cell 321: ", result_321)
# Cell 322 - SciPy Example
from scipy.integrate import quad
def func_322(x):
return x**2 + 322
result_322, _ = quad(func_322, 0, 3)
print(f"SciPy Cell 322: ", result_322)
# Cell 323 - SciPy Example
from scipy.integrate import quad
def func_323(x):
return x**2 + 323
result_323, _ = quad(func_323, 0, 4)
print(f"SciPy Cell 323: ", result_323)
# Cell 324 - SciPy Example
from scipy.integrate import quad
def func_324(x):
return x**2 + 324
result_324, _ = quad(func_324, 0, 5)
print(f"SciPy Cell 324: ", result_324)
# Cell 325 - SciPy Example
from scipy.integrate import quad
def func_325(x):
return x**2 + 325
result_325, _ = quad(func_325, 0, 6)
print(f"SciPy Cell 325: ", result_325)
# Cell 326 - SciPy Example
from scipy.integrate import quad
def func_326(x):
return x**2 + 326
result_326, _ = quad(func_326, 0, 7)
print(f"SciPy Cell 326: ", result_326)
# Cell 327 - SciPy Example
from scipy.integrate import quad
def func_327(x):
return x**2 + 327
result_327, _ = quad(func_327, 0, 8)
print(f"SciPy Cell 327: ", result_327)
# Cell 328 - SciPy Example
from scipy.integrate import quad
def func_328(x):
return x**2 + 328
result_328, _ = quad(func_328, 0, 9)
print(f"SciPy Cell 328: ", result_328)
# Cell 329 - SciPy Example
from scipy.integrate import quad
def func_329(x):
return x**2 + 329
result_329, _ = quad(func_329, 0, 10)
print(f"SciPy Cell 329: ", result_329)
# Cell 330 - SciPy Example
from scipy.integrate import quad
def func_330(x):
return x**2 + 330
result_330, _ = quad(func_330, 0, 1)
print(f"SciPy Cell 330: ", result_330)
# Cell 331 - SciPy Example
from scipy.integrate import quad
def func_331(x):
return x**2 + 331
result_331, _ = quad(func_331, 0, 2)
print(f"SciPy Cell 331: ", result_331)
# Cell 332 - SciPy Example
from scipy.integrate import quad
def func_332(x):
return x**2 + 332
result_332, _ = quad(func_332, 0, 3)
print(f"SciPy Cell 332: ", result_332)
# Cell 333 - SciPy Example
from scipy.integrate import quad
def func_333(x):
return x**2 + 333
result_333, _ = quad(func_333, 0, 4)
print(f"SciPy Cell 333: ", result_333)
# Cell 334 - SciPy Example
from scipy.integrate import quad
def func_334(x):
return x**2 + 334
result_334, _ = quad(func_334, 0, 5)
print(f"SciPy Cell 334: ", result_334)
# Cell 335 - SciPy Example
from scipy.integrate import quad
def func_335(x):
return x**2 + 335
result_335, _ = quad(func_335, 0, 6)
print(f"SciPy Cell 335: ", result_335)
# Cell 336 - SciPy Example
from scipy.integrate import quad
def func_336(x):
return x**2 + 336
result_336, _ = quad(func_336, 0, 7)
print(f"SciPy Cell 336: ", result_336)
# Cell 337 - SciPy Example
from scipy.integrate import quad
def func_337(x):
return x**2 + 337
result_337, _ = quad(func_337, 0, 8)
print(f"SciPy Cell 337: ", result_337)
# Cell 338 - SciPy Example
from scipy.integrate import quad
def func_338(x):
return x**2 + 338
result_338, _ = quad(func_338, 0, 9)
print(f"SciPy Cell 338: ", result_338)
# Cell 339 - SciPy Example
from scipy.integrate import quad
def func_339(x):
return x**2 + 339
result_339, _ = quad(func_339, 0, 10)
print(f"SciPy Cell 339: ", result_339)
# Cell 340 - SciPy Example
from scipy.integrate import quad
def func_340(x):
return x**2 + 340
result_340, _ = quad(func_340, 0, 1)
print(f"SciPy Cell 340: ", result_340)
# Cell 341 - SciPy Example
from scipy.integrate import quad
def func_341(x):
return x**2 + 341
result_341, _ = quad(func_341, 0, 2)
print(f"SciPy Cell 341: ", result_341)
# Cell 342 - SciPy Example
from scipy.integrate import quad
def func_342(x):
return x**2 + 342
result_342, _ = quad(func_342, 0, 3)
print(f"SciPy Cell 342: ", result_342)
# Cell 343 - SciPy Example
from scipy.integrate import quad
def func_343(x):
return x**2 + 343
result_343, _ = quad(func_343, 0, 4)
print(f"SciPy Cell 343: ", result_343)
# Cell 344 - SciPy Example
from scipy.integrate import quad
def func_344(x):
return x**2 + 344
result_344, _ = quad(func_344, 0, 5)
print(f"SciPy Cell 344: ", result_344)
# Cell 345 - SciPy Example
from scipy.integrate import quad
def func_345(x):
return x**2 + 345
result_345, _ = quad(func_345, 0, 6)
print(f"SciPy Cell 345: ", result_345)
# Cell 346 - SciPy Example
from scipy.integrate import quad
def func_346(x):
return x**2 + 346
result_346, _ = quad(func_346, 0, 7)
print(f"SciPy Cell 346: ", result_346)
# Cell 347 - SciPy Example
from scipy.integrate import quad
def func_347(x):
return x**2 + 347
result_347, _ = quad(func_347, 0, 8)
print(f"SciPy Cell 347: ", result_347)
# Cell 348 - SciPy Example
from scipy.integrate import quad
def func_348(x):
return x**2 + 348
result_348, _ = quad(func_348, 0, 9)
print(f"SciPy Cell 348: ", result_348)
# Cell 349 - SciPy Example
from scipy.integrate import quad
def func_349(x):
return x**2 + 349
result_349, _ = quad(func_349, 0, 10)
print(f"SciPy Cell 349: ", result_349)
# Cell 350 - SciPy Example
from scipy.integrate import quad
def func_350(x):
return x**2 + 350
result_350, _ = quad(func_350, 0, 1)
print(f"SciPy Cell 350: ", result_350)
# Cell 351 - SciPy Example
from scipy.integrate import quad
def func_351(x):
return x**2 + 351
result_351, _ = quad(func_351, 0, 2)
print(f"SciPy Cell 351: ", result_351)
# Cell 352 - SciPy Example
from scipy.integrate import quad
def func_352(x):
return x**2 + 352
result_352, _ = quad(func_352, 0, 3)
print(f"SciPy Cell 352: ", result_352)
# Cell 353 - SciPy Example
from scipy.integrate import quad
def func_353(x):
return x**2 + 353
result_353, _ = quad(func_353, 0, 4)
print(f"SciPy Cell 353: ", result_353)
# Cell 354 - SciPy Example
from scipy.integrate import quad
def func_354(x):
return x**2 + 354
result_354, _ = quad(func_354, 0, 5)
print(f"SciPy Cell 354: ", result_354)
# Cell 355 - SciPy Example
from scipy.integrate import quad
def func_355(x):
return x**2 + 355
result_355, _ = quad(func_355, 0, 6)
print(f"SciPy Cell 355: ", result_355)
# Cell 356 - SciPy Example
from scipy.integrate import quad
def func_356(x):
return x**2 + 356
result_356, _ = quad(func_356, 0, 7)
print(f"SciPy Cell 356: ", result_356)
# Cell 357 - SciPy Example
from scipy.integrate import quad
def func_357(x):
return x**2 + 357
result_357, _ = quad(func_357, 0, 8)
print(f"SciPy Cell 357: ", result_357)
# Cell 358 - SciPy Example
from scipy.integrate import quad
def func_358(x):
return x**2 + 358
result_358, _ = quad(func_358, 0, 9)
print(f"SciPy Cell 358: ", result_358)
# Cell 359 - SciPy Example
from scipy.integrate import quad
def func_359(x):
return x**2 + 359
result_359, _ = quad(func_359, 0, 10)
print(f"SciPy Cell 359: ", result_359)
# Cell 360 - SciPy Example
from scipy.integrate import quad
def func_360(x):
return x**2 + 360
result_360, _ = quad(func_360, 0, 1)
print(f"SciPy Cell 360: ", result_360)
# Cell 361 - SciPy Example
from scipy.integrate import quad
def func_361(x):
return x**2 + 361
result_361, _ = quad(func_361, 0, 2)
print(f"SciPy Cell 361: ", result_361)
# Cell 362 - SciPy Example
from scipy.integrate import quad
def func_362(x):
return x**2 + 362
result_362, _ = quad(func_362, 0, 3)
print(f"SciPy Cell 362: ", result_362)
# Cell 363 - SciPy Example
from scipy.integrate import quad
def func_363(x):
return x**2 + 363
result_363, _ = quad(func_363, 0, 4)
print(f"SciPy Cell 363: ", result_363)
# Cell 364 - SciPy Example
from scipy.integrate import quad
def func_364(x):
return x**2 + 364
result_364, _ = quad(func_364, 0, 5)
print(f"SciPy Cell 364: ", result_364)
# Cell 365 - SciPy Example
from scipy.integrate import quad
def func_365(x):
return x**2 + 365
result_365, _ = quad(func_365, 0, 6)
print(f"SciPy Cell 365: ", result_365)
# Cell 366 - SciPy Example
from scipy.integrate import quad
def func_366(x):
return x**2 + 366
result_366, _ = quad(func_366, 0, 7)
print(f"SciPy Cell 366: ", result_366)
# Cell 367 - SciPy Example
from scipy.integrate import quad
def func_367(x):
return x**2 + 367
result_367, _ = quad(func_367, 0, 8)
print(f"SciPy Cell 367: ", result_367)
# Cell 368 - SciPy Example
from scipy.integrate import quad
def func_368(x):
return x**2 + 368
result_368, _ = quad(func_368, 0, 9)
print(f"SciPy Cell 368: ", result_368)
# Cell 369 - SciPy Example
from scipy.integrate import quad
def func_369(x):
return x**2 + 369
result_369, _ = quad(func_369, 0, 10)
print(f"SciPy Cell 369: ", result_369)
# Cell 370 - SciPy Example
from scipy.integrate import quad
def func_370(x):
return x**2 + 370
result_370, _ = quad(func_370, 0, 1)
print(f"SciPy Cell 370: ", result_370)
# Cell 371 - SciPy Example
from scipy.integrate import quad
def func_371(x):
return x**2 + 371
result_371, _ = quad(func_371, 0, 2)
print(f"SciPy Cell 371: ", result_371)
# Cell 372 - SciPy Example
from scipy.integrate import quad
def func_372(x):
return x**2 + 372
result_372, _ = quad(func_372, 0, 3)
print(f"SciPy Cell 372: ", result_372)
# Cell 373 - SciPy Example
from scipy.integrate import quad
def func_373(x):
return x**2 + 373
result_373, _ = quad(func_373, 0, 4)
print(f"SciPy Cell 373: ", result_373)
# Cell 374 - SciPy Example
from scipy.integrate import quad
def func_374(x):
return x**2 + 374
result_374, _ = quad(func_374, 0, 5)
print(f"SciPy Cell 374: ", result_374)
# Cell 375 - SciPy Example
from scipy.integrate import quad
def func_375(x):
return x**2 + 375
result_375, _ = quad(func_375, 0, 6)
print(f"SciPy Cell 375: ", result_375)
# Cell 376 - SciPy Example
from scipy.integrate import quad
def func_376(x):
return x**2 + 376
result_376, _ = quad(func_376, 0, 7)
print(f"SciPy Cell 376: ", result_376)
# Cell 377 - SciPy Example
from scipy.integrate import quad
def func_377(x):
return x**2 + 377
result_377, _ = quad(func_377, 0, 8)
print(f"SciPy Cell 377: ", result_377)
# Cell 378 - SciPy Example
from scipy.integrate import quad
def func_378(x):
return x**2 + 378
result_378, _ = quad(func_378, 0, 9)
print(f"SciPy Cell 378: ", result_378)
# Cell 379 - SciPy Example
from scipy.integrate import quad
def func_379(x):
return x**2 + 379
result_379, _ = quad(func_379, 0, 10)
print(f"SciPy Cell 379: ", result_379)
# Cell 380 - SciPy Example
from scipy.integrate import quad
def func_380(x):
return x**2 + 380
result_380, _ = quad(func_380, 0, 1)
print(f"SciPy Cell 380: ", result_380)
# Cell 381 - SciPy Example
from scipy.integrate import quad
def func_381(x):
return x**2 + 381
result_381, _ = quad(func_381, 0, 2)
print(f"SciPy Cell 381: ", result_381)
# Cell 382 - SciPy Example
from scipy.integrate import quad
def func_382(x):
return x**2 + 382
result_382, _ = quad(func_382, 0, 3)
print(f"SciPy Cell 382: ", result_382)
# Cell 383 - SciPy Example
from scipy.integrate import quad
def func_383(x):
return x**2 + 383
result_383, _ = quad(func_383, 0, 4)
print(f"SciPy Cell 383: ", result_383)
# Cell 384 - SciPy Example
from scipy.integrate import quad
def func_384(x):
return x**2 + 384
result_384, _ = quad(func_384, 0, 5)
print(f"SciPy Cell 384: ", result_384)
# Cell 385 - SciPy Example
from scipy.integrate import quad
def func_385(x):
return x**2 + 385
result_385, _ = quad(func_385, 0, 6)
print(f"SciPy Cell 385: ", result_385)
# Cell 386 - SciPy Example
from scipy.integrate import quad
def func_386(x):
return x**2 + 386
result_386, _ = quad(func_386, 0, 7)
print(f"SciPy Cell 386: ", result_386)
# Cell 387 - SciPy Example
from scipy.integrate import quad
def func_387(x):
return x**2 + 387
result_387, _ = quad(func_387, 0, 8)
print(f"SciPy Cell 387: ", result_387)
# Cell 388 - SciPy Example
from scipy.integrate import quad
def func_388(x):
return x**2 + 388
result_388, _ = quad(func_388, 0, 9)
print(f"SciPy Cell 388: ", result_388)
# Cell 389 - SciPy Example
from scipy.integrate import quad
def func_389(x):
return x**2 + 389
result_389, _ = quad(func_389, 0, 10)
print(f"SciPy Cell 389: ", result_389)
# Cell 390 - SciPy Example
from scipy.integrate import quad
def func_390(x):
return x**2 + 390
result_390, _ = quad(func_390, 0, 1)
print(f"SciPy Cell 390: ", result_390)
# Cell 391 - SciPy Example
from scipy.integrate import quad
def func_391(x):
return x**2 + 391
result_391, _ = quad(func_391, 0, 2)
print(f"SciPy Cell 391: ", result_391)
# Cell 392 - SciPy Example
from scipy.integrate import quad
def func_392(x):
return x**2 + 392
result_392, _ = quad(func_392, 0, 3)
print(f"SciPy Cell 392: ", result_392)
# Cell 393 - SciPy Example
from scipy.integrate import quad
def func_393(x):
return x**2 + 393
result_393, _ = quad(func_393, 0, 4)
print(f"SciPy Cell 393: ", result_393)
# Cell 394 - SciPy Example
from scipy.integrate import quad
def func_394(x):
return x**2 + 394
result_394, _ = quad(func_394, 0, 5)
print(f"SciPy Cell 394: ", result_394)
# Cell 395 - SciPy Example
from scipy.integrate import quad
def func_395(x):
return x**2 + 395
result_395, _ = quad(func_395, 0, 6)
print(f"SciPy Cell 395: ", result_395)
# Cell 396 - SciPy Example
from scipy.integrate import quad
def func_396(x):
return x**2 + 396
result_396, _ = quad(func_396, 0, 7)
print(f"SciPy Cell 396: ", result_396)
# Cell 397 - SciPy Example
from scipy.integrate import quad
def func_397(x):
return x**2 + 397
result_397, _ = quad(func_397, 0, 8)
print(f"SciPy Cell 397: ", result_397)
# Cell 398 - SciPy Example
from scipy.integrate import quad
def func_398(x):
return x**2 + 398
result_398, _ = quad(func_398, 0, 9)
print(f"SciPy Cell 398: ", result_398)
# Cell 399 - SciPy Example
from scipy.integrate import quad
def func_399(x):
return x**2 + 399
result_399, _ = quad(func_399, 0, 10)
print(f"SciPy Cell 399: ", result_399)
# Cell 400 - SciPy Example
from scipy.integrate import quad
def func_400(x):
return x**2 + 400
result_400, _ = quad(func_400, 0, 1)
print(f"SciPy Cell 400: ", result_400)
# Cell 401 - SciPy Example
from scipy.integrate import quad
def func_401(x):
return x**2 + 401
result_401, _ = quad(func_401, 0, 2)
print(f"SciPy Cell 401: ", result_401)
# Cell 402 - SciPy Example
from scipy.integrate import quad
def func_402(x):
return x**2 + 402
result_402, _ = quad(func_402, 0, 3)
print(f"SciPy Cell 402: ", result_402)
# Cell 403 - SciPy Example
from scipy.integrate import quad
def func_403(x):
return x**2 + 403
result_403, _ = quad(func_403, 0, 4)
print(f"SciPy Cell 403: ", result_403)
# Cell 404 - SciPy Example
from scipy.integrate import quad
def func_404(x):
return x**2 + 404
result_404, _ = quad(func_404, 0, 5)
print(f"SciPy Cell 404: ", result_404)
# Cell 405 - SciPy Example
from scipy.integrate import quad
def func_405(x):
return x**2 + 405
result_405, _ = quad(func_405, 0, 6)
print(f"SciPy Cell 405: ", result_405)
# Cell 406 - SciPy Example
from scipy.integrate import quad
def func_406(x):
return x**2 + 406
result_406, _ = quad(func_406, 0, 7)
print(f"SciPy Cell 406: ", result_406)
# Cell 407 - SciPy Example
from scipy.integrate import quad
def func_407(x):
return x**2 + 407
result_407, _ = quad(func_407, 0, 8)
print(f"SciPy Cell 407: ", result_407)
# Cell 408 - SciPy Example
from scipy.integrate import quad
def func_408(x):
return x**2 + 408
result_408, _ = quad(func_408, 0, 9)
print(f"SciPy Cell 408: ", result_408)
# Cell 409 - SciPy Example
from scipy.integrate import quad
def func_409(x):
return x**2 + 409
result_409, _ = quad(func_409, 0, 10)
print(f"SciPy Cell 409: ", result_409)
# Cell 410 - SciPy Example
from scipy.integrate import quad
def func_410(x):
return x**2 + 410
result_410, _ = quad(func_410, 0, 1)
print(f"SciPy Cell 410: ", result_410)
# Cell 411 - SciPy Example
from scipy.integrate import quad
def func_411(x):
return x**2 + 411
result_411, _ = quad(func_411, 0, 2)
print(f"SciPy Cell 411: ", result_411)
# Cell 412 - SciPy Example
from scipy.integrate import quad
def func_412(x):
return x**2 + 412
result_412, _ = quad(func_412, 0, 3)
print(f"SciPy Cell 412: ", result_412)
# Cell 413 - SciPy Example
from scipy.integrate import quad
def func_413(x):
return x**2 + 413
result_413, _ = quad(func_413, 0, 4)
print(f"SciPy Cell 413: ", result_413)
# Cell 414 - SciPy Example
from scipy.integrate import quad
def func_414(x):
return x**2 + 414
result_414, _ = quad(func_414, 0, 5)
print(f"SciPy Cell 414: ", result_414)
# Cell 415 - SciPy Example
from scipy.integrate import quad
def func_415(x):
return x**2 + 415
result_415, _ = quad(func_415, 0, 6)
print(f"SciPy Cell 415: ", result_415)
# Cell 416 - SciPy Example
from scipy.integrate import quad
def func_416(x):
return x**2 + 416
result_416, _ = quad(func_416, 0, 7)
print(f"SciPy Cell 416: ", result_416)
# Cell 417 - SciPy Example
from scipy.integrate import quad
def func_417(x):
return x**2 + 417
result_417, _ = quad(func_417, 0, 8)
print(f"SciPy Cell 417: ", result_417)
# Cell 418 - SciPy Example
from scipy.integrate import quad
def func_418(x):
return x**2 + 418
result_418, _ = quad(func_418, 0, 9)
print(f"SciPy Cell 418: ", result_418)
# Cell 419 - SciPy Example
from scipy.integrate import quad
def func_419(x):
return x**2 + 419
result_419, _ = quad(func_419, 0, 10)
print(f"SciPy Cell 419: ", result_419)
# Cell 420 - SciPy Example
from scipy.integrate import quad
def func_420(x):
return x**2 + 420
result_420, _ = quad(func_420, 0, 1)
print(f"SciPy Cell 420: ", result_420)
# Cell 421 - SciPy Example
from scipy.integrate import quad
def func_421(x):
return x**2 + 421
result_421, _ = quad(func_421, 0, 2)
print(f"SciPy Cell 421: ", result_421)
# Cell 422 - SciPy Example
from scipy.integrate import quad
def func_422(x):
return x**2 + 422
result_422, _ = quad(func_422, 0, 3)
print(f"SciPy Cell 422: ", result_422)
# Cell 423 - SciPy Example
from scipy.integrate import quad
def func_423(x):
return x**2 + 423
result_423, _ = quad(func_423, 0, 4)
print(f"SciPy Cell 423: ", result_423)
# Cell 424 - SciPy Example
from scipy.integrate import quad
def func_424(x):
return x**2 + 424
result_424, _ = quad(func_424, 0, 5)
print(f"SciPy Cell 424: ", result_424)
# Cell 425 - SciPy Example
from scipy.integrate import quad
def func_425(x):
return x**2 + 425
result_425, _ = quad(func_425, 0, 6)
print(f"SciPy Cell 425: ", result_425)
# Cell 426 - SciPy Example
from scipy.integrate import quad
def func_426(x):
return x**2 + 426
result_426, _ = quad(func_426, 0, 7)
print(f"SciPy Cell 426: ", result_426)
# Cell 427 - SciPy Example
from scipy.integrate import quad
def func_427(x):
return x**2 + 427
result_427, _ = quad(func_427, 0, 8)
print(f"SciPy Cell 427: ", result_427)
# Cell 428 - SciPy Example
from scipy.integrate import quad
def func_428(x):
return x**2 + 428
result_428, _ = quad(func_428, 0, 9)
print(f"SciPy Cell 428: ", result_428)
# Cell 429 - SciPy Example
from scipy.integrate import quad
def func_429(x):
return x**2 + 429
result_429, _ = quad(func_429, 0, 10)
print(f"SciPy Cell 429: ", result_429)
# Cell 430 - SciPy Example
from scipy.integrate import quad
def func_430(x):
return x**2 + 430
result_430, _ = quad(func_430, 0, 1)
print(f"SciPy Cell 430: ", result_430)
# Cell 431 - SciPy Example
from scipy.integrate import quad
def func_431(x):
return x**2 + 431
result_431, _ = quad(func_431, 0, 2)
print(f"SciPy Cell 431: ", result_431)
# Cell 432 - SciPy Example
from scipy.integrate import quad
def func_432(x):
return x**2 + 432
result_432, _ = quad(func_432, 0, 3)
print(f"SciPy Cell 432: ", result_432)
# Cell 433 - SciPy Example
from scipy.integrate import quad
def func_433(x):
return x**2 + 433
result_433, _ = quad(func_433, 0, 4)
print(f"SciPy Cell 433: ", result_433)
# Cell 434 - SciPy Example
from scipy.integrate import quad
def func_434(x):
return x**2 + 434
result_434, _ = quad(func_434, 0, 5)
print(f"SciPy Cell 434: ", result_434)
# Cell 435 - SciPy Example
from scipy.integrate import quad
def func_435(x):
return x**2 + 435
result_435, _ = quad(func_435, 0, 6)
print(f"SciPy Cell 435: ", result_435)
# Cell 436 - SciPy Example
from scipy.integrate import quad
def func_436(x):
return x**2 + 436
result_436, _ = quad(func_436, 0, 7)
print(f"SciPy Cell 436: ", result_436)
# Cell 437 - SciPy Example
from scipy.integrate import quad
def func_437(x):
return x**2 + 437
result_437, _ = quad(func_437, 0, 8)
print(f"SciPy Cell 437: ", result_437)
# Cell 438 - SciPy Example
from scipy.integrate import quad
def func_438(x):
return x**2 + 438
result_438, _ = quad(func_438, 0, 9)
print(f"SciPy Cell 438: ", result_438)
# Cell 439 - SciPy Example
from scipy.integrate import quad
def func_439(x):
return x**2 + 439
result_439, _ = quad(func_439, 0, 10)
print(f"SciPy Cell 439: ", result_439)
# Cell 440 - SciPy Example
from scipy.integrate import quad
def func_440(x):
return x**2 + 440
result_440, _ = quad(func_440, 0, 1)
print(f"SciPy Cell 440: ", result_440)
# Cell 441 - SciPy Example
from scipy.integrate import quad
def func_441(x):
return x**2 + 441
result_441, _ = quad(func_441, 0, 2)
print(f"SciPy Cell 441: ", result_441)
# Cell 442 - SciPy Example
from scipy.integrate import quad
def func_442(x):
return x**2 + 442
result_442, _ = quad(func_442, 0, 3)
print(f"SciPy Cell 442: ", result_442)
# Cell 443 - SciPy Example
from scipy.integrate import quad
def func_443(x):
return x**2 + 443
result_443, _ = quad(func_443, 0, 4)
print(f"SciPy Cell 443: ", result_443)
# Cell 444 - SciPy Example
from scipy.integrate import quad
def func_444(x):
return x**2 + 444
result_444, _ = quad(func_444, 0, 5)
print(f"SciPy Cell 444: ", result_444)
# Cell 445 - SciPy Example
from scipy.integrate import quad
def func_445(x):
return x**2 + 445
result_445, _ = quad(func_445, 0, 6)
print(f"SciPy Cell 445: ", result_445)
# Cell 446 - SciPy Example
from scipy.integrate import quad
def func_446(x):
return x**2 + 446
result_446, _ = quad(func_446, 0, 7)
print(f"SciPy Cell 446: ", result_446)
# Cell 447 - SciPy Example
from scipy.integrate import quad
def func_447(x):
return x**2 + 447
result_447, _ = quad(func_447, 0, 8)
print(f"SciPy Cell 447: ", result_447)
# Cell 448 - SciPy Example
from scipy.integrate import quad
def func_448(x):
return x**2 + 448
result_448, _ = quad(func_448, 0, 9)
print(f"SciPy Cell 448: ", result_448)
# Cell 449 - SciPy Example
from scipy.integrate import quad
def func_449(x):
return x**2 + 449
result_449, _ = quad(func_449, 0, 10)
print(f"SciPy Cell 449: ", result_449)
# Cell 450 - SciPy Example
from scipy.integrate import quad
def func_450(x):
return x**2 + 450
result_450, _ = quad(func_450, 0, 1)
print(f"SciPy Cell 450: ", result_450)
# Cell 451 - TensorFlow Example
import tensorflow as tf
a_451 = tf.constant([451.0, 452.0])
b_451 = tf.constant([453.0, 454.0])
c_451 = tf.add(a_451, b_451)
print(f"TensorFlow Cell 451: ", c_451.numpy())
# Cell 452 - TensorFlow Example
import tensorflow as tf
a_452 = tf.constant([452.0, 453.0])
b_452 = tf.constant([454.0, 455.0])
c_452 = tf.add(a_452, b_452)
print(f"TensorFlow Cell 452: ", c_452.numpy())
# Cell 453 - TensorFlow Example
import tensorflow as tf
a_453 = tf.constant([453.0, 454.0])
b_453 = tf.constant([455.0, 456.0])
c_453 = tf.add(a_453, b_453)
print(f"TensorFlow Cell 453: ", c_453.numpy())
# Cell 454 - TensorFlow Example
import tensorflow as tf
a_454 = tf.constant([454.0, 455.0])
b_454 = tf.constant([456.0, 457.0])
c_454 = tf.add(a_454, b_454)
print(f"TensorFlow Cell 454: ", c_454.numpy())
# Cell 455 - TensorFlow Example
import tensorflow as tf
a_455 = tf.constant([455.0, 456.0])
b_455 = tf.constant([457.0, 458.0])
c_455 = tf.add(a_455, b_455)
print(f"TensorFlow Cell 455: ", c_455.numpy())
# Cell 456 - TensorFlow Example
import tensorflow as tf
a_456 = tf.constant([456.0, 457.0])
b_456 = tf.constant([458.0, 459.0])
c_456 = tf.add(a_456, b_456)
print(f"TensorFlow Cell 456: ", c_456.numpy())
# Cell 457 - TensorFlow Example
import tensorflow as tf
a_457 = tf.constant([457.0, 458.0])
b_457 = tf.constant([459.0, 460.0])
c_457 = tf.add(a_457, b_457)
print(f"TensorFlow Cell 457: ", c_457.numpy())
# Cell 458 - TensorFlow Example
import tensorflow as tf
a_458 = tf.constant([458.0, 459.0])
b_458 = tf.constant([460.0, 461.0])
c_458 = tf.add(a_458, b_458)
print(f"TensorFlow Cell 458: ", c_458.numpy())
# Cell 459 - TensorFlow Example
import tensorflow as tf
a_459 = tf.constant([459.0, 460.0])
b_459 = tf.constant([461.0, 462.0])
c_459 = tf.add(a_459, b_459)
print(f"TensorFlow Cell 459: ", c_459.numpy())
# Cell 460 - TensorFlow Example
import tensorflow as tf
a_460 = tf.constant([460.0, 461.0])
b_460 = tf.constant([462.0, 463.0])
c_460 = tf.add(a_460, b_460)
print(f"TensorFlow Cell 460: ", c_460.numpy())
# Cell 461 - TensorFlow Example
import tensorflow as tf
a_461 = tf.constant([461.0, 462.0])
b_461 = tf.constant([463.0, 464.0])
c_461 = tf.add(a_461, b_461)
print(f"TensorFlow Cell 461: ", c_461.numpy())
# Cell 462 - TensorFlow Example
import tensorflow as tf
a_462 = tf.constant([462.0, 463.0])
b_462 = tf.constant([464.0, 465.0])
c_462 = tf.add(a_462, b_462)
print(f"TensorFlow Cell 462: ", c_462.numpy())
# Cell 463 - TensorFlow Example
import tensorflow as tf
a_463 = tf.constant([463.0, 464.0])
b_463 = tf.constant([465.0, 466.0])
c_463 = tf.add(a_463, b_463)
print(f"TensorFlow Cell 463: ", c_463.numpy())
# Cell 464 - TensorFlow Example
import tensorflow as tf
a_464 = tf.constant([464.0, 465.0])
b_464 = tf.constant([466.0, 467.0])
c_464 = tf.add(a_464, b_464)
print(f"TensorFlow Cell 464: ", c_464.numpy())
# Cell 465 - TensorFlow Example
import tensorflow as tf
a_465 = tf.constant([465.0, 466.0])
b_465 = tf.constant([467.0, 468.0])
c_465 = tf.add(a_465, b_465)
print(f"TensorFlow Cell 465: ", c_465.numpy())
# Cell 466 - TensorFlow Example
import tensorflow as tf
a_466 = tf.constant([466.0, 467.0])
b_466 = tf.constant([468.0, 469.0])
c_466 = tf.add(a_466, b_466)
print(f"TensorFlow Cell 466: ", c_466.numpy())
# Cell 467 - TensorFlow Example
import tensorflow as tf
a_467 = tf.constant([467.0, 468.0])
b_467 = tf.constant([469.0, 470.0])
c_467 = tf.add(a_467, b_467)
print(f"TensorFlow Cell 467: ", c_467.numpy())
# Cell 468 - TensorFlow Example
import tensorflow as tf
a_468 = tf.constant([468.0, 469.0])
b_468 = tf.constant([470.0, 471.0])
c_468 = tf.add(a_468, b_468)
print(f"TensorFlow Cell 468: ", c_468.numpy())
# Cell 469 - TensorFlow Example
import tensorflow as tf
a_469 = tf.constant([469.0, 470.0])
b_469 = tf.constant([471.0, 472.0])
c_469 = tf.add(a_469, b_469)
print(f"TensorFlow Cell 469: ", c_469.numpy())
# Cell 470 - TensorFlow Example
import tensorflow as tf
a_470 = tf.constant([470.0, 471.0])
b_470 = tf.constant([472.0, 473.0])
c_470 = tf.add(a_470, b_470)
print(f"TensorFlow Cell 470: ", c_470.numpy())
# Cell 471 - TensorFlow Example
import tensorflow as tf
a_471 = tf.constant([471.0, 472.0])
b_471 = tf.constant([473.0, 474.0])
c_471 = tf.add(a_471, b_471)
print(f"TensorFlow Cell 471: ", c_471.numpy())
# Cell 472 - TensorFlow Example
import tensorflow as tf
a_472 = tf.constant([472.0, 473.0])
b_472 = tf.constant([474.0, 475.0])
c_472 = tf.add(a_472, b_472)
print(f"TensorFlow Cell 472: ", c_472.numpy())
# Cell 473 - TensorFlow Example
import tensorflow as tf
a_473 = tf.constant([473.0, 474.0])
b_473 = tf.constant([475.0, 476.0])
c_473 = tf.add(a_473, b_473)
print(f"TensorFlow Cell 473: ", c_473.numpy())
# Cell 474 - TensorFlow Example
import tensorflow as tf
a_474 = tf.constant([474.0, 475.0])
b_474 = tf.constant([476.0, 477.0])
c_474 = tf.add(a_474, b_474)
print(f"TensorFlow Cell 474: ", c_474.numpy())
# Cell 475 - TensorFlow Example
import tensorflow as tf
a_475 = tf.constant([475.0, 476.0])
b_475 = tf.constant([477.0, 478.0])
c_475 = tf.add(a_475, b_475)
print(f"TensorFlow Cell 475: ", c_475.numpy())
# Cell 476 - TensorFlow Example
import tensorflow as tf
a_476 = tf.constant([476.0, 477.0])
b_476 = tf.constant([478.0, 479.0])
c_476 = tf.add(a_476, b_476)
print(f"TensorFlow Cell 476: ", c_476.numpy())
# Cell 477 - TensorFlow Example
import tensorflow as tf
a_477 = tf.constant([477.0, 478.0])
b_477 = tf.constant([479.0, 480.0])
c_477 = tf.add(a_477, b_477)
print(f"TensorFlow Cell 477: ", c_477.numpy())
# Cell 478 - TensorFlow Example
import tensorflow as tf
a_478 = tf.constant([478.0, 479.0])
b_478 = tf.constant([480.0, 481.0])
c_478 = tf.add(a_478, b_478)
print(f"TensorFlow Cell 478: ", c_478.numpy())
# Cell 479 - TensorFlow Example
import tensorflow as tf
a_479 = tf.constant([479.0, 480.0])
b_479 = tf.constant([481.0, 482.0])
c_479 = tf.add(a_479, b_479)
print(f"TensorFlow Cell 479: ", c_479.numpy())
# Cell 480 - TensorFlow Example
import tensorflow as tf
a_480 = tf.constant([480.0, 481.0])
b_480 = tf.constant([482.0, 483.0])
c_480 = tf.add(a_480, b_480)
print(f"TensorFlow Cell 480: ", c_480.numpy())
# Cell 481 - TensorFlow Example
import tensorflow as tf
a_481 = tf.constant([481.0, 482.0])
b_481 = tf.constant([483.0, 484.0])
c_481 = tf.add(a_481, b_481)
print(f"TensorFlow Cell 481: ", c_481.numpy())
# Cell 482 - TensorFlow Example
import tensorflow as tf
a_482 = tf.constant([482.0, 483.0])
b_482 = tf.constant([484.0, 485.0])
c_482 = tf.add(a_482, b_482)
print(f"TensorFlow Cell 482: ", c_482.numpy())
# Cell 483 - TensorFlow Example
import tensorflow as tf
a_483 = tf.constant([483.0, 484.0])
b_483 = tf.constant([485.0, 486.0])
c_483 = tf.add(a_483, b_483)
print(f"TensorFlow Cell 483: ", c_483.numpy())
# Cell 484 - TensorFlow Example
import tensorflow as tf
a_484 = tf.constant([484.0, 485.0])
b_484 = tf.constant([486.0, 487.0])
c_484 = tf.add(a_484, b_484)
print(f"TensorFlow Cell 484: ", c_484.numpy())
# Cell 485 - TensorFlow Example
import tensorflow as tf
a_485 = tf.constant([485.0, 486.0])
b_485 = tf.constant([487.0, 488.0])
c_485 = tf.add(a_485, b_485)
print(f"TensorFlow Cell 485: ", c_485.numpy())
# Cell 486 - TensorFlow Example
import tensorflow as tf
a_486 = tf.constant([486.0, 487.0])
b_486 = tf.constant([488.0, 489.0])
c_486 = tf.add(a_486, b_486)
print(f"TensorFlow Cell 486: ", c_486.numpy())
# Cell 487 - TensorFlow Example
import tensorflow as tf
a_487 = tf.constant([487.0, 488.0])
b_487 = tf.constant([489.0, 490.0])
c_487 = tf.add(a_487, b_487)
print(f"TensorFlow Cell 487: ", c_487.numpy())
# Cell 488 - TensorFlow Example
import tensorflow as tf
a_488 = tf.constant([488.0, 489.0])
b_488 = tf.constant([490.0, 491.0])
c_488 = tf.add(a_488, b_488)
print(f"TensorFlow Cell 488: ", c_488.numpy())
# Cell 489 - TensorFlow Example
import tensorflow as tf
a_489 = tf.constant([489.0, 490.0])
b_489 = tf.constant([491.0, 492.0])
c_489 = tf.add(a_489, b_489)
print(f"TensorFlow Cell 489: ", c_489.numpy())
# Cell 490 - TensorFlow Example
import tensorflow as tf
a_490 = tf.constant([490.0, 491.0])
b_490 = tf.constant([492.0, 493.0])
c_490 = tf.add(a_490, b_490)
print(f"TensorFlow Cell 490: ", c_490.numpy())
# Cell 491 - TensorFlow Example
import tensorflow as tf
a_491 = tf.constant([491.0, 492.0])
b_491 = tf.constant([493.0, 494.0])
c_491 = tf.add(a_491, b_491)
print(f"TensorFlow Cell 491: ", c_491.numpy())
# Cell 492 - TensorFlow Example
import tensorflow as tf
a_492 = tf.constant([492.0, 493.0])
b_492 = tf.constant([494.0, 495.0])
c_492 = tf.add(a_492, b_492)
print(f"TensorFlow Cell 492: ", c_492.numpy())
# Cell 493 - TensorFlow Example
import tensorflow as tf
a_493 = tf.constant([493.0, 494.0])
b_493 = tf.constant([495.0, 496.0])
c_493 = tf.add(a_493, b_493)
print(f"TensorFlow Cell 493: ", c_493.numpy())
# Cell 494 - TensorFlow Example
import tensorflow as tf
a_494 = tf.constant([494.0, 495.0])
b_494 = tf.constant([496.0, 497.0])
c_494 = tf.add(a_494, b_494)
print(f"TensorFlow Cell 494: ", c_494.numpy())
# Cell 495 - TensorFlow Example
import tensorflow as tf
a_495 = tf.constant([495.0, 496.0])
b_495 = tf.constant([497.0, 498.0])
c_495 = tf.add(a_495, b_495)
print(f"TensorFlow Cell 495: ", c_495.numpy())
# Cell 496 - TensorFlow Example
import tensorflow as tf
a_496 = tf.constant([496.0, 497.0])
b_496 = tf.constant([498.0, 499.0])
c_496 = tf.add(a_496, b_496)
print(f"TensorFlow Cell 496: ", c_496.numpy())
# Cell 497 - TensorFlow Example
import tensorflow as tf
a_497 = tf.constant([497.0, 498.0])
b_497 = tf.constant([499.0, 500.0])
c_497 = tf.add(a_497, b_497)
print(f"TensorFlow Cell 497: ", c_497.numpy())
# Cell 498 - TensorFlow Example
import tensorflow as tf
a_498 = tf.constant([498.0, 499.0])
b_498 = tf.constant([500.0, 501.0])
c_498 = tf.add(a_498, b_498)
print(f"TensorFlow Cell 498: ", c_498.numpy())
# Cell 499 - TensorFlow Example
import tensorflow as tf
a_499 = tf.constant([499.0, 500.0])
b_499 = tf.constant([501.0, 502.0])
c_499 = tf.add(a_499, b_499)
print(f"TensorFlow Cell 499: ", c_499.numpy())
# Cell 500 - TensorFlow Example
import tensorflow as tf
a_500 = tf.constant([500.0, 501.0])
b_500 = tf.constant([502.0, 503.0])
c_500 = tf.add(a_500, b_500)
print(f"TensorFlow Cell 500: ", c_500.numpy())
# Cell 501 - TensorFlow Example
import tensorflow as tf
a_501 = tf.constant([501.0, 502.0])
b_501 = tf.constant([503.0, 504.0])
c_501 = tf.add(a_501, b_501)
print(f"TensorFlow Cell 501: ", c_501.numpy())
# Cell 502 - TensorFlow Example
import tensorflow as tf
a_502 = tf.constant([502.0, 503.0])
b_502 = tf.constant([504.0, 505.0])
c_502 = tf.add(a_502, b_502)
print(f"TensorFlow Cell 502: ", c_502.numpy())
# Cell 503 - TensorFlow Example
import tensorflow as tf
a_503 = tf.constant([503.0, 504.0])
b_503 = tf.constant([505.0, 506.0])
c_503 = tf.add(a_503, b_503)
print(f"TensorFlow Cell 503: ", c_503.numpy())
# Cell 504 - TensorFlow Example
import tensorflow as tf
a_504 = tf.constant([504.0, 505.0])
b_504 = tf.constant([506.0, 507.0])
c_504 = tf.add(a_504, b_504)
print(f"TensorFlow Cell 504: ", c_504.numpy())
# Cell 505 - TensorFlow Example
import tensorflow as tf
a_505 = tf.constant([505.0, 506.0])
b_505 = tf.constant([507.0, 508.0])
c_505 = tf.add(a_505, b_505)
print(f"TensorFlow Cell 505: ", c_505.numpy())
# Cell 506 - TensorFlow Example
import tensorflow as tf
a_506 = tf.constant([506.0, 507.0])
b_506 = tf.constant([508.0, 509.0])
c_506 = tf.add(a_506, b_506)
print(f"TensorFlow Cell 506: ", c_506.numpy())
# Cell 507 - TensorFlow Example
import tensorflow as tf
a_507 = tf.constant([507.0, 508.0])
b_507 = tf.constant([509.0, 510.0])
c_507 = tf.add(a_507, b_507)
print(f"TensorFlow Cell 507: ", c_507.numpy())
# Cell 508 - TensorFlow Example
import tensorflow as tf
a_508 = tf.constant([508.0, 509.0])
b_508 = tf.constant([510.0, 511.0])
c_508 = tf.add(a_508, b_508)
print(f"TensorFlow Cell 508: ", c_508.numpy())
# Cell 509 - TensorFlow Example
import tensorflow as tf
a_509 = tf.constant([509.0, 510.0])
b_509 = tf.constant([511.0, 512.0])
c_509 = tf.add(a_509, b_509)
print(f"TensorFlow Cell 509: ", c_509.numpy())
# Cell 510 - TensorFlow Example
import tensorflow as tf
a_510 = tf.constant([510.0, 511.0])
b_510 = tf.constant([512.0, 513.0])
c_510 = tf.add(a_510, b_510)
print(f"TensorFlow Cell 510: ", c_510.numpy())
# Cell 511 - TensorFlow Example
import tensorflow as tf
a_511 = tf.constant([511.0, 512.0])
b_511 = tf.constant([513.0, 514.0])
c_511 = tf.add(a_511, b_511)
print(f"TensorFlow Cell 511: ", c_511.numpy())
# Cell 512 - TensorFlow Example
import tensorflow as tf
a_512 = tf.constant([512.0, 513.0])
b_512 = tf.constant([514.0, 515.0])
c_512 = tf.add(a_512, b_512)
print(f"TensorFlow Cell 512: ", c_512.numpy())
# Cell 513 - TensorFlow Example
import tensorflow as tf
a_513 = tf.constant([513.0, 514.0])
b_513 = tf.constant([515.0, 516.0])
c_513 = tf.add(a_513, b_513)
print(f"TensorFlow Cell 513: ", c_513.numpy())
# Cell 514 - TensorFlow Example
import tensorflow as tf
a_514 = tf.constant([514.0, 515.0])
b_514 = tf.constant([516.0, 517.0])
c_514 = tf.add(a_514, b_514)
print(f"TensorFlow Cell 514: ", c_514.numpy())
# Cell 515 - TensorFlow Example
import tensorflow as tf
a_515 = tf.constant([515.0, 516.0])
b_515 = tf.constant([517.0, 518.0])
c_515 = tf.add(a_515, b_515)
print(f"TensorFlow Cell 515: ", c_515.numpy())
# Cell 516 - TensorFlow Example
import tensorflow as tf
a_516 = tf.constant([516.0, 517.0])
b_516 = tf.constant([518.0, 519.0])
c_516 = tf.add(a_516, b_516)
print(f"TensorFlow Cell 516: ", c_516.numpy())
# Cell 517 - TensorFlow Example
import tensorflow as tf
a_517 = tf.constant([517.0, 518.0])
b_517 = tf.constant([519.0, 520.0])
c_517 = tf.add(a_517, b_517)
print(f"TensorFlow Cell 517: ", c_517.numpy())
# Cell 518 - TensorFlow Example
import tensorflow as tf
a_518 = tf.constant([518.0, 519.0])
b_518 = tf.constant([520.0, 521.0])
c_518 = tf.add(a_518, b_518)
print(f"TensorFlow Cell 518: ", c_518.numpy())
# Cell 519 - TensorFlow Example
import tensorflow as tf
a_519 = tf.constant([519.0, 520.0])
b_519 = tf.constant([521.0, 522.0])
c_519 = tf.add(a_519, b_519)
print(f"TensorFlow Cell 519: ", c_519.numpy())
# Cell 520 - TensorFlow Example
import tensorflow as tf
a_520 = tf.constant([520.0, 521.0])
b_520 = tf.constant([522.0, 523.0])
c_520 = tf.add(a_520, b_520)
print(f"TensorFlow Cell 520: ", c_520.numpy())
# Cell 521 - TensorFlow Example
import tensorflow as tf
a_521 = tf.constant([521.0, 522.0])
b_521 = tf.constant([523.0, 524.0])
c_521 = tf.add(a_521, b_521)
print(f"TensorFlow Cell 521: ", c_521.numpy())
# Cell 522 - TensorFlow Example
import tensorflow as tf
a_522 = tf.constant([522.0, 523.0])
b_522 = tf.constant([524.0, 525.0])
c_522 = tf.add(a_522, b_522)
print(f"TensorFlow Cell 522: ", c_522.numpy())
# Cell 523 - TensorFlow Example
import tensorflow as tf
a_523 = tf.constant([523.0, 524.0])
b_523 = tf.constant([525.0, 526.0])
c_523 = tf.add(a_523, b_523)
print(f"TensorFlow Cell 523: ", c_523.numpy())
# Cell 524 - TensorFlow Example
import tensorflow as tf
a_524 = tf.constant([524.0, 525.0])
b_524 = tf.constant([526.0, 527.0])
c_524 = tf.add(a_524, b_524)
print(f"TensorFlow Cell 524: ", c_524.numpy())
# Cell 525 - TensorFlow Example
import tensorflow as tf
a_525 = tf.constant([525.0, 526.0])
b_525 = tf.constant([527.0, 528.0])
c_525 = tf.add(a_525, b_525)
print(f"TensorFlow Cell 525: ", c_525.numpy())
# Cell 526 - TensorFlow Example
import tensorflow as tf
a_526 = tf.constant([526.0, 527.0])
b_526 = tf.constant([528.0, 529.0])
c_526 = tf.add(a_526, b_526)
print(f"TensorFlow Cell 526: ", c_526.numpy())
# Cell 527 - TensorFlow Example
import tensorflow as tf
a_527 = tf.constant([527.0, 528.0])
b_527 = tf.constant([529.0, 530.0])
c_527 = tf.add(a_527, b_527)
print(f"TensorFlow Cell 527: ", c_527.numpy())
# Cell 528 - TensorFlow Example
import tensorflow as tf
a_528 = tf.constant([528.0, 529.0])
b_528 = tf.constant([530.0, 531.0])
c_528 = tf.add(a_528, b_528)
print(f"TensorFlow Cell 528: ", c_528.numpy())
# Cell 529 - TensorFlow Example
import tensorflow as tf
a_529 = tf.constant([529.0, 530.0])
b_529 = tf.constant([531.0, 532.0])
c_529 = tf.add(a_529, b_529)
print(f"TensorFlow Cell 529: ", c_529.numpy())
# Cell 530 - TensorFlow Example
import tensorflow as tf
a_530 = tf.constant([530.0, 531.0])
b_530 = tf.constant([532.0, 533.0])
c_530 = tf.add(a_530, b_530)
print(f"TensorFlow Cell 530: ", c_530.numpy())
# Cell 531 - TensorFlow Example
import tensorflow as tf
a_531 = tf.constant([531.0, 532.0])
b_531 = tf.constant([533.0, 534.0])
c_531 = tf.add(a_531, b_531)
print(f"TensorFlow Cell 531: ", c_531.numpy())
# Cell 532 - TensorFlow Example
import tensorflow as tf
a_532 = tf.constant([532.0, 533.0])
b_532 = tf.constant([534.0, 535.0])
c_532 = tf.add(a_532, b_532)
print(f"TensorFlow Cell 532: ", c_532.numpy())
# Cell 533 - TensorFlow Example
import tensorflow as tf
a_533 = tf.constant([533.0, 534.0])
b_533 = tf.constant([535.0, 536.0])
c_533 = tf.add(a_533, b_533)
print(f"TensorFlow Cell 533: ", c_533.numpy())
# Cell 534 - TensorFlow Example
import tensorflow as tf
a_534 = tf.constant([534.0, 535.0])
b_534 = tf.constant([536.0, 537.0])
c_534 = tf.add(a_534, b_534)
print(f"TensorFlow Cell 534: ", c_534.numpy())
# Cell 535 - TensorFlow Example
import tensorflow as tf
a_535 = tf.constant([535.0, 536.0])
b_535 = tf.constant([537.0, 538.0])
c_535 = tf.add(a_535, b_535)
print(f"TensorFlow Cell 535: ", c_535.numpy())
# Cell 536 - TensorFlow Example
import tensorflow as tf
a_536 = tf.constant([536.0, 537.0])
b_536 = tf.constant([538.0, 539.0])
c_536 = tf.add(a_536, b_536)
print(f"TensorFlow Cell 536: ", c_536.numpy())
# Cell 537 - TensorFlow Example
import tensorflow as tf
a_537 = tf.constant([537.0, 538.0])
b_537 = tf.constant([539.0, 540.0])
c_537 = tf.add(a_537, b_537)
print(f"TensorFlow Cell 537: ", c_537.numpy())
# Cell 538 - TensorFlow Example
import tensorflow as tf
a_538 = tf.constant([538.0, 539.0])
b_538 = tf.constant([540.0, 541.0])
c_538 = tf.add(a_538, b_538)
print(f"TensorFlow Cell 538: ", c_538.numpy())
# Cell 539 - TensorFlow Example
import tensorflow as tf
a_539 = tf.constant([539.0, 540.0])
b_539 = tf.constant([541.0, 542.0])
c_539 = tf.add(a_539, b_539)
print(f"TensorFlow Cell 539: ", c_539.numpy())
# Cell 540 - TensorFlow Example
import tensorflow as tf
a_540 = tf.constant([540.0, 541.0])
b_540 = tf.constant([542.0, 543.0])
c_540 = tf.add(a_540, b_540)
print(f"TensorFlow Cell 540: ", c_540.numpy())
# Cell 541 - TensorFlow Example
import tensorflow as tf
a_541 = tf.constant([541.0, 542.0])
b_541 = tf.constant([543.0, 544.0])
c_541 = tf.add(a_541, b_541)
print(f"TensorFlow Cell 541: ", c_541.numpy())
# Cell 542 - TensorFlow Example
import tensorflow as tf
a_542 = tf.constant([542.0, 543.0])
b_542 = tf.constant([544.0, 545.0])
c_542 = tf.add(a_542, b_542)
print(f"TensorFlow Cell 542: ", c_542.numpy())
# Cell 543 - TensorFlow Example
import tensorflow as tf
a_543 = tf.constant([543.0, 544.0])
b_543 = tf.constant([545.0, 546.0])
c_543 = tf.add(a_543, b_543)
print(f"TensorFlow Cell 543: ", c_543.numpy())
# Cell 544 - TensorFlow Example
import tensorflow as tf
a_544 = tf.constant([544.0, 545.0])
b_544 = tf.constant([546.0, 547.0])
c_544 = tf.add(a_544, b_544)
print(f"TensorFlow Cell 544: ", c_544.numpy())
# Cell 545 - TensorFlow Example
import tensorflow as tf
a_545 = tf.constant([545.0, 546.0])
b_545 = tf.constant([547.0, 548.0])
c_545 = tf.add(a_545, b_545)
print(f"TensorFlow Cell 545: ", c_545.numpy())
# Cell 546 - TensorFlow Example
import tensorflow as tf
a_546 = tf.constant([546.0, 547.0])
b_546 = tf.constant([548.0, 549.0])
c_546 = tf.add(a_546, b_546)
print(f"TensorFlow Cell 546: ", c_546.numpy())
# Cell 547 - TensorFlow Example
import tensorflow as tf
a_547 = tf.constant([547.0, 548.0])
b_547 = tf.constant([549.0, 550.0])
c_547 = tf.add(a_547, b_547)
print(f"TensorFlow Cell 547: ", c_547.numpy())
# Cell 548 - TensorFlow Example
import tensorflow as tf
a_548 = tf.constant([548.0, 549.0])
b_548 = tf.constant([550.0, 551.0])
c_548 = tf.add(a_548, b_548)
print(f"TensorFlow Cell 548: ", c_548.numpy())
# Cell 549 - TensorFlow Example
import tensorflow as tf
a_549 = tf.constant([549.0, 550.0])
b_549 = tf.constant([551.0, 552.0])
c_549 = tf.add(a_549, b_549)
print(f"TensorFlow Cell 549: ", c_549.numpy())
# Cell 550 - TensorFlow Example
import tensorflow as tf
a_550 = tf.constant([550.0, 551.0])
b_550 = tf.constant([552.0, 553.0])
c_550 = tf.add(a_550, b_550)
print(f"TensorFlow Cell 550: ", c_550.numpy())
# Cell 551 - TensorFlow Example
import tensorflow as tf
a_551 = tf.constant([551.0, 552.0])
b_551 = tf.constant([553.0, 554.0])
c_551 = tf.add(a_551, b_551)
print(f"TensorFlow Cell 551: ", c_551.numpy())
# Cell 552 - TensorFlow Example
import tensorflow as tf
a_552 = tf.constant([552.0, 553.0])
b_552 = tf.constant([554.0, 555.0])
c_552 = tf.add(a_552, b_552)
print(f"TensorFlow Cell 552: ", c_552.numpy())
# Cell 553 - TensorFlow Example
import tensorflow as tf
a_553 = tf.constant([553.0, 554.0])
b_553 = tf.constant([555.0, 556.0])
c_553 = tf.add(a_553, b_553)
print(f"TensorFlow Cell 553: ", c_553.numpy())
# Cell 554 - TensorFlow Example
import tensorflow as tf
a_554 = tf.constant([554.0, 555.0])
b_554 = tf.constant([556.0, 557.0])
c_554 = tf.add(a_554, b_554)
print(f"TensorFlow Cell 554: ", c_554.numpy())
# Cell 555 - TensorFlow Example
import tensorflow as tf
a_555 = tf.constant([555.0, 556.0])
b_555 = tf.constant([557.0, 558.0])
c_555 = tf.add(a_555, b_555)
print(f"TensorFlow Cell 555: ", c_555.numpy())
# Cell 556 - TensorFlow Example
import tensorflow as tf
a_556 = tf.constant([556.0, 557.0])
b_556 = tf.constant([558.0, 559.0])
c_556 = tf.add(a_556, b_556)
print(f"TensorFlow Cell 556: ", c_556.numpy())
# Cell 557 - TensorFlow Example
import tensorflow as tf
a_557 = tf.constant([557.0, 558.0])
b_557 = tf.constant([559.0, 560.0])
c_557 = tf.add(a_557, b_557)
print(f"TensorFlow Cell 557: ", c_557.numpy())
# Cell 558 - TensorFlow Example
import tensorflow as tf
a_558 = tf.constant([558.0, 559.0])
b_558 = tf.constant([560.0, 561.0])
c_558 = tf.add(a_558, b_558)
print(f"TensorFlow Cell 558: ", c_558.numpy())
# Cell 559 - TensorFlow Example
import tensorflow as tf
a_559 = tf.constant([559.0, 560.0])
b_559 = tf.constant([561.0, 562.0])
c_559 = tf.add(a_559, b_559)
print(f"TensorFlow Cell 559: ", c_559.numpy())
# Cell 560 - TensorFlow Example
import tensorflow as tf
a_560 = tf.constant([560.0, 561.0])
b_560 = tf.constant([562.0, 563.0])
c_560 = tf.add(a_560, b_560)
print(f"TensorFlow Cell 560: ", c_560.numpy())
# Cell 561 - TensorFlow Example
import tensorflow as tf
a_561 = tf.constant([561.0, 562.0])
b_561 = tf.constant([563.0, 564.0])
c_561 = tf.add(a_561, b_561)
print(f"TensorFlow Cell 561: ", c_561.numpy())
# Cell 562 - TensorFlow Example
import tensorflow as tf
a_562 = tf.constant([562.0, 563.0])
b_562 = tf.constant([564.0, 565.0])
c_562 = tf.add(a_562, b_562)
print(f"TensorFlow Cell 562: ", c_562.numpy())
# Cell 563 - TensorFlow Example
import tensorflow as tf
a_563 = tf.constant([563.0, 564.0])
b_563 = tf.constant([565.0, 566.0])
c_563 = tf.add(a_563, b_563)
print(f"TensorFlow Cell 563: ", c_563.numpy())
# Cell 564 - TensorFlow Example
import tensorflow as tf
a_564 = tf.constant([564.0, 565.0])
b_564 = tf.constant([566.0, 567.0])
c_564 = tf.add(a_564, b_564)
print(f"TensorFlow Cell 564: ", c_564.numpy())
# Cell 565 - TensorFlow Example
import tensorflow as tf
a_565 = tf.constant([565.0, 566.0])
b_565 = tf.constant([567.0, 568.0])
c_565 = tf.add(a_565, b_565)
print(f"TensorFlow Cell 565: ", c_565.numpy())
# Cell 566 - TensorFlow Example
import tensorflow as tf
a_566 = tf.constant([566.0, 567.0])
b_566 = tf.constant([568.0, 569.0])
c_566 = tf.add(a_566, b_566)
print(f"TensorFlow Cell 566: ", c_566.numpy())
# Cell 567 - TensorFlow Example
import tensorflow as tf
a_567 = tf.constant([567.0, 568.0])
b_567 = tf.constant([569.0, 570.0])
c_567 = tf.add(a_567, b_567)
print(f"TensorFlow Cell 567: ", c_567.numpy())
# Cell 568 - TensorFlow Example
import tensorflow as tf
a_568 = tf.constant([568.0, 569.0])
b_568 = tf.constant([570.0, 571.0])
c_568 = tf.add(a_568, b_568)
print(f"TensorFlow Cell 568: ", c_568.numpy())
# Cell 569 - TensorFlow Example
import tensorflow as tf
a_569 = tf.constant([569.0, 570.0])
b_569 = tf.constant([571.0, 572.0])
c_569 = tf.add(a_569, b_569)
print(f"TensorFlow Cell 569: ", c_569.numpy())
# Cell 570 - TensorFlow Example
import tensorflow as tf
a_570 = tf.constant([570.0, 571.0])
b_570 = tf.constant([572.0, 573.0])
c_570 = tf.add(a_570, b_570)
print(f"TensorFlow Cell 570: ", c_570.numpy())
# Cell 571 - TensorFlow Example
import tensorflow as tf
a_571 = tf.constant([571.0, 572.0])
b_571 = tf.constant([573.0, 574.0])
c_571 = tf.add(a_571, b_571)
print(f"TensorFlow Cell 571: ", c_571.numpy())
# Cell 572 - TensorFlow Example
import tensorflow as tf
a_572 = tf.constant([572.0, 573.0])
b_572 = tf.constant([574.0, 575.0])
c_572 = tf.add(a_572, b_572)
print(f"TensorFlow Cell 572: ", c_572.numpy())
# Cell 573 - TensorFlow Example
import tensorflow as tf
a_573 = tf.constant([573.0, 574.0])
b_573 = tf.constant([575.0, 576.0])
c_573 = tf.add(a_573, b_573)
print(f"TensorFlow Cell 573: ", c_573.numpy())
# Cell 574 - TensorFlow Example
import tensorflow as tf
a_574 = tf.constant([574.0, 575.0])
b_574 = tf.constant([576.0, 577.0])
c_574 = tf.add(a_574, b_574)
print(f"TensorFlow Cell 574: ", c_574.numpy())
# Cell 575 - TensorFlow Example
import tensorflow as tf
a_575 = tf.constant([575.0, 576.0])
b_575 = tf.constant([577.0, 578.0])
c_575 = tf.add(a_575, b_575)
print(f"TensorFlow Cell 575: ", c_575.numpy())
# Cell 576 - TensorFlow Example
import tensorflow as tf
a_576 = tf.constant([576.0, 577.0])
b_576 = tf.constant([578.0, 579.0])
c_576 = tf.add(a_576, b_576)
print(f"TensorFlow Cell 576: ", c_576.numpy())
# Cell 577 - TensorFlow Example
import tensorflow as tf
a_577 = tf.constant([577.0, 578.0])
b_577 = tf.constant([579.0, 580.0])
c_577 = tf.add(a_577, b_577)
print(f"TensorFlow Cell 577: ", c_577.numpy())
# Cell 578 - TensorFlow Example
import tensorflow as tf
a_578 = tf.constant([578.0, 579.0])
b_578 = tf.constant([580.0, 581.0])
c_578 = tf.add(a_578, b_578)
print(f"TensorFlow Cell 578: ", c_578.numpy())
# Cell 579 - TensorFlow Example
import tensorflow as tf
a_579 = tf.constant([579.0, 580.0])
b_579 = tf.constant([581.0, 582.0])
c_579 = tf.add(a_579, b_579)
print(f"TensorFlow Cell 579: ", c_579.numpy())
# Cell 580 - TensorFlow Example
import tensorflow as tf
a_580 = tf.constant([580.0, 581.0])
b_580 = tf.constant([582.0, 583.0])
c_580 = tf.add(a_580, b_580)
print(f"TensorFlow Cell 580: ", c_580.numpy())
# Cell 581 - TensorFlow Example
import tensorflow as tf
a_581 = tf.constant([581.0, 582.0])
b_581 = tf.constant([583.0, 584.0])
c_581 = tf.add(a_581, b_581)
print(f"TensorFlow Cell 581: ", c_581.numpy())
# Cell 582 - TensorFlow Example
import tensorflow as tf
a_582 = tf.constant([582.0, 583.0])
b_582 = tf.constant([584.0, 585.0])
c_582 = tf.add(a_582, b_582)
print(f"TensorFlow Cell 582: ", c_582.numpy())
# Cell 583 - TensorFlow Example
import tensorflow as tf
a_583 = tf.constant([583.0, 584.0])
b_583 = tf.constant([585.0, 586.0])
c_583 = tf.add(a_583, b_583)
print(f"TensorFlow Cell 583: ", c_583.numpy())
# Cell 584 - TensorFlow Example
import tensorflow as tf
a_584 = tf.constant([584.0, 585.0])
b_584 = tf.constant([586.0, 587.0])
c_584 = tf.add(a_584, b_584)
print(f"TensorFlow Cell 584: ", c_584.numpy())
# Cell 585 - TensorFlow Example
import tensorflow as tf
a_585 = tf.constant([585.0, 586.0])
b_585 = tf.constant([587.0, 588.0])
c_585 = tf.add(a_585, b_585)
print(f"TensorFlow Cell 585: ", c_585.numpy())
# Cell 586 - TensorFlow Example
import tensorflow as tf
a_586 = tf.constant([586.0, 587.0])
b_586 = tf.constant([588.0, 589.0])
c_586 = tf.add(a_586, b_586)
print(f"TensorFlow Cell 586: ", c_586.numpy())
# Cell 587 - TensorFlow Example
import tensorflow as tf
a_587 = tf.constant([587.0, 588.0])
b_587 = tf.constant([589.0, 590.0])
c_587 = tf.add(a_587, b_587)
print(f"TensorFlow Cell 587: ", c_587.numpy())
# Cell 588 - TensorFlow Example
import tensorflow as tf
a_588 = tf.constant([588.0, 589.0])
b_588 = tf.constant([590.0, 591.0])
c_588 = tf.add(a_588, b_588)
print(f"TensorFlow Cell 588: ", c_588.numpy())
# Cell 589 - TensorFlow Example
import tensorflow as tf
a_589 = tf.constant([589.0, 590.0])
b_589 = tf.constant([591.0, 592.0])
c_589 = tf.add(a_589, b_589)
print(f"TensorFlow Cell 589: ", c_589.numpy())
# Cell 590 - TensorFlow Example
import tensorflow as tf
a_590 = tf.constant([590.0, 591.0])
b_590 = tf.constant([592.0, 593.0])
c_590 = tf.add(a_590, b_590)
print(f"TensorFlow Cell 590: ", c_590.numpy())
# Cell 591 - TensorFlow Example
import tensorflow as tf
a_591 = tf.constant([591.0, 592.0])
b_591 = tf.constant([593.0, 594.0])
c_591 = tf.add(a_591, b_591)
print(f"TensorFlow Cell 591: ", c_591.numpy())
# Cell 592 - TensorFlow Example
import tensorflow as tf
a_592 = tf.constant([592.0, 593.0])
b_592 = tf.constant([594.0, 595.0])
c_592 = tf.add(a_592, b_592)
print(f"TensorFlow Cell 592: ", c_592.numpy())
# Cell 593 - TensorFlow Example
import tensorflow as tf
a_593 = tf.constant([593.0, 594.0])
b_593 = tf.constant([595.0, 596.0])
c_593 = tf.add(a_593, b_593)
print(f"TensorFlow Cell 593: ", c_593.numpy())
# Cell 594 - TensorFlow Example
import tensorflow as tf
a_594 = tf.constant([594.0, 595.0])
b_594 = tf.constant([596.0, 597.0])
c_594 = tf.add(a_594, b_594)
print(f"TensorFlow Cell 594: ", c_594.numpy())
# Cell 595 - TensorFlow Example
import tensorflow as tf
a_595 = tf.constant([595.0, 596.0])
b_595 = tf.constant([597.0, 598.0])
c_595 = tf.add(a_595, b_595)
print(f"TensorFlow Cell 595: ", c_595.numpy())
# Cell 596 - TensorFlow Example
import tensorflow as tf
a_596 = tf.constant([596.0, 597.0])
b_596 = tf.constant([598.0, 599.0])
c_596 = tf.add(a_596, b_596)
print(f"TensorFlow Cell 596: ", c_596.numpy())
# Cell 597 - TensorFlow Example
import tensorflow as tf
a_597 = tf.constant([597.0, 598.0])
b_597 = tf.constant([599.0, 600.0])
c_597 = tf.add(a_597, b_597)
print(f"TensorFlow Cell 597: ", c_597.numpy())
# Cell 598 - TensorFlow Example
import tensorflow as tf
a_598 = tf.constant([598.0, 599.0])
b_598 = tf.constant([600.0, 601.0])
c_598 = tf.add(a_598, b_598)
print(f"TensorFlow Cell 598: ", c_598.numpy())
# Cell 599 - TensorFlow Example
import tensorflow as tf
a_599 = tf.constant([599.0, 600.0])
b_599 = tf.constant([601.0, 602.0])
c_599 = tf.add(a_599, b_599)
print(f"TensorFlow Cell 599: ", c_599.numpy())
# Cell 600 - TensorFlow Example
import tensorflow as tf
a_600 = tf.constant([600.0, 601.0])
b_600 = tf.constant([602.0, 603.0])
c_600 = tf.add(a_600, b_600)
print(f"TensorFlow Cell 600: ", c_600.numpy())
Score: 600
Category: basics