1
2
3#[cfg(test)]
4#[cfg(feature = "all_tests")]
5mod generated_tests {
6 use array::dense::*;
7 use array::traits::*;
8
9
10
11 #[test]
12 fn test_matmul_0() {
13
14 let mut arr1 = Array::from(vec![0.7488038825386119,
15 0.4985070123025904,
16 0.22479664553084766,
17 0.19806286475962398,
18 0.7605307121989587]);
19 arr1.reshape(5, 1);
20
21 let mut arr2 = Array::from(vec![0.16911083656253545, 0.08833981417401027]);
22 arr2.reshape(1, 2);
23
24 let mut result = Array::from(vec![0.12663085099737917,
25 0.06614919583623838,
26 0.08430293788278122,
27 0.044038016831251886,
28 0.03801554878217339,
29 0.019858493893135938,
30 0.033494576751472334,
31 0.01749683666763731,
32 0.12861398497146678,
33 0.0671851417892837]);
34 result.reshape(5, 2);
35
36 assert!(allclose(&arr1.dot(&arr2), &result));
37 }
38
39
40
41 #[test]
42 fn test_matmul_1() {
43
44 let mut arr1 = Array::from(vec![0.8166018352206666,
45 0.3360715844645519,
46 0.8908165306793224,
47 0.19812181303297027,
48 0.03061665387269341,
49 0.8776149398973291,
50 0.7274355137182333,
51 0.5408809312773927,
52 0.1314581524025229,
53 0.4136673744184527,
54 0.7787288082639929,
55 0.5839013656536759,
56 0.18263143630201495,
57 0.8260822477490752,
58 0.10540183348780108,
59 0.28357667858256574,
60 0.06556326635477827,
61 0.05644418747007063,
62 0.7654558182151854,
63 0.01178802938496426]);
64 arr1.reshape(5, 4);
65
66 let mut arr2 = Array::from(vec![0.6119433411110109,
67 0.3318822556677169,
68 0.559648365456308,
69 0.33549964651986997]);
70 arr2.reshape(4, 1);
71
72 let mut result = Array::from(vec![1.1762640644768163,
73 0.8985739408054911,
74 0.8494468087735784,
75 0.5400499703258541,
76 0.4911948057091634]);
77 result.reshape(5, 1);
78
79 assert!(allclose(&arr1.dot(&arr2), &result));
80 }
81
82
83
84 #[test]
85 fn test_matmul_2() {
86
87 let mut arr1 = Array::from(vec![0.8286813263076767,
88 0.04689631938924976,
89 0.6262871483113925,
90 0.5475861559192435,
91 0.8192869956700687,
92 0.1989475396788123,
93 0.8568503024577332,
94 0.3516526394320879,
95 0.7546476915298572,
96 0.2959617068796787,
97 0.8839364795611863,
98 0.3255116378322488,
99 0.16501589771914849,
100 0.3925292439465873,
101 0.0934603745586503,
102 0.8211056578369285,
103 0.15115201964256386,
104 0.3841144486921996,
105 0.9442607122388011,
106 0.9876254749018722,
107 0.4563045470947841,
108 0.8261228438427398,
109 0.25137413420705934,
110 0.5973716482308843,
111 0.9028317603316274,
112 0.5345579488018151,
113 0.5902013629854229,
114 0.03928176722538734,
115 0.3571817586345363,
116 0.07961309015596418,
117 0.30545991834281827,
118 0.330719311982132,
119 0.7738302962105958,
120 0.039959208689977266,
121 0.42949217843163834,
122 0.3149268718426883,
123 0.6364911430675446,
124 0.34634715008003303,
125 0.04309735620499444,
126 0.879915174517916,
127 0.763240587143681,
128 0.8780966427248583,
129 0.41750914383926696,
130 0.6055775643937568,
131 0.5134666274082884,
132 0.5978366479629736,
133 0.2622156611319503,
134 0.30087130894070724,
135 0.025399782050106068,
136 0.30306256065103476,
137 0.24207587540352737,
138 0.5575781886626442,
139 0.5655070198881675,
140 0.47513224741505056,
141 0.2927979762895091,
142 0.06425106069482445]);
143 arr1.reshape(7, 8);
144
145 let mut arr2 = Array::from(vec![0.9788191457576426,
146 0.33970784363786366,
147 0.4950486308824543,
148 0.9770807259226818,
149 0.4407738249006665,
150 0.3182728054789512,
151 0.5197969858753801,
152 0.5781364298824675,
153 0.8539337505004864,
154 0.06809727353795003,
155 0.46453080777933253,
156 0.7819491186191484,
157 0.7186028103822503,
158 0.5860219800531759,
159 0.037094413234407875,
160 0.350656391283133,
161 0.563190684492745,
162 0.29972987242456284,
163 0.5123341532735493,
164 0.6734669252847205,
165 0.1591937333780935,
166 0.05047767015399762,
167 0.33781588706467947,
168 0.10806377277945256,
169 0.17890280857109042,
170 0.8858270961677057,
171 0.3653649712141158,
172 0.21876934917953672,
173 0.7524961702186028,
174 0.10687958439356915,
175 0.7446032407755606,
176 0.46978529344049447,
177 0.5982556712791092,
178 0.14762019228529766,
179 0.18403482209315125,
180 0.6450721264682419,
181 0.048628006263405577,
182 0.24861250780276944,
183 0.5424085162280042,
184 0.2267733432700092,
185 0.3814115349046321,
186 0.9222327869035463,
187 0.9253568728677768,
188 0.566749924575,
189 0.5334708849890026,
190 0.014860024633228108,
191 0.977899263402005,
192 0.5730289040331858,
193 0.791756996276624,
194 0.5615573602763689,
195 0.8773352415649347,
196 0.5841958285306755,
197 0.7088498263689552,
198 0.14853345135645857,
199 0.4284507389678964,
200 0.6938900663424117,
201 0.10461974452285316,
202 0.4396052377745905,
203 0.16620214770453368,
204 0.5069786292640474,
205 0.8190358641362125,
206 0.09010673472443853,
207 0.8000687506941452,
208 0.5651263539578045,
209 0.5893477116806074,
210 0.1981006572162689,
211 0.4361182553388343,
212 0.29590376222083736,
213 0.03755767594167769,
214 0.030684840372946276,
215 0.45310500020123345,
216 0.7448640769500677]);
217 arr2.reshape(8, 9);
218
219 let mut result = Array::from(vec![1.8636289999496571,
220 2.3371757355482212,
221 1.3228318747394487,
222 2.1560848952544682,
223 1.5322326485666165,
224 2.038490862178821,
225 2.2270085613097286,
226 2.002957804581816,
227 2.717839825753671,
228 1.8008296125574192,
229 2.2077383553073697,
230 1.2673980008136507,
231 1.9844205221589646,
232 1.499465602389063,
233 1.1162071011585086,
234 1.1859907055632388,
235 2.1981280821647404,
236 2.0987873423677605,
237 1.3537041135449412,
238 3.0566868346154705,
239 1.4965970972995377,
240 2.335362973616119,
241 1.9311801775721935,
242 2.0507318976290474,
243 1.6570616594938936,
244 2.4594555568901653,
245 2.238503177597988,
246 1.5674097294685154,
247 1.5555758505622812,
248 1.2999294023597958,
249 1.747863709065677,
250 1.25861045205271,
251 0.9609906345150541,
252 1.4054837803795253,
253 1.7893045900125117,
254 1.8652611203215783,
255 1.6009272519838944,
256 1.853081650709432,
257 1.2388871662996581,
258 1.8622396990960361,
259 1.3623303471332544,
260 1.4283433038837052,
261 1.3931878809354605,
262 1.9171142108524422,
263 2.1137404030753286,
264 1.4694860154230864,
265 2.475600057669217,
266 1.9037789114626875,
267 2.6850090288339303,
268 1.940704484426214,
269 1.8251757105090112,
270 1.9171191588033278,
271 2.2918185772743653,
272 2.2547501383738506,
273 0.487823715947414,
274 1.5782753643018803,
275 0.9700452783614332,
276 1.3311609808148681,
277 1.0826966847064747,
278 1.4682947509094475,
279 1.2877410689415112,
280 1.2152117412030659,
281 1.2150222079096793]);
282 result.reshape(7, 9);
283
284 assert!(allclose(&arr1.dot(&arr2), &result));
285 }
286
287
288
289 #[test]
290 fn test_matmul_3() {
291
292 let mut arr1 = Array::from(vec![0.02343208967343946,
293 0.9351290211010858,
294 0.20959771262641858,
295 0.5767729792632846,
296 0.5810473308202846,
297 0.23392116115287398,
298 0.4829791904668277,
299 0.5470433236745386,
300 0.8718123119359061,
301 0.9640360264185229,
302 0.16161057694639414,
303 0.016890216716548112,
304 0.017029974490559763,
305 0.1988350364892616,
306 0.8985460488111815,
307 0.7858558372753476,
308 0.6859219733533566,
309 0.3265324364801837,
310 0.4084904227904791,
311 0.5738732696838558,
312 0.000986666356991961,
313 0.7498525406321818,
314 0.7508390254874455,
315 0.3832725488828932,
316 0.37293850687954866,
317 0.8426818713989127,
318 0.759296481115939,
319 0.16578250597291844,
320 0.7541563261727,
321 0.5959939345983292,
322 0.9268088739455752,
323 0.4150991819310216,
324 0.09685600409892259,
325 0.8961532323425018,
326 0.7099478870139949,
327 0.4230056469476162]);
328 arr1.reshape(6, 6);
329
330 let mut arr2 = Array::from(vec![0.29536985892080336,
331 0.17858845187204242,
332 0.9284958901211762,
333 0.2780497576026819,
334 0.44770886382163244,
335 0.6098735604012505]);
336 arr2.reshape(6, 1);
337
338 let mut result = Array::from(vec![0.9317089507421266,
339 1.4005326320783942,
340 1.5995799679610947,
341 1.0024604111768296,
342 1.7128709075027795,
343 1.262818839226749]);
344 result.reshape(6, 1);
345
346 assert!(allclose(&arr1.dot(&arr2), &result));
347 }
348
349
350
351 #[test]
352 fn test_matmul_4() {
353
354 let mut arr1 = Array::from(vec![0.9659462515078151,
355 0.31700156230578813,
356 0.8655526182272831,
357 0.310283706940119]);
358 arr1.reshape(4, 1);
359
360 let mut arr2 = Array::from(vec![0.025263945431817092,
361 0.049195157773728626,
362 0.1846268380142655,
363 0.06903334161725405,
364 0.2574754234045431,
365 0.9135817315706746,
366 0.4578495119744105,
367 0.13021178947959489]);
368 arr2.reshape(1, 8);
369
370 let mut result = Array::from(vec![0.02440361338816171,
371 0.04751987824386872,
372 0.17833960210762034,
373 0.066682497564245,
374 0.24870742009300598,
375 0.882470849056712,
376 0.4422580198463643,
377 0.12577758994993943,
378 0.008008710171894197,
379 0.015594941872151713,
380 0.05852699609409984,
381 0.021883677143858717,
382 0.08162011147458445,
383 0.289606836201931,
384 0.14513901059683076,
385 0.04127734069566397,
386 0.021867274115260495,
387 0.042580997615155096,
388 0.15980424303827198,
389 0.05975198958179271,
390 0.22285852685698057,
391 0.7907530597256124,
392 0.3962928438435348,
393 0.11270515530812315,
394 0.007838990640517091,
395 0.015264455917536529,
396 0.05728669969969917,
397 0.021419921139465174,
398 0.0798904288199383,
399 0.28346952626452165,
400 0.1420632437961445,
401 0.040402596727035084]);
402 result.reshape(4, 8);
403
404 assert!(allclose(&arr1.dot(&arr2), &result));
405 }
406
407
408
409 #[test]
410 fn test_matmul_5() {
411
412 let mut arr1 = Array::from(vec![0.09867089880131952,
413 0.8213681077532083,
414 0.4104176887058165,
415 0.40899220374056944,
416 0.5390292018227953,
417 0.6081689510093544,
418 0.5686751048128866,
419 0.07936628579412774,
420 0.987080075759515,
421 0.36585267914564845,
422 0.30857405385931824,
423 0.40176833801872014,
424 0.038390814451594424,
425 0.05220999047317065,
426 0.20963889655800072,
427 0.26711682076210697,
428 0.020180928798586684,
429 0.4111256911223199,
430 0.5407066929358788,
431 0.7234816370105102,
432 0.8832868193093703,
433 0.1549640073546541,
434 0.45724875650392716,
435 0.9689067573450633,
436 0.3139064860941967,
437 0.9451165184585447,
438 0.26973426064522454,
439 0.04962017253947604,
440 0.6314965806026245,
441 0.3775599470346803,
442 0.22784243971893103,
443 0.23790885462249955,
444 0.24518122305941803,
445 0.6625928898409245,
446 0.34850521476817065,
447 0.3848432113135175,
448 0.8204147962839342,
449 0.8950223079366563,
450 0.2729546367619464,
451 0.875009045353079,
452 0.8780783411312396,
453 0.7863287989694552,
454 0.005609078913205612,
455 0.25295793983266146,
456 0.1933664500634107,
457 0.4109221319177436,
458 0.4467061619964898,
459 0.7937446692135952,
460 0.7232333002390631,
461 0.00010632549643607714,
462 0.5637395405854435,
463 0.8285313743206492,
464 0.002370990881480961,
465 0.3157881613333898,
466 0.7115358139407235,
467 0.3263716243060254]);
468 arr1.reshape(7, 8);
469
470 let mut arr2 = Array::from(vec![0.4225522573344933,
471 0.4188267989763754,
472 0.8685508176395133,
473 0.10833073330879162,
474 0.5736182708950517,
475 0.6022095859451538,
476 0.07127344705295213,
477 0.3046527511400685,
478 0.4713651000258645,
479 0.42877537239025043,
480 0.7639600082043996,
481 0.23942577748347948,
482 0.5932693472563628,
483 0.21598770917172883,
484 0.32855583463033844,
485 0.06827274752131252,
486 0.7256537772527641,
487 0.6122399098558322,
488 0.11700493983201266,
489 0.687366499029156,
490 0.14501861866387533,
491 0.9625283238089534,
492 0.7772782160176988,
493 0.9033500334815702,
494 0.7843792250906823,
495 0.5086868668262204,
496 0.13197066408625446,
497 0.22981003079385764,
498 0.616745871837231,
499 0.7689436658715406,
500 0.5374050367007986,
501 0.36771649094937364,
502 0.6696855200483852,
503 0.4067513089676259,
504 0.3569502760835511,
505 0.7099511276575683,
506 0.5572719426485148,
507 0.996989762789397,
508 0.3738451243037514,
509 0.700930402750168,
510 0.5439887620500772,
511 0.4443834577348068,
512 0.3007102925822702,
513 0.610080439674346,
514 0.6483314856533615,
515 0.8706156473347222,
516 0.5942777205222456,
517 0.15171964914679803,
518 0.8187215707992948,
519 0.16034803009580723,
520 0.6606953421294681,
521 0.17663504593674884,
522 0.48419865845573695,
523 0.7135545580113779,
524 0.4812012850088755,
525 0.14075845193491954,
526 0.7307873881381384,
527 0.8122958951949274,
528 0.7238205196421121,
529 0.6717322953422301,
530 0.26411314241336714,
531 0.2760733247794557,
532 0.8416991944273465,
533 0.5157516549724572,
534 0.828089476597136,
535 0.6297307138355206,
536 0.5418873200988024,
537 0.8256115586513965,
538 0.6778163004125543,
539 0.6942766250514122,
540 0.21917850452044407,
541 0.9003573954833297]);
542 arr2.reshape(8, 9);
543
544 let mut result = Array::from(vec![1.6803351750539757,
545 2.247766093561234,
546 1.4157121595594613,
547 2.49349776386414,
548 1.57129570748317,
549 2.051076084145239,
550 1.0262032009614412,
551 1.7785703722556165,
552 2.227454655753151,
553 1.0078900228533691,
554 1.4728123931861954,
555 1.6422965988599865,
556 1.2215946516109906,
557 1.4343431924055943,
558 1.635873429131049,
559 0.7623772214170802,
560 1.0317013918226794,
561 1.4943214632150388,
562 1.7612257637851552,
563 2.979826569861099,
564 2.048716934339299,
565 2.7977972034175536,
566 2.422942835535734,
567 2.5789750781049623,
568 1.8343434763942912,
569 1.7902875438482349,
570 2.7866803710798513,
571 1.493812919982045,
572 2.1525646617096337,
573 1.1858886743098567,
574 1.9467542719117805,
575 1.3775061384047076,
576 1.6208417630990763,
577 0.8005944987286125,
578 1.619505514578425,
579 1.8822340533283746,
580 2.335971112794045,
581 3.1986276322493823,
582 1.9110490829576317,
583 2.965623514350233,
584 2.2059502986105493,
585 2.670259038827183,
586 1.5769963919014895,
587 2.0711843722374064,
588 3.0285625734060786,
589 1.8568246117442722,
590 2.28550826921577,
591 2.1071735644131957,
592 1.967912402586874,
593 1.920635346531573,
594 2.157112561115595,
595 1.0233489855241942,
596 1.5454905755043362,
597 2.5848723844120904,
598 1.348984639587682,
599 1.7619290051916898,
600 2.1213423004624286,
601 2.0813224269950745,
602 1.9941361241740647,
603 2.40855754617413,
604 1.3017567818287086,
605 1.2252439751669943,
606 2.12320539560902]);
607 result.reshape(7, 9);
608
609 assert!(allclose(&arr1.dot(&arr2), &result));
610 }
611
612
613
614 #[test]
615 fn test_matmul_6() {
616
617 let mut arr1 = Array::from(vec![0.1531969301964562,
618 0.3438098945485848,
619 0.008466911174788372,
620 0.13208192652086204,
621 0.7255432465439993,
622 0.8295890150299017,
623 0.013528181111777338,
624 0.06701847975796726,
625 0.11185484645860788,
626 0.29526480118342946,
627 0.13478392460548572,
628 0.6648510436552199,
629 0.3165906947458056,
630 0.32703865522538256,
631 0.16205831294146922,
632 0.06406691280517696,
633 0.7413369011627189,
634 0.7107522445972044,
635 0.49148594359857856,
636 0.859942195700386,
637 0.5076293778149958,
638 0.5760300907293111,
639 0.253897470823194,
640 0.656954217532432,
641 0.6522032924009218,
642 0.06379972855892946,
643 0.03534275172587109,
644 0.6516784782252761]);
645 arr1.reshape(4, 7);
646
647 let mut arr2 = Array::from(vec![0.3273150721309004,
648 0.9145882805277057,
649 0.68681698320307,
650 0.604468051784674,
651 0.9648853179875961,
652 0.838491762190224,
653 0.6429768520274158,
654 0.2552744896661301,
655 0.3409119855738164,
656 0.25073788340317094,
657 0.2861426173287246,
658 0.9237574440277018,
659 0.3062530966510215,
660 0.5681850195842788,
661 0.3678206969289417,
662 0.7946997153513944,
663 0.03405577520367198,
664 0.21627897524280026,
665 0.7102738447959042,
666 0.6278623555090681,
667 0.18931700678206653,
668 0.7641131314841632,
669 0.8961528431903454,
670 0.6688551802336785,
671 0.22077251068170267,
672 0.43766394922338014,
673 0.5699983336709824,
674 0.11098208379454733]);
675 arr2.reshape(7, 4);
676
677 let mut result = Array::from(vec![0.609968651593792,
678 1.302304235850313,
679 1.6437692539934388,
680 1.3050729746393772,
681 0.426579726955514,
682 0.8345374005822861,
683 1.1943651139871583,
684 1.1144137232745686,
685 0.8768722922809966,
686 1.7772185144127468,
687 2.035132564640786,
688 2.3040638893066854,
689 1.0099645442190333,
690 1.6010373354151108,
691 1.4351973471200927,
692 1.6741987195645516]);
693 result.reshape(4, 4);
694
695 assert!(allclose(&arr1.dot(&arr2), &result));
696 }
697
698
699
700 #[test]
701 fn test_matmul_7() {
702
703 let mut arr1 = Array::from(vec![0.4299261028565723,
704 0.838846587613526,
705 0.5373540254236295,
706 0.2504239331501743,
707 0.058894011440773775,
708 0.09194928490764764,
709 0.17419994314144638,
710 0.43925435059827533,
711 0.8109342250751058,
712 0.9104021236063347,
713 0.5760907120119877,
714 0.2911544297803492,
715 0.6517863717812156,
716 0.6379207007555681,
717 0.5035747397173306,
718 0.9655527156217962,
719 0.8066911496104903,
720 0.9285193564036172,
721 0.613935126664438,
722 0.9820039163431012,
723 0.7149879558453262,
724 0.008659271417291059,
725 0.28814558099381116,
726 0.8413986575018212,
727 0.44317708702734737,
728 0.17304972347660363,
729 0.11452711222626355,
730 0.7978805960212307,
731 0.6489051514456138,
732 0.501745998146996,
733 0.2856402082321652,
734 0.6366958284853916,
735 0.3683419053302235,
736 0.5395385433522519,
737 0.7620668019798759,
738 0.8398874811543805,
739 0.10495741202168796,
740 0.5106313083459157,
741 0.6454886627441757,
742 0.1530668142526591,
743 0.0017596491043597728,
744 0.9670457532300503,
745 0.8078665332650923,
746 0.27406758936347153,
747 0.27908960707212593,
748 0.12067964142197818,
749 0.48068826499085704,
750 0.9323019787625625,
751 0.9149274257682686,
752 0.24387509597581103,
753 0.3948582964158739,
754 0.970239530226589,
755 0.2756196336037614,
756 0.9378494408664138,
757 0.7690121570235064,
758 0.8847186881060606]);
759 arr1.reshape(8, 7);
760
761 let mut arr2 = Array::from(vec![0.8710049752440003,
762 0.14647095922681508,
763 0.7891887879251763,
764 0.9092222456715098,
765 0.838170548530705,
766 0.7120311863871623,
767 0.3073794185374644,
768 0.35378455477098936,
769 0.2363533952237783,
770 0.08981163906322553,
771 0.19447817432203818,
772 0.6158078753671168,
773 0.9320836755651093,
774 0.6910839497831097]);
775 arr2.reshape(7, 2);
776
777 let mut result = Array::from(vec![1.7580164294212424,
778 1.4791778570089325,
779 2.752892631476799,
780 2.5220851383945195,
781 3.1646845665873133,
782 3.008527112889941,
783 1.8832680118917628,
784 1.6566190474769846,
785 2.298591691687037,
786 1.8718678795486745,
787 2.378671075848116,
788 1.4935386603259162,
789 2.3386795736316057,
790 1.85851439322815,
791 2.617831990792432,
792 2.3522937628261262]);
793 result.reshape(8, 2);
794
795 assert!(allclose(&arr1.dot(&arr2), &result));
796 }
797
798
799
800 #[test]
801 fn test_matmul_8() {
802
803 let mut arr1 =
804 Array::from(vec![0.5271468808849665, 0.8043829147090844, 0.29507589390599864]);
805 arr1.reshape(1, 3);
806
807 let mut arr2 = Array::from(vec![0.18333855055950088,
808 0.019732459506620614,
809 0.7433212319725496,
810 0.0382934041858366,
811 0.4336796689738486,
812 0.8320847613127487,
813 0.013458558499757745,
814 0.5093353915141386,
815 0.47954870014125284,
816 0.029654940797728235,
817 0.011428526824066254,
818 0.33184400023449434,
819 0.06143107860529495,
820 0.5981735080564744,
821 0.8859202535226233,
822 0.4121337753639407,
823 0.03827219890219569,
824 0.08084240379080565,
825 0.08191454230184858,
826 0.8093673338215349,
827 0.8006940028849979,
828 0.016909811354707704,
829 0.8612943252306178,
830 0.9113002243524484,
831 0.40087668463516213,
832 0.28689069833770775,
833 0.8430448852638386]);
834 arr2.reshape(3, 9);
835
836 let mut result = Array::from(vec![0.1446712795814323,
837 0.25841960572438155,
838 0.8950346117137078,
839 0.0745900363385533,
840 0.9639206276486024,
841 1.4201527306038018,
842 0.45689705067645436,
843 0.38393459513159073,
844 0.5665830730273458]);
845 result.reshape(1, 9);
846
847 assert!(allclose(&arr1.dot(&arr2), &result));
848 }
849
850
851
852 #[test]
853 fn test_matmul_9() {
854
855 let mut arr1 = Array::from(vec![0.2287556137159159,
856 0.841497971175196,
857 0.8443584735081981,
858 0.22014599338063867,
859 0.811137639752162,
860 0.5359535338891156,
861 0.6104284489824332,
862 0.5238698831262817]);
863 arr1.reshape(1, 8);
864
865 let mut arr2 = Array::from(vec![0.6396291484955626,
866 0.005156348033917069,
867 0.024738783415619525,
868 0.6900263853157124,
869 0.1715930195622134,
870 0.6939306736886565,
871 0.2852656231218128,
872 0.05510592078168841]);
873 arr2.reshape(8, 1);
874
875 let mut result = Array::from(vec![1.037555498152202]);
876 result.reshape(1, 1);
877
878 assert!(allclose(&arr1.dot(&arr2), &result));
879 }
880
881
882
883 #[test]
884 fn test_matmul_transpose_0() {
885
886 let mut arr1 = Array::from(vec![0.32281613557530464,
887 0.9669893878549964,
888 0.19493466478308674,
889 0.34739650514561404,
890 0.1040140651107091,
891 0.40178185247448894,
892 0.09284764508729115,
893 0.5048438064616992,
894 0.7425907409447408,
895 0.005290509169382895,
896 0.09016116884502079,
897 0.05618398091194032,
898 0.8843256633664335,
899 0.9855858566528506,
900 0.5201746856274987,
901 0.19841742953279573,
902 0.9333483160830192,
903 0.6545982033421369,
904 0.791791747160087,
905 0.511215678611379,
906 0.7882118923792203,
907 0.33479673167486723,
908 0.11325313441738971,
909 0.9048139767028247,
910 0.004223913508407007,
911 0.07350388060676039,
912 0.13229136395536234,
913 0.9421499192747]);
914 arr1.reshape(4, 7);
915
916 let mut arr2 = Array::from(vec![0.3029296862426224,
917 0.2133130511803032,
918 0.2556625525155257,
919 0.09592006679437992,
920 0.4017978829990967,
921 0.7310276403556994,
922 0.6482099352415909,
923 0.250845580834519,
924 0.22743891395182814,
925 0.49581615834046866,
926 0.8647649667829787,
927 0.6340637531228465,
928 0.7544924749082648,
929 0.4371231912677318,
930 0.4002120902427818,
931 0.7229163139452544,
932 0.3723685794123146,
933 0.5525980303993004,
934 0.08046361735719143,
935 0.594275567103534,
936 0.2809214669332072,
937 0.7424475863144008,
938 0.2988271966526831,
939 0.7575366841711616,
940 0.22636013801884003,
941 0.0044076449230693315,
942 0.13978028098719586,
943 0.29576370224015924,
944 0.19559381625075667,
945 0.5488820378428916,
946 0.2099921700900459,
947 0.7784921702787021,
948 0.4846799030422758,
949 0.6393403927232835,
950 0.16769630743472275,
951 0.9246826037822882,
952 0.7173399513633042,
953 0.15481361149816686,
954 0.7236336058193933,
955 0.1864099258251244,
956 0.8296645652434765,
957 0.19664176333975436,
958 0.9613006691117159,
959 0.5475975848164579,
960 0.22286359973606018,
961 0.21272669051414417,
962 0.6279879624064401,
963 0.633276129149952,
964 0.3032790372858618,
965 0.8163677514534665,
966 0.41905671700889435,
967 0.8138582852339901,
968 0.26521517056103106,
969 0.9834254714034867,
970 0.8723053226599075,
971 0.44852458936494555]);
972 arr2.reshape(8, 7);
973
974 let mut result = Array::from(vec![0.7829128741212573,
975 1.1076548927313479,
976 1.3660268758147975,
977 0.839024269644401,
978 1.2281432597825857,
979 1.6447200551382046,
980 1.3051059519284065,
981 1.413955077729016,
982 1.6292449749399673,
983 1.509786928716233,
984 1.5975945860323733,
985 1.0365024749344278,
986 1.335535247553272,
987 2.003547245521751,
988 1.8065190606418229,
989 2.0202579082637353,
990 1.7040925166223766,
991 2.4367546631322945,
992 1.6498377159836357,
993 1.6087877677536406,
994 1.7590327330700064,
995 1.9682442648248983,
996 2.0159815694487846,
997 3.019161374333937,
998 1.0942637348537207,
999 1.120269097250641,
1000 0.9043227105429124,
1001 1.2662674985779514,
1002 0.5991390445406645,
1003 0.8426811280976101,
1004 1.0020769397298828,
1005 1.668548794226767]);
1006 result.reshape(4, 8);
1007
1008 assert!(allclose(&arr1.dot(&(arr2.T())), &result));
1009 }
1010
1011
1012
1013 #[test]
1014 fn test_matmul_transpose_1() {
1015
1016 let mut arr1 = Array::from(vec![0.6809495248305892,
1017 0.18915818640159343,
1018 0.0450455494971731,
1019 0.013139545362499061,
1020 0.6618106166295956,
1021 0.10751234469652782,
1022 0.309957639304688,
1023 0.30794744829381004,
1024 0.11747222616483843,
1025 0.9469314207950004,
1026 0.977390549235605,
1027 0.9044792542687089,
1028 0.7961801494650353,
1029 0.06542942286782805,
1030 0.7170386259969244,
1031 0.4559104342797371,
1032 0.15148371295050145,
1033 0.64672019512236,
1034 0.02923457187959755,
1035 0.7535208725100521]);
1036 arr1.reshape(4, 5);
1037
1038 let mut arr2 = Array::from(vec![0.8897329460901544,
1039 0.010380039277155584,
1040 0.3274278428066417,
1041 0.828491091472489,
1042 0.11259759396041913,
1043 0.024695737913711602,
1044 0.8143535288722658,
1045 0.2489052719751651,
1046 0.24919659562913243,
1047 0.15823680006023388]);
1048 arr2.reshape(2, 5);
1049
1050 let mut result = Array::from(vec![0.7079801427393371,
1051 0.2900673865515695,
1052 0.40365210885083935,
1053 0.5108330141717774,
1054 1.274641169891677,
1055 1.0886433771225437,
1056 0.7280303587324788,
1057 0.42211229429543284]);
1058 result.reshape(4, 2);
1059
1060 assert!(allclose(&arr1.dot(&(arr2.T())), &result));
1061 }
1062
1063
1064
1065 #[test]
1066 fn test_matmul_transpose_2() {
1067
1068 let mut arr1 = Array::from(vec![0.366947042105522,
1069 0.349295593297441,
1070 0.33303578043732596,
1071 0.30336719777517984,
1072 0.31512728615391017,
1073 0.2702251773919264,
1074 0.9002946187524032,
1075 0.966974203293783,
1076 0.8966985473416658,
1077 0.3732753797966627,
1078 0.6482792162720238,
1079 0.3114418154612556,
1080 0.8099721019217031,
1081 0.8047728967088161,
1082 0.7944176886703367,
1083 0.11143517283136029,
1084 0.8115981436332995,
1085 0.7795523385965585,
1086 0.885080155097639,
1087 0.3224210518232872,
1088 0.10716543173998427,
1089 0.16124975726807989,
1090 0.672786361462869,
1091 0.7141498933545607]);
1092 arr1.reshape(6, 4);
1093
1094 let mut arr2 = Array::from(vec![0.23723420298054942,
1095 0.8057173684799351,
1096 0.9182962973982041,
1097 0.9846218462188032,
1098 0.9970471450204329,
1099 0.5159239606629441,
1100 0.7000843086171844,
1101 0.07655877521919541,
1102 0.9011414967516501,
1103 0.8135826471117177,
1104 0.3590617132505789,
1105 0.9757037370929743,
1106 0.38598609699619557,
1107 0.01620939199104432,
1108 0.018674455363305253,
1109 0.5441395433621551,
1110 0.44314631723327513,
1111 0.02570014744707827,
1112 0.368304514558738,
1113 0.42032050791090325]);
1114 arr2.reshape(5, 4);
1115
1116 let mut result = Array::from(vec![0.9730134097555654,
1117 0.802452011836729,
1118 1.0304289466491872,
1119 0.31859167606371497,
1120 0.4217582146760953,
1121 2.0713252296543336,
1122 1.1579249011624595,
1123 1.7705664615165373,
1124 0.6689963501607248,
1125 0.884613984006339,
1126 1.4154468412325385,
1127 1.5643261497920826,
1128 1.6483898319750427,
1129 0.5337378079584966,
1130 0.7766314353289808,
1131 1.6798049142966123,
1132 1.7874726907457785,
1133 1.778621426786623,
1134 0.40115445136891786,
1135 0.7190450457613462,
1136 1.9508663382245812,
1137 1.855706231371058,
1138 1.9979808431469654,
1139 0.5178721029830093,
1140 0.8411905356014459,
1141 1.4763298470230586,
1142 0.7157232170568675,
1143 1.1661317653115675,
1144 0.44513924299250907,
1145 0.5995962091075111]);
1146 result.reshape(6, 5);
1147
1148 assert!(allclose(&arr1.dot(&(arr2.T())), &result));
1149 }
1150
1151
1152
1153 #[test]
1154 fn test_matmul_transpose_3() {
1155
1156 let mut arr1 = Array::from(vec![0.925358894742719,
1157 0.6992302184569288,
1158 0.8928740543794887,
1159 0.9754788397983389,
1160 0.5061117835654796,
1161 0.9366270650173475,
1162 0.4882657956734827,
1163 0.44295295987512373,
1164 0.0233104247827286,
1165 0.12842847576732785,
1166 0.7086610689956077,
1167 0.8830636980843853,
1168 0.04744236715872807,
1169 0.43802410113810686,
1170 0.11376075624879389,
1171 0.16104217757221106,
1172 0.6023318418322183,
1173 0.980939241992898,
1174 0.5664028494798152,
1175 0.11405886530309117,
1176 0.524170006233087,
1177 0.07916192339377204,
1178 0.7216642542468835,
1179 0.12006624986679015,
1180 0.7417686262268323,
1181 0.7713428993319802,
1182 0.06811643131249667,
1183 0.4768252782722475,
1184 0.44243096136594984,
1185 0.22410925267462767,
1186 0.6418249309983912,
1187 0.20606751054744699,
1188 0.5911059348014961,
1189 0.20539031038896527,
1190 0.23649362147998976,
1191 0.4699634060531236,
1192 0.09843193158940089,
1193 0.20091195344582968,
1194 0.5424174383692495,
1195 0.1113514802481127,
1196 0.23498480301506675,
1197 0.7936012015605645,
1198 0.38022526965283854,
1199 0.6593704828215721,
1200 0.7667270434875092,
1201 0.8152019193996527,
1202 0.22028493098698365,
1203 0.7519034635253526,
1204 0.8747074419589803,
1205 0.298494434904939,
1206 0.4727865952754454,
1207 0.22055303550683525,
1208 0.8992782384935715,
1209 0.9531837264977053]);
1210 arr1.reshape(9, 6);
1211
1212 let mut arr2 = Array::from(vec![0.21325823493538731,
1213 0.0380136209209756,
1214 0.5668486704280946,
1215 0.15179717969563755,
1216 0.09452152183985785,
1217 0.7062092476664121,
1218 0.7768054491423071,
1219 0.6568681501402697,
1220 0.8338787454319962,
1221 0.9353569002817529,
1222 0.7045838818183099,
1223 0.39241111834607056,
1224 0.13806837340495992,
1225 0.12047223438561694,
1226 0.08497145948079843,
1227 0.46194116762750004,
1228 0.8737830712555522,
1229 0.6816395610502204,
1230 0.35460061572617096,
1231 0.7500113759420916,
1232 0.8195103581556754,
1233 0.30429266137660316,
1234 0.37504137257531567,
1235 0.9819895219734038,
1236 0.524157506354936,
1237 0.42741092643878753,
1238 0.5177706405135226,
1239 0.968976459901584,
1240 0.3986096682269529,
1241 0.2544486556082437,
1242 0.6432145486770265,
1243 0.46000586566151935,
1244 0.08480161648723994,
1245 0.07894648400880533,
1246 0.45490173613287155,
1247 0.4550962247572681,
1248 0.8312779808040611,
1249 0.1575017176252156,
1250 0.2603949552530008,
1251 0.936233645626559,
1252 0.6311176642674141,
1253 0.7134090490959616,
1254 0.5743026694270158,
1255 0.4522136434574674,
1256 0.5227429980971374,
1257 0.5577767757671542,
1258 0.84138917897813,
1259 0.671087704171892,
1260 0.8372540443335867,
1261 0.34298964015810507,
1262 0.07282651584859834,
1263 0.09673344668488926,
1264 0.991935404620845,
1265 0.25302526804618586]);
1266 arr2.reshape(9, 6);
1267
1268 let mut result = Array::from(vec![1.5874132352880161,
1269 3.5592365313025978,
1270 1.8191572400745657,
1271 2.9906848622885462,
1272 2.6314769977797945,
1273 1.726068663858263,
1274 3.0127507543295313,
1275 2.9128765151070923,
1276 1.912996045913283,
1277 0.844284983952279,
1278 1.6556489310587907,
1279 1.40323191475713,
1280 1.6964786067084,
1281 1.0889382646093413,
1282 1.2541864672985314,
1283 1.679193585582082,
1284 1.7534144489795866,
1285 1.50123516770811,
1286 0.865380925847222,
1287 1.3793969313301555,
1288 1.3383328226781717,
1289 1.6767496403373547,
1290 0.9167255854761861,
1291 0.9747936326487815,
1292 1.3687763724898943,
1293 1.539711735869806,
1294 1.0594987009085777,
1295 0.5872721897901105,
1296 1.5816336672336893,
1297 0.8854708025913408,
1298 1.128601139333808,
1299 1.0119532354369312,
1300 0.8504143388267457,
1301 1.240519373356222,
1302 1.3828020047899279,
1303 1.3053992856711985,
1304 0.49858952001179513,
1305 1.9853558394803,
1306 0.9607437854699225,
1307 1.4284669677201003,
1308 1.449166691798682,
1309 1.1786125802308012,
1310 1.641368364824858,
1311 1.5990345260434795,
1312 1.4322652791558057,
1313 0.865199347657793,
1314 1.6700046672539322,
1315 0.7855362841727803,
1316 1.4792547262096951,
1317 1.1434187361240846,
1318 0.8954249094013815,
1319 1.3967366906671252,
1320 1.3997165817973811,
1321 1.024464851793592,
1322 0.9356598839335093,
1323 1.241883312145559,
1324 0.8815982003785465,
1325 1.5314275092717167,
1326 0.8218085607826606,
1327 0.6785821166080641,
1328 1.073427380572591,
1329 1.2233287139980678,
1330 0.6354879384855953,
1331 1.2163376331032387,
1332 2.580607147012728,
1333 1.2786665526487393,
1334 2.3267414790321057,
1335 1.9471488291912697,
1336 1.1196541581255886,
1337 2.0582366431483528,
1338 2.061981133727548,
1339 1.0879567375540788,
1340 1.2575115111815691,
1341 2.483748335383767,
1342 1.7342874570847941,
1343 2.261895178335525,
1344 1.6455672903994412,
1345 1.6003122450376708,
1346 2.3512991164916297,
1347 2.4038081755783036,
1348 2.023704589242493]);
1349 result.reshape(9, 9);
1350
1351 assert!(allclose(&arr1.dot(&(arr2.T())), &result));
1352 }
1353
1354
1355
1356 #[test]
1357 fn test_matmul_transpose_4() {
1358
1359 let mut arr1 = Array::from(vec![0.0090899539715672,
1360 0.8072458651132488,
1361 0.35529167488218405,
1362 0.49492622902673444]);
1363 arr1.reshape(4, 1);
1364
1365 let mut arr2 = Array::from(vec![0.886757945405175, 0.3642479026632883]);
1366 arr2.reshape(2, 1);
1367
1368 let mut result = Array::from(vec![0.00806058890765454,
1369 0.0033109966694491806,
1370 0.7158316847846475,
1371 0.2940376133011126,
1372 0.315057715638089,
1373 0.12941424740956245,
1374 0.4388797659788781,
1375 0.18027584089603832]);
1376 result.reshape(4, 2);
1377
1378 assert!(allclose(&arr1.dot(&(arr2.T())), &result));
1379 }
1380
1381
1382
1383 #[test]
1384 fn test_matmul_transpose_5() {
1385
1386 let mut arr1 = Array::from(vec![0.7329702869424403,
1387 0.9226694542304723,
1388 0.11350702559826464,
1389 0.0528956901318941,
1390 0.983282695928186,
1391 0.5861293956834694,
1392 0.002704026118440561,
1393 0.5149829462418875,
1394 0.687186035429361]);
1395 arr1.reshape(1, 9);
1396
1397 let mut arr2 = Array::from(vec![0.6130971753715957,
1398 0.3106871258662929,
1399 0.8494692202657048,
1400 0.38324626496049474,
1401 0.6663324777094797,
1402 0.2638430979657117,
1403 0.705354491942043,
1404 0.7381416059458296,
1405 0.972902299988368,
1406 0.20574102904265834,
1407 0.6908971857920572,
1408 0.408033259260263,
1409 0.8074036228914386,
1410 0.7695767666103983,
1411 0.7367914897385391,
1412 0.0016274979892142438,
1413 0.0527367723268356,
1414 0.7393077117457478,
1415 0.8260329905282398,
1416 0.3658708614008537,
1417 0.7364171226011152,
1418 0.42969690597633725,
1419 0.00689279959220912,
1420 0.5011718489772471,
1421 0.007615569747099871,
1422 0.8728097962665927,
1423 0.15550074478902987]);
1424 arr2.reshape(3, 9);
1425
1426 let mut result =
1427 Array::from(vec![2.713178234584766, 2.601066146892677, 1.9062429546218687]);
1428 result.reshape(1, 3);
1429
1430 assert!(allclose(&arr1.dot(&(arr2.T())), &result));
1431 }
1432
1433
1434
1435 #[test]
1436 fn test_matmul_transpose_6() {
1437
1438 let mut arr1 = Array::from(vec![0.9276189989088249,
1439 0.8821012380772483,
1440 0.9576279927537044,
1441 0.22119528649355513,
1442 0.15085713741486573,
1443 0.12322318180711189,
1444 0.4779679546181437,
1445 0.25742220251992387,
1446 0.9464418322439493,
1447 0.4909424621118489,
1448 0.7208912195238542,
1449 0.9962322660739507,
1450 0.43533776323883855,
1451 0.021464328280912603,
1452 0.015101580588801289,
1453 0.4716963821413963]);
1454 arr1.reshape(2, 8);
1455
1456 let mut arr2 = Array::from(vec![0.6380396395660042,
1457 0.10554754374241415,
1458 0.21965756983369356,
1459 0.7349374715928855,
1460 0.7131278653062647,
1461 0.9603874411608422,
1462 0.7313319921709864,
1463 0.8400464200610347,
1464 0.5942567718918943,
1465 0.6819923645474909,
1466 0.7108151819484294,
1467 0.1756086825292481,
1468 0.3818892264503654,
1469 0.39877587789472135,
1470 0.3871422778639042,
1471 0.18732006765193376,
1472 0.42338466389086193,
1473 0.7379784022664586,
1474 0.9901201285264503,
1475 0.06883631042351934,
1476 0.8524458513130413,
1477 0.7847495669454642,
1478 0.4793364790425151,
1479 0.2975398248045932,
1480 0.4832935210264835,
1481 0.3928910553212097,
1482 0.8996944797582809,
1483 0.2800125195754294,
1484 0.09461643872180725,
1485 0.5045095661759922,
1486 0.1777668022757236,
1487 0.23142416909963948]);
1488 arr2.reshape(4, 8);
1489
1490 let mut result = Array::from(vec![1.849598533760568,
1491 2.2123816048166196,
1492 2.5381020520478583,
1493 1.9393734000168037,
1494 2.2845594999427936,
1495 1.8536308542383597,
1496 2.0808929411676527,
1497 1.7417010359535825]);
1498 result.reshape(2, 4);
1499
1500 assert!(allclose(&arr1.dot(&(arr2.T())), &result));
1501 }
1502
1503
1504
1505 #[test]
1506 fn test_matmul_transpose_7() {
1507
1508 let mut arr1 = Array::from(vec![0.08296678138090297,
1509 0.9437328935177516,
1510 0.744747815929632,
1511 0.21508580305827518,
1512 0.16520095858396622,
1513 0.569792729771405,
1514 0.8190018101155101,
1515 0.4311572898376439,
1516 0.763872645481208,
1517 0.7301066611155371,
1518 0.4460436259912971,
1519 0.712182594310135,
1520 0.6392523938198028,
1521 0.22942030313207395,
1522 0.9593009800692543]);
1523 arr1.reshape(5, 3);
1524
1525 let mut arr2 = Array::from(vec![0.595054503015288,
1526 0.4661395579234032,
1527 0.9263817177818151,
1528 0.20907644286927196,
1529 0.6835423168632275,
1530 0.9992868504856399,
1531 0.552504044859316,
1532 0.7112415725656607,
1533 0.1547054999725399,
1534 0.8769705245127782,
1535 0.9604000584486478,
1536 0.27916488757007085]);
1537 arr2.reshape(4, 3);
1538
1539 let mut result = Array::from(vec![1.1792017516786777,
1540 1.4066444674489742,
1541 0.8322781327862652,
1542 1.1870279881811592,
1543 0.7328400452325623,
1544 0.727277602956498,
1545 0.32448363489412957,
1546 0.5063490431479596,
1547 1.395967837054699,
1548 1.2292761280655893,
1549 0.877334101217712,
1550 1.3455703545481614,
1551 1.3021247701037246,
1552 1.1692124987922305,
1553 0.8308102177524938,
1554 1.2674787198914046,
1555 1.3760107839727485,
1556 1.249087957175066,
1557 0.6647719281953499,
1558 1.048743929888444]);
1559 result.reshape(5, 4);
1560
1561 assert!(allclose(&arr1.dot(&(arr2.T())), &result));
1562 }
1563
1564
1565
1566 #[test]
1567 fn test_matmul_transpose_8() {
1568
1569 let mut arr1 = Array::from(vec![0.7793405687788637,
1570 0.35782635935536344,
1571 0.36869416094740337,
1572 0.7011729025692875]);
1573 arr1.reshape(2, 2);
1574
1575 let mut arr2 = Array::from(vec![0.5530864171670206,
1576 0.6227455940690618,
1577 0.20527674341921576,
1578 0.643186558812475,
1579 0.49611844132635763,
1580 0.6569378460971378,
1581 0.29300880113941585,
1582 0.14126333075681263]);
1583 arr2.reshape(4, 2);
1584
1585 let mut result = Array::from(vec![0.6538774716691351,
1586 0.39012959869957675,
1587 0.6217149060366598,
1588 0.27890138909232814,
1589 0.6405720682644396,
1590 0.526669323013058,
1591 0.643542988810901,
1592 0.2070806537396611]);
1593 result.reshape(2, 4);
1594
1595 assert!(allclose(&arr1.dot(&(arr2.T())), &result));
1596 }
1597
1598
1599
1600 #[test]
1601 fn test_matmul_transpose_9() {
1602
1603 let mut arr1 = Array::from(vec![0.3012425110859006,
1604 0.9640430207954833,
1605 0.8380881355116987,
1606 0.6100424254373409,
1607 0.8600049266328298,
1608 0.09426288492393198,
1609 0.8013578186849197]);
1610 arr1.reshape(7, 1);
1611
1612 let mut arr2 = Array::from(vec![0.5875474663752694,
1613 0.2470255691434896,
1614 0.7333256607132345,
1615 0.9627502578511307]);
1616 arr2.reshape(4, 1);
1617
1618 let mut result = Array::from(vec![0.17699427415304492,
1619 0.07441460275120858,
1620 0.2209088634769819,
1621 0.2900213052236729,
1622 0.5664210343451475,
1623 0.23814327589081324,
1624 0.7069574851808302,
1625 0.9281326668504345,
1626 0.4924165606190721,
1627 0.20702919866718342,
1628 0.6145915357100392,
1629 0.8068695685658612,
1630 0.35842888144713386,
1631 0.15069607734533397,
1632 0.44735976469694205,
1633 0.5873185023899291,
1634 0.5052937157133687,
1635 0.2124432064676798,
1636 0.6306636810396566,
1637 0.8279699648689995,
1638 0.05538391921027982,
1639 0.023285342797441565,
1640 0.069125392367578,
1641 0.09075161676630697,
1642 0.47083575602833716,
1643 0.19795587124822764,
1644 0.587656251854835,
1645 0.7715074465699261]);
1646 result.reshape(7, 4);
1647
1648 assert!(allclose(&arr1.dot(&(arr2.T())), &result));
1649 }
1650
1651
1652
1653 #[test]
1654 fn test_index_0() {
1655
1656 let mut arr = Array::from(vec![0.215326974913587,
1657 0.6805099195535821,
1658 0.4748674293207318,
1659 0.9308159224933445,
1660 0.15796901892179882,
1661 0.48123372171929335,
1662 0.09109310508025259,
1663 0.17645768747481172,
1664 0.07362796696187168,
1665 0.34399329395805656,
1666 0.6769927850435898,
1667 0.27763892690350545,
1668 0.3104671690237111,
1669 0.05446100051600278,
1670 0.3025826095486641,
1671 0.8552415488703948]);
1672 arr.reshape(8, 2);
1673
1674 assert!(close(arr.get(0, 0), 0.215326974914));
1675 assert!(close(arr.get(0, 1), 0.680509919554));
1676 assert!(close(arr.get(1, 0), 0.474867429321));
1677 assert!(close(arr.get(1, 1), 0.930815922493));
1678 assert!(close(arr.get(2, 0), 0.157969018922));
1679 assert!(close(arr.get(2, 1), 0.481233721719));
1680 assert!(close(arr.get(3, 0), 0.0910931050803));
1681 assert!(close(arr.get(3, 1), 0.176457687475));
1682 assert!(close(arr.get(4, 0), 0.0736279669619));
1683 assert!(close(arr.get(4, 1), 0.343993293958));
1684 assert!(close(arr.get(5, 0), 0.676992785044));
1685 assert!(close(arr.get(5, 1), 0.277638926904));
1686 assert!(close(arr.get(6, 0), 0.310467169024));
1687 assert!(close(arr.get(6, 1), 0.054461000516));
1688 assert!(close(arr.get(7, 0), 0.302582609549));
1689 assert!(close(arr.get(7, 1), 0.85524154887));
1690 }
1691
1692
1693
1694 #[test]
1695 fn test_index_transpose_0() {
1696
1697 let mut arr = Array::from(vec![0.215326974913587,
1698 0.6805099195535821,
1699 0.4748674293207318,
1700 0.9308159224933445,
1701 0.15796901892179882,
1702 0.48123372171929335,
1703 0.09109310508025259,
1704 0.17645768747481172,
1705 0.07362796696187168,
1706 0.34399329395805656,
1707 0.6769927850435898,
1708 0.27763892690350545,
1709 0.3104671690237111,
1710 0.05446100051600278,
1711 0.3025826095486641,
1712 0.8552415488703948]);
1713 arr.reshape(8, 2);
1714
1715 let arr = arr.T();
1716 assert!(close(arr.get(0, 0), 0.215326974914));
1717 assert!(close(arr.get(1, 0), 0.680509919554));
1718 assert!(close(arr.get(0, 1), 0.474867429321));
1719 assert!(close(arr.get(1, 1), 0.930815922493));
1720 assert!(close(arr.get(0, 2), 0.157969018922));
1721 assert!(close(arr.get(1, 2), 0.481233721719));
1722 assert!(close(arr.get(0, 3), 0.0910931050803));
1723 assert!(close(arr.get(1, 3), 0.176457687475));
1724 assert!(close(arr.get(0, 4), 0.0736279669619));
1725 assert!(close(arr.get(1, 4), 0.343993293958));
1726 assert!(close(arr.get(0, 5), 0.676992785044));
1727 assert!(close(arr.get(1, 5), 0.277638926904));
1728 assert!(close(arr.get(0, 6), 0.310467169024));
1729 assert!(close(arr.get(1, 6), 0.054461000516));
1730 assert!(close(arr.get(0, 7), 0.302582609549));
1731 assert!(close(arr.get(1, 7), 0.85524154887));
1732 }
1733
1734
1735
1736 #[test]
1737 fn test_index_mut_0() {
1738
1739 let mut arr = Array::from(vec![0.215326974913587,
1740 0.6805099195535821,
1741 0.4748674293207318,
1742 0.9308159224933445,
1743 0.15796901892179882,
1744 0.48123372171929335,
1745 0.09109310508025259,
1746 0.17645768747481172,
1747 0.07362796696187168,
1748 0.34399329395805656,
1749 0.6769927850435898,
1750 0.27763892690350545,
1751 0.3104671690237111,
1752 0.05446100051600278,
1753 0.3025826095486641,
1754 0.8552415488703948]);
1755 arr.reshape(8, 2);
1756
1757 let mut v = arr.get(0, 0);
1758 v += 1.0;
1759 assert!(close(v, 1.21532697491));
1760 let mut v = arr.get(0, 1);
1761 v += 1.0;
1762 assert!(close(v, 1.68050991955));
1763 let mut v = arr.get(1, 0);
1764 v += 1.0;
1765 assert!(close(v, 1.47486742932));
1766 let mut v = arr.get(1, 1);
1767 v += 1.0;
1768 assert!(close(v, 1.93081592249));
1769 let mut v = arr.get(2, 0);
1770 v += 1.0;
1771 assert!(close(v, 1.15796901892));
1772 let mut v = arr.get(2, 1);
1773 v += 1.0;
1774 assert!(close(v, 1.48123372172));
1775 let mut v = arr.get(3, 0);
1776 v += 1.0;
1777 assert!(close(v, 1.09109310508));
1778 let mut v = arr.get(3, 1);
1779 v += 1.0;
1780 assert!(close(v, 1.17645768747));
1781 let mut v = arr.get(4, 0);
1782 v += 1.0;
1783 assert!(close(v, 1.07362796696));
1784 let mut v = arr.get(4, 1);
1785 v += 1.0;
1786 assert!(close(v, 1.34399329396));
1787 let mut v = arr.get(5, 0);
1788 v += 1.0;
1789 assert!(close(v, 1.67699278504));
1790 let mut v = arr.get(5, 1);
1791 v += 1.0;
1792 assert!(close(v, 1.2776389269));
1793 let mut v = arr.get(6, 0);
1794 v += 1.0;
1795 assert!(close(v, 1.31046716902));
1796 let mut v = arr.get(6, 1);
1797 v += 1.0;
1798 assert!(close(v, 1.05446100052));
1799 let mut v = arr.get(7, 0);
1800 v += 1.0;
1801 assert!(close(v, 1.30258260955));
1802 let mut v = arr.get(7, 1);
1803 v += 1.0;
1804 assert!(close(v, 1.85524154887));
1805 }
1806
1807
1808
1809 #[test]
1810 fn test_index_transpose_mut_0() {
1811
1812 let mut arr = Array::from(vec![0.215326974913587,
1813 0.6805099195535821,
1814 0.4748674293207318,
1815 0.9308159224933445,
1816 0.15796901892179882,
1817 0.48123372171929335,
1818 0.09109310508025259,
1819 0.17645768747481172,
1820 0.07362796696187168,
1821 0.34399329395805656,
1822 0.6769927850435898,
1823 0.27763892690350545,
1824 0.3104671690237111,
1825 0.05446100051600278,
1826 0.3025826095486641,
1827 0.8552415488703948]);
1828 arr.reshape(8, 2);
1829
1830 let arr = arr.T();
1831 let mut v = arr.get(0, 0);
1832 v += 1.0;
1833 assert!(close(v, 1.21532697491));
1834 let mut v = arr.get(1, 0);
1835 v += 1.0;
1836 assert!(close(v, 1.68050991955));
1837 let mut v = arr.get(0, 1);
1838 v += 1.0;
1839 assert!(close(v, 1.47486742932));
1840 let mut v = arr.get(1, 1);
1841 v += 1.0;
1842 assert!(close(v, 1.93081592249));
1843 let mut v = arr.get(0, 2);
1844 v += 1.0;
1845 assert!(close(v, 1.15796901892));
1846 let mut v = arr.get(1, 2);
1847 v += 1.0;
1848 assert!(close(v, 1.48123372172));
1849 let mut v = arr.get(0, 3);
1850 v += 1.0;
1851 assert!(close(v, 1.09109310508));
1852 let mut v = arr.get(1, 3);
1853 v += 1.0;
1854 assert!(close(v, 1.17645768747));
1855 let mut v = arr.get(0, 4);
1856 v += 1.0;
1857 assert!(close(v, 1.07362796696));
1858 let mut v = arr.get(1, 4);
1859 v += 1.0;
1860 assert!(close(v, 1.34399329396));
1861 let mut v = arr.get(0, 5);
1862 v += 1.0;
1863 assert!(close(v, 1.67699278504));
1864 let mut v = arr.get(1, 5);
1865 v += 1.0;
1866 assert!(close(v, 1.2776389269));
1867 let mut v = arr.get(0, 6);
1868 v += 1.0;
1869 assert!(close(v, 1.31046716902));
1870 let mut v = arr.get(1, 6);
1871 v += 1.0;
1872 assert!(close(v, 1.05446100052));
1873 let mut v = arr.get(0, 7);
1874 v += 1.0;
1875 assert!(close(v, 1.30258260955));
1876 let mut v = arr.get(1, 7);
1877 v += 1.0;
1878 assert!(close(v, 1.85524154887));
1879 }
1880
1881
1882
1883 #[test]
1884 fn test_index_unsafe_0() {
1885
1886 let mut arr = Array::from(vec![0.215326974913587,
1887 0.6805099195535821,
1888 0.4748674293207318,
1889 0.9308159224933445,
1890 0.15796901892179882,
1891 0.48123372171929335,
1892 0.09109310508025259,
1893 0.17645768747481172,
1894 0.07362796696187168,
1895 0.34399329395805656,
1896 0.6769927850435898,
1897 0.27763892690350545,
1898 0.3104671690237111,
1899 0.05446100051600278,
1900 0.3025826095486641,
1901 0.8552415488703948]);
1902 arr.reshape(8, 2);
1903
1904 unsafe {
1905 assert!(close(arr.get_unchecked(0, 0), 0.215326974914));
1906 };
1907 unsafe {
1908 assert!(close(arr.get_unchecked(0, 1), 0.680509919554));
1909 };
1910 unsafe {
1911 assert!(close(arr.get_unchecked(1, 0), 0.474867429321));
1912 };
1913 unsafe {
1914 assert!(close(arr.get_unchecked(1, 1), 0.930815922493));
1915 };
1916 unsafe {
1917 assert!(close(arr.get_unchecked(2, 0), 0.157969018922));
1918 };
1919 unsafe {
1920 assert!(close(arr.get_unchecked(2, 1), 0.481233721719));
1921 };
1922 unsafe {
1923 assert!(close(arr.get_unchecked(3, 0), 0.0910931050803));
1924 };
1925 unsafe {
1926 assert!(close(arr.get_unchecked(3, 1), 0.176457687475));
1927 };
1928 unsafe {
1929 assert!(close(arr.get_unchecked(4, 0), 0.0736279669619));
1930 };
1931 unsafe {
1932 assert!(close(arr.get_unchecked(4, 1), 0.343993293958));
1933 };
1934 unsafe {
1935 assert!(close(arr.get_unchecked(5, 0), 0.676992785044));
1936 };
1937 unsafe {
1938 assert!(close(arr.get_unchecked(5, 1), 0.277638926904));
1939 };
1940 unsafe {
1941 assert!(close(arr.get_unchecked(6, 0), 0.310467169024));
1942 };
1943 unsafe {
1944 assert!(close(arr.get_unchecked(6, 1), 0.054461000516));
1945 };
1946 unsafe {
1947 assert!(close(arr.get_unchecked(7, 0), 0.302582609549));
1948 };
1949 unsafe {
1950 assert!(close(arr.get_unchecked(7, 1), 0.85524154887));
1951 };
1952 }
1953
1954
1955
1956 #[test]
1957 fn test_index_transpose_unsafe_0() {
1958
1959 let mut arr = Array::from(vec![0.215326974913587,
1960 0.6805099195535821,
1961 0.4748674293207318,
1962 0.9308159224933445,
1963 0.15796901892179882,
1964 0.48123372171929335,
1965 0.09109310508025259,
1966 0.17645768747481172,
1967 0.07362796696187168,
1968 0.34399329395805656,
1969 0.6769927850435898,
1970 0.27763892690350545,
1971 0.3104671690237111,
1972 0.05446100051600278,
1973 0.3025826095486641,
1974 0.8552415488703948]);
1975 arr.reshape(8, 2);
1976
1977 let arr = arr.T();
1978 unsafe {
1979 assert!(close(arr.get_unchecked(0, 0), 0.215326974914));
1980 };
1981 unsafe {
1982 assert!(close(arr.get_unchecked(1, 0), 0.680509919554));
1983 };
1984 unsafe {
1985 assert!(close(arr.get_unchecked(0, 1), 0.474867429321));
1986 };
1987 unsafe {
1988 assert!(close(arr.get_unchecked(1, 1), 0.930815922493));
1989 };
1990 unsafe {
1991 assert!(close(arr.get_unchecked(0, 2), 0.157969018922));
1992 };
1993 unsafe {
1994 assert!(close(arr.get_unchecked(1, 2), 0.481233721719));
1995 };
1996 unsafe {
1997 assert!(close(arr.get_unchecked(0, 3), 0.0910931050803));
1998 };
1999 unsafe {
2000 assert!(close(arr.get_unchecked(1, 3), 0.176457687475));
2001 };
2002 unsafe {
2003 assert!(close(arr.get_unchecked(0, 4), 0.0736279669619));
2004 };
2005 unsafe {
2006 assert!(close(arr.get_unchecked(1, 4), 0.343993293958));
2007 };
2008 unsafe {
2009 assert!(close(arr.get_unchecked(0, 5), 0.676992785044));
2010 };
2011 unsafe {
2012 assert!(close(arr.get_unchecked(1, 5), 0.277638926904));
2013 };
2014 unsafe {
2015 assert!(close(arr.get_unchecked(0, 6), 0.310467169024));
2016 };
2017 unsafe {
2018 assert!(close(arr.get_unchecked(1, 6), 0.054461000516));
2019 };
2020 unsafe {
2021 assert!(close(arr.get_unchecked(0, 7), 0.302582609549));
2022 };
2023 unsafe {
2024 assert!(close(arr.get_unchecked(1, 7), 0.85524154887));
2025 };
2026 }
2027
2028
2029
2030 #[test]
2031 fn test_index_1() {
2032
2033 let mut arr = Array::from(vec![0.9570919550354068,
2034 0.4584494243018158,
2035 0.7325601962236107,
2036 0.7243072717708018,
2037 0.3613850934270306,
2038 0.5761485027298561,
2039 0.09116891942241268,
2040 0.79391017855673,
2041 0.4270675742297524,
2042 0.6014689371746276,
2043 0.0566050497078342,
2044 0.08454409755727632,
2045 0.018154562228838156,
2046 0.6510911907876277,
2047 0.43693418658497074,
2048 0.1121532057198672,
2049 0.05423778016957859,
2050 0.6384092286500843,
2051 0.951293670338954,
2052 0.9984309373462644]);
2053 arr.reshape(4, 5);
2054
2055 assert!(close(arr.get(0, 0), 0.957091955035));
2056 assert!(close(arr.get(0, 1), 0.458449424302));
2057 assert!(close(arr.get(0, 2), 0.732560196224));
2058 assert!(close(arr.get(0, 3), 0.724307271771));
2059 assert!(close(arr.get(0, 4), 0.361385093427));
2060 assert!(close(arr.get(1, 0), 0.57614850273));
2061 assert!(close(arr.get(1, 1), 0.0911689194224));
2062 assert!(close(arr.get(1, 2), 0.793910178557));
2063 assert!(close(arr.get(1, 3), 0.42706757423));
2064 assert!(close(arr.get(1, 4), 0.601468937175));
2065 assert!(close(arr.get(2, 0), 0.0566050497078));
2066 assert!(close(arr.get(2, 1), 0.0845440975573));
2067 assert!(close(arr.get(2, 2), 0.0181545622288));
2068 assert!(close(arr.get(2, 3), 0.651091190788));
2069 assert!(close(arr.get(2, 4), 0.436934186585));
2070 assert!(close(arr.get(3, 0), 0.11215320572));
2071 assert!(close(arr.get(3, 1), 0.0542377801696));
2072 assert!(close(arr.get(3, 2), 0.63840922865));
2073 assert!(close(arr.get(3, 3), 0.951293670339));
2074 assert!(close(arr.get(3, 4), 0.998430937346));
2075 }
2076
2077
2078
2079 #[test]
2080 fn test_index_transpose_1() {
2081
2082 let mut arr = Array::from(vec![0.9570919550354068,
2083 0.4584494243018158,
2084 0.7325601962236107,
2085 0.7243072717708018,
2086 0.3613850934270306,
2087 0.5761485027298561,
2088 0.09116891942241268,
2089 0.79391017855673,
2090 0.4270675742297524,
2091 0.6014689371746276,
2092 0.0566050497078342,
2093 0.08454409755727632,
2094 0.018154562228838156,
2095 0.6510911907876277,
2096 0.43693418658497074,
2097 0.1121532057198672,
2098 0.05423778016957859,
2099 0.6384092286500843,
2100 0.951293670338954,
2101 0.9984309373462644]);
2102 arr.reshape(4, 5);
2103
2104 let arr = arr.T();
2105 assert!(close(arr.get(0, 0), 0.957091955035));
2106 assert!(close(arr.get(1, 0), 0.458449424302));
2107 assert!(close(arr.get(2, 0), 0.732560196224));
2108 assert!(close(arr.get(3, 0), 0.724307271771));
2109 assert!(close(arr.get(4, 0), 0.361385093427));
2110 assert!(close(arr.get(0, 1), 0.57614850273));
2111 assert!(close(arr.get(1, 1), 0.0911689194224));
2112 assert!(close(arr.get(2, 1), 0.793910178557));
2113 assert!(close(arr.get(3, 1), 0.42706757423));
2114 assert!(close(arr.get(4, 1), 0.601468937175));
2115 assert!(close(arr.get(0, 2), 0.0566050497078));
2116 assert!(close(arr.get(1, 2), 0.0845440975573));
2117 assert!(close(arr.get(2, 2), 0.0181545622288));
2118 assert!(close(arr.get(3, 2), 0.651091190788));
2119 assert!(close(arr.get(4, 2), 0.436934186585));
2120 assert!(close(arr.get(0, 3), 0.11215320572));
2121 assert!(close(arr.get(1, 3), 0.0542377801696));
2122 assert!(close(arr.get(2, 3), 0.63840922865));
2123 assert!(close(arr.get(3, 3), 0.951293670339));
2124 assert!(close(arr.get(4, 3), 0.998430937346));
2125 }
2126
2127
2128
2129 #[test]
2130 fn test_index_mut_1() {
2131
2132 let mut arr = Array::from(vec![0.9570919550354068,
2133 0.4584494243018158,
2134 0.7325601962236107,
2135 0.7243072717708018,
2136 0.3613850934270306,
2137 0.5761485027298561,
2138 0.09116891942241268,
2139 0.79391017855673,
2140 0.4270675742297524,
2141 0.6014689371746276,
2142 0.0566050497078342,
2143 0.08454409755727632,
2144 0.018154562228838156,
2145 0.6510911907876277,
2146 0.43693418658497074,
2147 0.1121532057198672,
2148 0.05423778016957859,
2149 0.6384092286500843,
2150 0.951293670338954,
2151 0.9984309373462644]);
2152 arr.reshape(4, 5);
2153
2154 let mut v = arr.get(0, 0);
2155 v += 1.0;
2156 assert!(close(v, 1.95709195504));
2157 let mut v = arr.get(0, 1);
2158 v += 1.0;
2159 assert!(close(v, 1.4584494243));
2160 let mut v = arr.get(0, 2);
2161 v += 1.0;
2162 assert!(close(v, 1.73256019622));
2163 let mut v = arr.get(0, 3);
2164 v += 1.0;
2165 assert!(close(v, 1.72430727177));
2166 let mut v = arr.get(0, 4);
2167 v += 1.0;
2168 assert!(close(v, 1.36138509343));
2169 let mut v = arr.get(1, 0);
2170 v += 1.0;
2171 assert!(close(v, 1.57614850273));
2172 let mut v = arr.get(1, 1);
2173 v += 1.0;
2174 assert!(close(v, 1.09116891942));
2175 let mut v = arr.get(1, 2);
2176 v += 1.0;
2177 assert!(close(v, 1.79391017856));
2178 let mut v = arr.get(1, 3);
2179 v += 1.0;
2180 assert!(close(v, 1.42706757423));
2181 let mut v = arr.get(1, 4);
2182 v += 1.0;
2183 assert!(close(v, 1.60146893717));
2184 let mut v = arr.get(2, 0);
2185 v += 1.0;
2186 assert!(close(v, 1.05660504971));
2187 let mut v = arr.get(2, 1);
2188 v += 1.0;
2189 assert!(close(v, 1.08454409756));
2190 let mut v = arr.get(2, 2);
2191 v += 1.0;
2192 assert!(close(v, 1.01815456223));
2193 let mut v = arr.get(2, 3);
2194 v += 1.0;
2195 assert!(close(v, 1.65109119079));
2196 let mut v = arr.get(2, 4);
2197 v += 1.0;
2198 assert!(close(v, 1.43693418658));
2199 let mut v = arr.get(3, 0);
2200 v += 1.0;
2201 assert!(close(v, 1.11215320572));
2202 let mut v = arr.get(3, 1);
2203 v += 1.0;
2204 assert!(close(v, 1.05423778017));
2205 let mut v = arr.get(3, 2);
2206 v += 1.0;
2207 assert!(close(v, 1.63840922865));
2208 let mut v = arr.get(3, 3);
2209 v += 1.0;
2210 assert!(close(v, 1.95129367034));
2211 let mut v = arr.get(3, 4);
2212 v += 1.0;
2213 assert!(close(v, 1.99843093735));
2214 }
2215
2216
2217
2218 #[test]
2219 fn test_index_transpose_mut_1() {
2220
2221 let mut arr = Array::from(vec![0.9570919550354068,
2222 0.4584494243018158,
2223 0.7325601962236107,
2224 0.7243072717708018,
2225 0.3613850934270306,
2226 0.5761485027298561,
2227 0.09116891942241268,
2228 0.79391017855673,
2229 0.4270675742297524,
2230 0.6014689371746276,
2231 0.0566050497078342,
2232 0.08454409755727632,
2233 0.018154562228838156,
2234 0.6510911907876277,
2235 0.43693418658497074,
2236 0.1121532057198672,
2237 0.05423778016957859,
2238 0.6384092286500843,
2239 0.951293670338954,
2240 0.9984309373462644]);
2241 arr.reshape(4, 5);
2242
2243 let arr = arr.T();
2244 let mut v = arr.get(0, 0);
2245 v += 1.0;
2246 assert!(close(v, 1.95709195504));
2247 let mut v = arr.get(1, 0);
2248 v += 1.0;
2249 assert!(close(v, 1.4584494243));
2250 let mut v = arr.get(2, 0);
2251 v += 1.0;
2252 assert!(close(v, 1.73256019622));
2253 let mut v = arr.get(3, 0);
2254 v += 1.0;
2255 assert!(close(v, 1.72430727177));
2256 let mut v = arr.get(4, 0);
2257 v += 1.0;
2258 assert!(close(v, 1.36138509343));
2259 let mut v = arr.get(0, 1);
2260 v += 1.0;
2261 assert!(close(v, 1.57614850273));
2262 let mut v = arr.get(1, 1);
2263 v += 1.0;
2264 assert!(close(v, 1.09116891942));
2265 let mut v = arr.get(2, 1);
2266 v += 1.0;
2267 assert!(close(v, 1.79391017856));
2268 let mut v = arr.get(3, 1);
2269 v += 1.0;
2270 assert!(close(v, 1.42706757423));
2271 let mut v = arr.get(4, 1);
2272 v += 1.0;
2273 assert!(close(v, 1.60146893717));
2274 let mut v = arr.get(0, 2);
2275 v += 1.0;
2276 assert!(close(v, 1.05660504971));
2277 let mut v = arr.get(1, 2);
2278 v += 1.0;
2279 assert!(close(v, 1.08454409756));
2280 let mut v = arr.get(2, 2);
2281 v += 1.0;
2282 assert!(close(v, 1.01815456223));
2283 let mut v = arr.get(3, 2);
2284 v += 1.0;
2285 assert!(close(v, 1.65109119079));
2286 let mut v = arr.get(4, 2);
2287 v += 1.0;
2288 assert!(close(v, 1.43693418658));
2289 let mut v = arr.get(0, 3);
2290 v += 1.0;
2291 assert!(close(v, 1.11215320572));
2292 let mut v = arr.get(1, 3);
2293 v += 1.0;
2294 assert!(close(v, 1.05423778017));
2295 let mut v = arr.get(2, 3);
2296 v += 1.0;
2297 assert!(close(v, 1.63840922865));
2298 let mut v = arr.get(3, 3);
2299 v += 1.0;
2300 assert!(close(v, 1.95129367034));
2301 let mut v = arr.get(4, 3);
2302 v += 1.0;
2303 assert!(close(v, 1.99843093735));
2304 }
2305
2306
2307
2308 #[test]
2309 fn test_index_unsafe_1() {
2310
2311 let mut arr = Array::from(vec![0.9570919550354068,
2312 0.4584494243018158,
2313 0.7325601962236107,
2314 0.7243072717708018,
2315 0.3613850934270306,
2316 0.5761485027298561,
2317 0.09116891942241268,
2318 0.79391017855673,
2319 0.4270675742297524,
2320 0.6014689371746276,
2321 0.0566050497078342,
2322 0.08454409755727632,
2323 0.018154562228838156,
2324 0.6510911907876277,
2325 0.43693418658497074,
2326 0.1121532057198672,
2327 0.05423778016957859,
2328 0.6384092286500843,
2329 0.951293670338954,
2330 0.9984309373462644]);
2331 arr.reshape(4, 5);
2332
2333 unsafe {
2334 assert!(close(arr.get_unchecked(0, 0), 0.957091955035));
2335 };
2336 unsafe {
2337 assert!(close(arr.get_unchecked(0, 1), 0.458449424302));
2338 };
2339 unsafe {
2340 assert!(close(arr.get_unchecked(0, 2), 0.732560196224));
2341 };
2342 unsafe {
2343 assert!(close(arr.get_unchecked(0, 3), 0.724307271771));
2344 };
2345 unsafe {
2346 assert!(close(arr.get_unchecked(0, 4), 0.361385093427));
2347 };
2348 unsafe {
2349 assert!(close(arr.get_unchecked(1, 0), 0.57614850273));
2350 };
2351 unsafe {
2352 assert!(close(arr.get_unchecked(1, 1), 0.0911689194224));
2353 };
2354 unsafe {
2355 assert!(close(arr.get_unchecked(1, 2), 0.793910178557));
2356 };
2357 unsafe {
2358 assert!(close(arr.get_unchecked(1, 3), 0.42706757423));
2359 };
2360 unsafe {
2361 assert!(close(arr.get_unchecked(1, 4), 0.601468937175));
2362 };
2363 unsafe {
2364 assert!(close(arr.get_unchecked(2, 0), 0.0566050497078));
2365 };
2366 unsafe {
2367 assert!(close(arr.get_unchecked(2, 1), 0.0845440975573));
2368 };
2369 unsafe {
2370 assert!(close(arr.get_unchecked(2, 2), 0.0181545622288));
2371 };
2372 unsafe {
2373 assert!(close(arr.get_unchecked(2, 3), 0.651091190788));
2374 };
2375 unsafe {
2376 assert!(close(arr.get_unchecked(2, 4), 0.436934186585));
2377 };
2378 unsafe {
2379 assert!(close(arr.get_unchecked(3, 0), 0.11215320572));
2380 };
2381 unsafe {
2382 assert!(close(arr.get_unchecked(3, 1), 0.0542377801696));
2383 };
2384 unsafe {
2385 assert!(close(arr.get_unchecked(3, 2), 0.63840922865));
2386 };
2387 unsafe {
2388 assert!(close(arr.get_unchecked(3, 3), 0.951293670339));
2389 };
2390 unsafe {
2391 assert!(close(arr.get_unchecked(3, 4), 0.998430937346));
2392 };
2393 }
2394
2395
2396
2397 #[test]
2398 fn test_index_transpose_unsafe_1() {
2399
2400 let mut arr = Array::from(vec![0.9570919550354068,
2401 0.4584494243018158,
2402 0.7325601962236107,
2403 0.7243072717708018,
2404 0.3613850934270306,
2405 0.5761485027298561,
2406 0.09116891942241268,
2407 0.79391017855673,
2408 0.4270675742297524,
2409 0.6014689371746276,
2410 0.0566050497078342,
2411 0.08454409755727632,
2412 0.018154562228838156,
2413 0.6510911907876277,
2414 0.43693418658497074,
2415 0.1121532057198672,
2416 0.05423778016957859,
2417 0.6384092286500843,
2418 0.951293670338954,
2419 0.9984309373462644]);
2420 arr.reshape(4, 5);
2421
2422 let arr = arr.T();
2423 unsafe {
2424 assert!(close(arr.get_unchecked(0, 0), 0.957091955035));
2425 };
2426 unsafe {
2427 assert!(close(arr.get_unchecked(1, 0), 0.458449424302));
2428 };
2429 unsafe {
2430 assert!(close(arr.get_unchecked(2, 0), 0.732560196224));
2431 };
2432 unsafe {
2433 assert!(close(arr.get_unchecked(3, 0), 0.724307271771));
2434 };
2435 unsafe {
2436 assert!(close(arr.get_unchecked(4, 0), 0.361385093427));
2437 };
2438 unsafe {
2439 assert!(close(arr.get_unchecked(0, 1), 0.57614850273));
2440 };
2441 unsafe {
2442 assert!(close(arr.get_unchecked(1, 1), 0.0911689194224));
2443 };
2444 unsafe {
2445 assert!(close(arr.get_unchecked(2, 1), 0.793910178557));
2446 };
2447 unsafe {
2448 assert!(close(arr.get_unchecked(3, 1), 0.42706757423));
2449 };
2450 unsafe {
2451 assert!(close(arr.get_unchecked(4, 1), 0.601468937175));
2452 };
2453 unsafe {
2454 assert!(close(arr.get_unchecked(0, 2), 0.0566050497078));
2455 };
2456 unsafe {
2457 assert!(close(arr.get_unchecked(1, 2), 0.0845440975573));
2458 };
2459 unsafe {
2460 assert!(close(arr.get_unchecked(2, 2), 0.0181545622288));
2461 };
2462 unsafe {
2463 assert!(close(arr.get_unchecked(3, 2), 0.651091190788));
2464 };
2465 unsafe {
2466 assert!(close(arr.get_unchecked(4, 2), 0.436934186585));
2467 };
2468 unsafe {
2469 assert!(close(arr.get_unchecked(0, 3), 0.11215320572));
2470 };
2471 unsafe {
2472 assert!(close(arr.get_unchecked(1, 3), 0.0542377801696));
2473 };
2474 unsafe {
2475 assert!(close(arr.get_unchecked(2, 3), 0.63840922865));
2476 };
2477 unsafe {
2478 assert!(close(arr.get_unchecked(3, 3), 0.951293670339));
2479 };
2480 unsafe {
2481 assert!(close(arr.get_unchecked(4, 3), 0.998430937346));
2482 };
2483 }
2484
2485
2486
2487 #[test]
2488 fn test_index_2() {
2489
2490 let mut arr = Array::from(vec![0.8601557407225077,
2491 0.40321033442362164,
2492 0.14247985606097524,
2493 0.26937234786738784,
2494 0.5798684722291974,
2495 0.5632966236167654,
2496 0.8942163566518069,
2497 0.4935655841140425,
2498 0.7686310384422732,
2499 0.3707877682545938,
2500 0.33448589916704596,
2501 0.38941280660658095,
2502 0.4880493616861097,
2503 0.7933563093096604,
2504 0.1663297283689782,
2505 0.2144586116668381]);
2506 arr.reshape(2, 8);
2507
2508 assert!(close(arr.get(0, 0), 0.860155740723));
2509 assert!(close(arr.get(0, 1), 0.403210334424));
2510 assert!(close(arr.get(0, 2), 0.142479856061));
2511 assert!(close(arr.get(0, 3), 0.269372347867));
2512 assert!(close(arr.get(0, 4), 0.579868472229));
2513 assert!(close(arr.get(0, 5), 0.563296623617));
2514 assert!(close(arr.get(0, 6), 0.894216356652));
2515 assert!(close(arr.get(0, 7), 0.493565584114));
2516 assert!(close(arr.get(1, 0), 0.768631038442));
2517 assert!(close(arr.get(1, 1), 0.370787768255));
2518 assert!(close(arr.get(1, 2), 0.334485899167));
2519 assert!(close(arr.get(1, 3), 0.389412806607));
2520 assert!(close(arr.get(1, 4), 0.488049361686));
2521 assert!(close(arr.get(1, 5), 0.79335630931));
2522 assert!(close(arr.get(1, 6), 0.166329728369));
2523 assert!(close(arr.get(1, 7), 0.214458611667));
2524 }
2525
2526
2527
2528 #[test]
2529 fn test_index_transpose_2() {
2530
2531 let mut arr = Array::from(vec![0.8601557407225077,
2532 0.40321033442362164,
2533 0.14247985606097524,
2534 0.26937234786738784,
2535 0.5798684722291974,
2536 0.5632966236167654,
2537 0.8942163566518069,
2538 0.4935655841140425,
2539 0.7686310384422732,
2540 0.3707877682545938,
2541 0.33448589916704596,
2542 0.38941280660658095,
2543 0.4880493616861097,
2544 0.7933563093096604,
2545 0.1663297283689782,
2546 0.2144586116668381]);
2547 arr.reshape(2, 8);
2548
2549 let arr = arr.T();
2550 assert!(close(arr.get(0, 0), 0.860155740723));
2551 assert!(close(arr.get(1, 0), 0.403210334424));
2552 assert!(close(arr.get(2, 0), 0.142479856061));
2553 assert!(close(arr.get(3, 0), 0.269372347867));
2554 assert!(close(arr.get(4, 0), 0.579868472229));
2555 assert!(close(arr.get(5, 0), 0.563296623617));
2556 assert!(close(arr.get(6, 0), 0.894216356652));
2557 assert!(close(arr.get(7, 0), 0.493565584114));
2558 assert!(close(arr.get(0, 1), 0.768631038442));
2559 assert!(close(arr.get(1, 1), 0.370787768255));
2560 assert!(close(arr.get(2, 1), 0.334485899167));
2561 assert!(close(arr.get(3, 1), 0.389412806607));
2562 assert!(close(arr.get(4, 1), 0.488049361686));
2563 assert!(close(arr.get(5, 1), 0.79335630931));
2564 assert!(close(arr.get(6, 1), 0.166329728369));
2565 assert!(close(arr.get(7, 1), 0.214458611667));
2566 }
2567
2568
2569
2570 #[test]
2571 fn test_index_mut_2() {
2572
2573 let mut arr = Array::from(vec![0.8601557407225077,
2574 0.40321033442362164,
2575 0.14247985606097524,
2576 0.26937234786738784,
2577 0.5798684722291974,
2578 0.5632966236167654,
2579 0.8942163566518069,
2580 0.4935655841140425,
2581 0.7686310384422732,
2582 0.3707877682545938,
2583 0.33448589916704596,
2584 0.38941280660658095,
2585 0.4880493616861097,
2586 0.7933563093096604,
2587 0.1663297283689782,
2588 0.2144586116668381]);
2589 arr.reshape(2, 8);
2590
2591 let mut v = arr.get(0, 0);
2592 v += 1.0;
2593 assert!(close(v, 1.86015574072));
2594 let mut v = arr.get(0, 1);
2595 v += 1.0;
2596 assert!(close(v, 1.40321033442));
2597 let mut v = arr.get(0, 2);
2598 v += 1.0;
2599 assert!(close(v, 1.14247985606));
2600 let mut v = arr.get(0, 3);
2601 v += 1.0;
2602 assert!(close(v, 1.26937234787));
2603 let mut v = arr.get(0, 4);
2604 v += 1.0;
2605 assert!(close(v, 1.57986847223));
2606 let mut v = arr.get(0, 5);
2607 v += 1.0;
2608 assert!(close(v, 1.56329662362));
2609 let mut v = arr.get(0, 6);
2610 v += 1.0;
2611 assert!(close(v, 1.89421635665));
2612 let mut v = arr.get(0, 7);
2613 v += 1.0;
2614 assert!(close(v, 1.49356558411));
2615 let mut v = arr.get(1, 0);
2616 v += 1.0;
2617 assert!(close(v, 1.76863103844));
2618 let mut v = arr.get(1, 1);
2619 v += 1.0;
2620 assert!(close(v, 1.37078776825));
2621 let mut v = arr.get(1, 2);
2622 v += 1.0;
2623 assert!(close(v, 1.33448589917));
2624 let mut v = arr.get(1, 3);
2625 v += 1.0;
2626 assert!(close(v, 1.38941280661));
2627 let mut v = arr.get(1, 4);
2628 v += 1.0;
2629 assert!(close(v, 1.48804936169));
2630 let mut v = arr.get(1, 5);
2631 v += 1.0;
2632 assert!(close(v, 1.79335630931));
2633 let mut v = arr.get(1, 6);
2634 v += 1.0;
2635 assert!(close(v, 1.16632972837));
2636 let mut v = arr.get(1, 7);
2637 v += 1.0;
2638 assert!(close(v, 1.21445861167));
2639 }
2640
2641
2642
2643 #[test]
2644 fn test_index_transpose_mut_2() {
2645
2646 let mut arr = Array::from(vec![0.8601557407225077,
2647 0.40321033442362164,
2648 0.14247985606097524,
2649 0.26937234786738784,
2650 0.5798684722291974,
2651 0.5632966236167654,
2652 0.8942163566518069,
2653 0.4935655841140425,
2654 0.7686310384422732,
2655 0.3707877682545938,
2656 0.33448589916704596,
2657 0.38941280660658095,
2658 0.4880493616861097,
2659 0.7933563093096604,
2660 0.1663297283689782,
2661 0.2144586116668381]);
2662 arr.reshape(2, 8);
2663
2664 let arr = arr.T();
2665 let mut v = arr.get(0, 0);
2666 v += 1.0;
2667 assert!(close(v, 1.86015574072));
2668 let mut v = arr.get(1, 0);
2669 v += 1.0;
2670 assert!(close(v, 1.40321033442));
2671 let mut v = arr.get(2, 0);
2672 v += 1.0;
2673 assert!(close(v, 1.14247985606));
2674 let mut v = arr.get(3, 0);
2675 v += 1.0;
2676 assert!(close(v, 1.26937234787));
2677 let mut v = arr.get(4, 0);
2678 v += 1.0;
2679 assert!(close(v, 1.57986847223));
2680 let mut v = arr.get(5, 0);
2681 v += 1.0;
2682 assert!(close(v, 1.56329662362));
2683 let mut v = arr.get(6, 0);
2684 v += 1.0;
2685 assert!(close(v, 1.89421635665));
2686 let mut v = arr.get(7, 0);
2687 v += 1.0;
2688 assert!(close(v, 1.49356558411));
2689 let mut v = arr.get(0, 1);
2690 v += 1.0;
2691 assert!(close(v, 1.76863103844));
2692 let mut v = arr.get(1, 1);
2693 v += 1.0;
2694 assert!(close(v, 1.37078776825));
2695 let mut v = arr.get(2, 1);
2696 v += 1.0;
2697 assert!(close(v, 1.33448589917));
2698 let mut v = arr.get(3, 1);
2699 v += 1.0;
2700 assert!(close(v, 1.38941280661));
2701 let mut v = arr.get(4, 1);
2702 v += 1.0;
2703 assert!(close(v, 1.48804936169));
2704 let mut v = arr.get(5, 1);
2705 v += 1.0;
2706 assert!(close(v, 1.79335630931));
2707 let mut v = arr.get(6, 1);
2708 v += 1.0;
2709 assert!(close(v, 1.16632972837));
2710 let mut v = arr.get(7, 1);
2711 v += 1.0;
2712 assert!(close(v, 1.21445861167));
2713 }
2714
2715
2716
2717 #[test]
2718 fn test_index_unsafe_2() {
2719
2720 let mut arr = Array::from(vec![0.8601557407225077,
2721 0.40321033442362164,
2722 0.14247985606097524,
2723 0.26937234786738784,
2724 0.5798684722291974,
2725 0.5632966236167654,
2726 0.8942163566518069,
2727 0.4935655841140425,
2728 0.7686310384422732,
2729 0.3707877682545938,
2730 0.33448589916704596,
2731 0.38941280660658095,
2732 0.4880493616861097,
2733 0.7933563093096604,
2734 0.1663297283689782,
2735 0.2144586116668381]);
2736 arr.reshape(2, 8);
2737
2738 unsafe {
2739 assert!(close(arr.get_unchecked(0, 0), 0.860155740723));
2740 };
2741 unsafe {
2742 assert!(close(arr.get_unchecked(0, 1), 0.403210334424));
2743 };
2744 unsafe {
2745 assert!(close(arr.get_unchecked(0, 2), 0.142479856061));
2746 };
2747 unsafe {
2748 assert!(close(arr.get_unchecked(0, 3), 0.269372347867));
2749 };
2750 unsafe {
2751 assert!(close(arr.get_unchecked(0, 4), 0.579868472229));
2752 };
2753 unsafe {
2754 assert!(close(arr.get_unchecked(0, 5), 0.563296623617));
2755 };
2756 unsafe {
2757 assert!(close(arr.get_unchecked(0, 6), 0.894216356652));
2758 };
2759 unsafe {
2760 assert!(close(arr.get_unchecked(0, 7), 0.493565584114));
2761 };
2762 unsafe {
2763 assert!(close(arr.get_unchecked(1, 0), 0.768631038442));
2764 };
2765 unsafe {
2766 assert!(close(arr.get_unchecked(1, 1), 0.370787768255));
2767 };
2768 unsafe {
2769 assert!(close(arr.get_unchecked(1, 2), 0.334485899167));
2770 };
2771 unsafe {
2772 assert!(close(arr.get_unchecked(1, 3), 0.389412806607));
2773 };
2774 unsafe {
2775 assert!(close(arr.get_unchecked(1, 4), 0.488049361686));
2776 };
2777 unsafe {
2778 assert!(close(arr.get_unchecked(1, 5), 0.79335630931));
2779 };
2780 unsafe {
2781 assert!(close(arr.get_unchecked(1, 6), 0.166329728369));
2782 };
2783 unsafe {
2784 assert!(close(arr.get_unchecked(1, 7), 0.214458611667));
2785 };
2786 }
2787
2788
2789
2790 #[test]
2791 fn test_index_transpose_unsafe_2() {
2792
2793 let mut arr = Array::from(vec![0.8601557407225077,
2794 0.40321033442362164,
2795 0.14247985606097524,
2796 0.26937234786738784,
2797 0.5798684722291974,
2798 0.5632966236167654,
2799 0.8942163566518069,
2800 0.4935655841140425,
2801 0.7686310384422732,
2802 0.3707877682545938,
2803 0.33448589916704596,
2804 0.38941280660658095,
2805 0.4880493616861097,
2806 0.7933563093096604,
2807 0.1663297283689782,
2808 0.2144586116668381]);
2809 arr.reshape(2, 8);
2810
2811 let arr = arr.T();
2812 unsafe {
2813 assert!(close(arr.get_unchecked(0, 0), 0.860155740723));
2814 };
2815 unsafe {
2816 assert!(close(arr.get_unchecked(1, 0), 0.403210334424));
2817 };
2818 unsafe {
2819 assert!(close(arr.get_unchecked(2, 0), 0.142479856061));
2820 };
2821 unsafe {
2822 assert!(close(arr.get_unchecked(3, 0), 0.269372347867));
2823 };
2824 unsafe {
2825 assert!(close(arr.get_unchecked(4, 0), 0.579868472229));
2826 };
2827 unsafe {
2828 assert!(close(arr.get_unchecked(5, 0), 0.563296623617));
2829 };
2830 unsafe {
2831 assert!(close(arr.get_unchecked(6, 0), 0.894216356652));
2832 };
2833 unsafe {
2834 assert!(close(arr.get_unchecked(7, 0), 0.493565584114));
2835 };
2836 unsafe {
2837 assert!(close(arr.get_unchecked(0, 1), 0.768631038442));
2838 };
2839 unsafe {
2840 assert!(close(arr.get_unchecked(1, 1), 0.370787768255));
2841 };
2842 unsafe {
2843 assert!(close(arr.get_unchecked(2, 1), 0.334485899167));
2844 };
2845 unsafe {
2846 assert!(close(arr.get_unchecked(3, 1), 0.389412806607));
2847 };
2848 unsafe {
2849 assert!(close(arr.get_unchecked(4, 1), 0.488049361686));
2850 };
2851 unsafe {
2852 assert!(close(arr.get_unchecked(5, 1), 0.79335630931));
2853 };
2854 unsafe {
2855 assert!(close(arr.get_unchecked(6, 1), 0.166329728369));
2856 };
2857 unsafe {
2858 assert!(close(arr.get_unchecked(7, 1), 0.214458611667));
2859 };
2860 }
2861
2862
2863
2864 #[test]
2865 fn test_index_3() {
2866
2867 let mut arr = Array::from(vec![0.3647979523539372,
2868 0.36308406394227044,
2869 0.21404950758183616,
2870 0.36811953573544476,
2871 0.15420979571680848,
2872 0.7091867671879617,
2873 0.8245692241181685,
2874 0.28601877391422614,
2875 0.7053682579186311,
2876 0.9436051798229766,
2877 0.13564080650832278,
2878 0.49162020823877484,
2879 0.6575486409921484,
2880 0.5224264019283387,
2881 0.1304045608362886,
2882 0.40313708114722413,
2883 0.4123952289574855,
2884 0.4308186558945438,
2885 0.11908643991366652,
2886 0.2579691080534129,
2887 0.47102938170577524,
2888 0.878796734322898,
2889 0.7789561501543262,
2890 0.7959634630696436,
2891 0.004418088734142178,
2892 0.8552923824803051,
2893 0.19673926667104624,
2894 0.9213117917011139,
2895 0.11573887674353178,
2896 0.09984725008755602,
2897 0.4149531641983125,
2898 0.8301283257987035,
2899 0.6583325997105612,
2900 0.8405620427928018,
2901 0.29872918139103655,
2902 0.2913539353436094,
2903 0.21961401853166496,
2904 0.8731108344033446,
2905 0.9925319133165988,
2906 0.12493108260697727,
2907 0.5167221149865642,
2908 0.35603600906937594]);
2909 arr.reshape(7, 6);
2910
2911 assert!(close(arr.get(0, 0), 0.364797952354));
2912 assert!(close(arr.get(0, 1), 0.363084063942));
2913 assert!(close(arr.get(0, 2), 0.214049507582));
2914 assert!(close(arr.get(0, 3), 0.368119535735));
2915 assert!(close(arr.get(0, 4), 0.154209795717));
2916 assert!(close(arr.get(0, 5), 0.709186767188));
2917 assert!(close(arr.get(1, 0), 0.824569224118));
2918 assert!(close(arr.get(1, 1), 0.286018773914));
2919 assert!(close(arr.get(1, 2), 0.705368257919));
2920 assert!(close(arr.get(1, 3), 0.943605179823));
2921 assert!(close(arr.get(1, 4), 0.135640806508));
2922 assert!(close(arr.get(1, 5), 0.491620208239));
2923 assert!(close(arr.get(2, 0), 0.657548640992));
2924 assert!(close(arr.get(2, 1), 0.522426401928));
2925 assert!(close(arr.get(2, 2), 0.130404560836));
2926 assert!(close(arr.get(2, 3), 0.403137081147));
2927 assert!(close(arr.get(2, 4), 0.412395228957));
2928 assert!(close(arr.get(2, 5), 0.430818655895));
2929 assert!(close(arr.get(3, 0), 0.119086439914));
2930 assert!(close(arr.get(3, 1), 0.257969108053));
2931 assert!(close(arr.get(3, 2), 0.471029381706));
2932 assert!(close(arr.get(3, 3), 0.878796734323));
2933 assert!(close(arr.get(3, 4), 0.778956150154));
2934 assert!(close(arr.get(3, 5), 0.79596346307));
2935 assert!(close(arr.get(4, 0), 0.00441808873414));
2936 assert!(close(arr.get(4, 1), 0.85529238248));
2937 assert!(close(arr.get(4, 2), 0.196739266671));
2938 assert!(close(arr.get(4, 3), 0.921311791701));
2939 assert!(close(arr.get(4, 4), 0.115738876744));
2940 assert!(close(arr.get(4, 5), 0.0998472500876));
2941 assert!(close(arr.get(5, 0), 0.414953164198));
2942 assert!(close(arr.get(5, 1), 0.830128325799));
2943 assert!(close(arr.get(5, 2), 0.658332599711));
2944 assert!(close(arr.get(5, 3), 0.840562042793));
2945 assert!(close(arr.get(5, 4), 0.298729181391));
2946 assert!(close(arr.get(5, 5), 0.291353935344));
2947 assert!(close(arr.get(6, 0), 0.219614018532));
2948 assert!(close(arr.get(6, 1), 0.873110834403));
2949 assert!(close(arr.get(6, 2), 0.992531913317));
2950 assert!(close(arr.get(6, 3), 0.124931082607));
2951 assert!(close(arr.get(6, 4), 0.516722114987));
2952 assert!(close(arr.get(6, 5), 0.356036009069));
2953 }
2954
2955
2956
2957 #[test]
2958 fn test_index_transpose_3() {
2959
2960 let mut arr = Array::from(vec![0.3647979523539372,
2961 0.36308406394227044,
2962 0.21404950758183616,
2963 0.36811953573544476,
2964 0.15420979571680848,
2965 0.7091867671879617,
2966 0.8245692241181685,
2967 0.28601877391422614,
2968 0.7053682579186311,
2969 0.9436051798229766,
2970 0.13564080650832278,
2971 0.49162020823877484,
2972 0.6575486409921484,
2973 0.5224264019283387,
2974 0.1304045608362886,
2975 0.40313708114722413,
2976 0.4123952289574855,
2977 0.4308186558945438,
2978 0.11908643991366652,
2979 0.2579691080534129,
2980 0.47102938170577524,
2981 0.878796734322898,
2982 0.7789561501543262,
2983 0.7959634630696436,
2984 0.004418088734142178,
2985 0.8552923824803051,
2986 0.19673926667104624,
2987 0.9213117917011139,
2988 0.11573887674353178,
2989 0.09984725008755602,
2990 0.4149531641983125,
2991 0.8301283257987035,
2992 0.6583325997105612,
2993 0.8405620427928018,
2994 0.29872918139103655,
2995 0.2913539353436094,
2996 0.21961401853166496,
2997 0.8731108344033446,
2998 0.9925319133165988,
2999 0.12493108260697727,
3000 0.5167221149865642,
3001 0.35603600906937594]);
3002 arr.reshape(7, 6);
3003
3004 let arr = arr.T();
3005 assert!(close(arr.get(0, 0), 0.364797952354));
3006 assert!(close(arr.get(1, 0), 0.363084063942));
3007 assert!(close(arr.get(2, 0), 0.214049507582));
3008 assert!(close(arr.get(3, 0), 0.368119535735));
3009 assert!(close(arr.get(4, 0), 0.154209795717));
3010 assert!(close(arr.get(5, 0), 0.709186767188));
3011 assert!(close(arr.get(0, 1), 0.824569224118));
3012 assert!(close(arr.get(1, 1), 0.286018773914));
3013 assert!(close(arr.get(2, 1), 0.705368257919));
3014 assert!(close(arr.get(3, 1), 0.943605179823));
3015 assert!(close(arr.get(4, 1), 0.135640806508));
3016 assert!(close(arr.get(5, 1), 0.491620208239));
3017 assert!(close(arr.get(0, 2), 0.657548640992));
3018 assert!(close(arr.get(1, 2), 0.522426401928));
3019 assert!(close(arr.get(2, 2), 0.130404560836));
3020 assert!(close(arr.get(3, 2), 0.403137081147));
3021 assert!(close(arr.get(4, 2), 0.412395228957));
3022 assert!(close(arr.get(5, 2), 0.430818655895));
3023 assert!(close(arr.get(0, 3), 0.119086439914));
3024 assert!(close(arr.get(1, 3), 0.257969108053));
3025 assert!(close(arr.get(2, 3), 0.471029381706));
3026 assert!(close(arr.get(3, 3), 0.878796734323));
3027 assert!(close(arr.get(4, 3), 0.778956150154));
3028 assert!(close(arr.get(5, 3), 0.79596346307));
3029 assert!(close(arr.get(0, 4), 0.00441808873414));
3030 assert!(close(arr.get(1, 4), 0.85529238248));
3031 assert!(close(arr.get(2, 4), 0.196739266671));
3032 assert!(close(arr.get(3, 4), 0.921311791701));
3033 assert!(close(arr.get(4, 4), 0.115738876744));
3034 assert!(close(arr.get(5, 4), 0.0998472500876));
3035 assert!(close(arr.get(0, 5), 0.414953164198));
3036 assert!(close(arr.get(1, 5), 0.830128325799));
3037 assert!(close(arr.get(2, 5), 0.658332599711));
3038 assert!(close(arr.get(3, 5), 0.840562042793));
3039 assert!(close(arr.get(4, 5), 0.298729181391));
3040 assert!(close(arr.get(5, 5), 0.291353935344));
3041 assert!(close(arr.get(0, 6), 0.219614018532));
3042 assert!(close(arr.get(1, 6), 0.873110834403));
3043 assert!(close(arr.get(2, 6), 0.992531913317));
3044 assert!(close(arr.get(3, 6), 0.124931082607));
3045 assert!(close(arr.get(4, 6), 0.516722114987));
3046 assert!(close(arr.get(5, 6), 0.356036009069));
3047 }
3048
3049
3050
3051 #[test]
3052 fn test_index_mut_3() {
3053
3054 let mut arr = Array::from(vec![0.3647979523539372,
3055 0.36308406394227044,
3056 0.21404950758183616,
3057 0.36811953573544476,
3058 0.15420979571680848,
3059 0.7091867671879617,
3060 0.8245692241181685,
3061 0.28601877391422614,
3062 0.7053682579186311,
3063 0.9436051798229766,
3064 0.13564080650832278,
3065 0.49162020823877484,
3066 0.6575486409921484,
3067 0.5224264019283387,
3068 0.1304045608362886,
3069 0.40313708114722413,
3070 0.4123952289574855,
3071 0.4308186558945438,
3072 0.11908643991366652,
3073 0.2579691080534129,
3074 0.47102938170577524,
3075 0.878796734322898,
3076 0.7789561501543262,
3077 0.7959634630696436,
3078 0.004418088734142178,
3079 0.8552923824803051,
3080 0.19673926667104624,
3081 0.9213117917011139,
3082 0.11573887674353178,
3083 0.09984725008755602,
3084 0.4149531641983125,
3085 0.8301283257987035,
3086 0.6583325997105612,
3087 0.8405620427928018,
3088 0.29872918139103655,
3089 0.2913539353436094,
3090 0.21961401853166496,
3091 0.8731108344033446,
3092 0.9925319133165988,
3093 0.12493108260697727,
3094 0.5167221149865642,
3095 0.35603600906937594]);
3096 arr.reshape(7, 6);
3097
3098 let mut v = arr.get(0, 0);
3099 v += 1.0;
3100 assert!(close(v, 1.36479795235));
3101 let mut v = arr.get(0, 1);
3102 v += 1.0;
3103 assert!(close(v, 1.36308406394));
3104 let mut v = arr.get(0, 2);
3105 v += 1.0;
3106 assert!(close(v, 1.21404950758));
3107 let mut v = arr.get(0, 3);
3108 v += 1.0;
3109 assert!(close(v, 1.36811953574));
3110 let mut v = arr.get(0, 4);
3111 v += 1.0;
3112 assert!(close(v, 1.15420979572));
3113 let mut v = arr.get(0, 5);
3114 v += 1.0;
3115 assert!(close(v, 1.70918676719));
3116 let mut v = arr.get(1, 0);
3117 v += 1.0;
3118 assert!(close(v, 1.82456922412));
3119 let mut v = arr.get(1, 1);
3120 v += 1.0;
3121 assert!(close(v, 1.28601877391));
3122 let mut v = arr.get(1, 2);
3123 v += 1.0;
3124 assert!(close(v, 1.70536825792));
3125 let mut v = arr.get(1, 3);
3126 v += 1.0;
3127 assert!(close(v, 1.94360517982));
3128 let mut v = arr.get(1, 4);
3129 v += 1.0;
3130 assert!(close(v, 1.13564080651));
3131 let mut v = arr.get(1, 5);
3132 v += 1.0;
3133 assert!(close(v, 1.49162020824));
3134 let mut v = arr.get(2, 0);
3135 v += 1.0;
3136 assert!(close(v, 1.65754864099));
3137 let mut v = arr.get(2, 1);
3138 v += 1.0;
3139 assert!(close(v, 1.52242640193));
3140 let mut v = arr.get(2, 2);
3141 v += 1.0;
3142 assert!(close(v, 1.13040456084));
3143 let mut v = arr.get(2, 3);
3144 v += 1.0;
3145 assert!(close(v, 1.40313708115));
3146 let mut v = arr.get(2, 4);
3147 v += 1.0;
3148 assert!(close(v, 1.41239522896));
3149 let mut v = arr.get(2, 5);
3150 v += 1.0;
3151 assert!(close(v, 1.43081865589));
3152 let mut v = arr.get(3, 0);
3153 v += 1.0;
3154 assert!(close(v, 1.11908643991));
3155 let mut v = arr.get(3, 1);
3156 v += 1.0;
3157 assert!(close(v, 1.25796910805));
3158 let mut v = arr.get(3, 2);
3159 v += 1.0;
3160 assert!(close(v, 1.47102938171));
3161 let mut v = arr.get(3, 3);
3162 v += 1.0;
3163 assert!(close(v, 1.87879673432));
3164 let mut v = arr.get(3, 4);
3165 v += 1.0;
3166 assert!(close(v, 1.77895615015));
3167 let mut v = arr.get(3, 5);
3168 v += 1.0;
3169 assert!(close(v, 1.79596346307));
3170 let mut v = arr.get(4, 0);
3171 v += 1.0;
3172 assert!(close(v, 1.00441808873));
3173 let mut v = arr.get(4, 1);
3174 v += 1.0;
3175 assert!(close(v, 1.85529238248));
3176 let mut v = arr.get(4, 2);
3177 v += 1.0;
3178 assert!(close(v, 1.19673926667));
3179 let mut v = arr.get(4, 3);
3180 v += 1.0;
3181 assert!(close(v, 1.9213117917));
3182 let mut v = arr.get(4, 4);
3183 v += 1.0;
3184 assert!(close(v, 1.11573887674));
3185 let mut v = arr.get(4, 5);
3186 v += 1.0;
3187 assert!(close(v, 1.09984725009));
3188 let mut v = arr.get(5, 0);
3189 v += 1.0;
3190 assert!(close(v, 1.4149531642));
3191 let mut v = arr.get(5, 1);
3192 v += 1.0;
3193 assert!(close(v, 1.8301283258));
3194 let mut v = arr.get(5, 2);
3195 v += 1.0;
3196 assert!(close(v, 1.65833259971));
3197 let mut v = arr.get(5, 3);
3198 v += 1.0;
3199 assert!(close(v, 1.84056204279));
3200 let mut v = arr.get(5, 4);
3201 v += 1.0;
3202 assert!(close(v, 1.29872918139));
3203 let mut v = arr.get(5, 5);
3204 v += 1.0;
3205 assert!(close(v, 1.29135393534));
3206 let mut v = arr.get(6, 0);
3207 v += 1.0;
3208 assert!(close(v, 1.21961401853));
3209 let mut v = arr.get(6, 1);
3210 v += 1.0;
3211 assert!(close(v, 1.8731108344));
3212 let mut v = arr.get(6, 2);
3213 v += 1.0;
3214 assert!(close(v, 1.99253191332));
3215 let mut v = arr.get(6, 3);
3216 v += 1.0;
3217 assert!(close(v, 1.12493108261));
3218 let mut v = arr.get(6, 4);
3219 v += 1.0;
3220 assert!(close(v, 1.51672211499));
3221 let mut v = arr.get(6, 5);
3222 v += 1.0;
3223 assert!(close(v, 1.35603600907));
3224 }
3225
3226
3227
3228 #[test]
3229 fn test_index_transpose_mut_3() {
3230
3231 let mut arr = Array::from(vec![0.3647979523539372,
3232 0.36308406394227044,
3233 0.21404950758183616,
3234 0.36811953573544476,
3235 0.15420979571680848,
3236 0.7091867671879617,
3237 0.8245692241181685,
3238 0.28601877391422614,
3239 0.7053682579186311,
3240 0.9436051798229766,
3241 0.13564080650832278,
3242 0.49162020823877484,
3243 0.6575486409921484,
3244 0.5224264019283387,
3245 0.1304045608362886,
3246 0.40313708114722413,
3247 0.4123952289574855,
3248 0.4308186558945438,
3249 0.11908643991366652,
3250 0.2579691080534129,
3251 0.47102938170577524,
3252 0.878796734322898,
3253 0.7789561501543262,
3254 0.7959634630696436,
3255 0.004418088734142178,
3256 0.8552923824803051,
3257 0.19673926667104624,
3258 0.9213117917011139,
3259 0.11573887674353178,
3260 0.09984725008755602,
3261 0.4149531641983125,
3262 0.8301283257987035,
3263 0.6583325997105612,
3264 0.8405620427928018,
3265 0.29872918139103655,
3266 0.2913539353436094,
3267 0.21961401853166496,
3268 0.8731108344033446,
3269 0.9925319133165988,
3270 0.12493108260697727,
3271 0.5167221149865642,
3272 0.35603600906937594]);
3273 arr.reshape(7, 6);
3274
3275 let arr = arr.T();
3276 let mut v = arr.get(0, 0);
3277 v += 1.0;
3278 assert!(close(v, 1.36479795235));
3279 let mut v = arr.get(1, 0);
3280 v += 1.0;
3281 assert!(close(v, 1.36308406394));
3282 let mut v = arr.get(2, 0);
3283 v += 1.0;
3284 assert!(close(v, 1.21404950758));
3285 let mut v = arr.get(3, 0);
3286 v += 1.0;
3287 assert!(close(v, 1.36811953574));
3288 let mut v = arr.get(4, 0);
3289 v += 1.0;
3290 assert!(close(v, 1.15420979572));
3291 let mut v = arr.get(5, 0);
3292 v += 1.0;
3293 assert!(close(v, 1.70918676719));
3294 let mut v = arr.get(0, 1);
3295 v += 1.0;
3296 assert!(close(v, 1.82456922412));
3297 let mut v = arr.get(1, 1);
3298 v += 1.0;
3299 assert!(close(v, 1.28601877391));
3300 let mut v = arr.get(2, 1);
3301 v += 1.0;
3302 assert!(close(v, 1.70536825792));
3303 let mut v = arr.get(3, 1);
3304 v += 1.0;
3305 assert!(close(v, 1.94360517982));
3306 let mut v = arr.get(4, 1);
3307 v += 1.0;
3308 assert!(close(v, 1.13564080651));
3309 let mut v = arr.get(5, 1);
3310 v += 1.0;
3311 assert!(close(v, 1.49162020824));
3312 let mut v = arr.get(0, 2);
3313 v += 1.0;
3314 assert!(close(v, 1.65754864099));
3315 let mut v = arr.get(1, 2);
3316 v += 1.0;
3317 assert!(close(v, 1.52242640193));
3318 let mut v = arr.get(2, 2);
3319 v += 1.0;
3320 assert!(close(v, 1.13040456084));
3321 let mut v = arr.get(3, 2);
3322 v += 1.0;
3323 assert!(close(v, 1.40313708115));
3324 let mut v = arr.get(4, 2);
3325 v += 1.0;
3326 assert!(close(v, 1.41239522896));
3327 let mut v = arr.get(5, 2);
3328 v += 1.0;
3329 assert!(close(v, 1.43081865589));
3330 let mut v = arr.get(0, 3);
3331 v += 1.0;
3332 assert!(close(v, 1.11908643991));
3333 let mut v = arr.get(1, 3);
3334 v += 1.0;
3335 assert!(close(v, 1.25796910805));
3336 let mut v = arr.get(2, 3);
3337 v += 1.0;
3338 assert!(close(v, 1.47102938171));
3339 let mut v = arr.get(3, 3);
3340 v += 1.0;
3341 assert!(close(v, 1.87879673432));
3342 let mut v = arr.get(4, 3);
3343 v += 1.0;
3344 assert!(close(v, 1.77895615015));
3345 let mut v = arr.get(5, 3);
3346 v += 1.0;
3347 assert!(close(v, 1.79596346307));
3348 let mut v = arr.get(0, 4);
3349 v += 1.0;
3350 assert!(close(v, 1.00441808873));
3351 let mut v = arr.get(1, 4);
3352 v += 1.0;
3353 assert!(close(v, 1.85529238248));
3354 let mut v = arr.get(2, 4);
3355 v += 1.0;
3356 assert!(close(v, 1.19673926667));
3357 let mut v = arr.get(3, 4);
3358 v += 1.0;
3359 assert!(close(v, 1.9213117917));
3360 let mut v = arr.get(4, 4);
3361 v += 1.0;
3362 assert!(close(v, 1.11573887674));
3363 let mut v = arr.get(5, 4);
3364 v += 1.0;
3365 assert!(close(v, 1.09984725009));
3366 let mut v = arr.get(0, 5);
3367 v += 1.0;
3368 assert!(close(v, 1.4149531642));
3369 let mut v = arr.get(1, 5);
3370 v += 1.0;
3371 assert!(close(v, 1.8301283258));
3372 let mut v = arr.get(2, 5);
3373 v += 1.0;
3374 assert!(close(v, 1.65833259971));
3375 let mut v = arr.get(3, 5);
3376 v += 1.0;
3377 assert!(close(v, 1.84056204279));
3378 let mut v = arr.get(4, 5);
3379 v += 1.0;
3380 assert!(close(v, 1.29872918139));
3381 let mut v = arr.get(5, 5);
3382 v += 1.0;
3383 assert!(close(v, 1.29135393534));
3384 let mut v = arr.get(0, 6);
3385 v += 1.0;
3386 assert!(close(v, 1.21961401853));
3387 let mut v = arr.get(1, 6);
3388 v += 1.0;
3389 assert!(close(v, 1.8731108344));
3390 let mut v = arr.get(2, 6);
3391 v += 1.0;
3392 assert!(close(v, 1.99253191332));
3393 let mut v = arr.get(3, 6);
3394 v += 1.0;
3395 assert!(close(v, 1.12493108261));
3396 let mut v = arr.get(4, 6);
3397 v += 1.0;
3398 assert!(close(v, 1.51672211499));
3399 let mut v = arr.get(5, 6);
3400 v += 1.0;
3401 assert!(close(v, 1.35603600907));
3402 }
3403
3404
3405
3406 #[test]
3407 fn test_index_unsafe_3() {
3408
3409 let mut arr = Array::from(vec![0.3647979523539372,
3410 0.36308406394227044,
3411 0.21404950758183616,
3412 0.36811953573544476,
3413 0.15420979571680848,
3414 0.7091867671879617,
3415 0.8245692241181685,
3416 0.28601877391422614,
3417 0.7053682579186311,
3418 0.9436051798229766,
3419 0.13564080650832278,
3420 0.49162020823877484,
3421 0.6575486409921484,
3422 0.5224264019283387,
3423 0.1304045608362886,
3424 0.40313708114722413,
3425 0.4123952289574855,
3426 0.4308186558945438,
3427 0.11908643991366652,
3428 0.2579691080534129,
3429 0.47102938170577524,
3430 0.878796734322898,
3431 0.7789561501543262,
3432 0.7959634630696436,
3433 0.004418088734142178,
3434 0.8552923824803051,
3435 0.19673926667104624,
3436 0.9213117917011139,
3437 0.11573887674353178,
3438 0.09984725008755602,
3439 0.4149531641983125,
3440 0.8301283257987035,
3441 0.6583325997105612,
3442 0.8405620427928018,
3443 0.29872918139103655,
3444 0.2913539353436094,
3445 0.21961401853166496,
3446 0.8731108344033446,
3447 0.9925319133165988,
3448 0.12493108260697727,
3449 0.5167221149865642,
3450 0.35603600906937594]);
3451 arr.reshape(7, 6);
3452
3453 unsafe {
3454 assert!(close(arr.get_unchecked(0, 0), 0.364797952354));
3455 };
3456 unsafe {
3457 assert!(close(arr.get_unchecked(0, 1), 0.363084063942));
3458 };
3459 unsafe {
3460 assert!(close(arr.get_unchecked(0, 2), 0.214049507582));
3461 };
3462 unsafe {
3463 assert!(close(arr.get_unchecked(0, 3), 0.368119535735));
3464 };
3465 unsafe {
3466 assert!(close(arr.get_unchecked(0, 4), 0.154209795717));
3467 };
3468 unsafe {
3469 assert!(close(arr.get_unchecked(0, 5), 0.709186767188));
3470 };
3471 unsafe {
3472 assert!(close(arr.get_unchecked(1, 0), 0.824569224118));
3473 };
3474 unsafe {
3475 assert!(close(arr.get_unchecked(1, 1), 0.286018773914));
3476 };
3477 unsafe {
3478 assert!(close(arr.get_unchecked(1, 2), 0.705368257919));
3479 };
3480 unsafe {
3481 assert!(close(arr.get_unchecked(1, 3), 0.943605179823));
3482 };
3483 unsafe {
3484 assert!(close(arr.get_unchecked(1, 4), 0.135640806508));
3485 };
3486 unsafe {
3487 assert!(close(arr.get_unchecked(1, 5), 0.491620208239));
3488 };
3489 unsafe {
3490 assert!(close(arr.get_unchecked(2, 0), 0.657548640992));
3491 };
3492 unsafe {
3493 assert!(close(arr.get_unchecked(2, 1), 0.522426401928));
3494 };
3495 unsafe {
3496 assert!(close(arr.get_unchecked(2, 2), 0.130404560836));
3497 };
3498 unsafe {
3499 assert!(close(arr.get_unchecked(2, 3), 0.403137081147));
3500 };
3501 unsafe {
3502 assert!(close(arr.get_unchecked(2, 4), 0.412395228957));
3503 };
3504 unsafe {
3505 assert!(close(arr.get_unchecked(2, 5), 0.430818655895));
3506 };
3507 unsafe {
3508 assert!(close(arr.get_unchecked(3, 0), 0.119086439914));
3509 };
3510 unsafe {
3511 assert!(close(arr.get_unchecked(3, 1), 0.257969108053));
3512 };
3513 unsafe {
3514 assert!(close(arr.get_unchecked(3, 2), 0.471029381706));
3515 };
3516 unsafe {
3517 assert!(close(arr.get_unchecked(3, 3), 0.878796734323));
3518 };
3519 unsafe {
3520 assert!(close(arr.get_unchecked(3, 4), 0.778956150154));
3521 };
3522 unsafe {
3523 assert!(close(arr.get_unchecked(3, 5), 0.79596346307));
3524 };
3525 unsafe {
3526 assert!(close(arr.get_unchecked(4, 0), 0.00441808873414));
3527 };
3528 unsafe {
3529 assert!(close(arr.get_unchecked(4, 1), 0.85529238248));
3530 };
3531 unsafe {
3532 assert!(close(arr.get_unchecked(4, 2), 0.196739266671));
3533 };
3534 unsafe {
3535 assert!(close(arr.get_unchecked(4, 3), 0.921311791701));
3536 };
3537 unsafe {
3538 assert!(close(arr.get_unchecked(4, 4), 0.115738876744));
3539 };
3540 unsafe {
3541 assert!(close(arr.get_unchecked(4, 5), 0.0998472500876));
3542 };
3543 unsafe {
3544 assert!(close(arr.get_unchecked(5, 0), 0.414953164198));
3545 };
3546 unsafe {
3547 assert!(close(arr.get_unchecked(5, 1), 0.830128325799));
3548 };
3549 unsafe {
3550 assert!(close(arr.get_unchecked(5, 2), 0.658332599711));
3551 };
3552 unsafe {
3553 assert!(close(arr.get_unchecked(5, 3), 0.840562042793));
3554 };
3555 unsafe {
3556 assert!(close(arr.get_unchecked(5, 4), 0.298729181391));
3557 };
3558 unsafe {
3559 assert!(close(arr.get_unchecked(5, 5), 0.291353935344));
3560 };
3561 unsafe {
3562 assert!(close(arr.get_unchecked(6, 0), 0.219614018532));
3563 };
3564 unsafe {
3565 assert!(close(arr.get_unchecked(6, 1), 0.873110834403));
3566 };
3567 unsafe {
3568 assert!(close(arr.get_unchecked(6, 2), 0.992531913317));
3569 };
3570 unsafe {
3571 assert!(close(arr.get_unchecked(6, 3), 0.124931082607));
3572 };
3573 unsafe {
3574 assert!(close(arr.get_unchecked(6, 4), 0.516722114987));
3575 };
3576 unsafe {
3577 assert!(close(arr.get_unchecked(6, 5), 0.356036009069));
3578 };
3579 }
3580
3581
3582
3583 #[test]
3584 fn test_index_transpose_unsafe_3() {
3585
3586 let mut arr = Array::from(vec![0.3647979523539372,
3587 0.36308406394227044,
3588 0.21404950758183616,
3589 0.36811953573544476,
3590 0.15420979571680848,
3591 0.7091867671879617,
3592 0.8245692241181685,
3593 0.28601877391422614,
3594 0.7053682579186311,
3595 0.9436051798229766,
3596 0.13564080650832278,
3597 0.49162020823877484,
3598 0.6575486409921484,
3599 0.5224264019283387,
3600 0.1304045608362886,
3601 0.40313708114722413,
3602 0.4123952289574855,
3603 0.4308186558945438,
3604 0.11908643991366652,
3605 0.2579691080534129,
3606 0.47102938170577524,
3607 0.878796734322898,
3608 0.7789561501543262,
3609 0.7959634630696436,
3610 0.004418088734142178,
3611 0.8552923824803051,
3612 0.19673926667104624,
3613 0.9213117917011139,
3614 0.11573887674353178,
3615 0.09984725008755602,
3616 0.4149531641983125,
3617 0.8301283257987035,
3618 0.6583325997105612,
3619 0.8405620427928018,
3620 0.29872918139103655,
3621 0.2913539353436094,
3622 0.21961401853166496,
3623 0.8731108344033446,
3624 0.9925319133165988,
3625 0.12493108260697727,
3626 0.5167221149865642,
3627 0.35603600906937594]);
3628 arr.reshape(7, 6);
3629
3630 let arr = arr.T();
3631 unsafe {
3632 assert!(close(arr.get_unchecked(0, 0), 0.364797952354));
3633 };
3634 unsafe {
3635 assert!(close(arr.get_unchecked(1, 0), 0.363084063942));
3636 };
3637 unsafe {
3638 assert!(close(arr.get_unchecked(2, 0), 0.214049507582));
3639 };
3640 unsafe {
3641 assert!(close(arr.get_unchecked(3, 0), 0.368119535735));
3642 };
3643 unsafe {
3644 assert!(close(arr.get_unchecked(4, 0), 0.154209795717));
3645 };
3646 unsafe {
3647 assert!(close(arr.get_unchecked(5, 0), 0.709186767188));
3648 };
3649 unsafe {
3650 assert!(close(arr.get_unchecked(0, 1), 0.824569224118));
3651 };
3652 unsafe {
3653 assert!(close(arr.get_unchecked(1, 1), 0.286018773914));
3654 };
3655 unsafe {
3656 assert!(close(arr.get_unchecked(2, 1), 0.705368257919));
3657 };
3658 unsafe {
3659 assert!(close(arr.get_unchecked(3, 1), 0.943605179823));
3660 };
3661 unsafe {
3662 assert!(close(arr.get_unchecked(4, 1), 0.135640806508));
3663 };
3664 unsafe {
3665 assert!(close(arr.get_unchecked(5, 1), 0.491620208239));
3666 };
3667 unsafe {
3668 assert!(close(arr.get_unchecked(0, 2), 0.657548640992));
3669 };
3670 unsafe {
3671 assert!(close(arr.get_unchecked(1, 2), 0.522426401928));
3672 };
3673 unsafe {
3674 assert!(close(arr.get_unchecked(2, 2), 0.130404560836));
3675 };
3676 unsafe {
3677 assert!(close(arr.get_unchecked(3, 2), 0.403137081147));
3678 };
3679 unsafe {
3680 assert!(close(arr.get_unchecked(4, 2), 0.412395228957));
3681 };
3682 unsafe {
3683 assert!(close(arr.get_unchecked(5, 2), 0.430818655895));
3684 };
3685 unsafe {
3686 assert!(close(arr.get_unchecked(0, 3), 0.119086439914));
3687 };
3688 unsafe {
3689 assert!(close(arr.get_unchecked(1, 3), 0.257969108053));
3690 };
3691 unsafe {
3692 assert!(close(arr.get_unchecked(2, 3), 0.471029381706));
3693 };
3694 unsafe {
3695 assert!(close(arr.get_unchecked(3, 3), 0.878796734323));
3696 };
3697 unsafe {
3698 assert!(close(arr.get_unchecked(4, 3), 0.778956150154));
3699 };
3700 unsafe {
3701 assert!(close(arr.get_unchecked(5, 3), 0.79596346307));
3702 };
3703 unsafe {
3704 assert!(close(arr.get_unchecked(0, 4), 0.00441808873414));
3705 };
3706 unsafe {
3707 assert!(close(arr.get_unchecked(1, 4), 0.85529238248));
3708 };
3709 unsafe {
3710 assert!(close(arr.get_unchecked(2, 4), 0.196739266671));
3711 };
3712 unsafe {
3713 assert!(close(arr.get_unchecked(3, 4), 0.921311791701));
3714 };
3715 unsafe {
3716 assert!(close(arr.get_unchecked(4, 4), 0.115738876744));
3717 };
3718 unsafe {
3719 assert!(close(arr.get_unchecked(5, 4), 0.0998472500876));
3720 };
3721 unsafe {
3722 assert!(close(arr.get_unchecked(0, 5), 0.414953164198));
3723 };
3724 unsafe {
3725 assert!(close(arr.get_unchecked(1, 5), 0.830128325799));
3726 };
3727 unsafe {
3728 assert!(close(arr.get_unchecked(2, 5), 0.658332599711));
3729 };
3730 unsafe {
3731 assert!(close(arr.get_unchecked(3, 5), 0.840562042793));
3732 };
3733 unsafe {
3734 assert!(close(arr.get_unchecked(4, 5), 0.298729181391));
3735 };
3736 unsafe {
3737 assert!(close(arr.get_unchecked(5, 5), 0.291353935344));
3738 };
3739 unsafe {
3740 assert!(close(arr.get_unchecked(0, 6), 0.219614018532));
3741 };
3742 unsafe {
3743 assert!(close(arr.get_unchecked(1, 6), 0.873110834403));
3744 };
3745 unsafe {
3746 assert!(close(arr.get_unchecked(2, 6), 0.992531913317));
3747 };
3748 unsafe {
3749 assert!(close(arr.get_unchecked(3, 6), 0.124931082607));
3750 };
3751 unsafe {
3752 assert!(close(arr.get_unchecked(4, 6), 0.516722114987));
3753 };
3754 unsafe {
3755 assert!(close(arr.get_unchecked(5, 6), 0.356036009069));
3756 };
3757 }
3758
3759
3760
3761 #[test]
3762 fn test_index_4() {
3763
3764 let mut arr = Array::from(vec![0.5053414095220631,
3765 0.9515944229974294,
3766 0.01869972616290927,
3767 0.3651095484212574,
3768 0.8093171436120703,
3769 0.9938563301832937,
3770 0.7758112569774406,
3771 0.46560288920814796,
3772 0.8620975137755558,
3773 0.17856062156157082,
3774 0.2541026841563959,
3775 0.07316076458101406,
3776 0.15855693769656998,
3777 0.9379247087641616,
3778 0.6889503228688164,
3779 0.11422222893176381,
3780 0.3136968489406069,
3781 0.3251977875790155,
3782 0.7135826937372265,
3783 0.7586005116188119,
3784 0.7254964300735486,
3785 0.8396463691221457,
3786 0.43328029656121825,
3787 0.3686468314958711,
3788 0.7397710935379666,
3789 0.4497911236174056,
3790 0.5277789783225971,
3791 0.22823121143029412,
3792 0.7205020351076907,
3793 0.2132560721407628,
3794 0.37245617251888463,
3795 0.40826816005663624,
3796 0.7529853065158498,
3797 0.9729367471961934,
3798 0.048377437598617234,
3799 0.09664827683400845,
3800 0.7560699295668065,
3801 0.4478976116896861,
3802 0.558090641317851,
3803 0.3656423016037962,
3804 0.33863293933524385,
3805 0.23582037368450148,
3806 0.22741518352824397,
3807 0.09084584446404942,
3808 0.8013604880752093,
3809 0.1843352626509892,
3810 0.1665774834355107,
3811 0.87658036046777,
3812 0.3009038897952965,
3813 0.08246224260539736,
3814 0.5704847701699387,
3815 0.5819718051730493,
3816 0.4394951741102917,
3817 0.21381802195045596,
3818 0.8467866649649154,
3819 0.2865978160316519,
3820 0.9874348113942802,
3821 0.35161673710515395,
3822 0.9226350504489396,
3823 0.9679307765092823,
3824 0.17781774635851644,
3825 0.18987386900845993,
3826 0.46406215038482046,
3827 0.33304177328203266,
3828 0.8178083065304194,
3829 0.492501643062211,
3830 0.8463273348799848,
3831 0.8002574160133654,
3832 0.17853709265446838,
3833 0.3800898764290961,
3834 0.591937855111794,
3835 0.6308336324475695]);
3836 arr.reshape(9, 8);
3837
3838 assert!(close(arr.get(0, 0), 0.505341409522));
3839 assert!(close(arr.get(0, 1), 0.951594422997));
3840 assert!(close(arr.get(0, 2), 0.0186997261629));
3841 assert!(close(arr.get(0, 3), 0.365109548421));
3842 assert!(close(arr.get(0, 4), 0.809317143612));
3843 assert!(close(arr.get(0, 5), 0.993856330183));
3844 assert!(close(arr.get(0, 6), 0.775811256977));
3845 assert!(close(arr.get(0, 7), 0.465602889208));
3846 assert!(close(arr.get(1, 0), 0.862097513776));
3847 assert!(close(arr.get(1, 1), 0.178560621562));
3848 assert!(close(arr.get(1, 2), 0.254102684156));
3849 assert!(close(arr.get(1, 3), 0.073160764581));
3850 assert!(close(arr.get(1, 4), 0.158556937697));
3851 assert!(close(arr.get(1, 5), 0.937924708764));
3852 assert!(close(arr.get(1, 6), 0.688950322869));
3853 assert!(close(arr.get(1, 7), 0.114222228932));
3854 assert!(close(arr.get(2, 0), 0.313696848941));
3855 assert!(close(arr.get(2, 1), 0.325197787579));
3856 assert!(close(arr.get(2, 2), 0.713582693737));
3857 assert!(close(arr.get(2, 3), 0.758600511619));
3858 assert!(close(arr.get(2, 4), 0.725496430074));
3859 assert!(close(arr.get(2, 5), 0.839646369122));
3860 assert!(close(arr.get(2, 6), 0.433280296561));
3861 assert!(close(arr.get(2, 7), 0.368646831496));
3862 assert!(close(arr.get(3, 0), 0.739771093538));
3863 assert!(close(arr.get(3, 1), 0.449791123617));
3864 assert!(close(arr.get(3, 2), 0.527778978323));
3865 assert!(close(arr.get(3, 3), 0.22823121143));
3866 assert!(close(arr.get(3, 4), 0.720502035108));
3867 assert!(close(arr.get(3, 5), 0.213256072141));
3868 assert!(close(arr.get(3, 6), 0.372456172519));
3869 assert!(close(arr.get(3, 7), 0.408268160057));
3870 assert!(close(arr.get(4, 0), 0.752985306516));
3871 assert!(close(arr.get(4, 1), 0.972936747196));
3872 assert!(close(arr.get(4, 2), 0.0483774375986));
3873 assert!(close(arr.get(4, 3), 0.096648276834));
3874 assert!(close(arr.get(4, 4), 0.756069929567));
3875 assert!(close(arr.get(4, 5), 0.44789761169));
3876 assert!(close(arr.get(4, 6), 0.558090641318));
3877 assert!(close(arr.get(4, 7), 0.365642301604));
3878 assert!(close(arr.get(5, 0), 0.338632939335));
3879 assert!(close(arr.get(5, 1), 0.235820373685));
3880 assert!(close(arr.get(5, 2), 0.227415183528));
3881 assert!(close(arr.get(5, 3), 0.090845844464));
3882 assert!(close(arr.get(5, 4), 0.801360488075));
3883 assert!(close(arr.get(5, 5), 0.184335262651));
3884 assert!(close(arr.get(5, 6), 0.166577483436));
3885 assert!(close(arr.get(5, 7), 0.876580360468));
3886 assert!(close(arr.get(6, 0), 0.300903889795));
3887 assert!(close(arr.get(6, 1), 0.0824622426054));
3888 assert!(close(arr.get(6, 2), 0.57048477017));
3889 assert!(close(arr.get(6, 3), 0.581971805173));
3890 assert!(close(arr.get(6, 4), 0.43949517411));
3891 assert!(close(arr.get(6, 5), 0.21381802195));
3892 assert!(close(arr.get(6, 6), 0.846786664965));
3893 assert!(close(arr.get(6, 7), 0.286597816032));
3894 assert!(close(arr.get(7, 0), 0.987434811394));
3895 assert!(close(arr.get(7, 1), 0.351616737105));
3896 assert!(close(arr.get(7, 2), 0.922635050449));
3897 assert!(close(arr.get(7, 3), 0.967930776509));
3898 assert!(close(arr.get(7, 4), 0.177817746359));
3899 assert!(close(arr.get(7, 5), 0.189873869008));
3900 assert!(close(arr.get(7, 6), 0.464062150385));
3901 assert!(close(arr.get(7, 7), 0.333041773282));
3902 assert!(close(arr.get(8, 0), 0.81780830653));
3903 assert!(close(arr.get(8, 1), 0.492501643062));
3904 assert!(close(arr.get(8, 2), 0.84632733488));
3905 assert!(close(arr.get(8, 3), 0.800257416013));
3906 assert!(close(arr.get(8, 4), 0.178537092654));
3907 assert!(close(arr.get(8, 5), 0.380089876429));
3908 assert!(close(arr.get(8, 6), 0.591937855112));
3909 assert!(close(arr.get(8, 7), 0.630833632448));
3910 }
3911
3912
3913
3914 #[test]
3915 fn test_index_transpose_4() {
3916
3917 let mut arr = Array::from(vec![0.5053414095220631,
3918 0.9515944229974294,
3919 0.01869972616290927,
3920 0.3651095484212574,
3921 0.8093171436120703,
3922 0.9938563301832937,
3923 0.7758112569774406,
3924 0.46560288920814796,
3925 0.8620975137755558,
3926 0.17856062156157082,
3927 0.2541026841563959,
3928 0.07316076458101406,
3929 0.15855693769656998,
3930 0.9379247087641616,
3931 0.6889503228688164,
3932 0.11422222893176381,
3933 0.3136968489406069,
3934 0.3251977875790155,
3935 0.7135826937372265,
3936 0.7586005116188119,
3937 0.7254964300735486,
3938 0.8396463691221457,
3939 0.43328029656121825,
3940 0.3686468314958711,
3941 0.7397710935379666,
3942 0.4497911236174056,
3943 0.5277789783225971,
3944 0.22823121143029412,
3945 0.7205020351076907,
3946 0.2132560721407628,
3947 0.37245617251888463,
3948 0.40826816005663624,
3949 0.7529853065158498,
3950 0.9729367471961934,
3951 0.048377437598617234,
3952 0.09664827683400845,
3953 0.7560699295668065,
3954 0.4478976116896861,
3955 0.558090641317851,
3956 0.3656423016037962,
3957 0.33863293933524385,
3958 0.23582037368450148,
3959 0.22741518352824397,
3960 0.09084584446404942,
3961 0.8013604880752093,
3962 0.1843352626509892,
3963 0.1665774834355107,
3964 0.87658036046777,
3965 0.3009038897952965,
3966 0.08246224260539736,
3967 0.5704847701699387,
3968 0.5819718051730493,
3969 0.4394951741102917,
3970 0.21381802195045596,
3971 0.8467866649649154,
3972 0.2865978160316519,
3973 0.9874348113942802,
3974 0.35161673710515395,
3975 0.9226350504489396,
3976 0.9679307765092823,
3977 0.17781774635851644,
3978 0.18987386900845993,
3979 0.46406215038482046,
3980 0.33304177328203266,
3981 0.8178083065304194,
3982 0.492501643062211,
3983 0.8463273348799848,
3984 0.8002574160133654,
3985 0.17853709265446838,
3986 0.3800898764290961,
3987 0.591937855111794,
3988 0.6308336324475695]);
3989 arr.reshape(9, 8);
3990
3991 let arr = arr.T();
3992 assert!(close(arr.get(0, 0), 0.505341409522));
3993 assert!(close(arr.get(1, 0), 0.951594422997));
3994 assert!(close(arr.get(2, 0), 0.0186997261629));
3995 assert!(close(arr.get(3, 0), 0.365109548421));
3996 assert!(close(arr.get(4, 0), 0.809317143612));
3997 assert!(close(arr.get(5, 0), 0.993856330183));
3998 assert!(close(arr.get(6, 0), 0.775811256977));
3999 assert!(close(arr.get(7, 0), 0.465602889208));
4000 assert!(close(arr.get(0, 1), 0.862097513776));
4001 assert!(close(arr.get(1, 1), 0.178560621562));
4002 assert!(close(arr.get(2, 1), 0.254102684156));
4003 assert!(close(arr.get(3, 1), 0.073160764581));
4004 assert!(close(arr.get(4, 1), 0.158556937697));
4005 assert!(close(arr.get(5, 1), 0.937924708764));
4006 assert!(close(arr.get(6, 1), 0.688950322869));
4007 assert!(close(arr.get(7, 1), 0.114222228932));
4008 assert!(close(arr.get(0, 2), 0.313696848941));
4009 assert!(close(arr.get(1, 2), 0.325197787579));
4010 assert!(close(arr.get(2, 2), 0.713582693737));
4011 assert!(close(arr.get(3, 2), 0.758600511619));
4012 assert!(close(arr.get(4, 2), 0.725496430074));
4013 assert!(close(arr.get(5, 2), 0.839646369122));
4014 assert!(close(arr.get(6, 2), 0.433280296561));
4015 assert!(close(arr.get(7, 2), 0.368646831496));
4016 assert!(close(arr.get(0, 3), 0.739771093538));
4017 assert!(close(arr.get(1, 3), 0.449791123617));
4018 assert!(close(arr.get(2, 3), 0.527778978323));
4019 assert!(close(arr.get(3, 3), 0.22823121143));
4020 assert!(close(arr.get(4, 3), 0.720502035108));
4021 assert!(close(arr.get(5, 3), 0.213256072141));
4022 assert!(close(arr.get(6, 3), 0.372456172519));
4023 assert!(close(arr.get(7, 3), 0.408268160057));
4024 assert!(close(arr.get(0, 4), 0.752985306516));
4025 assert!(close(arr.get(1, 4), 0.972936747196));
4026 assert!(close(arr.get(2, 4), 0.0483774375986));
4027 assert!(close(arr.get(3, 4), 0.096648276834));
4028 assert!(close(arr.get(4, 4), 0.756069929567));
4029 assert!(close(arr.get(5, 4), 0.44789761169));
4030 assert!(close(arr.get(6, 4), 0.558090641318));
4031 assert!(close(arr.get(7, 4), 0.365642301604));
4032 assert!(close(arr.get(0, 5), 0.338632939335));
4033 assert!(close(arr.get(1, 5), 0.235820373685));
4034 assert!(close(arr.get(2, 5), 0.227415183528));
4035 assert!(close(arr.get(3, 5), 0.090845844464));
4036 assert!(close(arr.get(4, 5), 0.801360488075));
4037 assert!(close(arr.get(5, 5), 0.184335262651));
4038 assert!(close(arr.get(6, 5), 0.166577483436));
4039 assert!(close(arr.get(7, 5), 0.876580360468));
4040 assert!(close(arr.get(0, 6), 0.300903889795));
4041 assert!(close(arr.get(1, 6), 0.0824622426054));
4042 assert!(close(arr.get(2, 6), 0.57048477017));
4043 assert!(close(arr.get(3, 6), 0.581971805173));
4044 assert!(close(arr.get(4, 6), 0.43949517411));
4045 assert!(close(arr.get(5, 6), 0.21381802195));
4046 assert!(close(arr.get(6, 6), 0.846786664965));
4047 assert!(close(arr.get(7, 6), 0.286597816032));
4048 assert!(close(arr.get(0, 7), 0.987434811394));
4049 assert!(close(arr.get(1, 7), 0.351616737105));
4050 assert!(close(arr.get(2, 7), 0.922635050449));
4051 assert!(close(arr.get(3, 7), 0.967930776509));
4052 assert!(close(arr.get(4, 7), 0.177817746359));
4053 assert!(close(arr.get(5, 7), 0.189873869008));
4054 assert!(close(arr.get(6, 7), 0.464062150385));
4055 assert!(close(arr.get(7, 7), 0.333041773282));
4056 assert!(close(arr.get(0, 8), 0.81780830653));
4057 assert!(close(arr.get(1, 8), 0.492501643062));
4058 assert!(close(arr.get(2, 8), 0.84632733488));
4059 assert!(close(arr.get(3, 8), 0.800257416013));
4060 assert!(close(arr.get(4, 8), 0.178537092654));
4061 assert!(close(arr.get(5, 8), 0.380089876429));
4062 assert!(close(arr.get(6, 8), 0.591937855112));
4063 assert!(close(arr.get(7, 8), 0.630833632448));
4064 }
4065
4066
4067
4068 #[test]
4069 fn test_index_mut_4() {
4070
4071 let mut arr = Array::from(vec![0.5053414095220631,
4072 0.9515944229974294,
4073 0.01869972616290927,
4074 0.3651095484212574,
4075 0.8093171436120703,
4076 0.9938563301832937,
4077 0.7758112569774406,
4078 0.46560288920814796,
4079 0.8620975137755558,
4080 0.17856062156157082,
4081 0.2541026841563959,
4082 0.07316076458101406,
4083 0.15855693769656998,
4084 0.9379247087641616,
4085 0.6889503228688164,
4086 0.11422222893176381,
4087 0.3136968489406069,
4088 0.3251977875790155,
4089 0.7135826937372265,
4090 0.7586005116188119,
4091 0.7254964300735486,
4092 0.8396463691221457,
4093 0.43328029656121825,
4094 0.3686468314958711,
4095 0.7397710935379666,
4096 0.4497911236174056,
4097 0.5277789783225971,
4098 0.22823121143029412,
4099 0.7205020351076907,
4100 0.2132560721407628,
4101 0.37245617251888463,
4102 0.40826816005663624,
4103 0.7529853065158498,
4104 0.9729367471961934,
4105 0.048377437598617234,
4106 0.09664827683400845,
4107 0.7560699295668065,
4108 0.4478976116896861,
4109 0.558090641317851,
4110 0.3656423016037962,
4111 0.33863293933524385,
4112 0.23582037368450148,
4113 0.22741518352824397,
4114 0.09084584446404942,
4115 0.8013604880752093,
4116 0.1843352626509892,
4117 0.1665774834355107,
4118 0.87658036046777,
4119 0.3009038897952965,
4120 0.08246224260539736,
4121 0.5704847701699387,
4122 0.5819718051730493,
4123 0.4394951741102917,
4124 0.21381802195045596,
4125 0.8467866649649154,
4126 0.2865978160316519,
4127 0.9874348113942802,
4128 0.35161673710515395,
4129 0.9226350504489396,
4130 0.9679307765092823,
4131 0.17781774635851644,
4132 0.18987386900845993,
4133 0.46406215038482046,
4134 0.33304177328203266,
4135 0.8178083065304194,
4136 0.492501643062211,
4137 0.8463273348799848,
4138 0.8002574160133654,
4139 0.17853709265446838,
4140 0.3800898764290961,
4141 0.591937855111794,
4142 0.6308336324475695]);
4143 arr.reshape(9, 8);
4144
4145 let mut v = arr.get(0, 0);
4146 v += 1.0;
4147 assert!(close(v, 1.50534140952));
4148 let mut v = arr.get(0, 1);
4149 v += 1.0;
4150 assert!(close(v, 1.951594423));
4151 let mut v = arr.get(0, 2);
4152 v += 1.0;
4153 assert!(close(v, 1.01869972616));
4154 let mut v = arr.get(0, 3);
4155 v += 1.0;
4156 assert!(close(v, 1.36510954842));
4157 let mut v = arr.get(0, 4);
4158 v += 1.0;
4159 assert!(close(v, 1.80931714361));
4160 let mut v = arr.get(0, 5);
4161 v += 1.0;
4162 assert!(close(v, 1.99385633018));
4163 let mut v = arr.get(0, 6);
4164 v += 1.0;
4165 assert!(close(v, 1.77581125698));
4166 let mut v = arr.get(0, 7);
4167 v += 1.0;
4168 assert!(close(v, 1.46560288921));
4169 let mut v = arr.get(1, 0);
4170 v += 1.0;
4171 assert!(close(v, 1.86209751378));
4172 let mut v = arr.get(1, 1);
4173 v += 1.0;
4174 assert!(close(v, 1.17856062156));
4175 let mut v = arr.get(1, 2);
4176 v += 1.0;
4177 assert!(close(v, 1.25410268416));
4178 let mut v = arr.get(1, 3);
4179 v += 1.0;
4180 assert!(close(v, 1.07316076458));
4181 let mut v = arr.get(1, 4);
4182 v += 1.0;
4183 assert!(close(v, 1.1585569377));
4184 let mut v = arr.get(1, 5);
4185 v += 1.0;
4186 assert!(close(v, 1.93792470876));
4187 let mut v = arr.get(1, 6);
4188 v += 1.0;
4189 assert!(close(v, 1.68895032287));
4190 let mut v = arr.get(1, 7);
4191 v += 1.0;
4192 assert!(close(v, 1.11422222893));
4193 let mut v = arr.get(2, 0);
4194 v += 1.0;
4195 assert!(close(v, 1.31369684894));
4196 let mut v = arr.get(2, 1);
4197 v += 1.0;
4198 assert!(close(v, 1.32519778758));
4199 let mut v = arr.get(2, 2);
4200 v += 1.0;
4201 assert!(close(v, 1.71358269374));
4202 let mut v = arr.get(2, 3);
4203 v += 1.0;
4204 assert!(close(v, 1.75860051162));
4205 let mut v = arr.get(2, 4);
4206 v += 1.0;
4207 assert!(close(v, 1.72549643007));
4208 let mut v = arr.get(2, 5);
4209 v += 1.0;
4210 assert!(close(v, 1.83964636912));
4211 let mut v = arr.get(2, 6);
4212 v += 1.0;
4213 assert!(close(v, 1.43328029656));
4214 let mut v = arr.get(2, 7);
4215 v += 1.0;
4216 assert!(close(v, 1.3686468315));
4217 let mut v = arr.get(3, 0);
4218 v += 1.0;
4219 assert!(close(v, 1.73977109354));
4220 let mut v = arr.get(3, 1);
4221 v += 1.0;
4222 assert!(close(v, 1.44979112362));
4223 let mut v = arr.get(3, 2);
4224 v += 1.0;
4225 assert!(close(v, 1.52777897832));
4226 let mut v = arr.get(3, 3);
4227 v += 1.0;
4228 assert!(close(v, 1.22823121143));
4229 let mut v = arr.get(3, 4);
4230 v += 1.0;
4231 assert!(close(v, 1.72050203511));
4232 let mut v = arr.get(3, 5);
4233 v += 1.0;
4234 assert!(close(v, 1.21325607214));
4235 let mut v = arr.get(3, 6);
4236 v += 1.0;
4237 assert!(close(v, 1.37245617252));
4238 let mut v = arr.get(3, 7);
4239 v += 1.0;
4240 assert!(close(v, 1.40826816006));
4241 let mut v = arr.get(4, 0);
4242 v += 1.0;
4243 assert!(close(v, 1.75298530652));
4244 let mut v = arr.get(4, 1);
4245 v += 1.0;
4246 assert!(close(v, 1.9729367472));
4247 let mut v = arr.get(4, 2);
4248 v += 1.0;
4249 assert!(close(v, 1.0483774376));
4250 let mut v = arr.get(4, 3);
4251 v += 1.0;
4252 assert!(close(v, 1.09664827683));
4253 let mut v = arr.get(4, 4);
4254 v += 1.0;
4255 assert!(close(v, 1.75606992957));
4256 let mut v = arr.get(4, 5);
4257 v += 1.0;
4258 assert!(close(v, 1.44789761169));
4259 let mut v = arr.get(4, 6);
4260 v += 1.0;
4261 assert!(close(v, 1.55809064132));
4262 let mut v = arr.get(4, 7);
4263 v += 1.0;
4264 assert!(close(v, 1.3656423016));
4265 let mut v = arr.get(5, 0);
4266 v += 1.0;
4267 assert!(close(v, 1.33863293934));
4268 let mut v = arr.get(5, 1);
4269 v += 1.0;
4270 assert!(close(v, 1.23582037368));
4271 let mut v = arr.get(5, 2);
4272 v += 1.0;
4273 assert!(close(v, 1.22741518353));
4274 let mut v = arr.get(5, 3);
4275 v += 1.0;
4276 assert!(close(v, 1.09084584446));
4277 let mut v = arr.get(5, 4);
4278 v += 1.0;
4279 assert!(close(v, 1.80136048808));
4280 let mut v = arr.get(5, 5);
4281 v += 1.0;
4282 assert!(close(v, 1.18433526265));
4283 let mut v = arr.get(5, 6);
4284 v += 1.0;
4285 assert!(close(v, 1.16657748344));
4286 let mut v = arr.get(5, 7);
4287 v += 1.0;
4288 assert!(close(v, 1.87658036047));
4289 let mut v = arr.get(6, 0);
4290 v += 1.0;
4291 assert!(close(v, 1.3009038898));
4292 let mut v = arr.get(6, 1);
4293 v += 1.0;
4294 assert!(close(v, 1.08246224261));
4295 let mut v = arr.get(6, 2);
4296 v += 1.0;
4297 assert!(close(v, 1.57048477017));
4298 let mut v = arr.get(6, 3);
4299 v += 1.0;
4300 assert!(close(v, 1.58197180517));
4301 let mut v = arr.get(6, 4);
4302 v += 1.0;
4303 assert!(close(v, 1.43949517411));
4304 let mut v = arr.get(6, 5);
4305 v += 1.0;
4306 assert!(close(v, 1.21381802195));
4307 let mut v = arr.get(6, 6);
4308 v += 1.0;
4309 assert!(close(v, 1.84678666496));
4310 let mut v = arr.get(6, 7);
4311 v += 1.0;
4312 assert!(close(v, 1.28659781603));
4313 let mut v = arr.get(7, 0);
4314 v += 1.0;
4315 assert!(close(v, 1.98743481139));
4316 let mut v = arr.get(7, 1);
4317 v += 1.0;
4318 assert!(close(v, 1.35161673711));
4319 let mut v = arr.get(7, 2);
4320 v += 1.0;
4321 assert!(close(v, 1.92263505045));
4322 let mut v = arr.get(7, 3);
4323 v += 1.0;
4324 assert!(close(v, 1.96793077651));
4325 let mut v = arr.get(7, 4);
4326 v += 1.0;
4327 assert!(close(v, 1.17781774636));
4328 let mut v = arr.get(7, 5);
4329 v += 1.0;
4330 assert!(close(v, 1.18987386901));
4331 let mut v = arr.get(7, 6);
4332 v += 1.0;
4333 assert!(close(v, 1.46406215038));
4334 let mut v = arr.get(7, 7);
4335 v += 1.0;
4336 assert!(close(v, 1.33304177328));
4337 let mut v = arr.get(8, 0);
4338 v += 1.0;
4339 assert!(close(v, 1.81780830653));
4340 let mut v = arr.get(8, 1);
4341 v += 1.0;
4342 assert!(close(v, 1.49250164306));
4343 let mut v = arr.get(8, 2);
4344 v += 1.0;
4345 assert!(close(v, 1.84632733488));
4346 let mut v = arr.get(8, 3);
4347 v += 1.0;
4348 assert!(close(v, 1.80025741601));
4349 let mut v = arr.get(8, 4);
4350 v += 1.0;
4351 assert!(close(v, 1.17853709265));
4352 let mut v = arr.get(8, 5);
4353 v += 1.0;
4354 assert!(close(v, 1.38008987643));
4355 let mut v = arr.get(8, 6);
4356 v += 1.0;
4357 assert!(close(v, 1.59193785511));
4358 let mut v = arr.get(8, 7);
4359 v += 1.0;
4360 assert!(close(v, 1.63083363245));
4361 }
4362
4363
4364
4365 #[test]
4366 fn test_index_transpose_mut_4() {
4367
4368 let mut arr = Array::from(vec![0.5053414095220631,
4369 0.9515944229974294,
4370 0.01869972616290927,
4371 0.3651095484212574,
4372 0.8093171436120703,
4373 0.9938563301832937,
4374 0.7758112569774406,
4375 0.46560288920814796,
4376 0.8620975137755558,
4377 0.17856062156157082,
4378 0.2541026841563959,
4379 0.07316076458101406,
4380 0.15855693769656998,
4381 0.9379247087641616,
4382 0.6889503228688164,
4383 0.11422222893176381,
4384 0.3136968489406069,
4385 0.3251977875790155,
4386 0.7135826937372265,
4387 0.7586005116188119,
4388 0.7254964300735486,
4389 0.8396463691221457,
4390 0.43328029656121825,
4391 0.3686468314958711,
4392 0.7397710935379666,
4393 0.4497911236174056,
4394 0.5277789783225971,
4395 0.22823121143029412,
4396 0.7205020351076907,
4397 0.2132560721407628,
4398 0.37245617251888463,
4399 0.40826816005663624,
4400 0.7529853065158498,
4401 0.9729367471961934,
4402 0.048377437598617234,
4403 0.09664827683400845,
4404 0.7560699295668065,
4405 0.4478976116896861,
4406 0.558090641317851,
4407 0.3656423016037962,
4408 0.33863293933524385,
4409 0.23582037368450148,
4410 0.22741518352824397,
4411 0.09084584446404942,
4412 0.8013604880752093,
4413 0.1843352626509892,
4414 0.1665774834355107,
4415 0.87658036046777,
4416 0.3009038897952965,
4417 0.08246224260539736,
4418 0.5704847701699387,
4419 0.5819718051730493,
4420 0.4394951741102917,
4421 0.21381802195045596,
4422 0.8467866649649154,
4423 0.2865978160316519,
4424 0.9874348113942802,
4425 0.35161673710515395,
4426 0.9226350504489396,
4427 0.9679307765092823,
4428 0.17781774635851644,
4429 0.18987386900845993,
4430 0.46406215038482046,
4431 0.33304177328203266,
4432 0.8178083065304194,
4433 0.492501643062211,
4434 0.8463273348799848,
4435 0.8002574160133654,
4436 0.17853709265446838,
4437 0.3800898764290961,
4438 0.591937855111794,
4439 0.6308336324475695]);
4440 arr.reshape(9, 8);
4441
4442 let arr = arr.T();
4443 let mut v = arr.get(0, 0);
4444 v += 1.0;
4445 assert!(close(v, 1.50534140952));
4446 let mut v = arr.get(1, 0);
4447 v += 1.0;
4448 assert!(close(v, 1.951594423));
4449 let mut v = arr.get(2, 0);
4450 v += 1.0;
4451 assert!(close(v, 1.01869972616));
4452 let mut v = arr.get(3, 0);
4453 v += 1.0;
4454 assert!(close(v, 1.36510954842));
4455 let mut v = arr.get(4, 0);
4456 v += 1.0;
4457 assert!(close(v, 1.80931714361));
4458 let mut v = arr.get(5, 0);
4459 v += 1.0;
4460 assert!(close(v, 1.99385633018));
4461 let mut v = arr.get(6, 0);
4462 v += 1.0;
4463 assert!(close(v, 1.77581125698));
4464 let mut v = arr.get(7, 0);
4465 v += 1.0;
4466 assert!(close(v, 1.46560288921));
4467 let mut v = arr.get(0, 1);
4468 v += 1.0;
4469 assert!(close(v, 1.86209751378));
4470 let mut v = arr.get(1, 1);
4471 v += 1.0;
4472 assert!(close(v, 1.17856062156));
4473 let mut v = arr.get(2, 1);
4474 v += 1.0;
4475 assert!(close(v, 1.25410268416));
4476 let mut v = arr.get(3, 1);
4477 v += 1.0;
4478 assert!(close(v, 1.07316076458));
4479 let mut v = arr.get(4, 1);
4480 v += 1.0;
4481 assert!(close(v, 1.1585569377));
4482 let mut v = arr.get(5, 1);
4483 v += 1.0;
4484 assert!(close(v, 1.93792470876));
4485 let mut v = arr.get(6, 1);
4486 v += 1.0;
4487 assert!(close(v, 1.68895032287));
4488 let mut v = arr.get(7, 1);
4489 v += 1.0;
4490 assert!(close(v, 1.11422222893));
4491 let mut v = arr.get(0, 2);
4492 v += 1.0;
4493 assert!(close(v, 1.31369684894));
4494 let mut v = arr.get(1, 2);
4495 v += 1.0;
4496 assert!(close(v, 1.32519778758));
4497 let mut v = arr.get(2, 2);
4498 v += 1.0;
4499 assert!(close(v, 1.71358269374));
4500 let mut v = arr.get(3, 2);
4501 v += 1.0;
4502 assert!(close(v, 1.75860051162));
4503 let mut v = arr.get(4, 2);
4504 v += 1.0;
4505 assert!(close(v, 1.72549643007));
4506 let mut v = arr.get(5, 2);
4507 v += 1.0;
4508 assert!(close(v, 1.83964636912));
4509 let mut v = arr.get(6, 2);
4510 v += 1.0;
4511 assert!(close(v, 1.43328029656));
4512 let mut v = arr.get(7, 2);
4513 v += 1.0;
4514 assert!(close(v, 1.3686468315));
4515 let mut v = arr.get(0, 3);
4516 v += 1.0;
4517 assert!(close(v, 1.73977109354));
4518 let mut v = arr.get(1, 3);
4519 v += 1.0;
4520 assert!(close(v, 1.44979112362));
4521 let mut v = arr.get(2, 3);
4522 v += 1.0;
4523 assert!(close(v, 1.52777897832));
4524 let mut v = arr.get(3, 3);
4525 v += 1.0;
4526 assert!(close(v, 1.22823121143));
4527 let mut v = arr.get(4, 3);
4528 v += 1.0;
4529 assert!(close(v, 1.72050203511));
4530 let mut v = arr.get(5, 3);
4531 v += 1.0;
4532 assert!(close(v, 1.21325607214));
4533 let mut v = arr.get(6, 3);
4534 v += 1.0;
4535 assert!(close(v, 1.37245617252));
4536 let mut v = arr.get(7, 3);
4537 v += 1.0;
4538 assert!(close(v, 1.40826816006));
4539 let mut v = arr.get(0, 4);
4540 v += 1.0;
4541 assert!(close(v, 1.75298530652));
4542 let mut v = arr.get(1, 4);
4543 v += 1.0;
4544 assert!(close(v, 1.9729367472));
4545 let mut v = arr.get(2, 4);
4546 v += 1.0;
4547 assert!(close(v, 1.0483774376));
4548 let mut v = arr.get(3, 4);
4549 v += 1.0;
4550 assert!(close(v, 1.09664827683));
4551 let mut v = arr.get(4, 4);
4552 v += 1.0;
4553 assert!(close(v, 1.75606992957));
4554 let mut v = arr.get(5, 4);
4555 v += 1.0;
4556 assert!(close(v, 1.44789761169));
4557 let mut v = arr.get(6, 4);
4558 v += 1.0;
4559 assert!(close(v, 1.55809064132));
4560 let mut v = arr.get(7, 4);
4561 v += 1.0;
4562 assert!(close(v, 1.3656423016));
4563 let mut v = arr.get(0, 5);
4564 v += 1.0;
4565 assert!(close(v, 1.33863293934));
4566 let mut v = arr.get(1, 5);
4567 v += 1.0;
4568 assert!(close(v, 1.23582037368));
4569 let mut v = arr.get(2, 5);
4570 v += 1.0;
4571 assert!(close(v, 1.22741518353));
4572 let mut v = arr.get(3, 5);
4573 v += 1.0;
4574 assert!(close(v, 1.09084584446));
4575 let mut v = arr.get(4, 5);
4576 v += 1.0;
4577 assert!(close(v, 1.80136048808));
4578 let mut v = arr.get(5, 5);
4579 v += 1.0;
4580 assert!(close(v, 1.18433526265));
4581 let mut v = arr.get(6, 5);
4582 v += 1.0;
4583 assert!(close(v, 1.16657748344));
4584 let mut v = arr.get(7, 5);
4585 v += 1.0;
4586 assert!(close(v, 1.87658036047));
4587 let mut v = arr.get(0, 6);
4588 v += 1.0;
4589 assert!(close(v, 1.3009038898));
4590 let mut v = arr.get(1, 6);
4591 v += 1.0;
4592 assert!(close(v, 1.08246224261));
4593 let mut v = arr.get(2, 6);
4594 v += 1.0;
4595 assert!(close(v, 1.57048477017));
4596 let mut v = arr.get(3, 6);
4597 v += 1.0;
4598 assert!(close(v, 1.58197180517));
4599 let mut v = arr.get(4, 6);
4600 v += 1.0;
4601 assert!(close(v, 1.43949517411));
4602 let mut v = arr.get(5, 6);
4603 v += 1.0;
4604 assert!(close(v, 1.21381802195));
4605 let mut v = arr.get(6, 6);
4606 v += 1.0;
4607 assert!(close(v, 1.84678666496));
4608 let mut v = arr.get(7, 6);
4609 v += 1.0;
4610 assert!(close(v, 1.28659781603));
4611 let mut v = arr.get(0, 7);
4612 v += 1.0;
4613 assert!(close(v, 1.98743481139));
4614 let mut v = arr.get(1, 7);
4615 v += 1.0;
4616 assert!(close(v, 1.35161673711));
4617 let mut v = arr.get(2, 7);
4618 v += 1.0;
4619 assert!(close(v, 1.92263505045));
4620 let mut v = arr.get(3, 7);
4621 v += 1.0;
4622 assert!(close(v, 1.96793077651));
4623 let mut v = arr.get(4, 7);
4624 v += 1.0;
4625 assert!(close(v, 1.17781774636));
4626 let mut v = arr.get(5, 7);
4627 v += 1.0;
4628 assert!(close(v, 1.18987386901));
4629 let mut v = arr.get(6, 7);
4630 v += 1.0;
4631 assert!(close(v, 1.46406215038));
4632 let mut v = arr.get(7, 7);
4633 v += 1.0;
4634 assert!(close(v, 1.33304177328));
4635 let mut v = arr.get(0, 8);
4636 v += 1.0;
4637 assert!(close(v, 1.81780830653));
4638 let mut v = arr.get(1, 8);
4639 v += 1.0;
4640 assert!(close(v, 1.49250164306));
4641 let mut v = arr.get(2, 8);
4642 v += 1.0;
4643 assert!(close(v, 1.84632733488));
4644 let mut v = arr.get(3, 8);
4645 v += 1.0;
4646 assert!(close(v, 1.80025741601));
4647 let mut v = arr.get(4, 8);
4648 v += 1.0;
4649 assert!(close(v, 1.17853709265));
4650 let mut v = arr.get(5, 8);
4651 v += 1.0;
4652 assert!(close(v, 1.38008987643));
4653 let mut v = arr.get(6, 8);
4654 v += 1.0;
4655 assert!(close(v, 1.59193785511));
4656 let mut v = arr.get(7, 8);
4657 v += 1.0;
4658 assert!(close(v, 1.63083363245));
4659 }
4660
4661
4662
4663 #[test]
4664 fn test_index_unsafe_4() {
4665
4666 let mut arr = Array::from(vec![0.5053414095220631,
4667 0.9515944229974294,
4668 0.01869972616290927,
4669 0.3651095484212574,
4670 0.8093171436120703,
4671 0.9938563301832937,
4672 0.7758112569774406,
4673 0.46560288920814796,
4674 0.8620975137755558,
4675 0.17856062156157082,
4676 0.2541026841563959,
4677 0.07316076458101406,
4678 0.15855693769656998,
4679 0.9379247087641616,
4680 0.6889503228688164,
4681 0.11422222893176381,
4682 0.3136968489406069,
4683 0.3251977875790155,
4684 0.7135826937372265,
4685 0.7586005116188119,
4686 0.7254964300735486,
4687 0.8396463691221457,
4688 0.43328029656121825,
4689 0.3686468314958711,
4690 0.7397710935379666,
4691 0.4497911236174056,
4692 0.5277789783225971,
4693 0.22823121143029412,
4694 0.7205020351076907,
4695 0.2132560721407628,
4696 0.37245617251888463,
4697 0.40826816005663624,
4698 0.7529853065158498,
4699 0.9729367471961934,
4700 0.048377437598617234,
4701 0.09664827683400845,
4702 0.7560699295668065,
4703 0.4478976116896861,
4704 0.558090641317851,
4705 0.3656423016037962,
4706 0.33863293933524385,
4707 0.23582037368450148,
4708 0.22741518352824397,
4709 0.09084584446404942,
4710 0.8013604880752093,
4711 0.1843352626509892,
4712 0.1665774834355107,
4713 0.87658036046777,
4714 0.3009038897952965,
4715 0.08246224260539736,
4716 0.5704847701699387,
4717 0.5819718051730493,
4718 0.4394951741102917,
4719 0.21381802195045596,
4720 0.8467866649649154,
4721 0.2865978160316519,
4722 0.9874348113942802,
4723 0.35161673710515395,
4724 0.9226350504489396,
4725 0.9679307765092823,
4726 0.17781774635851644,
4727 0.18987386900845993,
4728 0.46406215038482046,
4729 0.33304177328203266,
4730 0.8178083065304194,
4731 0.492501643062211,
4732 0.8463273348799848,
4733 0.8002574160133654,
4734 0.17853709265446838,
4735 0.3800898764290961,
4736 0.591937855111794,
4737 0.6308336324475695]);
4738 arr.reshape(9, 8);
4739
4740 unsafe {
4741 assert!(close(arr.get_unchecked(0, 0), 0.505341409522));
4742 };
4743 unsafe {
4744 assert!(close(arr.get_unchecked(0, 1), 0.951594422997));
4745 };
4746 unsafe {
4747 assert!(close(arr.get_unchecked(0, 2), 0.0186997261629));
4748 };
4749 unsafe {
4750 assert!(close(arr.get_unchecked(0, 3), 0.365109548421));
4751 };
4752 unsafe {
4753 assert!(close(arr.get_unchecked(0, 4), 0.809317143612));
4754 };
4755 unsafe {
4756 assert!(close(arr.get_unchecked(0, 5), 0.993856330183));
4757 };
4758 unsafe {
4759 assert!(close(arr.get_unchecked(0, 6), 0.775811256977));
4760 };
4761 unsafe {
4762 assert!(close(arr.get_unchecked(0, 7), 0.465602889208));
4763 };
4764 unsafe {
4765 assert!(close(arr.get_unchecked(1, 0), 0.862097513776));
4766 };
4767 unsafe {
4768 assert!(close(arr.get_unchecked(1, 1), 0.178560621562));
4769 };
4770 unsafe {
4771 assert!(close(arr.get_unchecked(1, 2), 0.254102684156));
4772 };
4773 unsafe {
4774 assert!(close(arr.get_unchecked(1, 3), 0.073160764581));
4775 };
4776 unsafe {
4777 assert!(close(arr.get_unchecked(1, 4), 0.158556937697));
4778 };
4779 unsafe {
4780 assert!(close(arr.get_unchecked(1, 5), 0.937924708764));
4781 };
4782 unsafe {
4783 assert!(close(arr.get_unchecked(1, 6), 0.688950322869));
4784 };
4785 unsafe {
4786 assert!(close(arr.get_unchecked(1, 7), 0.114222228932));
4787 };
4788 unsafe {
4789 assert!(close(arr.get_unchecked(2, 0), 0.313696848941));
4790 };
4791 unsafe {
4792 assert!(close(arr.get_unchecked(2, 1), 0.325197787579));
4793 };
4794 unsafe {
4795 assert!(close(arr.get_unchecked(2, 2), 0.713582693737));
4796 };
4797 unsafe {
4798 assert!(close(arr.get_unchecked(2, 3), 0.758600511619));
4799 };
4800 unsafe {
4801 assert!(close(arr.get_unchecked(2, 4), 0.725496430074));
4802 };
4803 unsafe {
4804 assert!(close(arr.get_unchecked(2, 5), 0.839646369122));
4805 };
4806 unsafe {
4807 assert!(close(arr.get_unchecked(2, 6), 0.433280296561));
4808 };
4809 unsafe {
4810 assert!(close(arr.get_unchecked(2, 7), 0.368646831496));
4811 };
4812 unsafe {
4813 assert!(close(arr.get_unchecked(3, 0), 0.739771093538));
4814 };
4815 unsafe {
4816 assert!(close(arr.get_unchecked(3, 1), 0.449791123617));
4817 };
4818 unsafe {
4819 assert!(close(arr.get_unchecked(3, 2), 0.527778978323));
4820 };
4821 unsafe {
4822 assert!(close(arr.get_unchecked(3, 3), 0.22823121143));
4823 };
4824 unsafe {
4825 assert!(close(arr.get_unchecked(3, 4), 0.720502035108));
4826 };
4827 unsafe {
4828 assert!(close(arr.get_unchecked(3, 5), 0.213256072141));
4829 };
4830 unsafe {
4831 assert!(close(arr.get_unchecked(3, 6), 0.372456172519));
4832 };
4833 unsafe {
4834 assert!(close(arr.get_unchecked(3, 7), 0.408268160057));
4835 };
4836 unsafe {
4837 assert!(close(arr.get_unchecked(4, 0), 0.752985306516));
4838 };
4839 unsafe {
4840 assert!(close(arr.get_unchecked(4, 1), 0.972936747196));
4841 };
4842 unsafe {
4843 assert!(close(arr.get_unchecked(4, 2), 0.0483774375986));
4844 };
4845 unsafe {
4846 assert!(close(arr.get_unchecked(4, 3), 0.096648276834));
4847 };
4848 unsafe {
4849 assert!(close(arr.get_unchecked(4, 4), 0.756069929567));
4850 };
4851 unsafe {
4852 assert!(close(arr.get_unchecked(4, 5), 0.44789761169));
4853 };
4854 unsafe {
4855 assert!(close(arr.get_unchecked(4, 6), 0.558090641318));
4856 };
4857 unsafe {
4858 assert!(close(arr.get_unchecked(4, 7), 0.365642301604));
4859 };
4860 unsafe {
4861 assert!(close(arr.get_unchecked(5, 0), 0.338632939335));
4862 };
4863 unsafe {
4864 assert!(close(arr.get_unchecked(5, 1), 0.235820373685));
4865 };
4866 unsafe {
4867 assert!(close(arr.get_unchecked(5, 2), 0.227415183528));
4868 };
4869 unsafe {
4870 assert!(close(arr.get_unchecked(5, 3), 0.090845844464));
4871 };
4872 unsafe {
4873 assert!(close(arr.get_unchecked(5, 4), 0.801360488075));
4874 };
4875 unsafe {
4876 assert!(close(arr.get_unchecked(5, 5), 0.184335262651));
4877 };
4878 unsafe {
4879 assert!(close(arr.get_unchecked(5, 6), 0.166577483436));
4880 };
4881 unsafe {
4882 assert!(close(arr.get_unchecked(5, 7), 0.876580360468));
4883 };
4884 unsafe {
4885 assert!(close(arr.get_unchecked(6, 0), 0.300903889795));
4886 };
4887 unsafe {
4888 assert!(close(arr.get_unchecked(6, 1), 0.0824622426054));
4889 };
4890 unsafe {
4891 assert!(close(arr.get_unchecked(6, 2), 0.57048477017));
4892 };
4893 unsafe {
4894 assert!(close(arr.get_unchecked(6, 3), 0.581971805173));
4895 };
4896 unsafe {
4897 assert!(close(arr.get_unchecked(6, 4), 0.43949517411));
4898 };
4899 unsafe {
4900 assert!(close(arr.get_unchecked(6, 5), 0.21381802195));
4901 };
4902 unsafe {
4903 assert!(close(arr.get_unchecked(6, 6), 0.846786664965));
4904 };
4905 unsafe {
4906 assert!(close(arr.get_unchecked(6, 7), 0.286597816032));
4907 };
4908 unsafe {
4909 assert!(close(arr.get_unchecked(7, 0), 0.987434811394));
4910 };
4911 unsafe {
4912 assert!(close(arr.get_unchecked(7, 1), 0.351616737105));
4913 };
4914 unsafe {
4915 assert!(close(arr.get_unchecked(7, 2), 0.922635050449));
4916 };
4917 unsafe {
4918 assert!(close(arr.get_unchecked(7, 3), 0.967930776509));
4919 };
4920 unsafe {
4921 assert!(close(arr.get_unchecked(7, 4), 0.177817746359));
4922 };
4923 unsafe {
4924 assert!(close(arr.get_unchecked(7, 5), 0.189873869008));
4925 };
4926 unsafe {
4927 assert!(close(arr.get_unchecked(7, 6), 0.464062150385));
4928 };
4929 unsafe {
4930 assert!(close(arr.get_unchecked(7, 7), 0.333041773282));
4931 };
4932 unsafe {
4933 assert!(close(arr.get_unchecked(8, 0), 0.81780830653));
4934 };
4935 unsafe {
4936 assert!(close(arr.get_unchecked(8, 1), 0.492501643062));
4937 };
4938 unsafe {
4939 assert!(close(arr.get_unchecked(8, 2), 0.84632733488));
4940 };
4941 unsafe {
4942 assert!(close(arr.get_unchecked(8, 3), 0.800257416013));
4943 };
4944 unsafe {
4945 assert!(close(arr.get_unchecked(8, 4), 0.178537092654));
4946 };
4947 unsafe {
4948 assert!(close(arr.get_unchecked(8, 5), 0.380089876429));
4949 };
4950 unsafe {
4951 assert!(close(arr.get_unchecked(8, 6), 0.591937855112));
4952 };
4953 unsafe {
4954 assert!(close(arr.get_unchecked(8, 7), 0.630833632448));
4955 };
4956 }
4957
4958
4959
4960 #[test]
4961 fn test_index_transpose_unsafe_4() {
4962
4963 let mut arr = Array::from(vec![0.5053414095220631,
4964 0.9515944229974294,
4965 0.01869972616290927,
4966 0.3651095484212574,
4967 0.8093171436120703,
4968 0.9938563301832937,
4969 0.7758112569774406,
4970 0.46560288920814796,
4971 0.8620975137755558,
4972 0.17856062156157082,
4973 0.2541026841563959,
4974 0.07316076458101406,
4975 0.15855693769656998,
4976 0.9379247087641616,
4977 0.6889503228688164,
4978 0.11422222893176381,
4979 0.3136968489406069,
4980 0.3251977875790155,
4981 0.7135826937372265,
4982 0.7586005116188119,
4983 0.7254964300735486,
4984 0.8396463691221457,
4985 0.43328029656121825,
4986 0.3686468314958711,
4987 0.7397710935379666,
4988 0.4497911236174056,
4989 0.5277789783225971,
4990 0.22823121143029412,
4991 0.7205020351076907,
4992 0.2132560721407628,
4993 0.37245617251888463,
4994 0.40826816005663624,
4995 0.7529853065158498,
4996 0.9729367471961934,
4997 0.048377437598617234,
4998 0.09664827683400845,
4999 0.7560699295668065,
5000 0.4478976116896861,
5001 0.558090641317851,
5002 0.3656423016037962,
5003 0.33863293933524385,
5004 0.23582037368450148,
5005 0.22741518352824397,
5006 0.09084584446404942,
5007 0.8013604880752093,
5008 0.1843352626509892,
5009 0.1665774834355107,
5010 0.87658036046777,
5011 0.3009038897952965,
5012 0.08246224260539736,
5013 0.5704847701699387,
5014 0.5819718051730493,
5015 0.4394951741102917,
5016 0.21381802195045596,
5017 0.8467866649649154,
5018 0.2865978160316519,
5019 0.9874348113942802,
5020 0.35161673710515395,
5021 0.9226350504489396,
5022 0.9679307765092823,
5023 0.17781774635851644,
5024 0.18987386900845993,
5025 0.46406215038482046,
5026 0.33304177328203266,
5027 0.8178083065304194,
5028 0.492501643062211,
5029 0.8463273348799848,
5030 0.8002574160133654,
5031 0.17853709265446838,
5032 0.3800898764290961,
5033 0.591937855111794,
5034 0.6308336324475695]);
5035 arr.reshape(9, 8);
5036
5037 let arr = arr.T();
5038 unsafe {
5039 assert!(close(arr.get_unchecked(0, 0), 0.505341409522));
5040 };
5041 unsafe {
5042 assert!(close(arr.get_unchecked(1, 0), 0.951594422997));
5043 };
5044 unsafe {
5045 assert!(close(arr.get_unchecked(2, 0), 0.0186997261629));
5046 };
5047 unsafe {
5048 assert!(close(arr.get_unchecked(3, 0), 0.365109548421));
5049 };
5050 unsafe {
5051 assert!(close(arr.get_unchecked(4, 0), 0.809317143612));
5052 };
5053 unsafe {
5054 assert!(close(arr.get_unchecked(5, 0), 0.993856330183));
5055 };
5056 unsafe {
5057 assert!(close(arr.get_unchecked(6, 0), 0.775811256977));
5058 };
5059 unsafe {
5060 assert!(close(arr.get_unchecked(7, 0), 0.465602889208));
5061 };
5062 unsafe {
5063 assert!(close(arr.get_unchecked(0, 1), 0.862097513776));
5064 };
5065 unsafe {
5066 assert!(close(arr.get_unchecked(1, 1), 0.178560621562));
5067 };
5068 unsafe {
5069 assert!(close(arr.get_unchecked(2, 1), 0.254102684156));
5070 };
5071 unsafe {
5072 assert!(close(arr.get_unchecked(3, 1), 0.073160764581));
5073 };
5074 unsafe {
5075 assert!(close(arr.get_unchecked(4, 1), 0.158556937697));
5076 };
5077 unsafe {
5078 assert!(close(arr.get_unchecked(5, 1), 0.937924708764));
5079 };
5080 unsafe {
5081 assert!(close(arr.get_unchecked(6, 1), 0.688950322869));
5082 };
5083 unsafe {
5084 assert!(close(arr.get_unchecked(7, 1), 0.114222228932));
5085 };
5086 unsafe {
5087 assert!(close(arr.get_unchecked(0, 2), 0.313696848941));
5088 };
5089 unsafe {
5090 assert!(close(arr.get_unchecked(1, 2), 0.325197787579));
5091 };
5092 unsafe {
5093 assert!(close(arr.get_unchecked(2, 2), 0.713582693737));
5094 };
5095 unsafe {
5096 assert!(close(arr.get_unchecked(3, 2), 0.758600511619));
5097 };
5098 unsafe {
5099 assert!(close(arr.get_unchecked(4, 2), 0.725496430074));
5100 };
5101 unsafe {
5102 assert!(close(arr.get_unchecked(5, 2), 0.839646369122));
5103 };
5104 unsafe {
5105 assert!(close(arr.get_unchecked(6, 2), 0.433280296561));
5106 };
5107 unsafe {
5108 assert!(close(arr.get_unchecked(7, 2), 0.368646831496));
5109 };
5110 unsafe {
5111 assert!(close(arr.get_unchecked(0, 3), 0.739771093538));
5112 };
5113 unsafe {
5114 assert!(close(arr.get_unchecked(1, 3), 0.449791123617));
5115 };
5116 unsafe {
5117 assert!(close(arr.get_unchecked(2, 3), 0.527778978323));
5118 };
5119 unsafe {
5120 assert!(close(arr.get_unchecked(3, 3), 0.22823121143));
5121 };
5122 unsafe {
5123 assert!(close(arr.get_unchecked(4, 3), 0.720502035108));
5124 };
5125 unsafe {
5126 assert!(close(arr.get_unchecked(5, 3), 0.213256072141));
5127 };
5128 unsafe {
5129 assert!(close(arr.get_unchecked(6, 3), 0.372456172519));
5130 };
5131 unsafe {
5132 assert!(close(arr.get_unchecked(7, 3), 0.408268160057));
5133 };
5134 unsafe {
5135 assert!(close(arr.get_unchecked(0, 4), 0.752985306516));
5136 };
5137 unsafe {
5138 assert!(close(arr.get_unchecked(1, 4), 0.972936747196));
5139 };
5140 unsafe {
5141 assert!(close(arr.get_unchecked(2, 4), 0.0483774375986));
5142 };
5143 unsafe {
5144 assert!(close(arr.get_unchecked(3, 4), 0.096648276834));
5145 };
5146 unsafe {
5147 assert!(close(arr.get_unchecked(4, 4), 0.756069929567));
5148 };
5149 unsafe {
5150 assert!(close(arr.get_unchecked(5, 4), 0.44789761169));
5151 };
5152 unsafe {
5153 assert!(close(arr.get_unchecked(6, 4), 0.558090641318));
5154 };
5155 unsafe {
5156 assert!(close(arr.get_unchecked(7, 4), 0.365642301604));
5157 };
5158 unsafe {
5159 assert!(close(arr.get_unchecked(0, 5), 0.338632939335));
5160 };
5161 unsafe {
5162 assert!(close(arr.get_unchecked(1, 5), 0.235820373685));
5163 };
5164 unsafe {
5165 assert!(close(arr.get_unchecked(2, 5), 0.227415183528));
5166 };
5167 unsafe {
5168 assert!(close(arr.get_unchecked(3, 5), 0.090845844464));
5169 };
5170 unsafe {
5171 assert!(close(arr.get_unchecked(4, 5), 0.801360488075));
5172 };
5173 unsafe {
5174 assert!(close(arr.get_unchecked(5, 5), 0.184335262651));
5175 };
5176 unsafe {
5177 assert!(close(arr.get_unchecked(6, 5), 0.166577483436));
5178 };
5179 unsafe {
5180 assert!(close(arr.get_unchecked(7, 5), 0.876580360468));
5181 };
5182 unsafe {
5183 assert!(close(arr.get_unchecked(0, 6), 0.300903889795));
5184 };
5185 unsafe {
5186 assert!(close(arr.get_unchecked(1, 6), 0.0824622426054));
5187 };
5188 unsafe {
5189 assert!(close(arr.get_unchecked(2, 6), 0.57048477017));
5190 };
5191 unsafe {
5192 assert!(close(arr.get_unchecked(3, 6), 0.581971805173));
5193 };
5194 unsafe {
5195 assert!(close(arr.get_unchecked(4, 6), 0.43949517411));
5196 };
5197 unsafe {
5198 assert!(close(arr.get_unchecked(5, 6), 0.21381802195));
5199 };
5200 unsafe {
5201 assert!(close(arr.get_unchecked(6, 6), 0.846786664965));
5202 };
5203 unsafe {
5204 assert!(close(arr.get_unchecked(7, 6), 0.286597816032));
5205 };
5206 unsafe {
5207 assert!(close(arr.get_unchecked(0, 7), 0.987434811394));
5208 };
5209 unsafe {
5210 assert!(close(arr.get_unchecked(1, 7), 0.351616737105));
5211 };
5212 unsafe {
5213 assert!(close(arr.get_unchecked(2, 7), 0.922635050449));
5214 };
5215 unsafe {
5216 assert!(close(arr.get_unchecked(3, 7), 0.967930776509));
5217 };
5218 unsafe {
5219 assert!(close(arr.get_unchecked(4, 7), 0.177817746359));
5220 };
5221 unsafe {
5222 assert!(close(arr.get_unchecked(5, 7), 0.189873869008));
5223 };
5224 unsafe {
5225 assert!(close(arr.get_unchecked(6, 7), 0.464062150385));
5226 };
5227 unsafe {
5228 assert!(close(arr.get_unchecked(7, 7), 0.333041773282));
5229 };
5230 unsafe {
5231 assert!(close(arr.get_unchecked(0, 8), 0.81780830653));
5232 };
5233 unsafe {
5234 assert!(close(arr.get_unchecked(1, 8), 0.492501643062));
5235 };
5236 unsafe {
5237 assert!(close(arr.get_unchecked(2, 8), 0.84632733488));
5238 };
5239 unsafe {
5240 assert!(close(arr.get_unchecked(3, 8), 0.800257416013));
5241 };
5242 unsafe {
5243 assert!(close(arr.get_unchecked(4, 8), 0.178537092654));
5244 };
5245 unsafe {
5246 assert!(close(arr.get_unchecked(5, 8), 0.380089876429));
5247 };
5248 unsafe {
5249 assert!(close(arr.get_unchecked(6, 8), 0.591937855112));
5250 };
5251 unsafe {
5252 assert!(close(arr.get_unchecked(7, 8), 0.630833632448));
5253 };
5254 }
5255
5256
5257
5258 #[test]
5259 fn test_index_5() {
5260
5261 let mut arr = Array::from(vec![0.09152800621372814,
5262 0.1558614252975501,
5263 0.7802910977108659,
5264 0.28435944268744473,
5265 0.2960239682177843,
5266 0.9654803796310318,
5267 0.731031133492046,
5268 0.03883748361393946,
5269 0.015524690587036316,
5270 0.8712234607833866,
5271 0.8537783664660846,
5272 0.3106777819640948,
5273 0.7473480048614148,
5274 0.4319809610352656,
5275 0.31093699252150475,
5276 0.4998025835687895,
5277 0.6807904826516954,
5278 0.39650981304667443,
5279 0.7254553133137138,
5280 0.4275754465438585,
5281 0.5990890226697482]);
5282 arr.reshape(7, 3);
5283
5284 assert!(close(arr.get(0, 0), 0.0915280062137));
5285 assert!(close(arr.get(0, 1), 0.155861425298));
5286 assert!(close(arr.get(0, 2), 0.780291097711));
5287 assert!(close(arr.get(1, 0), 0.284359442687));
5288 assert!(close(arr.get(1, 1), 0.296023968218));
5289 assert!(close(arr.get(1, 2), 0.965480379631));
5290 assert!(close(arr.get(2, 0), 0.731031133492));
5291 assert!(close(arr.get(2, 1), 0.0388374836139));
5292 assert!(close(arr.get(2, 2), 0.015524690587));
5293 assert!(close(arr.get(3, 0), 0.871223460783));
5294 assert!(close(arr.get(3, 1), 0.853778366466));
5295 assert!(close(arr.get(3, 2), 0.310677781964));
5296 assert!(close(arr.get(4, 0), 0.747348004861));
5297 assert!(close(arr.get(4, 1), 0.431980961035));
5298 assert!(close(arr.get(4, 2), 0.310936992522));
5299 assert!(close(arr.get(5, 0), 0.499802583569));
5300 assert!(close(arr.get(5, 1), 0.680790482652));
5301 assert!(close(arr.get(5, 2), 0.396509813047));
5302 assert!(close(arr.get(6, 0), 0.725455313314));
5303 assert!(close(arr.get(6, 1), 0.427575446544));
5304 assert!(close(arr.get(6, 2), 0.59908902267));
5305 }
5306
5307
5308
5309 #[test]
5310 fn test_index_transpose_5() {
5311
5312 let mut arr = Array::from(vec![0.09152800621372814,
5313 0.1558614252975501,
5314 0.7802910977108659,
5315 0.28435944268744473,
5316 0.2960239682177843,
5317 0.9654803796310318,
5318 0.731031133492046,
5319 0.03883748361393946,
5320 0.015524690587036316,
5321 0.8712234607833866,
5322 0.8537783664660846,
5323 0.3106777819640948,
5324 0.7473480048614148,
5325 0.4319809610352656,
5326 0.31093699252150475,
5327 0.4998025835687895,
5328 0.6807904826516954,
5329 0.39650981304667443,
5330 0.7254553133137138,
5331 0.4275754465438585,
5332 0.5990890226697482]);
5333 arr.reshape(7, 3);
5334
5335 let arr = arr.T();
5336 assert!(close(arr.get(0, 0), 0.0915280062137));
5337 assert!(close(arr.get(1, 0), 0.155861425298));
5338 assert!(close(arr.get(2, 0), 0.780291097711));
5339 assert!(close(arr.get(0, 1), 0.284359442687));
5340 assert!(close(arr.get(1, 1), 0.296023968218));
5341 assert!(close(arr.get(2, 1), 0.965480379631));
5342 assert!(close(arr.get(0, 2), 0.731031133492));
5343 assert!(close(arr.get(1, 2), 0.0388374836139));
5344 assert!(close(arr.get(2, 2), 0.015524690587));
5345 assert!(close(arr.get(0, 3), 0.871223460783));
5346 assert!(close(arr.get(1, 3), 0.853778366466));
5347 assert!(close(arr.get(2, 3), 0.310677781964));
5348 assert!(close(arr.get(0, 4), 0.747348004861));
5349 assert!(close(arr.get(1, 4), 0.431980961035));
5350 assert!(close(arr.get(2, 4), 0.310936992522));
5351 assert!(close(arr.get(0, 5), 0.499802583569));
5352 assert!(close(arr.get(1, 5), 0.680790482652));
5353 assert!(close(arr.get(2, 5), 0.396509813047));
5354 assert!(close(arr.get(0, 6), 0.725455313314));
5355 assert!(close(arr.get(1, 6), 0.427575446544));
5356 assert!(close(arr.get(2, 6), 0.59908902267));
5357 }
5358
5359
5360
5361 #[test]
5362 fn test_index_mut_5() {
5363
5364 let mut arr = Array::from(vec![0.09152800621372814,
5365 0.1558614252975501,
5366 0.7802910977108659,
5367 0.28435944268744473,
5368 0.2960239682177843,
5369 0.9654803796310318,
5370 0.731031133492046,
5371 0.03883748361393946,
5372 0.015524690587036316,
5373 0.8712234607833866,
5374 0.8537783664660846,
5375 0.3106777819640948,
5376 0.7473480048614148,
5377 0.4319809610352656,
5378 0.31093699252150475,
5379 0.4998025835687895,
5380 0.6807904826516954,
5381 0.39650981304667443,
5382 0.7254553133137138,
5383 0.4275754465438585,
5384 0.5990890226697482]);
5385 arr.reshape(7, 3);
5386
5387 let mut v = arr.get(0, 0);
5388 v += 1.0;
5389 assert!(close(v, 1.09152800621));
5390 let mut v = arr.get(0, 1);
5391 v += 1.0;
5392 assert!(close(v, 1.1558614253));
5393 let mut v = arr.get(0, 2);
5394 v += 1.0;
5395 assert!(close(v, 1.78029109771));
5396 let mut v = arr.get(1, 0);
5397 v += 1.0;
5398 assert!(close(v, 1.28435944269));
5399 let mut v = arr.get(1, 1);
5400 v += 1.0;
5401 assert!(close(v, 1.29602396822));
5402 let mut v = arr.get(1, 2);
5403 v += 1.0;
5404 assert!(close(v, 1.96548037963));
5405 let mut v = arr.get(2, 0);
5406 v += 1.0;
5407 assert!(close(v, 1.73103113349));
5408 let mut v = arr.get(2, 1);
5409 v += 1.0;
5410 assert!(close(v, 1.03883748361));
5411 let mut v = arr.get(2, 2);
5412 v += 1.0;
5413 assert!(close(v, 1.01552469059));
5414 let mut v = arr.get(3, 0);
5415 v += 1.0;
5416 assert!(close(v, 1.87122346078));
5417 let mut v = arr.get(3, 1);
5418 v += 1.0;
5419 assert!(close(v, 1.85377836647));
5420 let mut v = arr.get(3, 2);
5421 v += 1.0;
5422 assert!(close(v, 1.31067778196));
5423 let mut v = arr.get(4, 0);
5424 v += 1.0;
5425 assert!(close(v, 1.74734800486));
5426 let mut v = arr.get(4, 1);
5427 v += 1.0;
5428 assert!(close(v, 1.43198096104));
5429 let mut v = arr.get(4, 2);
5430 v += 1.0;
5431 assert!(close(v, 1.31093699252));
5432 let mut v = arr.get(5, 0);
5433 v += 1.0;
5434 assert!(close(v, 1.49980258357));
5435 let mut v = arr.get(5, 1);
5436 v += 1.0;
5437 assert!(close(v, 1.68079048265));
5438 let mut v = arr.get(5, 2);
5439 v += 1.0;
5440 assert!(close(v, 1.39650981305));
5441 let mut v = arr.get(6, 0);
5442 v += 1.0;
5443 assert!(close(v, 1.72545531331));
5444 let mut v = arr.get(6, 1);
5445 v += 1.0;
5446 assert!(close(v, 1.42757544654));
5447 let mut v = arr.get(6, 2);
5448 v += 1.0;
5449 assert!(close(v, 1.59908902267));
5450 }
5451
5452
5453
5454 #[test]
5455 fn test_index_transpose_mut_5() {
5456
5457 let mut arr = Array::from(vec![0.09152800621372814,
5458 0.1558614252975501,
5459 0.7802910977108659,
5460 0.28435944268744473,
5461 0.2960239682177843,
5462 0.9654803796310318,
5463 0.731031133492046,
5464 0.03883748361393946,
5465 0.015524690587036316,
5466 0.8712234607833866,
5467 0.8537783664660846,
5468 0.3106777819640948,
5469 0.7473480048614148,
5470 0.4319809610352656,
5471 0.31093699252150475,
5472 0.4998025835687895,
5473 0.6807904826516954,
5474 0.39650981304667443,
5475 0.7254553133137138,
5476 0.4275754465438585,
5477 0.5990890226697482]);
5478 arr.reshape(7, 3);
5479
5480 let arr = arr.T();
5481 let mut v = arr.get(0, 0);
5482 v += 1.0;
5483 assert!(close(v, 1.09152800621));
5484 let mut v = arr.get(1, 0);
5485 v += 1.0;
5486 assert!(close(v, 1.1558614253));
5487 let mut v = arr.get(2, 0);
5488 v += 1.0;
5489 assert!(close(v, 1.78029109771));
5490 let mut v = arr.get(0, 1);
5491 v += 1.0;
5492 assert!(close(v, 1.28435944269));
5493 let mut v = arr.get(1, 1);
5494 v += 1.0;
5495 assert!(close(v, 1.29602396822));
5496 let mut v = arr.get(2, 1);
5497 v += 1.0;
5498 assert!(close(v, 1.96548037963));
5499 let mut v = arr.get(0, 2);
5500 v += 1.0;
5501 assert!(close(v, 1.73103113349));
5502 let mut v = arr.get(1, 2);
5503 v += 1.0;
5504 assert!(close(v, 1.03883748361));
5505 let mut v = arr.get(2, 2);
5506 v += 1.0;
5507 assert!(close(v, 1.01552469059));
5508 let mut v = arr.get(0, 3);
5509 v += 1.0;
5510 assert!(close(v, 1.87122346078));
5511 let mut v = arr.get(1, 3);
5512 v += 1.0;
5513 assert!(close(v, 1.85377836647));
5514 let mut v = arr.get(2, 3);
5515 v += 1.0;
5516 assert!(close(v, 1.31067778196));
5517 let mut v = arr.get(0, 4);
5518 v += 1.0;
5519 assert!(close(v, 1.74734800486));
5520 let mut v = arr.get(1, 4);
5521 v += 1.0;
5522 assert!(close(v, 1.43198096104));
5523 let mut v = arr.get(2, 4);
5524 v += 1.0;
5525 assert!(close(v, 1.31093699252));
5526 let mut v = arr.get(0, 5);
5527 v += 1.0;
5528 assert!(close(v, 1.49980258357));
5529 let mut v = arr.get(1, 5);
5530 v += 1.0;
5531 assert!(close(v, 1.68079048265));
5532 let mut v = arr.get(2, 5);
5533 v += 1.0;
5534 assert!(close(v, 1.39650981305));
5535 let mut v = arr.get(0, 6);
5536 v += 1.0;
5537 assert!(close(v, 1.72545531331));
5538 let mut v = arr.get(1, 6);
5539 v += 1.0;
5540 assert!(close(v, 1.42757544654));
5541 let mut v = arr.get(2, 6);
5542 v += 1.0;
5543 assert!(close(v, 1.59908902267));
5544 }
5545
5546
5547
5548 #[test]
5549 fn test_index_unsafe_5() {
5550
5551 let mut arr = Array::from(vec![0.09152800621372814,
5552 0.1558614252975501,
5553 0.7802910977108659,
5554 0.28435944268744473,
5555 0.2960239682177843,
5556 0.9654803796310318,
5557 0.731031133492046,
5558 0.03883748361393946,
5559 0.015524690587036316,
5560 0.8712234607833866,
5561 0.8537783664660846,
5562 0.3106777819640948,
5563 0.7473480048614148,
5564 0.4319809610352656,
5565 0.31093699252150475,
5566 0.4998025835687895,
5567 0.6807904826516954,
5568 0.39650981304667443,
5569 0.7254553133137138,
5570 0.4275754465438585,
5571 0.5990890226697482]);
5572 arr.reshape(7, 3);
5573
5574 unsafe {
5575 assert!(close(arr.get_unchecked(0, 0), 0.0915280062137));
5576 };
5577 unsafe {
5578 assert!(close(arr.get_unchecked(0, 1), 0.155861425298));
5579 };
5580 unsafe {
5581 assert!(close(arr.get_unchecked(0, 2), 0.780291097711));
5582 };
5583 unsafe {
5584 assert!(close(arr.get_unchecked(1, 0), 0.284359442687));
5585 };
5586 unsafe {
5587 assert!(close(arr.get_unchecked(1, 1), 0.296023968218));
5588 };
5589 unsafe {
5590 assert!(close(arr.get_unchecked(1, 2), 0.965480379631));
5591 };
5592 unsafe {
5593 assert!(close(arr.get_unchecked(2, 0), 0.731031133492));
5594 };
5595 unsafe {
5596 assert!(close(arr.get_unchecked(2, 1), 0.0388374836139));
5597 };
5598 unsafe {
5599 assert!(close(arr.get_unchecked(2, 2), 0.015524690587));
5600 };
5601 unsafe {
5602 assert!(close(arr.get_unchecked(3, 0), 0.871223460783));
5603 };
5604 unsafe {
5605 assert!(close(arr.get_unchecked(3, 1), 0.853778366466));
5606 };
5607 unsafe {
5608 assert!(close(arr.get_unchecked(3, 2), 0.310677781964));
5609 };
5610 unsafe {
5611 assert!(close(arr.get_unchecked(4, 0), 0.747348004861));
5612 };
5613 unsafe {
5614 assert!(close(arr.get_unchecked(4, 1), 0.431980961035));
5615 };
5616 unsafe {
5617 assert!(close(arr.get_unchecked(4, 2), 0.310936992522));
5618 };
5619 unsafe {
5620 assert!(close(arr.get_unchecked(5, 0), 0.499802583569));
5621 };
5622 unsafe {
5623 assert!(close(arr.get_unchecked(5, 1), 0.680790482652));
5624 };
5625 unsafe {
5626 assert!(close(arr.get_unchecked(5, 2), 0.396509813047));
5627 };
5628 unsafe {
5629 assert!(close(arr.get_unchecked(6, 0), 0.725455313314));
5630 };
5631 unsafe {
5632 assert!(close(arr.get_unchecked(6, 1), 0.427575446544));
5633 };
5634 unsafe {
5635 assert!(close(arr.get_unchecked(6, 2), 0.59908902267));
5636 };
5637 }
5638
5639
5640
5641 #[test]
5642 fn test_index_transpose_unsafe_5() {
5643
5644 let mut arr = Array::from(vec![0.09152800621372814,
5645 0.1558614252975501,
5646 0.7802910977108659,
5647 0.28435944268744473,
5648 0.2960239682177843,
5649 0.9654803796310318,
5650 0.731031133492046,
5651 0.03883748361393946,
5652 0.015524690587036316,
5653 0.8712234607833866,
5654 0.8537783664660846,
5655 0.3106777819640948,
5656 0.7473480048614148,
5657 0.4319809610352656,
5658 0.31093699252150475,
5659 0.4998025835687895,
5660 0.6807904826516954,
5661 0.39650981304667443,
5662 0.7254553133137138,
5663 0.4275754465438585,
5664 0.5990890226697482]);
5665 arr.reshape(7, 3);
5666
5667 let arr = arr.T();
5668 unsafe {
5669 assert!(close(arr.get_unchecked(0, 0), 0.0915280062137));
5670 };
5671 unsafe {
5672 assert!(close(arr.get_unchecked(1, 0), 0.155861425298));
5673 };
5674 unsafe {
5675 assert!(close(arr.get_unchecked(2, 0), 0.780291097711));
5676 };
5677 unsafe {
5678 assert!(close(arr.get_unchecked(0, 1), 0.284359442687));
5679 };
5680 unsafe {
5681 assert!(close(arr.get_unchecked(1, 1), 0.296023968218));
5682 };
5683 unsafe {
5684 assert!(close(arr.get_unchecked(2, 1), 0.965480379631));
5685 };
5686 unsafe {
5687 assert!(close(arr.get_unchecked(0, 2), 0.731031133492));
5688 };
5689 unsafe {
5690 assert!(close(arr.get_unchecked(1, 2), 0.0388374836139));
5691 };
5692 unsafe {
5693 assert!(close(arr.get_unchecked(2, 2), 0.015524690587));
5694 };
5695 unsafe {
5696 assert!(close(arr.get_unchecked(0, 3), 0.871223460783));
5697 };
5698 unsafe {
5699 assert!(close(arr.get_unchecked(1, 3), 0.853778366466));
5700 };
5701 unsafe {
5702 assert!(close(arr.get_unchecked(2, 3), 0.310677781964));
5703 };
5704 unsafe {
5705 assert!(close(arr.get_unchecked(0, 4), 0.747348004861));
5706 };
5707 unsafe {
5708 assert!(close(arr.get_unchecked(1, 4), 0.431980961035));
5709 };
5710 unsafe {
5711 assert!(close(arr.get_unchecked(2, 4), 0.310936992522));
5712 };
5713 unsafe {
5714 assert!(close(arr.get_unchecked(0, 5), 0.499802583569));
5715 };
5716 unsafe {
5717 assert!(close(arr.get_unchecked(1, 5), 0.680790482652));
5718 };
5719 unsafe {
5720 assert!(close(arr.get_unchecked(2, 5), 0.396509813047));
5721 };
5722 unsafe {
5723 assert!(close(arr.get_unchecked(0, 6), 0.725455313314));
5724 };
5725 unsafe {
5726 assert!(close(arr.get_unchecked(1, 6), 0.427575446544));
5727 };
5728 unsafe {
5729 assert!(close(arr.get_unchecked(2, 6), 0.59908902267));
5730 };
5731 }
5732
5733
5734
5735 #[test]
5736 fn test_index_6() {
5737
5738 let mut arr = Array::from(vec![0.1997387179767336]);
5739 arr.reshape(1, 1);
5740
5741 assert!(close(arr.get(0, 0), 0.199738717977));
5742 }
5743
5744
5745
5746 #[test]
5747 fn test_index_transpose_6() {
5748
5749 let mut arr = Array::from(vec![0.1997387179767336]);
5750 arr.reshape(1, 1);
5751
5752 let arr = arr.T();
5753 assert!(close(arr.get(0, 0), 0.199738717977));
5754 }
5755
5756
5757
5758 #[test]
5759 fn test_index_mut_6() {
5760
5761 let mut arr = Array::from(vec![0.1997387179767336]);
5762 arr.reshape(1, 1);
5763
5764 let mut v = arr.get(0, 0);
5765 v += 1.0;
5766 assert!(close(v, 1.19973871798));
5767 }
5768
5769
5770
5771 #[test]
5772 fn test_index_transpose_mut_6() {
5773
5774 let mut arr = Array::from(vec![0.1997387179767336]);
5775 arr.reshape(1, 1);
5776
5777 let arr = arr.T();
5778 let mut v = arr.get(0, 0);
5779 v += 1.0;
5780 assert!(close(v, 1.19973871798));
5781 }
5782
5783
5784
5785 #[test]
5786 fn test_index_unsafe_6() {
5787
5788 let mut arr = Array::from(vec![0.1997387179767336]);
5789 arr.reshape(1, 1);
5790
5791 unsafe {
5792 assert!(close(arr.get_unchecked(0, 0), 0.199738717977));
5793 };
5794 }
5795
5796
5797
5798 #[test]
5799 fn test_index_transpose_unsafe_6() {
5800
5801 let mut arr = Array::from(vec![0.1997387179767336]);
5802 arr.reshape(1, 1);
5803
5804 let arr = arr.T();
5805 unsafe {
5806 assert!(close(arr.get_unchecked(0, 0), 0.199738717977));
5807 };
5808 }
5809
5810
5811
5812 #[test]
5813 fn test_index_7() {
5814
5815 let mut arr = Array::from(vec![0.7290688662070789,
5816 0.10701545300146353,
5817 0.8133094795587649,
5818 0.7727568754312601,
5819 0.058066140581452874,
5820 0.1406388640685593,
5821 0.6369940029688143,
5822 0.37915658124608276,
5823 0.2840350156111312,
5824 0.36249068359756387,
5825 0.2842751827925457,
5826 0.8852568677946027,
5827 0.9392662970818118,
5828 0.7232943243389232,
5829 0.520528368063512,
5830 0.7363552471090443]);
5831 arr.reshape(2, 8);
5832
5833 assert!(close(arr.get(0, 0), 0.729068866207));
5834 assert!(close(arr.get(0, 1), 0.107015453001));
5835 assert!(close(arr.get(0, 2), 0.813309479559));
5836 assert!(close(arr.get(0, 3), 0.772756875431));
5837 assert!(close(arr.get(0, 4), 0.0580661405815));
5838 assert!(close(arr.get(0, 5), 0.140638864069));
5839 assert!(close(arr.get(0, 6), 0.636994002969));
5840 assert!(close(arr.get(0, 7), 0.379156581246));
5841 assert!(close(arr.get(1, 0), 0.284035015611));
5842 assert!(close(arr.get(1, 1), 0.362490683598));
5843 assert!(close(arr.get(1, 2), 0.284275182793));
5844 assert!(close(arr.get(1, 3), 0.885256867795));
5845 assert!(close(arr.get(1, 4), 0.939266297082));
5846 assert!(close(arr.get(1, 5), 0.723294324339));
5847 assert!(close(arr.get(1, 6), 0.520528368064));
5848 assert!(close(arr.get(1, 7), 0.736355247109));
5849 }
5850
5851
5852
5853 #[test]
5854 fn test_index_transpose_7() {
5855
5856 let mut arr = Array::from(vec![0.7290688662070789,
5857 0.10701545300146353,
5858 0.8133094795587649,
5859 0.7727568754312601,
5860 0.058066140581452874,
5861 0.1406388640685593,
5862 0.6369940029688143,
5863 0.37915658124608276,
5864 0.2840350156111312,
5865 0.36249068359756387,
5866 0.2842751827925457,
5867 0.8852568677946027,
5868 0.9392662970818118,
5869 0.7232943243389232,
5870 0.520528368063512,
5871 0.7363552471090443]);
5872 arr.reshape(2, 8);
5873
5874 let arr = arr.T();
5875 assert!(close(arr.get(0, 0), 0.729068866207));
5876 assert!(close(arr.get(1, 0), 0.107015453001));
5877 assert!(close(arr.get(2, 0), 0.813309479559));
5878 assert!(close(arr.get(3, 0), 0.772756875431));
5879 assert!(close(arr.get(4, 0), 0.0580661405815));
5880 assert!(close(arr.get(5, 0), 0.140638864069));
5881 assert!(close(arr.get(6, 0), 0.636994002969));
5882 assert!(close(arr.get(7, 0), 0.379156581246));
5883 assert!(close(arr.get(0, 1), 0.284035015611));
5884 assert!(close(arr.get(1, 1), 0.362490683598));
5885 assert!(close(arr.get(2, 1), 0.284275182793));
5886 assert!(close(arr.get(3, 1), 0.885256867795));
5887 assert!(close(arr.get(4, 1), 0.939266297082));
5888 assert!(close(arr.get(5, 1), 0.723294324339));
5889 assert!(close(arr.get(6, 1), 0.520528368064));
5890 assert!(close(arr.get(7, 1), 0.736355247109));
5891 }
5892
5893
5894
5895 #[test]
5896 fn test_index_mut_7() {
5897
5898 let mut arr = Array::from(vec![0.7290688662070789,
5899 0.10701545300146353,
5900 0.8133094795587649,
5901 0.7727568754312601,
5902 0.058066140581452874,
5903 0.1406388640685593,
5904 0.6369940029688143,
5905 0.37915658124608276,
5906 0.2840350156111312,
5907 0.36249068359756387,
5908 0.2842751827925457,
5909 0.8852568677946027,
5910 0.9392662970818118,
5911 0.7232943243389232,
5912 0.520528368063512,
5913 0.7363552471090443]);
5914 arr.reshape(2, 8);
5915
5916 let mut v = arr.get(0, 0);
5917 v += 1.0;
5918 assert!(close(v, 1.72906886621));
5919 let mut v = arr.get(0, 1);
5920 v += 1.0;
5921 assert!(close(v, 1.107015453));
5922 let mut v = arr.get(0, 2);
5923 v += 1.0;
5924 assert!(close(v, 1.81330947956));
5925 let mut v = arr.get(0, 3);
5926 v += 1.0;
5927 assert!(close(v, 1.77275687543));
5928 let mut v = arr.get(0, 4);
5929 v += 1.0;
5930 assert!(close(v, 1.05806614058));
5931 let mut v = arr.get(0, 5);
5932 v += 1.0;
5933 assert!(close(v, 1.14063886407));
5934 let mut v = arr.get(0, 6);
5935 v += 1.0;
5936 assert!(close(v, 1.63699400297));
5937 let mut v = arr.get(0, 7);
5938 v += 1.0;
5939 assert!(close(v, 1.37915658125));
5940 let mut v = arr.get(1, 0);
5941 v += 1.0;
5942 assert!(close(v, 1.28403501561));
5943 let mut v = arr.get(1, 1);
5944 v += 1.0;
5945 assert!(close(v, 1.3624906836));
5946 let mut v = arr.get(1, 2);
5947 v += 1.0;
5948 assert!(close(v, 1.28427518279));
5949 let mut v = arr.get(1, 3);
5950 v += 1.0;
5951 assert!(close(v, 1.88525686779));
5952 let mut v = arr.get(1, 4);
5953 v += 1.0;
5954 assert!(close(v, 1.93926629708));
5955 let mut v = arr.get(1, 5);
5956 v += 1.0;
5957 assert!(close(v, 1.72329432434));
5958 let mut v = arr.get(1, 6);
5959 v += 1.0;
5960 assert!(close(v, 1.52052836806));
5961 let mut v = arr.get(1, 7);
5962 v += 1.0;
5963 assert!(close(v, 1.73635524711));
5964 }
5965
5966
5967
5968 #[test]
5969 fn test_index_transpose_mut_7() {
5970
5971 let mut arr = Array::from(vec![0.7290688662070789,
5972 0.10701545300146353,
5973 0.8133094795587649,
5974 0.7727568754312601,
5975 0.058066140581452874,
5976 0.1406388640685593,
5977 0.6369940029688143,
5978 0.37915658124608276,
5979 0.2840350156111312,
5980 0.36249068359756387,
5981 0.2842751827925457,
5982 0.8852568677946027,
5983 0.9392662970818118,
5984 0.7232943243389232,
5985 0.520528368063512,
5986 0.7363552471090443]);
5987 arr.reshape(2, 8);
5988
5989 let arr = arr.T();
5990 let mut v = arr.get(0, 0);
5991 v += 1.0;
5992 assert!(close(v, 1.72906886621));
5993 let mut v = arr.get(1, 0);
5994 v += 1.0;
5995 assert!(close(v, 1.107015453));
5996 let mut v = arr.get(2, 0);
5997 v += 1.0;
5998 assert!(close(v, 1.81330947956));
5999 let mut v = arr.get(3, 0);
6000 v += 1.0;
6001 assert!(close(v, 1.77275687543));
6002 let mut v = arr.get(4, 0);
6003 v += 1.0;
6004 assert!(close(v, 1.05806614058));
6005 let mut v = arr.get(5, 0);
6006 v += 1.0;
6007 assert!(close(v, 1.14063886407));
6008 let mut v = arr.get(6, 0);
6009 v += 1.0;
6010 assert!(close(v, 1.63699400297));
6011 let mut v = arr.get(7, 0);
6012 v += 1.0;
6013 assert!(close(v, 1.37915658125));
6014 let mut v = arr.get(0, 1);
6015 v += 1.0;
6016 assert!(close(v, 1.28403501561));
6017 let mut v = arr.get(1, 1);
6018 v += 1.0;
6019 assert!(close(v, 1.3624906836));
6020 let mut v = arr.get(2, 1);
6021 v += 1.0;
6022 assert!(close(v, 1.28427518279));
6023 let mut v = arr.get(3, 1);
6024 v += 1.0;
6025 assert!(close(v, 1.88525686779));
6026 let mut v = arr.get(4, 1);
6027 v += 1.0;
6028 assert!(close(v, 1.93926629708));
6029 let mut v = arr.get(5, 1);
6030 v += 1.0;
6031 assert!(close(v, 1.72329432434));
6032 let mut v = arr.get(6, 1);
6033 v += 1.0;
6034 assert!(close(v, 1.52052836806));
6035 let mut v = arr.get(7, 1);
6036 v += 1.0;
6037 assert!(close(v, 1.73635524711));
6038 }
6039
6040
6041
6042 #[test]
6043 fn test_index_unsafe_7() {
6044
6045 let mut arr = Array::from(vec![0.7290688662070789,
6046 0.10701545300146353,
6047 0.8133094795587649,
6048 0.7727568754312601,
6049 0.058066140581452874,
6050 0.1406388640685593,
6051 0.6369940029688143,
6052 0.37915658124608276,
6053 0.2840350156111312,
6054 0.36249068359756387,
6055 0.2842751827925457,
6056 0.8852568677946027,
6057 0.9392662970818118,
6058 0.7232943243389232,
6059 0.520528368063512,
6060 0.7363552471090443]);
6061 arr.reshape(2, 8);
6062
6063 unsafe {
6064 assert!(close(arr.get_unchecked(0, 0), 0.729068866207));
6065 };
6066 unsafe {
6067 assert!(close(arr.get_unchecked(0, 1), 0.107015453001));
6068 };
6069 unsafe {
6070 assert!(close(arr.get_unchecked(0, 2), 0.813309479559));
6071 };
6072 unsafe {
6073 assert!(close(arr.get_unchecked(0, 3), 0.772756875431));
6074 };
6075 unsafe {
6076 assert!(close(arr.get_unchecked(0, 4), 0.0580661405815));
6077 };
6078 unsafe {
6079 assert!(close(arr.get_unchecked(0, 5), 0.140638864069));
6080 };
6081 unsafe {
6082 assert!(close(arr.get_unchecked(0, 6), 0.636994002969));
6083 };
6084 unsafe {
6085 assert!(close(arr.get_unchecked(0, 7), 0.379156581246));
6086 };
6087 unsafe {
6088 assert!(close(arr.get_unchecked(1, 0), 0.284035015611));
6089 };
6090 unsafe {
6091 assert!(close(arr.get_unchecked(1, 1), 0.362490683598));
6092 };
6093 unsafe {
6094 assert!(close(arr.get_unchecked(1, 2), 0.284275182793));
6095 };
6096 unsafe {
6097 assert!(close(arr.get_unchecked(1, 3), 0.885256867795));
6098 };
6099 unsafe {
6100 assert!(close(arr.get_unchecked(1, 4), 0.939266297082));
6101 };
6102 unsafe {
6103 assert!(close(arr.get_unchecked(1, 5), 0.723294324339));
6104 };
6105 unsafe {
6106 assert!(close(arr.get_unchecked(1, 6), 0.520528368064));
6107 };
6108 unsafe {
6109 assert!(close(arr.get_unchecked(1, 7), 0.736355247109));
6110 };
6111 }
6112
6113
6114
6115 #[test]
6116 fn test_index_transpose_unsafe_7() {
6117
6118 let mut arr = Array::from(vec![0.7290688662070789,
6119 0.10701545300146353,
6120 0.8133094795587649,
6121 0.7727568754312601,
6122 0.058066140581452874,
6123 0.1406388640685593,
6124 0.6369940029688143,
6125 0.37915658124608276,
6126 0.2840350156111312,
6127 0.36249068359756387,
6128 0.2842751827925457,
6129 0.8852568677946027,
6130 0.9392662970818118,
6131 0.7232943243389232,
6132 0.520528368063512,
6133 0.7363552471090443]);
6134 arr.reshape(2, 8);
6135
6136 let arr = arr.T();
6137 unsafe {
6138 assert!(close(arr.get_unchecked(0, 0), 0.729068866207));
6139 };
6140 unsafe {
6141 assert!(close(arr.get_unchecked(1, 0), 0.107015453001));
6142 };
6143 unsafe {
6144 assert!(close(arr.get_unchecked(2, 0), 0.813309479559));
6145 };
6146 unsafe {
6147 assert!(close(arr.get_unchecked(3, 0), 0.772756875431));
6148 };
6149 unsafe {
6150 assert!(close(arr.get_unchecked(4, 0), 0.0580661405815));
6151 };
6152 unsafe {
6153 assert!(close(arr.get_unchecked(5, 0), 0.140638864069));
6154 };
6155 unsafe {
6156 assert!(close(arr.get_unchecked(6, 0), 0.636994002969));
6157 };
6158 unsafe {
6159 assert!(close(arr.get_unchecked(7, 0), 0.379156581246));
6160 };
6161 unsafe {
6162 assert!(close(arr.get_unchecked(0, 1), 0.284035015611));
6163 };
6164 unsafe {
6165 assert!(close(arr.get_unchecked(1, 1), 0.362490683598));
6166 };
6167 unsafe {
6168 assert!(close(arr.get_unchecked(2, 1), 0.284275182793));
6169 };
6170 unsafe {
6171 assert!(close(arr.get_unchecked(3, 1), 0.885256867795));
6172 };
6173 unsafe {
6174 assert!(close(arr.get_unchecked(4, 1), 0.939266297082));
6175 };
6176 unsafe {
6177 assert!(close(arr.get_unchecked(5, 1), 0.723294324339));
6178 };
6179 unsafe {
6180 assert!(close(arr.get_unchecked(6, 1), 0.520528368064));
6181 };
6182 unsafe {
6183 assert!(close(arr.get_unchecked(7, 1), 0.736355247109));
6184 };
6185 }
6186
6187
6188
6189 #[test]
6190 fn test_index_8() {
6191
6192 let mut arr = Array::from(vec![0.07063263155528676,
6193 0.12404813469596765,
6194 0.11003071509029239,
6195 0.2307718142908437,
6196 0.872667486390751]);
6197 arr.reshape(1, 5);
6198
6199 assert!(close(arr.get(0, 0), 0.0706326315553));
6200 assert!(close(arr.get(0, 1), 0.124048134696));
6201 assert!(close(arr.get(0, 2), 0.11003071509));
6202 assert!(close(arr.get(0, 3), 0.230771814291));
6203 assert!(close(arr.get(0, 4), 0.872667486391));
6204 }
6205
6206
6207
6208 #[test]
6209 fn test_index_transpose_8() {
6210
6211 let mut arr = Array::from(vec![0.07063263155528676,
6212 0.12404813469596765,
6213 0.11003071509029239,
6214 0.2307718142908437,
6215 0.872667486390751]);
6216 arr.reshape(1, 5);
6217
6218 let arr = arr.T();
6219 assert!(close(arr.get(0, 0), 0.0706326315553));
6220 assert!(close(arr.get(1, 0), 0.124048134696));
6221 assert!(close(arr.get(2, 0), 0.11003071509));
6222 assert!(close(arr.get(3, 0), 0.230771814291));
6223 assert!(close(arr.get(4, 0), 0.872667486391));
6224 }
6225
6226
6227
6228 #[test]
6229 fn test_index_mut_8() {
6230
6231 let mut arr = Array::from(vec![0.07063263155528676,
6232 0.12404813469596765,
6233 0.11003071509029239,
6234 0.2307718142908437,
6235 0.872667486390751]);
6236 arr.reshape(1, 5);
6237
6238 let mut v = arr.get(0, 0);
6239 v += 1.0;
6240 assert!(close(v, 1.07063263156));
6241 let mut v = arr.get(0, 1);
6242 v += 1.0;
6243 assert!(close(v, 1.1240481347));
6244 let mut v = arr.get(0, 2);
6245 v += 1.0;
6246 assert!(close(v, 1.11003071509));
6247 let mut v = arr.get(0, 3);
6248 v += 1.0;
6249 assert!(close(v, 1.23077181429));
6250 let mut v = arr.get(0, 4);
6251 v += 1.0;
6252 assert!(close(v, 1.87266748639));
6253 }
6254
6255
6256
6257 #[test]
6258 fn test_index_transpose_mut_8() {
6259
6260 let mut arr = Array::from(vec![0.07063263155528676,
6261 0.12404813469596765,
6262 0.11003071509029239,
6263 0.2307718142908437,
6264 0.872667486390751]);
6265 arr.reshape(1, 5);
6266
6267 let arr = arr.T();
6268 let mut v = arr.get(0, 0);
6269 v += 1.0;
6270 assert!(close(v, 1.07063263156));
6271 let mut v = arr.get(1, 0);
6272 v += 1.0;
6273 assert!(close(v, 1.1240481347));
6274 let mut v = arr.get(2, 0);
6275 v += 1.0;
6276 assert!(close(v, 1.11003071509));
6277 let mut v = arr.get(3, 0);
6278 v += 1.0;
6279 assert!(close(v, 1.23077181429));
6280 let mut v = arr.get(4, 0);
6281 v += 1.0;
6282 assert!(close(v, 1.87266748639));
6283 }
6284
6285
6286
6287 #[test]
6288 fn test_index_unsafe_8() {
6289
6290 let mut arr = Array::from(vec![0.07063263155528676,
6291 0.12404813469596765,
6292 0.11003071509029239,
6293 0.2307718142908437,
6294 0.872667486390751]);
6295 arr.reshape(1, 5);
6296
6297 unsafe {
6298 assert!(close(arr.get_unchecked(0, 0), 0.0706326315553));
6299 };
6300 unsafe {
6301 assert!(close(arr.get_unchecked(0, 1), 0.124048134696));
6302 };
6303 unsafe {
6304 assert!(close(arr.get_unchecked(0, 2), 0.11003071509));
6305 };
6306 unsafe {
6307 assert!(close(arr.get_unchecked(0, 3), 0.230771814291));
6308 };
6309 unsafe {
6310 assert!(close(arr.get_unchecked(0, 4), 0.872667486391));
6311 };
6312 }
6313
6314
6315
6316 #[test]
6317 fn test_index_transpose_unsafe_8() {
6318
6319 let mut arr = Array::from(vec![0.07063263155528676,
6320 0.12404813469596765,
6321 0.11003071509029239,
6322 0.2307718142908437,
6323 0.872667486390751]);
6324 arr.reshape(1, 5);
6325
6326 let arr = arr.T();
6327 unsafe {
6328 assert!(close(arr.get_unchecked(0, 0), 0.0706326315553));
6329 };
6330 unsafe {
6331 assert!(close(arr.get_unchecked(1, 0), 0.124048134696));
6332 };
6333 unsafe {
6334 assert!(close(arr.get_unchecked(2, 0), 0.11003071509));
6335 };
6336 unsafe {
6337 assert!(close(arr.get_unchecked(3, 0), 0.230771814291));
6338 };
6339 unsafe {
6340 assert!(close(arr.get_unchecked(4, 0), 0.872667486391));
6341 };
6342 }
6343
6344
6345
6346 #[test]
6347 fn test_index_9() {
6348
6349 let mut arr = Array::from(vec![0.8838213961957216,
6350 0.7310938683329141,
6351 0.591505339227943,
6352 0.3930296867058841,
6353 0.27046020836139695,
6354 0.9695271560912553]);
6355 arr.reshape(1, 6);
6356
6357 assert!(close(arr.get(0, 0), 0.883821396196));
6358 assert!(close(arr.get(0, 1), 0.731093868333));
6359 assert!(close(arr.get(0, 2), 0.591505339228));
6360 assert!(close(arr.get(0, 3), 0.393029686706));
6361 assert!(close(arr.get(0, 4), 0.270460208361));
6362 assert!(close(arr.get(0, 5), 0.969527156091));
6363 }
6364
6365
6366
6367 #[test]
6368 fn test_index_transpose_9() {
6369
6370 let mut arr = Array::from(vec![0.8838213961957216,
6371 0.7310938683329141,
6372 0.591505339227943,
6373 0.3930296867058841,
6374 0.27046020836139695,
6375 0.9695271560912553]);
6376 arr.reshape(1, 6);
6377
6378 let arr = arr.T();
6379 assert!(close(arr.get(0, 0), 0.883821396196));
6380 assert!(close(arr.get(1, 0), 0.731093868333));
6381 assert!(close(arr.get(2, 0), 0.591505339228));
6382 assert!(close(arr.get(3, 0), 0.393029686706));
6383 assert!(close(arr.get(4, 0), 0.270460208361));
6384 assert!(close(arr.get(5, 0), 0.969527156091));
6385 }
6386
6387
6388
6389 #[test]
6390 fn test_index_mut_9() {
6391
6392 let mut arr = Array::from(vec![0.8838213961957216,
6393 0.7310938683329141,
6394 0.591505339227943,
6395 0.3930296867058841,
6396 0.27046020836139695,
6397 0.9695271560912553]);
6398 arr.reshape(1, 6);
6399
6400 let mut v = arr.get(0, 0);
6401 v += 1.0;
6402 assert!(close(v, 1.8838213962));
6403 let mut v = arr.get(0, 1);
6404 v += 1.0;
6405 assert!(close(v, 1.73109386833));
6406 let mut v = arr.get(0, 2);
6407 v += 1.0;
6408 assert!(close(v, 1.59150533923));
6409 let mut v = arr.get(0, 3);
6410 v += 1.0;
6411 assert!(close(v, 1.39302968671));
6412 let mut v = arr.get(0, 4);
6413 v += 1.0;
6414 assert!(close(v, 1.27046020836));
6415 let mut v = arr.get(0, 5);
6416 v += 1.0;
6417 assert!(close(v, 1.96952715609));
6418 }
6419
6420
6421
6422 #[test]
6423 fn test_index_transpose_mut_9() {
6424
6425 let mut arr = Array::from(vec![0.8838213961957216,
6426 0.7310938683329141,
6427 0.591505339227943,
6428 0.3930296867058841,
6429 0.27046020836139695,
6430 0.9695271560912553]);
6431 arr.reshape(1, 6);
6432
6433 let arr = arr.T();
6434 let mut v = arr.get(0, 0);
6435 v += 1.0;
6436 assert!(close(v, 1.8838213962));
6437 let mut v = arr.get(1, 0);
6438 v += 1.0;
6439 assert!(close(v, 1.73109386833));
6440 let mut v = arr.get(2, 0);
6441 v += 1.0;
6442 assert!(close(v, 1.59150533923));
6443 let mut v = arr.get(3, 0);
6444 v += 1.0;
6445 assert!(close(v, 1.39302968671));
6446 let mut v = arr.get(4, 0);
6447 v += 1.0;
6448 assert!(close(v, 1.27046020836));
6449 let mut v = arr.get(5, 0);
6450 v += 1.0;
6451 assert!(close(v, 1.96952715609));
6452 }
6453
6454
6455
6456 #[test]
6457 fn test_index_unsafe_9() {
6458
6459 let mut arr = Array::from(vec![0.8838213961957216,
6460 0.7310938683329141,
6461 0.591505339227943,
6462 0.3930296867058841,
6463 0.27046020836139695,
6464 0.9695271560912553]);
6465 arr.reshape(1, 6);
6466
6467 unsafe {
6468 assert!(close(arr.get_unchecked(0, 0), 0.883821396196));
6469 };
6470 unsafe {
6471 assert!(close(arr.get_unchecked(0, 1), 0.731093868333));
6472 };
6473 unsafe {
6474 assert!(close(arr.get_unchecked(0, 2), 0.591505339228));
6475 };
6476 unsafe {
6477 assert!(close(arr.get_unchecked(0, 3), 0.393029686706));
6478 };
6479 unsafe {
6480 assert!(close(arr.get_unchecked(0, 4), 0.270460208361));
6481 };
6482 unsafe {
6483 assert!(close(arr.get_unchecked(0, 5), 0.969527156091));
6484 };
6485 }
6486
6487
6488
6489 #[test]
6490 fn test_index_transpose_unsafe_9() {
6491
6492 let mut arr = Array::from(vec![0.8838213961957216,
6493 0.7310938683329141,
6494 0.591505339227943,
6495 0.3930296867058841,
6496 0.27046020836139695,
6497 0.9695271560912553]);
6498 arr.reshape(1, 6);
6499
6500 let arr = arr.T();
6501 unsafe {
6502 assert!(close(arr.get_unchecked(0, 0), 0.883821396196));
6503 };
6504 unsafe {
6505 assert!(close(arr.get_unchecked(1, 0), 0.731093868333));
6506 };
6507 unsafe {
6508 assert!(close(arr.get_unchecked(2, 0), 0.591505339228));
6509 };
6510 unsafe {
6511 assert!(close(arr.get_unchecked(3, 0), 0.393029686706));
6512 };
6513 unsafe {
6514 assert!(close(arr.get_unchecked(4, 0), 0.270460208361));
6515 };
6516 unsafe {
6517 assert!(close(arr.get_unchecked(5, 0), 0.969527156091));
6518 };
6519 }
6520
6521
6522
6523 #[test]
6524 fn test_scalar_get_rows_0() {
6525
6526 let mut arr = Array::from(vec![0.3722480632739109,
6527 0.48249797217655366,
6528 0.5820075840726694,
6529 0.12173900162762719,
6530 0.3539321652146755,
6531 0.1850050587355847,
6532 0.8609992285586576]);
6533 arr.reshape(1, 7);
6534
6535 let mut result = Array::from(vec![0.3722480632739109,
6536 0.48249797217655366,
6537 0.5820075840726694,
6538 0.12173900162762719,
6539 0.3539321652146755,
6540 0.1850050587355847,
6541 0.8609992285586576]);
6542 result.reshape(1, 7);
6543
6544 let idx: usize = 0;
6545
6546 assert!(allclose(&arr.get_rows(&idx), &result));
6547 }
6548
6549
6550
6551 #[test]
6552 fn test_scalar_get_rows_1() {
6553
6554 let mut arr = Array::from(vec![0.16670442758124215,
6555 0.9809173509734783,
6556 0.5219543568353495,
6557 0.7688874271143169,
6558 0.33020029888139446,
6559 0.9140498832450512,
6560 0.8937884622689195,
6561 0.9992433283863036,
6562 0.3557146765666962,
6563 0.14757544764625197,
6564 0.4938452726563023,
6565 0.1399278194103637,
6566 0.13894021778041787,
6567 0.10644549909602319,
6568 0.11332534418104068,
6569 0.6330836000967018]);
6570 arr.reshape(4, 4);
6571
6572 let mut result = Array::from(vec![0.13894021778041787,
6573 0.10644549909602319,
6574 0.11332534418104068,
6575 0.6330836000967018]);
6576 result.reshape(1, 4);
6577
6578 let idx: usize = 3;
6579
6580 assert!(allclose(&arr.get_rows(&idx), &result));
6581 }
6582
6583
6584
6585 #[test]
6586 fn test_scalar_get_rows_2() {
6587
6588 let mut arr = Array::from(vec![0.26989012057050243,
6589 0.19514630721957138,
6590 0.9087828287867478,
6591 0.7073279384566468,
6592 0.8670738434351174,
6593 0.20551684587161345,
6594 0.23736843669262042,
6595 0.8825217634984357,
6596 0.9967793452074264,
6597 0.9607407952348515,
6598 0.5016280907924334,
6599 0.3863801399925716,
6600 0.40457003033682537,
6601 0.7568353115420497,
6602 0.23408554719273722,
6603 0.7778764933399568]);
6604 arr.reshape(8, 2);
6605
6606 let mut result = Array::from(vec![0.9087828287867478, 0.7073279384566468]);
6607 result.reshape(1, 2);
6608
6609 let idx: usize = 1;
6610
6611 assert!(allclose(&arr.get_rows(&idx), &result));
6612 }
6613
6614
6615
6616 #[test]
6617 fn test_scalar_get_rows_3() {
6618
6619 let mut arr = Array::from(vec![0.5844832321191438,
6620 0.4503348688179716,
6621 0.13646171935781248,
6622 0.8044103204618683,
6623 0.014390653665222297,
6624 0.2191313304598439,
6625 0.6137879456561219,
6626 0.9673146277449449,
6627 0.9094277994690535,
6628 0.923587539666623,
6629 0.6570233338121578,
6630 0.18803787926140947]);
6631 arr.reshape(4, 3);
6632
6633 let mut result =
6634 Array::from(vec![0.8044103204618683, 0.014390653665222297, 0.2191313304598439]);
6635 result.reshape(1, 3);
6636
6637 let idx: usize = 1;
6638
6639 assert!(allclose(&arr.get_rows(&idx), &result));
6640 }
6641
6642
6643
6644 #[test]
6645 fn test_scalar_get_rows_4() {
6646
6647 let mut arr = Array::from(vec![0.2397046682128683,
6648 0.12059059016191787,
6649 0.4400190962098014,
6650 0.7821202495865915,
6651 0.43502082593671665,
6652 0.8710523086890986,
6653 0.27462666577600936,
6654 0.4737198628516651,
6655 0.779403312554097,
6656 0.8497818487077968,
6657 0.4585144543444213,
6658 0.6566950512254239,
6659 0.7714250944269657,
6660 0.629090962649588,
6661 0.20490665514239403,
6662 0.8472739199350465,
6663 0.8382349609471311,
6664 0.41058660070453323,
6665 0.6627993636988255,
6666 0.4272446641429759,
6667 0.5790230468688655,
6668 0.5194114756785692,
6669 0.13428662473013508,
6670 0.9410554241236381,
6671 0.22547806367281786,
6672 0.8831624935411332,
6673 0.2428643127508242,
6674 0.23826687309168026,
6675 0.6908727281613396,
6676 0.8711031906585175,
6677 0.17951077959070694,
6678 0.45117215797109533,
6679 0.1864955345396303,
6680 0.9834791816066387,
6681 0.48963697623625646,
6682 0.8287057473069219,
6683 0.3838953307927665,
6684 0.053125704439537236,
6685 0.29116373677210794,
6686 0.941779753628731,
6687 0.013885558608201398,
6688 0.6695737944604466,
6689 0.9767080260738779,
6690 0.3905862231789099,
6691 0.3140191121443441,
6692 0.24744334004685142,
6693 0.394621332891979,
6694 0.15634518603333325,
6695 0.3205295548163746,
6696 0.5068037073961843,
6697 0.47478726211958033,
6698 0.6019871405304179,
6699 0.8206113642862755,
6700 0.3086874205021116]);
6701 arr.reshape(9, 6);
6702
6703 let mut result = Array::from(vec![0.2397046682128683,
6704 0.12059059016191787,
6705 0.4400190962098014,
6706 0.7821202495865915,
6707 0.43502082593671665,
6708 0.8710523086890986]);
6709 result.reshape(1, 6);
6710
6711 let idx: usize = 0;
6712
6713 assert!(allclose(&arr.get_rows(&idx), &result));
6714 }
6715
6716
6717
6718 #[test]
6719 fn test_scalar_get_rows_5() {
6720
6721 let mut arr = Array::from(vec![0.49632664377337465,
6722 0.3719845767674499,
6723 0.37053512307586267,
6724 0.3063503408877194,
6725 0.4222632051696087]);
6726 arr.reshape(5, 1);
6727
6728 let mut result = Array::from(vec![0.4222632051696087]);
6729 result.reshape(1, 1);
6730
6731 let idx: usize = 4;
6732
6733 assert!(allclose(&arr.get_rows(&idx), &result));
6734 }
6735
6736
6737
6738 #[test]
6739 fn test_scalar_get_rows_6() {
6740
6741 let mut arr = Array::from(vec![0.2579576201021455,
6742 0.5187867882127396,
6743 0.19431182767596933,
6744 0.4853530731493949,
6745 0.5800636798501165,
6746 0.5935396495668448,
6747 0.7818523710669958,
6748 0.6132598583687154,
6749 0.6494647210287537,
6750 0.5815011751052933,
6751 0.36488424933613706,
6752 0.19940341495893144,
6753 0.6430731579879294,
6754 0.2231986815293715,
6755 0.5794192953806522,
6756 0.8491681513249606,
6757 0.5590567778062495,
6758 0.16413498179673358]);
6759 arr.reshape(3, 6);
6760
6761 let mut result = Array::from(vec![0.6430731579879294,
6762 0.2231986815293715,
6763 0.5794192953806522,
6764 0.8491681513249606,
6765 0.5590567778062495,
6766 0.16413498179673358]);
6767 result.reshape(1, 6);
6768
6769 let idx: usize = 2;
6770
6771 assert!(allclose(&arr.get_rows(&idx), &result));
6772 }
6773
6774
6775
6776 #[test]
6777 fn test_scalar_get_rows_7() {
6778
6779 let mut arr = Array::from(vec![0.0003004822330865409,
6780 0.599644854758037,
6781 0.9066722654745323,
6782 0.12616649234955135,
6783 0.2534106622805612,
6784 0.9164076040760916,
6785 0.20340819793158404,
6786 0.7320736399666427,
6787 0.5683945013977814,
6788 0.23072766845419346,
6789 0.7938839212240894,
6790 0.47344349796693097,
6791 0.8383480152551277,
6792 0.48575519261064704,
6793 0.7853055020747374,
6794 0.40113284411194683,
6795 0.8482045983316658,
6796 0.7943761574061883,
6797 0.470393509932051,
6798 0.13830664250813218,
6799 0.015439826684317759,
6800 0.5608858777071175,
6801 0.1771614502126876,
6802 0.7044040681265694,
6803 0.09777558221533078,
6804 0.21432627220156175,
6805 0.07768823652706491,
6806 0.6298968348041116,
6807 0.5068347570793338,
6808 0.8804620017635494,
6809 0.9712860082615138,
6810 0.17783419253812272,
6811 0.5936442286236709,
6812 0.8849029635338052,
6813 0.9698629174778053,
6814 0.867364503753128,
6815 0.29225868007766787,
6816 0.8942658646465623,
6817 0.3302812009351821,
6818 0.6424149581009345,
6819 0.7006204805735523,
6820 0.061902304150032506,
6821 0.13803559152972933,
6822 0.3442386295139299,
6823 0.19841689104524585,
6824 0.030700064583753628,
6825 0.9033796569089796,
6826 0.27420842487171393,
6827 0.5110210625290373]);
6828 arr.reshape(7, 7);
6829
6830 let mut result = Array::from(vec![0.5068347570793338,
6831 0.8804620017635494,
6832 0.9712860082615138,
6833 0.17783419253812272,
6834 0.5936442286236709,
6835 0.8849029635338052,
6836 0.9698629174778053]);
6837 result.reshape(1, 7);
6838
6839 let idx: usize = 4;
6840
6841 assert!(allclose(&arr.get_rows(&idx), &result));
6842 }
6843
6844
6845
6846 #[test]
6847 fn test_scalar_get_rows_8() {
6848
6849 let mut arr = Array::from(vec![0.931526619904902,
6850 0.28768586515767547,
6851 0.7414423543862344,
6852 0.4062206036800229,
6853 0.2557090044121624,
6854 0.6404601813355759,
6855 0.03727392470604762,
6856 0.5473945412299315,
6857 0.9650248941651993,
6858 0.6874838609580888,
6859 0.27640726332886334,
6860 0.9906692306763057,
6861 0.809775187614569,
6862 0.005625003712199317,
6863 0.7514209327286175,
6864 0.7704877295307784,
6865 0.4049076312518529,
6866 0.7781298308142054,
6867 0.8169347786156945,
6868 0.13463958039956947,
6869 0.06395392493747731,
6870 0.8362206409319478,
6871 0.11603620710083096,
6872 0.708130338663838,
6873 0.4552777547181637,
6874 0.9371679662979221,
6875 0.4820369439007033,
6876 0.48165707398977875,
6877 0.6823571469673899,
6878 0.3811314781909264,
6879 0.6362682433519532,
6880 0.8706117127113122,
6881 0.3738584026965758,
6882 0.03855252280591348,
6883 0.2507708970035266,
6884 0.870001531720022,
6885 0.6412087161983915,
6886 0.6211277966332598,
6887 0.34025327585085585,
6888 0.7977161831745702,
6889 0.29715686603486524,
6890 0.045924417571815646]);
6891 arr.reshape(7, 6);
6892
6893 let mut result = Array::from(vec![0.809775187614569,
6894 0.005625003712199317,
6895 0.7514209327286175,
6896 0.7704877295307784,
6897 0.4049076312518529,
6898 0.7781298308142054]);
6899 result.reshape(1, 6);
6900
6901 let idx: usize = 2;
6902
6903 assert!(allclose(&arr.get_rows(&idx), &result));
6904 }
6905
6906
6907
6908 #[test]
6909 fn test_scalar_get_rows_9() {
6910
6911 let mut arr = Array::from(vec![0.20868550871724179,
6912 0.5605127695203469,
6913 0.339804058118506,
6914 0.7256905381163948,
6915 0.6611417510563221,
6916 0.969019548886142,
6917 0.8471190899730158,
6918 0.4380513125992891,
6919 0.8646212553805457,
6920 0.6487929773201981,
6921 0.6937440457173739,
6922 0.9679474559715064,
6923 0.24340259978189238,
6924 0.7870005431727255,
6925 0.6427913578996599,
6926 0.6660887992362555,
6927 0.40442105665544525,
6928 0.12523251977686645,
6929 0.837216006531832,
6930 0.16563066983169672,
6931 0.6202657886890243,
6932 0.5242136939252772,
6933 0.35801788839394355,
6934 0.11278053040947844]);
6935 arr.reshape(6, 4);
6936
6937 let mut result = Array::from(vec![0.40442105665544525,
6938 0.12523251977686645,
6939 0.837216006531832,
6940 0.16563066983169672]);
6941 result.reshape(1, 4);
6942
6943 let idx: usize = 4;
6944
6945 assert!(allclose(&arr.get_rows(&idx), &result));
6946 }
6947
6948
6949
6950 #[test]
6951 fn test_scalar_get_rows_transpose_0() {
6952
6953 let mut arr = Array::from(vec![0.7707843100914994,
6954 0.25091438495265406,
6955 0.8799693575880421,
6956 0.28563785932012686,
6957 0.697387193772135,
6958 0.5745064605630149,
6959 0.3904684326376954,
6960 0.28571568506794665,
6961 0.19545894929132046,
6962 0.6664775490939762,
6963 0.8209682309863416,
6964 0.3129695667863188,
6965 0.28191295400607375,
6966 0.18339346264137957,
6967 0.8465732304205962,
6968 0.9730523995670246,
6969 0.2109218243532145,
6970 0.49922436813494864]);
6971 arr.reshape(3, 6);
6972 arr = arr.T();
6973
6974 let mut result =
6975 Array::from(vec![0.5745064605630149, 0.3129695667863188, 0.49922436813494864]);
6976 result.reshape(1, 3);
6977
6978 let idx: usize = 5;
6979
6980 assert!(result.rows() == arr.get_rows(&idx).rows());
6981 assert!(result.cols() == arr.get_rows(&idx).cols());
6982
6983 assert!(allclose(&arr.get_rows(&idx), &result));
6984 }
6985
6986
6987
6988 #[test]
6989 fn test_scalar_get_rows_transpose_1() {
6990
6991 let mut arr = Array::from(vec![0.8594613111600163,
6992 0.14690297325717538,
6993 0.36217549328710164,
6994 0.6272167734212485,
6995 0.9673960754471982,
6996 0.2802010597596365,
6997 0.6460370890906921,
6998 0.43445879437479584,
6999 0.36081982771335175,
7000 0.44704186652259914,
7001 0.9154543840398504,
7002 0.3032997978422961,
7003 0.30700592101137414,
7004 0.886361245126547,
7005 0.19701898755505798]);
7006 arr.reshape(3, 5);
7007 arr = arr.T();
7008
7009 let mut result =
7010 Array::from(vec![0.36217549328710164, 0.43445879437479584, 0.30700592101137414]);
7011 result.reshape(1, 3);
7012
7013 let idx: usize = 2;
7014
7015 assert!(result.rows() == arr.get_rows(&idx).rows());
7016 assert!(result.cols() == arr.get_rows(&idx).cols());
7017
7018 assert!(allclose(&arr.get_rows(&idx), &result));
7019 }
7020
7021
7022
7023 #[test]
7024 fn test_scalar_get_rows_transpose_2() {
7025
7026 let mut arr = Array::from(vec![0.9541227305606255,
7027 0.6436514862833917,
7028 0.05859880017805563,
7029 0.23740708112108921,
7030 0.6072948457117148,
7031 0.5153597444844064,
7032 0.7587734480095167,
7033 0.23496117804708339,
7034 0.7771437499400726,
7035 0.7706168427008873,
7036 0.43584816639713464,
7037 0.703954723101276,
7038 0.9577244694951818,
7039 0.7946375870867021,
7040 0.10922041808660654,
7041 0.819411678218866,
7042 0.6355308938638995,
7043 0.06877967645041005,
7044 0.3811764684296527,
7045 0.9921908931812915,
7046 0.8527221762738942,
7047 0.03496940112518232,
7048 0.22919479317057834,
7049 0.6380091288901746,
7050 0.03329140891772331,
7051 0.4434655962686078,
7052 0.6140546880271847,
7053 0.6049292778513715,
7054 0.8845983157047473,
7055 0.5187565119910739,
7056 0.45958691213113745,
7057 0.317342479918148,
7058 0.4536731172546462,
7059 0.1942795849181388,
7060 0.13596727707476342,
7061 0.007921842826076553,
7062 0.290848054525918,
7063 0.8171792662661755,
7064 0.028357492411058116,
7065 0.695459635030089,
7066 0.9297292850189345,
7067 0.8283853636719709,
7068 0.6896760468575567,
7069 0.5004061928319378,
7070 0.5655060981307017,
7071 0.5120046968859553,
7072 0.2870811351605541,
7073 0.49104494765902285,
7074 0.3042674258735121,
7075 0.9202396671021099,
7076 0.3701132534793684,
7077 0.28934686211569405,
7078 0.5596495519904526,
7079 0.4485370611544647,
7080 0.5827264812049985,
7081 0.4317454997180723,
7082 0.6406673646590401,
7083 0.03728142071869567,
7084 0.857937152947629,
7085 0.6171188866116344,
7086 0.5232003602724022,
7087 0.26352030884203537,
7088 0.5328790292223157,
7089 0.33551305279647825,
7090 0.3073471457584256,
7091 0.09859015258325021,
7092 0.3773165596884256,
7093 0.58367287565519,
7094 0.9674106150793919,
7095 0.4382350150053752,
7096 0.6841041985442428,
7097 0.5190145970051133]);
7098 arr.reshape(9, 8);
7099 arr = arr.T();
7100
7101 let mut result = Array::from(vec![0.23496117804708339,
7102 0.819411678218866,
7103 0.6380091288901746,
7104 0.317342479918148,
7105 0.695459635030089,
7106 0.49104494765902285,
7107 0.4317454997180723,
7108 0.33551305279647825,
7109 0.5190145970051133]);
7110 result.reshape(1, 9);
7111
7112 let idx: usize = 7;
7113
7114 assert!(result.rows() == arr.get_rows(&idx).rows());
7115 assert!(result.cols() == arr.get_rows(&idx).cols());
7116
7117 assert!(allclose(&arr.get_rows(&idx), &result));
7118 }
7119
7120
7121
7122 #[test]
7123 fn test_scalar_get_rows_transpose_3() {
7124
7125 let mut arr = Array::from(vec![0.11150410087280771,
7126 0.8096039756173166,
7127 0.5744293231689495,
7128 0.059355119750942986,
7129 0.7842416618915636,
7130 0.3698268883505256,
7131 0.6987867634920802,
7132 0.9850152274624763,
7133 0.794244913511597,
7134 0.025396092650194824,
7135 0.01084474325417173,
7136 0.0022690198050676624,
7137 0.2921005452564077,
7138 0.7779608346761091,
7139 0.7022235820264277,
7140 0.33857628541159523,
7141 0.21168576739457567,
7142 0.5127633258342936,
7143 0.7148059326047405,
7144 0.02933047462391103,
7145 0.37277204859284707,
7146 0.2622751957229126,
7147 0.769345021219707,
7148 0.8241687223332037,
7149 0.6480223588154045,
7150 0.42766567757621143,
7151 0.16057617377570332]);
7152 arr.reshape(3, 9);
7153 arr = arr.T();
7154
7155 let mut result =
7156 Array::from(vec![0.5744293231689495, 0.0022690198050676624, 0.37277204859284707]);
7157 result.reshape(1, 3);
7158
7159 let idx: usize = 2;
7160
7161 assert!(result.rows() == arr.get_rows(&idx).rows());
7162 assert!(result.cols() == arr.get_rows(&idx).cols());
7163
7164 assert!(allclose(&arr.get_rows(&idx), &result));
7165 }
7166
7167
7168
7169 #[test]
7170 fn test_scalar_get_rows_transpose_4() {
7171
7172 let mut arr = Array::from(vec![0.6558098708625699,
7173 0.47151809331807215,
7174 0.05884612525722377,
7175 0.5240257710120293,
7176 0.9370667780812278,
7177 0.7657489477793658,
7178 0.5760646653908316,
7179 0.9256479511538042,
7180 0.4108022698020962,
7181 0.547463796860828,
7182 0.5696259018989306,
7183 0.5318535519727353]);
7184 arr.reshape(3, 4);
7185 arr = arr.T();
7186
7187 let mut result =
7188 Array::from(vec![0.6558098708625699, 0.9370667780812278, 0.4108022698020962]);
7189 result.reshape(1, 3);
7190
7191 let idx: usize = 0;
7192
7193 assert!(result.rows() == arr.get_rows(&idx).rows());
7194 assert!(result.cols() == arr.get_rows(&idx).cols());
7195
7196 assert!(allclose(&arr.get_rows(&idx), &result));
7197 }
7198
7199
7200
7201 #[test]
7202 fn test_scalar_get_rows_transpose_5() {
7203
7204 let mut arr = Array::from(vec![0.1676678409149912,
7205 0.861383405027676,
7206 0.9216207547768913,
7207 0.6191954561476947,
7208 0.12362933806379073,
7209 0.44381481157270497,
7210 0.19877703470687746,
7211 0.14107562648466954,
7212 0.6710861414183165,
7213 0.24887924418424412,
7214 0.36999837265698077,
7215 0.34671285416782716,
7216 0.8249131922342992,
7217 0.841648699352834]);
7218 arr.reshape(2, 7);
7219 arr = arr.T();
7220
7221 let mut result = Array::from(vec![0.6191954561476947, 0.36999837265698077]);
7222 result.reshape(1, 2);
7223
7224 let idx: usize = 3;
7225
7226 assert!(result.rows() == arr.get_rows(&idx).rows());
7227 assert!(result.cols() == arr.get_rows(&idx).cols());
7228
7229 assert!(allclose(&arr.get_rows(&idx), &result));
7230 }
7231
7232
7233
7234 #[test]
7235 fn test_scalar_get_rows_transpose_6() {
7236
7237 let mut arr = Array::from(vec![0.3678106032600512,
7238 0.9177846520753015,
7239 0.7063829900311207,
7240 0.13420500263139923,
7241 0.09380833093393104,
7242 0.8015041392130045,
7243 0.49066927237870794,
7244 0.5416854778529434]);
7245 arr.reshape(4, 2);
7246 arr = arr.T();
7247
7248 let mut result = Array::from(vec![0.3678106032600512,
7249 0.7063829900311207,
7250 0.09380833093393104,
7251 0.49066927237870794]);
7252 result.reshape(1, 4);
7253
7254 let idx: usize = 0;
7255
7256 assert!(result.rows() == arr.get_rows(&idx).rows());
7257 assert!(result.cols() == arr.get_rows(&idx).cols());
7258
7259 assert!(allclose(&arr.get_rows(&idx), &result));
7260 }
7261
7262
7263
7264 #[test]
7265 fn test_scalar_get_rows_transpose_7() {
7266
7267 let mut arr = Array::from(vec![0.2718385852867393,
7268 0.013460642713719828,
7269 0.12798750635805256,
7270 0.7919986749289545,
7271 0.9391186519981108,
7272 0.9806978175296652,
7273 0.48024033473364547,
7274 0.1669245810689408,
7275 0.6801699678508741,
7276 0.9490436766686265,
7277 0.44904300995572166,
7278 0.23258694099688615,
7279 0.7220265418019424,
7280 0.14200835687922775,
7281 0.10019118536548222,
7282 0.6312223198556238,
7283 0.09417371194068569,
7284 0.13715955368621513,
7285 0.9505754201392806,
7286 0.6387252873419664,
7287 0.9996498787040119,
7288 0.7780565108493451,
7289 0.016974953804198112,
7290 0.2079781316192134,
7291 0.1272207720538362,
7292 0.5722512148113048,
7293 0.9093077469603993,
7294 0.8031151814245743,
7295 0.7878095174291018,
7296 0.68571961443512,
7297 0.2304103778988914,
7298 0.9477147799579432,
7299 0.04830228168121298,
7300 0.23860575739602574,
7301 0.4924570255163495,
7302 0.8433460131727744]);
7303 arr.reshape(6, 6);
7304 arr = arr.T();
7305
7306 let mut result = Array::from(vec![0.2718385852867393,
7307 0.48024033473364547,
7308 0.7220265418019424,
7309 0.9505754201392806,
7310 0.1272207720538362,
7311 0.2304103778988914]);
7312 result.reshape(1, 6);
7313
7314 let idx: usize = 0;
7315
7316 assert!(result.rows() == arr.get_rows(&idx).rows());
7317 assert!(result.cols() == arr.get_rows(&idx).cols());
7318
7319 assert!(allclose(&arr.get_rows(&idx), &result));
7320 }
7321
7322
7323
7324 #[test]
7325 fn test_scalar_get_rows_transpose_8() {
7326
7327 let mut arr = Array::from(vec![0.7585933989589557,
7328 0.29088432020241584,
7329 0.7643341872939214,
7330 0.836775218001464,
7331 0.3769148476585228,
7332 0.6977319782273234,
7333 0.9199661944212296,
7334 0.4686776725666314,
7335 0.7316101282371349,
7336 0.010247040539513863,
7337 0.04393813135038249,
7338 0.5246689967353431,
7339 0.2908815249594344,
7340 0.1962702360964671,
7341 0.14616285960637965,
7342 0.26404283873074286,
7343 0.29377021478284215,
7344 0.728609074576266,
7345 0.12980871138479078,
7346 0.6287927742441822,
7347 0.1928991963488823,
7348 0.6248893174890445,
7349 0.055569813316688976,
7350 0.4193956556537305,
7351 0.755910885757368,
7352 0.23272758704023733,
7353 0.9134030871532263,
7354 0.2278706667044479,
7355 0.9689881107806262,
7356 0.3147237564886278,
7357 0.62197218783676,
7358 0.14674543088775016,
7359 0.7825943647079507,
7360 0.17626465303951122,
7361 0.031700206452515256,
7362 0.35552418832283306,
7363 0.28987457696053687,
7364 0.9213173807005415,
7365 0.22233723243411985,
7366 0.6330528087199453,
7367 0.05729903201260578,
7368 0.8950982415656692,
7369 0.6337288687754038,
7370 0.46276848503218115,
7371 0.09078810453420316,
7372 0.9821533348159726,
7373 0.7516318919626817,
7374 0.9263977611806433,
7375 0.5772193772944185,
7376 0.44456220698867976,
7377 0.11843053646665092,
7378 0.0033921197532106317,
7379 0.42989727068529604,
7380 0.4456215234976457,
7381 0.2254006325494674,
7382 0.3159194865379922]);
7383 arr.reshape(7, 8);
7384 arr = arr.T();
7385
7386 let mut result = Array::from(vec![0.4686776725666314,
7387 0.26404283873074286,
7388 0.4193956556537305,
7389 0.14674543088775016,
7390 0.6330528087199453,
7391 0.9263977611806433,
7392 0.3159194865379922]);
7393 result.reshape(1, 7);
7394
7395 let idx: usize = 7;
7396
7397 assert!(result.rows() == arr.get_rows(&idx).rows());
7398 assert!(result.cols() == arr.get_rows(&idx).cols());
7399
7400 assert!(allclose(&arr.get_rows(&idx), &result));
7401 }
7402
7403
7404
7405 #[test]
7406 fn test_scalar_get_rows_transpose_9() {
7407
7408 let mut arr = Array::from(vec![0.9058704104647929,
7409 0.9174485614828881,
7410 0.2406691976095029,
7411 0.220714202251722,
7412 0.042199568357976114,
7413 0.48665612442387685,
7414 0.7575461347311593,
7415 0.22419192871566973,
7416 0.7097752684375215,
7417 0.1925008894000757,
7418 0.47933693147499434,
7419 0.12753850011229628,
7420 0.2843434588211813,
7421 0.10319057485057492,
7422 0.32444345473467084,
7423 0.6295224472317583,
7424 0.6165680202130384,
7425 0.2385542680818219,
7426 0.129278413055962,
7427 0.9159942040797456,
7428 0.49442243513535344,
7429 0.5507984587600816,
7430 0.6474250958230049,
7431 0.8448279100953802,
7432 0.9713486908733158,
7433 0.1182634921189929,
7434 0.0448569910081652,
7435 0.15855114104871249,
7436 0.9514234005377552,
7437 0.42671958367097107,
7438 0.5068355074640134,
7439 0.025359934640823978,
7440 0.015614477870282917,
7441 0.5521159014023806,
7442 0.8069985935631249]);
7443 arr.reshape(5, 7);
7444 arr = arr.T();
7445
7446 let mut result = Array::from(vec![0.9058704104647929,
7447 0.22419192871566973,
7448 0.32444345473467084,
7449 0.5507984587600816,
7450 0.9514234005377552]);
7451 result.reshape(1, 5);
7452
7453 let idx: usize = 0;
7454
7455 assert!(result.rows() == arr.get_rows(&idx).rows());
7456 assert!(result.cols() == arr.get_rows(&idx).cols());
7457
7458 assert!(allclose(&arr.get_rows(&idx), &result));
7459 }
7460
7461
7462
7463 #[test]
7464 fn test_vector_get_rows_0() {
7465
7466 let mut arr = Array::from(vec![0.3026844973337608,
7467 0.8583123142333691,
7468 0.16731151966900837,
7469 0.33635588451063736,
7470 0.25153161820736425,
7471 0.8198965297579482,
7472 0.19126813305801438,
7473 0.13342028215153323,
7474 0.3797980276515116,
7475 0.4900123765802087,
7476 0.616117445213224,
7477 0.1828317097820401,
7478 0.5898986540355099,
7479 0.3692672059112524,
7480 0.6908363003317866,
7481 0.9633087827572147,
7482 0.163924010361174,
7483 0.787286431532979,
7484 0.0062766626905627065,
7485 0.011035925966384141,
7486 0.1510046354942679,
7487 0.14695199875222964,
7488 0.9807243048269062,
7489 0.12424636914338416,
7490 0.6790951821322875,
7491 0.8923964585077467,
7492 0.739767274915941,
7493 0.010890909522523917,
7494 0.6574676777099638,
7495 0.6136875926278141,
7496 0.4347439135955087,
7497 0.8487007059005109,
7498 0.5333639316338004,
7499 0.967014539220958,
7500 0.40717927241375096,
7501 0.5224381236816471,
7502 0.06735827556768936,
7503 0.9123264304961389,
7504 0.9182013378973746,
7505 0.9388849921242717,
7506 0.5490865080468417,
7507 0.4681106050264714,
7508 0.8696358174378072,
7509 0.9809946801858267,
7510 0.7491782709821655,
7511 0.5770106605516356,
7512 0.02573069722647492,
7513 0.996612204499,
7514 0.9429686133491813,
7515 0.8358333441720264,
7516 0.33798216924245283,
7517 0.7930204735387772,
7518 0.6955254885973183,
7519 0.09245543915764765]);
7520 arr.reshape(6, 9);
7521
7522 let mut result = Array::from(vec![0.010890909522523917,
7523 0.6574676777099638,
7524 0.6136875926278141,
7525 0.4347439135955087,
7526 0.8487007059005109,
7527 0.5333639316338004,
7528 0.967014539220958,
7529 0.40717927241375096,
7530 0.5224381236816471,
7531 0.3026844973337608,
7532 0.8583123142333691,
7533 0.16731151966900837,
7534 0.33635588451063736,
7535 0.25153161820736425,
7536 0.8198965297579482,
7537 0.19126813305801438,
7538 0.13342028215153323,
7539 0.3797980276515116,
7540 0.5770106605516356,
7541 0.02573069722647492,
7542 0.996612204499,
7543 0.9429686133491813,
7544 0.8358333441720264,
7545 0.33798216924245283,
7546 0.7930204735387772,
7547 0.6955254885973183,
7548 0.09245543915764765,
7549 0.3026844973337608,
7550 0.8583123142333691,
7551 0.16731151966900837,
7552 0.33635588451063736,
7553 0.25153161820736425,
7554 0.8198965297579482,
7555 0.19126813305801438,
7556 0.13342028215153323,
7557 0.3797980276515116,
7558 0.5770106605516356,
7559 0.02573069722647492,
7560 0.996612204499,
7561 0.9429686133491813,
7562 0.8358333441720264,
7563 0.33798216924245283,
7564 0.7930204735387772,
7565 0.6955254885973183,
7566 0.09245543915764765,
7567 0.4900123765802087,
7568 0.616117445213224,
7569 0.1828317097820401,
7570 0.5898986540355099,
7571 0.3692672059112524,
7572 0.6908363003317866,
7573 0.9633087827572147,
7574 0.163924010361174,
7575 0.787286431532979,
7576 0.3026844973337608,
7577 0.8583123142333691,
7578 0.16731151966900837,
7579 0.33635588451063736,
7580 0.25153161820736425,
7581 0.8198965297579482,
7582 0.19126813305801438,
7583 0.13342028215153323,
7584 0.3797980276515116,
7585 0.0062766626905627065,
7586 0.011035925966384141,
7587 0.1510046354942679,
7588 0.14695199875222964,
7589 0.9807243048269062,
7590 0.12424636914338416,
7591 0.6790951821322875,
7592 0.8923964585077467,
7593 0.739767274915941,
7594 0.4900123765802087,
7595 0.616117445213224,
7596 0.1828317097820401,
7597 0.5898986540355099,
7598 0.3692672059112524,
7599 0.6908363003317866,
7600 0.9633087827572147,
7601 0.163924010361174,
7602 0.787286431532979,
7603 0.3026844973337608,
7604 0.8583123142333691,
7605 0.16731151966900837,
7606 0.33635588451063736,
7607 0.25153161820736425,
7608 0.8198965297579482,
7609 0.19126813305801438,
7610 0.13342028215153323,
7611 0.3797980276515116,
7612 0.3026844973337608,
7613 0.8583123142333691,
7614 0.16731151966900837,
7615 0.33635588451063736,
7616 0.25153161820736425,
7617 0.8198965297579482,
7618 0.19126813305801438,
7619 0.13342028215153323,
7620 0.3797980276515116,
7621 0.0062766626905627065,
7622 0.011035925966384141,
7623 0.1510046354942679,
7624 0.14695199875222964,
7625 0.9807243048269062,
7626 0.12424636914338416,
7627 0.6790951821322875,
7628 0.8923964585077467,
7629 0.739767274915941,
7630 0.06735827556768936,
7631 0.9123264304961389,
7632 0.9182013378973746,
7633 0.9388849921242717,
7634 0.5490865080468417,
7635 0.4681106050264714,
7636 0.8696358174378072,
7637 0.9809946801858267,
7638 0.7491782709821655,
7639 0.5770106605516356,
7640 0.02573069722647492,
7641 0.996612204499,
7642 0.9429686133491813,
7643 0.8358333441720264,
7644 0.33798216924245283,
7645 0.7930204735387772,
7646 0.6955254885973183,
7647 0.09245543915764765,
7648 0.3026844973337608,
7649 0.8583123142333691,
7650 0.16731151966900837,
7651 0.33635588451063736,
7652 0.25153161820736425,
7653 0.8198965297579482,
7654 0.19126813305801438,
7655 0.13342028215153323,
7656 0.3797980276515116,
7657 0.3026844973337608,
7658 0.8583123142333691,
7659 0.16731151966900837,
7660 0.33635588451063736,
7661 0.25153161820736425,
7662 0.8198965297579482,
7663 0.19126813305801438,
7664 0.13342028215153323,
7665 0.3797980276515116,
7666 0.010890909522523917,
7667 0.6574676777099638,
7668 0.6136875926278141,
7669 0.4347439135955087,
7670 0.8487007059005109,
7671 0.5333639316338004,
7672 0.967014539220958,
7673 0.40717927241375096,
7674 0.5224381236816471,
7675 0.5770106605516356,
7676 0.02573069722647492,
7677 0.996612204499,
7678 0.9429686133491813,
7679 0.8358333441720264,
7680 0.33798216924245283,
7681 0.7930204735387772,
7682 0.6955254885973183,
7683 0.09245543915764765]);
7684 result.reshape(18, 9);
7685
7686 let row_indices = vec![3, 0, 5, 0, 5, 1, 0, 2, 1, 0, 0, 2, 4, 5, 0, 0, 3, 5];
7687
7688 assert!(allclose(&arr.get_rows(&row_indices), &result));
7689 }
7690
7691
7692
7693 #[test]
7694 fn test_vector_get_rows_1() {
7695
7696 let mut arr = Array::from(vec![0.40258765614931946,
7697 0.8648480271843979,
7698 0.6708914564572481,
7699 0.06757502395018489,
7700 0.4413393834989374,
7701 0.08968535802444089,
7702 0.8213416852040862,
7703 0.457376335302924,
7704 0.23855110040042882,
7705 0.616438629950499,
7706 0.5387156695241515,
7707 0.37018301896466577,
7708 0.6912342106136757,
7709 0.5195059603022482,
7710 0.0724011456810435,
7711 0.13496393429333542]);
7712 arr.reshape(2, 8);
7713
7714 let mut result = Array::from(vec![0.23855110040042882,
7715 0.616438629950499,
7716 0.5387156695241515,
7717 0.37018301896466577,
7718 0.6912342106136757,
7719 0.5195059603022482,
7720 0.0724011456810435,
7721 0.13496393429333542,
7722 0.40258765614931946,
7723 0.8648480271843979,
7724 0.6708914564572481,
7725 0.06757502395018489,
7726 0.4413393834989374,
7727 0.08968535802444089,
7728 0.8213416852040862,
7729 0.457376335302924,
7730 0.40258765614931946,
7731 0.8648480271843979,
7732 0.6708914564572481,
7733 0.06757502395018489,
7734 0.4413393834989374,
7735 0.08968535802444089,
7736 0.8213416852040862,
7737 0.457376335302924,
7738 0.40258765614931946,
7739 0.8648480271843979,
7740 0.6708914564572481,
7741 0.06757502395018489,
7742 0.4413393834989374,
7743 0.08968535802444089,
7744 0.8213416852040862,
7745 0.457376335302924,
7746 0.23855110040042882,
7747 0.616438629950499,
7748 0.5387156695241515,
7749 0.37018301896466577,
7750 0.6912342106136757,
7751 0.5195059603022482,
7752 0.0724011456810435,
7753 0.13496393429333542,
7754 0.23855110040042882,
7755 0.616438629950499,
7756 0.5387156695241515,
7757 0.37018301896466577,
7758 0.6912342106136757,
7759 0.5195059603022482,
7760 0.0724011456810435,
7761 0.13496393429333542]);
7762 result.reshape(6, 8);
7763
7764 let row_indices = vec![1, 0, 0, 0, 1, 1];
7765
7766 assert!(allclose(&arr.get_rows(&row_indices), &result));
7767 }
7768
7769
7770
7771 #[test]
7772 fn test_vector_get_rows_2() {
7773
7774 let mut arr = Array::from(vec![0.7146019424816038,
7775 0.7604593963908357,
7776 0.547861287122224,
7777 0.806551731427299,
7778 0.8976235506641399,
7779 0.837475405322677]);
7780 arr.reshape(3, 2);
7781
7782 let mut result = Array::from(vec![0.8976235506641399,
7783 0.837475405322677,
7784 0.8976235506641399,
7785 0.837475405322677,
7786 0.8976235506641399,
7787 0.837475405322677,
7788 0.7146019424816038,
7789 0.7604593963908357,
7790 0.547861287122224,
7791 0.806551731427299,
7792 0.8976235506641399,
7793 0.837475405322677,
7794 0.8976235506641399,
7795 0.837475405322677,
7796 0.8976235506641399,
7797 0.837475405322677,
7798 0.7146019424816038,
7799 0.7604593963908357]);
7800 result.reshape(9, 2);
7801
7802 let row_indices = vec![2, 2, 2, 0, 1, 2, 2, 2, 0];
7803
7804 assert!(allclose(&arr.get_rows(&row_indices), &result));
7805 }
7806
7807
7808
7809 #[test]
7810 fn test_vector_get_rows_3() {
7811
7812 let mut arr = Array::from(vec![0.2505884199600942,
7813 0.49024553437887664,
7814 0.144728966583754,
7815 0.6285692473489818,
7816 0.6366624500674968,
7817 0.5259820200687467,
7818 0.6229188777968119,
7819 0.1108941671517305,
7820 0.9981887673808209,
7821 0.695013205184841,
7822 0.8430025598280413,
7823 0.06877934668725594,
7824 0.1865271289078707,
7825 0.834327304480662,
7826 0.6973326180719766,
7827 0.7337671453471607,
7828 0.06550764176187263,
7829 0.3121230981253994,
7830 0.695656664836412,
7831 0.3669402084032456,
7832 0.9234219334387136,
7833 0.4627697526924629,
7834 0.10224532398210873,
7835 0.2849527838404887,
7836 0.4057823573720447,
7837 0.18238603082813143,
7838 0.412660297610816,
7839 0.856733381427474,
7840 0.6539807660395075,
7841 0.5551732967298979,
7842 0.4380490943165041,
7843 0.889643380848384,
7844 0.4817776492498722,
7845 0.5983094652632307,
7846 0.2623658934182619,
7847 0.23962451838010246,
7848 0.00884989893626087,
7849 0.9057841488055146,
7850 0.24524862385794655,
7851 0.9715877319119964,
7852 0.26277368049984917,
7853 0.7770402747102846,
7854 0.6565242488306049,
7855 0.5284852136062448,
7856 0.18581485402229525,
7857 0.8242536596595306,
7858 0.9554458372087256,
7859 0.1590267262839623]);
7860 arr.reshape(8, 6);
7861
7862 let mut result = Array::from(vec![0.695656664836412,
7863 0.3669402084032456,
7864 0.9234219334387136,
7865 0.4627697526924629,
7866 0.10224532398210873,
7867 0.2849527838404887,
7868 0.6565242488306049,
7869 0.5284852136062448,
7870 0.18581485402229525,
7871 0.8242536596595306,
7872 0.9554458372087256,
7873 0.1590267262839623,
7874 0.4057823573720447,
7875 0.18238603082813143,
7876 0.412660297610816,
7877 0.856733381427474,
7878 0.6539807660395075,
7879 0.5551732967298979,
7880 0.6565242488306049,
7881 0.5284852136062448,
7882 0.18581485402229525,
7883 0.8242536596595306,
7884 0.9554458372087256,
7885 0.1590267262839623,
7886 0.00884989893626087,
7887 0.9057841488055146,
7888 0.24524862385794655,
7889 0.9715877319119964,
7890 0.26277368049984917,
7891 0.7770402747102846,
7892 0.4057823573720447,
7893 0.18238603082813143,
7894 0.412660297610816,
7895 0.856733381427474,
7896 0.6539807660395075,
7897 0.5551732967298979,
7898 0.6229188777968119,
7899 0.1108941671517305,
7900 0.9981887673808209,
7901 0.695013205184841,
7902 0.8430025598280413,
7903 0.06877934668725594,
7904 0.6229188777968119,
7905 0.1108941671517305,
7906 0.9981887673808209,
7907 0.695013205184841,
7908 0.8430025598280413,
7909 0.06877934668725594,
7910 0.4057823573720447,
7911 0.18238603082813143,
7912 0.412660297610816,
7913 0.856733381427474,
7914 0.6539807660395075,
7915 0.5551732967298979,
7916 0.1865271289078707,
7917 0.834327304480662,
7918 0.6973326180719766,
7919 0.7337671453471607,
7920 0.06550764176187263,
7921 0.3121230981253994,
7922 0.6229188777968119,
7923 0.1108941671517305,
7924 0.9981887673808209,
7925 0.695013205184841,
7926 0.8430025598280413,
7927 0.06877934668725594,
7928 0.2505884199600942,
7929 0.49024553437887664,
7930 0.144728966583754,
7931 0.6285692473489818,
7932 0.6366624500674968,
7933 0.5259820200687467,
7934 0.2505884199600942,
7935 0.49024553437887664,
7936 0.144728966583754,
7937 0.6285692473489818,
7938 0.6366624500674968,
7939 0.5259820200687467,
7940 0.00884989893626087,
7941 0.9057841488055146,
7942 0.24524862385794655,
7943 0.9715877319119964,
7944 0.26277368049984917,
7945 0.7770402747102846,
7946 0.1865271289078707,
7947 0.834327304480662,
7948 0.6973326180719766,
7949 0.7337671453471607,
7950 0.06550764176187263,
7951 0.3121230981253994,
7952 0.4380490943165041,
7953 0.889643380848384,
7954 0.4817776492498722,
7955 0.5983094652632307,
7956 0.2623658934182619,
7957 0.23962451838010246,
7958 0.4380490943165041,
7959 0.889643380848384,
7960 0.4817776492498722,
7961 0.5983094652632307,
7962 0.2623658934182619,
7963 0.23962451838010246,
7964 0.2505884199600942,
7965 0.49024553437887664,
7966 0.144728966583754,
7967 0.6285692473489818,
7968 0.6366624500674968,
7969 0.5259820200687467,
7970 0.6229188777968119,
7971 0.1108941671517305,
7972 0.9981887673808209,
7973 0.695013205184841,
7974 0.8430025598280413,
7975 0.06877934668725594,
7976 0.00884989893626087,
7977 0.9057841488055146,
7978 0.24524862385794655,
7979 0.9715877319119964,
7980 0.26277368049984917,
7981 0.7770402747102846,
7982 0.4057823573720447,
7983 0.18238603082813143,
7984 0.412660297610816,
7985 0.856733381427474,
7986 0.6539807660395075,
7987 0.5551732967298979,
7988 0.6229188777968119,
7989 0.1108941671517305,
7990 0.9981887673808209,
7991 0.695013205184841,
7992 0.8430025598280413,
7993 0.06877934668725594,
7994 0.6565242488306049,
7995 0.5284852136062448,
7996 0.18581485402229525,
7997 0.8242536596595306,
7998 0.9554458372087256,
7999 0.1590267262839623,
8000 0.6229188777968119,
8001 0.1108941671517305,
8002 0.9981887673808209,
8003 0.695013205184841,
8004 0.8430025598280413,
8005 0.06877934668725594]);
8006 result.reshape(24, 6);
8007
8008 let row_indices = vec![3, 7, 4, 7, 6, 4, 1, 1, 4, 2, 1, 0, 0, 6, 2, 5, 5, 0, 1, 6, 4, 1,
8009 7, 1];
8010
8011 assert!(allclose(&arr.get_rows(&row_indices), &result));
8012 }
8013
8014
8015
8016 #[test]
8017 fn test_vector_get_rows_4() {
8018
8019 let mut arr = Array::from(vec![0.6418545486584504,
8020 0.698072460973478,
8021 0.4923078842530585,
8022 0.47437858537223776,
8023 0.7435934406874709]);
8024 arr.reshape(5, 1);
8025
8026 let mut result = Array::from(vec![0.6418545486584504,
8027 0.47437858537223776,
8028 0.7435934406874709,
8029 0.6418545486584504,
8030 0.698072460973478,
8031 0.7435934406874709,
8032 0.7435934406874709,
8033 0.47437858537223776,
8034 0.7435934406874709,
8035 0.4923078842530585,
8036 0.698072460973478,
8037 0.7435934406874709,
8038 0.7435934406874709,
8039 0.698072460973478,
8040 0.4923078842530585]);
8041 result.reshape(15, 1);
8042
8043 let row_indices = vec![0, 3, 4, 0, 1, 4, 4, 3, 4, 2, 1, 4, 4, 1, 2];
8044
8045 assert!(allclose(&arr.get_rows(&row_indices), &result));
8046 }
8047
8048
8049
8050 #[test]
8051 fn test_vector_get_rows_5() {
8052
8053 let mut arr = Array::from(vec![0.819358467518517,
8054 0.009406812625449512,
8055 0.5327024186084796,
8056 0.6398490954260115,
8057 0.32573240418057636,
8058 0.8534213204353883,
8059 0.6788630404199507,
8060 0.1737116431972744,
8061 0.33537126000813644,
8062 0.1268993925657509,
8063 0.5798735177443395,
8064 0.8622107475596431,
8065 0.9911988496391825,
8066 0.5527702746550726,
8067 0.04320273618352122,
8068 0.8123342963358758,
8069 0.5007629131321141,
8070 0.15361949182403334,
8071 0.1182076776850719,
8072 0.764703550471804]);
8073 arr.reshape(5, 4);
8074
8075 let mut result = Array::from(vec![0.819358467518517,
8076 0.009406812625449512,
8077 0.5327024186084796,
8078 0.6398490954260115,
8079 0.32573240418057636,
8080 0.8534213204353883,
8081 0.6788630404199507,
8082 0.1737116431972744,
8083 0.5007629131321141,
8084 0.15361949182403334,
8085 0.1182076776850719,
8086 0.764703550471804,
8087 0.32573240418057636,
8088 0.8534213204353883,
8089 0.6788630404199507,
8090 0.1737116431972744,
8091 0.9911988496391825,
8092 0.5527702746550726,
8093 0.04320273618352122,
8094 0.8123342963358758,
8095 0.5007629131321141,
8096 0.15361949182403334,
8097 0.1182076776850719,
8098 0.764703550471804,
8099 0.9911988496391825,
8100 0.5527702746550726,
8101 0.04320273618352122,
8102 0.8123342963358758,
8103 0.33537126000813644,
8104 0.1268993925657509,
8105 0.5798735177443395,
8106 0.8622107475596431,
8107 0.33537126000813644,
8108 0.1268993925657509,
8109 0.5798735177443395,
8110 0.8622107475596431,
8111 0.33537126000813644,
8112 0.1268993925657509,
8113 0.5798735177443395,
8114 0.8622107475596431,
8115 0.819358467518517,
8116 0.009406812625449512,
8117 0.5327024186084796,
8118 0.6398490954260115,
8119 0.32573240418057636,
8120 0.8534213204353883,
8121 0.6788630404199507,
8122 0.1737116431972744,
8123 0.819358467518517,
8124 0.009406812625449512,
8125 0.5327024186084796,
8126 0.6398490954260115,
8127 0.9911988496391825,
8128 0.5527702746550726,
8129 0.04320273618352122,
8130 0.8123342963358758,
8131 0.5007629131321141,
8132 0.15361949182403334,
8133 0.1182076776850719,
8134 0.764703550471804]);
8135 result.reshape(15, 4);
8136
8137 let row_indices = vec![0, 1, 4, 1, 3, 4, 3, 2, 2, 2, 0, 1, 0, 3, 4];
8138
8139 assert!(allclose(&arr.get_rows(&row_indices), &result));
8140 }
8141
8142
8143
8144 #[test]
8145 fn test_vector_get_rows_6() {
8146
8147 let mut arr = Array::from(vec![0.6900150631232679,
8148 0.7731518741359212,
8149 0.34912537458948045,
8150 0.1709133857024866,
8151 0.13747958011812222,
8152 0.664095105359734,
8153 0.7710649587420478,
8154 0.9962079319111661,
8155 0.7229867591675645,
8156 0.7590563174316188,
8157 0.017267460477273566,
8158 0.4925750669418595,
8159 0.6809995305980964,
8160 0.040766766137549704,
8161 0.3005275479442364,
8162 0.491532843254729,
8163 0.7006624453094809,
8164 0.0026875257677486664]);
8165 arr.reshape(9, 2);
8166
8167 let mut result = Array::from(vec![0.7710649587420478,
8168 0.9962079319111661,
8169 0.34912537458948045,
8170 0.1709133857024866,
8171 0.3005275479442364,
8172 0.491532843254729,
8173 0.017267460477273566,
8174 0.4925750669418595,
8175 0.34912537458948045,
8176 0.1709133857024866,
8177 0.7229867591675645,
8178 0.7590563174316188,
8179 0.7006624453094809,
8180 0.0026875257677486664,
8181 0.6900150631232679,
8182 0.7731518741359212,
8183 0.6809995305980964,
8184 0.040766766137549704,
8185 0.017267460477273566,
8186 0.4925750669418595,
8187 0.7229867591675645,
8188 0.7590563174316188,
8189 0.7710649587420478,
8190 0.9962079319111661,
8191 0.017267460477273566,
8192 0.4925750669418595,
8193 0.6809995305980964,
8194 0.040766766137549704,
8195 0.13747958011812222,
8196 0.664095105359734,
8197 0.7710649587420478,
8198 0.9962079319111661,
8199 0.7229867591675645,
8200 0.7590563174316188,
8201 0.3005275479442364,
8202 0.491532843254729,
8203 0.13747958011812222,
8204 0.664095105359734,
8205 0.6900150631232679,
8206 0.7731518741359212,
8207 0.13747958011812222,
8208 0.664095105359734,
8209 0.017267460477273566,
8210 0.4925750669418595,
8211 0.017267460477273566,
8212 0.4925750669418595,
8213 0.34912537458948045,
8214 0.1709133857024866,
8215 0.7229867591675645,
8216 0.7590563174316188,
8217 0.7229867591675645,
8218 0.7590563174316188,
8219 0.7006624453094809,
8220 0.0026875257677486664]);
8221 result.reshape(27, 2);
8222
8223 let row_indices = vec![3, 1, 7, 5, 1, 4, 8, 0, 6, 5, 4, 3, 5, 6, 2, 3, 4, 7, 2, 0, 2, 5,
8224 5, 1, 4, 4, 8];
8225
8226 assert!(allclose(&arr.get_rows(&row_indices), &result));
8227 }
8228
8229
8230
8231 #[test]
8232 fn test_vector_get_rows_7() {
8233
8234 let mut arr = Array::from(vec![0.9809742862124755,
8235 0.45876863559686953,
8236 0.8921192752561767,
8237 0.4496693736012606,
8238 0.8548674608930824,
8239 0.6499230764988503,
8240 0.08914519817649025,
8241 0.9742340082767662]);
8242 arr.reshape(8, 1);
8243
8244 let mut result = Array::from(vec![0.9742340082767662,
8245 0.8921192752561767,
8246 0.45876863559686953,
8247 0.9809742862124755,
8248 0.8548674608930824,
8249 0.6499230764988503,
8250 0.9809742862124755,
8251 0.8548674608930824,
8252 0.8921192752561767,
8253 0.4496693736012606,
8254 0.08914519817649025,
8255 0.45876863559686953,
8256 0.8548674608930824,
8257 0.9809742862124755,
8258 0.08914519817649025,
8259 0.45876863559686953,
8260 0.45876863559686953,
8261 0.4496693736012606,
8262 0.9809742862124755,
8263 0.08914519817649025,
8264 0.08914519817649025,
8265 0.6499230764988503,
8266 0.6499230764988503,
8267 0.45876863559686953]);
8268 result.reshape(24, 1);
8269
8270 let row_indices = vec![7, 2, 1, 0, 4, 5, 0, 4, 2, 3, 6, 1, 4, 0, 6, 1, 1, 3, 0, 6, 6, 5,
8271 5, 1];
8272
8273 assert!(allclose(&arr.get_rows(&row_indices), &result));
8274 }
8275
8276
8277
8278 #[test]
8279 fn test_vector_get_rows_8() {
8280
8281 let mut arr = Array::from(vec![0.751709653232715,
8282 0.7756910087539991,
8283 0.5504751396551519,
8284 0.20474158382817575,
8285 0.2997018642810668,
8286 0.48405352548051805,
8287 0.661170305597254,
8288 0.020350315122093288,
8289 0.8922053189738424,
8290 0.7459105873555202,
8291 0.5195262617458084,
8292 0.9985331097507912,
8293 0.26088353014360777,
8294 0.2552270403611949,
8295 0.5343326342043001,
8296 0.22971192633100435,
8297 0.7719378728355539,
8298 0.47782380137572855,
8299 0.5761747752392753,
8300 0.5600443043446207,
8301 0.36239152439432665,
8302 0.44024149151879477,
8303 0.44396773449968385,
8304 0.2429694031521269,
8305 0.9321179241793749,
8306 0.7498620431109351,
8307 0.8615156210253515,
8308 0.0002734266745958447,
8309 0.5109176556349699,
8310 0.7732697225620627,
8311 0.04579321708009976,
8312 0.9931324883531597,
8313 0.06772954439271461,
8314 0.7670567693562633,
8315 0.7806116771942163,
8316 0.7228187765847592,
8317 0.43007154425460414,
8318 0.16253574685246341,
8319 0.7396077555280184,
8320 0.611832276792692,
8321 0.5411739307316743,
8322 0.525478505436911,
8323 0.1130763245253541,
8324 0.564466682768384,
8325 0.7914634227919178,
8326 0.19962502963620465,
8327 0.7222048225287095,
8328 0.38156195755806055,
8329 0.06388072451634419,
8330 0.2145921979438138,
8331 0.46986905666160494,
8332 0.4359724620028569,
8333 0.6761247374630346,
8334 0.7817905297679897,
8335 0.5724638243073898,
8336 0.7306214231067651,
8337 0.8034977391607832,
8338 0.3327528376971386,
8339 0.7473018037656469,
8340 0.5342787537083562,
8341 0.9642799365706598,
8342 0.9393284325065456,
8343 0.04231331894218049]);
8344 arr.reshape(9, 7);
8345
8346 let mut result = Array::from(vec![0.2145921979438138,
8347 0.46986905666160494,
8348 0.4359724620028569,
8349 0.6761247374630346,
8350 0.7817905297679897,
8351 0.5724638243073898,
8352 0.7306214231067651,
8353 0.5109176556349699,
8354 0.7732697225620627,
8355 0.04579321708009976,
8356 0.9931324883531597,
8357 0.06772954439271461,
8358 0.7670567693562633,
8359 0.7806116771942163,
8360 0.44024149151879477,
8361 0.44396773449968385,
8362 0.2429694031521269,
8363 0.9321179241793749,
8364 0.7498620431109351,
8365 0.8615156210253515,
8366 0.0002734266745958447,
8367 0.5343326342043001,
8368 0.22971192633100435,
8369 0.7719378728355539,
8370 0.47782380137572855,
8371 0.5761747752392753,
8372 0.5600443043446207,
8373 0.36239152439432665,
8374 0.020350315122093288,
8375 0.8922053189738424,
8376 0.7459105873555202,
8377 0.5195262617458084,
8378 0.9985331097507912,
8379 0.26088353014360777,
8380 0.2552270403611949,
8381 0.2145921979438138,
8382 0.46986905666160494,
8383 0.4359724620028569,
8384 0.6761247374630346,
8385 0.7817905297679897,
8386 0.5724638243073898,
8387 0.7306214231067651,
8388 0.751709653232715,
8389 0.7756910087539991,
8390 0.5504751396551519,
8391 0.20474158382817575,
8392 0.2997018642810668,
8393 0.48405352548051805,
8394 0.661170305597254,
8395 0.2145921979438138,
8396 0.46986905666160494,
8397 0.4359724620028569,
8398 0.6761247374630346,
8399 0.7817905297679897,
8400 0.5724638243073898,
8401 0.7306214231067651,
8402 0.44024149151879477,
8403 0.44396773449968385,
8404 0.2429694031521269,
8405 0.9321179241793749,
8406 0.7498620431109351,
8407 0.8615156210253515,
8408 0.0002734266745958447,
8409 0.8034977391607832,
8410 0.3327528376971386,
8411 0.7473018037656469,
8412 0.5342787537083562,
8413 0.9642799365706598,
8414 0.9393284325065456,
8415 0.04231331894218049,
8416 0.5109176556349699,
8417 0.7732697225620627,
8418 0.04579321708009976,
8419 0.9931324883531597,
8420 0.06772954439271461,
8421 0.7670567693562633,
8422 0.7806116771942163,
8423 0.020350315122093288,
8424 0.8922053189738424,
8425 0.7459105873555202,
8426 0.5195262617458084,
8427 0.9985331097507912,
8428 0.26088353014360777,
8429 0.2552270403611949,
8430 0.2145921979438138,
8431 0.46986905666160494,
8432 0.4359724620028569,
8433 0.6761247374630346,
8434 0.7817905297679897,
8435 0.5724638243073898,
8436 0.7306214231067651,
8437 0.020350315122093288,
8438 0.8922053189738424,
8439 0.7459105873555202,
8440 0.5195262617458084,
8441 0.9985331097507912,
8442 0.26088353014360777,
8443 0.2552270403611949,
8444 0.5343326342043001,
8445 0.22971192633100435,
8446 0.7719378728355539,
8447 0.47782380137572855,
8448 0.5761747752392753,
8449 0.5600443043446207,
8450 0.36239152439432665,
8451 0.2145921979438138,
8452 0.46986905666160494,
8453 0.4359724620028569,
8454 0.6761247374630346,
8455 0.7817905297679897,
8456 0.5724638243073898,
8457 0.7306214231067651,
8458 0.5109176556349699,
8459 0.7732697225620627,
8460 0.04579321708009976,
8461 0.9931324883531597,
8462 0.06772954439271461,
8463 0.7670567693562633,
8464 0.7806116771942163,
8465 0.44024149151879477,
8466 0.44396773449968385,
8467 0.2429694031521269,
8468 0.9321179241793749,
8469 0.7498620431109351,
8470 0.8615156210253515,
8471 0.0002734266745958447,
8472 0.2145921979438138,
8473 0.46986905666160494,
8474 0.4359724620028569,
8475 0.6761247374630346,
8476 0.7817905297679897,
8477 0.5724638243073898,
8478 0.7306214231067651,
8479 0.7228187765847592,
8480 0.43007154425460414,
8481 0.16253574685246341,
8482 0.7396077555280184,
8483 0.611832276792692,
8484 0.5411739307316743,
8485 0.525478505436911,
8486 0.5343326342043001,
8487 0.22971192633100435,
8488 0.7719378728355539,
8489 0.47782380137572855,
8490 0.5761747752392753,
8491 0.5600443043446207,
8492 0.36239152439432665,
8493 0.1130763245253541,
8494 0.564466682768384,
8495 0.7914634227919178,
8496 0.19962502963620465,
8497 0.7222048225287095,
8498 0.38156195755806055,
8499 0.06388072451634419,
8500 0.8034977391607832,
8501 0.3327528376971386,
8502 0.7473018037656469,
8503 0.5342787537083562,
8504 0.9642799365706598,
8505 0.9393284325065456,
8506 0.04231331894218049,
8507 0.7228187765847592,
8508 0.43007154425460414,
8509 0.16253574685246341,
8510 0.7396077555280184,
8511 0.611832276792692,
8512 0.5411739307316743,
8513 0.525478505436911,
8514 0.751709653232715,
8515 0.7756910087539991,
8516 0.5504751396551519,
8517 0.20474158382817575,
8518 0.2997018642810668,
8519 0.48405352548051805,
8520 0.661170305597254,
8521 0.5343326342043001,
8522 0.22971192633100435,
8523 0.7719378728355539,
8524 0.47782380137572855,
8525 0.5761747752392753,
8526 0.5600443043446207,
8527 0.36239152439432665,
8528 0.751709653232715,
8529 0.7756910087539991,
8530 0.5504751396551519,
8531 0.20474158382817575,
8532 0.2997018642810668,
8533 0.48405352548051805,
8534 0.661170305597254]);
8535 result.reshape(27, 7);
8536
8537 let row_indices = vec![7, 4, 3, 2, 1, 7, 0, 7, 3, 8, 4, 1, 7, 1, 2, 7, 4, 3, 7, 5, 2, 6,
8538 8, 5, 0, 2, 0];
8539
8540 assert!(allclose(&arr.get_rows(&row_indices), &result));
8541 }
8542
8543
8544
8545 #[test]
8546 fn test_vector_get_rows_9() {
8547
8548 let mut arr = Array::from(vec![0.8751940474245478,
8549 0.7200327656901061,
8550 0.8025573700139234,
8551 0.8702428712065159,
8552 0.4223003750624127,
8553 0.2964625971077186,
8554 0.3768516801106607,
8555 0.7966622926398341,
8556 0.8151088765493302,
8557 0.5379149571200327,
8558 0.1074410804224426,
8559 0.3902887576702486,
8560 0.7686278406178223,
8561 0.4018098819435899,
8562 0.9702119168942321,
8563 0.39072085218690344,
8564 0.9111009439807813,
8565 0.4226698209640033,
8566 0.5292444768122545,
8567 0.32618019582547464,
8568 0.026073392823797392,
8569 0.7375491512448457,
8570 0.5187852631960822,
8571 0.5666406905758409,
8572 0.49549394126787416,
8573 0.43004391495324124,
8574 0.8962503037090311,
8575 0.6362379182176706,
8576 0.2605960713261556,
8577 0.41762440895716757,
8578 0.7373843974158949,
8579 0.913378739973925,
8580 0.34114790713481635,
8581 0.5589204512553507,
8582 0.4303328844354496]);
8583 arr.reshape(7, 5);
8584
8585 let mut result = Array::from(vec![0.39072085218690344,
8586 0.9111009439807813,
8587 0.4226698209640033,
8588 0.5292444768122545,
8589 0.32618019582547464,
8590 0.39072085218690344,
8591 0.9111009439807813,
8592 0.4226698209640033,
8593 0.5292444768122545,
8594 0.32618019582547464,
8595 0.026073392823797392,
8596 0.7375491512448457,
8597 0.5187852631960822,
8598 0.5666406905758409,
8599 0.49549394126787416,
8600 0.39072085218690344,
8601 0.9111009439807813,
8602 0.4226698209640033,
8603 0.5292444768122545,
8604 0.32618019582547464,
8605 0.026073392823797392,
8606 0.7375491512448457,
8607 0.5187852631960822,
8608 0.5666406905758409,
8609 0.49549394126787416,
8610 0.8751940474245478,
8611 0.7200327656901061,
8612 0.8025573700139234,
8613 0.8702428712065159,
8614 0.4223003750624127,
8615 0.7373843974158949,
8616 0.913378739973925,
8617 0.34114790713481635,
8618 0.5589204512553507,
8619 0.4303328844354496,
8620 0.39072085218690344,
8621 0.9111009439807813,
8622 0.4226698209640033,
8623 0.5292444768122545,
8624 0.32618019582547464,
8625 0.39072085218690344,
8626 0.9111009439807813,
8627 0.4226698209640033,
8628 0.5292444768122545,
8629 0.32618019582547464,
8630 0.7373843974158949,
8631 0.913378739973925,
8632 0.34114790713481635,
8633 0.5589204512553507,
8634 0.4303328844354496,
8635 0.43004391495324124,
8636 0.8962503037090311,
8637 0.6362379182176706,
8638 0.2605960713261556,
8639 0.41762440895716757,
8640 0.39072085218690344,
8641 0.9111009439807813,
8642 0.4226698209640033,
8643 0.5292444768122545,
8644 0.32618019582547464,
8645 0.7373843974158949,
8646 0.913378739973925,
8647 0.34114790713481635,
8648 0.5589204512553507,
8649 0.4303328844354496,
8650 0.39072085218690344,
8651 0.9111009439807813,
8652 0.4226698209640033,
8653 0.5292444768122545,
8654 0.32618019582547464,
8655 0.39072085218690344,
8656 0.9111009439807813,
8657 0.4226698209640033,
8658 0.5292444768122545,
8659 0.32618019582547464,
8660 0.1074410804224426,
8661 0.3902887576702486,
8662 0.7686278406178223,
8663 0.4018098819435899,
8664 0.9702119168942321,
8665 0.8751940474245478,
8666 0.7200327656901061,
8667 0.8025573700139234,
8668 0.8702428712065159,
8669 0.4223003750624127,
8670 0.1074410804224426,
8671 0.3902887576702486,
8672 0.7686278406178223,
8673 0.4018098819435899,
8674 0.9702119168942321,
8675 0.7373843974158949,
8676 0.913378739973925,
8677 0.34114790713481635,
8678 0.5589204512553507,
8679 0.4303328844354496,
8680 0.2964625971077186,
8681 0.3768516801106607,
8682 0.7966622926398341,
8683 0.8151088765493302,
8684 0.5379149571200327,
8685 0.39072085218690344,
8686 0.9111009439807813,
8687 0.4226698209640033,
8688 0.5292444768122545,
8689 0.32618019582547464]);
8690 result.reshape(21, 5);
8691
8692 let row_indices = vec![3, 3, 4, 3, 4, 0, 6, 3, 3, 6, 5, 3, 6, 3, 3, 2, 0, 2, 6, 1, 3];
8693
8694 assert!(allclose(&arr.get_rows(&row_indices), &result));
8695 }
8696
8697
8698
8699 #[test]
8700 fn test_scalar_add_0() {
8701
8702 let mut arr = Array::from(vec![0.06811702594060087,
8703 0.0032471397228261978,
8704 0.5562333371936806,
8705 0.9348887679753367,
8706 0.2779799974915451,
8707 0.2840277318568395,
8708 0.05578500441875145,
8709 0.20069047841331833,
8710 0.8148074793579072,
8711 0.39323724045807107,
8712 0.8398094055020797,
8713 0.036468790331246725,
8714 0.6506392529438814,
8715 0.8673875170184757,
8716 0.8219330025814674,
8717 0.9186250940898061,
8718 0.19608298103170663,
8719 0.3817598767008713,
8720 0.954662525609448,
8721 0.3457412055584168,
8722 0.49403958483043986]);
8723 arr.reshape(3, 7);
8724
8725 let mut result = Array::from(vec![0.39118270414807965,
8726 0.326312817930305,
8727 0.8792990154011594,
8728 1.2579544461828154,
8729 0.6010456756990239,
8730 0.6070934100643183,
8731 0.37885068262623023,
8732 0.5237561566207971,
8733 1.137873157565386,
8734 0.7163029186655498,
8735 1.1628750837095585,
8736 0.3595344685387255,
8737 0.9737049311513601,
8738 1.1904531952259545,
8739 1.1449986807889463,
8740 1.241690772297285,
8741 0.5191486592391854,
8742 0.7048255549083501,
8743 1.2777282038169266,
8744 0.6688068837658956,
8745 0.8171052630379186]);
8746 result.reshape(3, 7);
8747
8748 let rhs = 0.323065678207;
8749
8750 assert!(allclose(&(arr.add(rhs)), &result));
8751
8752 arr.add_inplace(rhs);
8753 assert!(allclose(&(arr), &result));
8754 }
8755
8756
8757
8758 #[test]
8759 fn test_scalar_add_1() {
8760
8761 let mut arr = Array::from(vec![0.523554117221654,
8762 0.5405895625742049,
8763 0.2776740067914204,
8764 0.5515042893078336,
8765 0.31576747712868725,
8766 0.6246240875665414,
8767 0.9606289652790903,
8768 0.7784157928181845,
8769 0.5096025362838101,
8770 0.19050403548585448,
8771 0.06359843609825355,
8772 0.9920051273565584]);
8773 arr.reshape(2, 6);
8774
8775 let mut result = Array::from(vec![1.2613960443050702,
8776 1.278431489657621,
8777 1.0155159338748367,
8778 1.28934621639125,
8779 1.0536094042121036,
8780 1.3624660146499576,
8781 1.6984708923625065,
8782 1.5162577199016007,
8783 1.2474444633672264,
8784 0.9283459625692707,
8785 0.8014403631816698,
8786 1.7298470544399747]);
8787 result.reshape(2, 6);
8788
8789 let rhs = 0.737841927083;
8790
8791 assert!(allclose(&(arr.add(rhs)), &result));
8792
8793 arr.add_inplace(rhs);
8794 assert!(allclose(&(arr), &result));
8795 }
8796
8797
8798
8799 #[test]
8800 fn test_scalar_add_2() {
8801
8802 let mut arr = Array::from(vec![0.08370795679307508,
8803 0.7621734331141712,
8804 0.9562068294243001,
8805 0.22427242579832596,
8806 0.42277971497076405,
8807 0.18993578541966183,
8808 0.8966402386959843,
8809 0.5497714950340916,
8810 0.979407327448822,
8811 0.22505291801672678]);
8812 arr.reshape(5, 2);
8813
8814 let mut result = Array::from(vec![-0.6928843447479325,
8815 -0.014418868426836373,
8816 0.17961452788329257,
8817 -0.5523198757426816,
8818 -0.3538125865702435,
8819 -0.5866565161213457,
8820 0.12004793715497675,
8821 -0.22682080650691594,
8822 0.20281502590781442,
8823 -0.5515393835242808]);
8824 result.reshape(5, 2);
8825
8826 let rhs = -0.776592301541;
8827
8828 assert!(allclose(&(arr.add(rhs)), &result));
8829
8830 arr.add_inplace(rhs);
8831 assert!(allclose(&(arr), &result));
8832 }
8833
8834
8835
8836 #[test]
8837 fn test_scalar_add_3() {
8838
8839 let mut arr = Array::from(vec![0.4936907903068515,
8840 0.20194296368602416,
8841 0.3829007797075089,
8842 0.5640015695389897,
8843 0.778032931813845,
8844 0.20997168576500402,
8845 0.19074236652852994,
8846 0.31859275161178546]);
8847 arr.reshape(1, 8);
8848
8849 let mut result = Array::from(vec![-0.3385239219948635,
8850 -0.6302717486156908,
8851 -0.44931393259420604,
8852 -0.26821314276272523,
8853 -0.054181780487869924,
8854 -0.6222430265367109,
8855 -0.641472345773185,
8856 -0.5136219606899295]);
8857 result.reshape(1, 8);
8858
8859 let rhs = -0.832214712302;
8860
8861 assert!(allclose(&(arr.add(rhs)), &result));
8862
8863 arr.add_inplace(rhs);
8864 assert!(allclose(&(arr), &result));
8865 }
8866
8867
8868
8869 #[test]
8870 fn test_scalar_add_4() {
8871
8872 let mut arr = Array::from(vec![0.22856424898298544,
8873 0.31940267402449873,
8874 0.8887093921856027,
8875 0.19072686256910676,
8876 0.46462772784032014,
8877 0.08752074191367665,
8878 0.8546930292034037,
8879 0.022770779845259437]);
8880 arr.reshape(8, 1);
8881
8882 let mut result = Array::from(vec![-0.3555348247285869,
8883 -0.2646963996870736,
8884 0.3046103184740304,
8885 -0.39337221114246557,
8886 -0.11947134587125219,
8887 -0.4965783317978957,
8888 0.2705939554918314,
8889 -0.5613282938663129]);
8890 result.reshape(8, 1);
8891
8892 let rhs = -0.584099073712;
8893
8894 assert!(allclose(&(arr.add(rhs)), &result));
8895
8896 arr.add_inplace(rhs);
8897 assert!(allclose(&(arr), &result));
8898 }
8899
8900
8901
8902 #[test]
8903 fn test_scalar_add_5() {
8904
8905 let mut arr = Array::from(vec![0.9809205056841841,
8906 0.33299564214047805,
8907 0.7794303578945068,
8908 0.10485171110895442,
8909 0.41109205328440135,
8910 0.13965197006300867,
8911 0.8565358169677101,
8912 0.8431696666964094,
8913 0.6623608102945309,
8914 0.8895539806717817,
8915 0.6539035744899716,
8916 0.8889465311848584,
8917 0.4877182653207157,
8918 0.16435065364786217,
8919 0.8638084923944652,
8920 0.3213782661144825,
8921 0.5534350763775198,
8922 0.5720898040673107,
8923 0.04459127396247098,
8924 0.5895633328775719,
8925 0.9658090410489292,
8926 0.3534478214947444,
8927 0.5285776368934987,
8928 0.13445147873841157,
8929 0.36101860852519785,
8930 0.3343563716507818,
8931 0.363015951384304,
8932 0.584979662494934,
8933 0.9548274787099071,
8934 0.1075713091854591,
8935 0.2038098798210375,
8936 0.01140797599229293,
8937 0.08184250431205853,
8938 0.9042079612866117,
8939 0.8979491942667515,
8940 0.869373724494945,
8941 0.3538388463563201,
8942 0.4754988589174608,
8943 0.4694231674732119,
8944 0.1887409583134234,
8945 0.9148221048400892,
8946 0.6559195021254881,
8947 0.1897196903434769,
8948 0.7602151618545422,
8949 0.44835948468885367,
8950 0.7131453192939813,
8951 0.879632358051081,
8952 0.3493184807385423,
8953 0.7590567490943513,
8954 0.41898863180099055,
8955 0.548792375495095,
8956 0.704546184617159,
8957 0.7541363839955707,
8958 0.5848805009620869,
8959 0.5822557475310346,
8960 0.7146597150121486,
8961 0.2796232248768632,
8962 0.27467637251457966,
8963 0.06960804611156912,
8964 0.3593073709314968,
8965 0.8817491601357033,
8966 0.13658583253315493,
8967 0.2291696765983675]);
8968 arr.reshape(9, 7);
8969
8970 let mut result = Array::from(vec![1.5866544112473009,
8971 0.9387295477035947,
8972 1.3851642634576233,
8973 0.7105856166720711,
8974 1.0168259588475181,
8975 0.7453858756261253,
8976 1.4622697225308268,
8977 1.448903572259526,
8978 1.2680947158576474,
8979 1.4952878862348984,
8980 1.2596374800530883,
8981 1.4946804367479751,
8982 1.0934521708838325,
8983 0.7700845592109788,
8984 1.469542397957582,
8985 0.9271121716775992,
8986 1.1591689819406366,
8987 1.1778237096304274,
8988 0.6503251795255877,
8989 1.1952972384406886,
8990 1.5715429466120459,
8991 0.9591817270578611,
8992 1.1343115424566155,
8993 0.7401853843015282,
8994 0.9667525140883145,
8995 0.9400902772138985,
8996 0.9687498569474207,
8997 1.1907135680580507,
8998 1.560561384273024,
8999 0.7133052147485758,
9000 0.8095437853841542,
9001 0.6171418815554096,
9002 0.6875764098751752,
9003 1.5099418668497284,
9004 1.503683099829868,
9005 1.4751076300580617,
9006 0.9595727519194368,
9007 1.0812327644805775,
9008 1.0751570730363285,
9009 0.7944748638765401,
9010 1.5205560104032059,
9011 1.2616534076886048,
9012 0.7954535959065936,
9013 1.3659490674176589,
9014 1.0540933902519702,
9015 1.318879224857098,
9016 1.4853662636141975,
9017 0.955052386301659,
9018 1.364790654657468,
9019 1.0247225373641071,
9020 1.1545262810582115,
9021 1.3102800901802758,
9022 1.3598702895586874,
9023 1.1906144065252036,
9024 1.1879896530941512,
9025 1.3203936205752653,
9026 0.8853571304399799,
9027 0.8804102780776963,
9028 0.6753419516746858,
9029 0.9650412764946135,
9030 1.4874830656988198,
9031 0.7423197380962716,
9032 0.8349035821614842]);
9033 result.reshape(9, 7);
9034
9035 let rhs = 0.605733905563;
9036
9037 assert!(allclose(&(arr.add(rhs)), &result));
9038
9039 arr.add_inplace(rhs);
9040 assert!(allclose(&(arr), &result));
9041 }
9042
9043
9044
9045 #[test]
9046 fn test_scalar_add_6() {
9047
9048 let mut arr = Array::from(vec![0.6985484562924693,
9049 0.45624836780039457,
9050 0.2154741062034795,
9051 0.1941943611438679,
9052 0.9654363394193848,
9053 0.8242325296917633]);
9054 arr.reshape(6, 1);
9055
9056 let mut result = Array::from(vec![0.7911678879366814,
9057 0.5488677994446066,
9058 0.30809353784769156,
9059 0.28681379278807995,
9060 1.058055771063597,
9061 0.9168519613359754]);
9062 result.reshape(6, 1);
9063
9064 let rhs = 0.0926194316442;
9065
9066 assert!(allclose(&(arr.add(rhs)), &result));
9067
9068 arr.add_inplace(rhs);
9069 assert!(allclose(&(arr), &result));
9070 }
9071
9072
9073
9074 #[test]
9075 fn test_scalar_add_7() {
9076
9077 let mut arr = Array::from(vec![0.17364595662240045,
9078 0.7907920202091278,
9079 0.2062734698221016,
9080 0.9321037630582465,
9081 0.8049973740006956,
9082 0.1390513599284552,
9083 0.666894980732186,
9084 0.6837041938551661,
9085 0.22571750944930125,
9086 0.5397374300779394,
9087 0.03285953663228669,
9088 0.5551032080307319,
9089 0.1841128248076318,
9090 0.19843902091275567,
9091 0.7338783373618613,
9092 0.8422643621113209,
9093 0.47726124014639304,
9094 0.6353777538401215,
9095 0.7834161837208827,
9096 0.06576775345683428,
9097 0.3535972264171642,
9098 0.7335322528559519,
9099 0.6599711886078127,
9100 0.7547132773001621,
9101 0.4286641696259391,
9102 0.6448843452242246,
9103 0.10311468165230331,
9104 0.4455711553915871,
9105 0.41214572940218475,
9106 0.5320895529540762,
9107 0.583553426888169,
9108 0.6090282662471606,
9109 0.21001713013934487,
9110 0.6050812060055928,
9111 0.3236972496574251,
9112 0.31412388136935265,
9113 0.10581303071284542,
9114 0.3751722159246088,
9115 0.5249028685145385,
9116 0.7933697765126563,
9117 0.875907701559008,
9118 0.028364517270292988,
9119 0.3129619809852322,
9120 0.4360716921593736,
9121 0.2289188200282407,
9122 0.5463355515296112,
9123 0.38494710552778266,
9124 0.2405553425204674,
9125 0.4350503547556466,
9126 0.45577216951250654,
9127 0.3500071863552816,
9128 0.44845541886354634,
9129 0.8402537017145358,
9130 0.8380513354975876,
9131 0.45533315507777516,
9132 0.01823725565443879,
9133 0.5259951641359074,
9134 0.9316871781742284,
9135 0.9605882157757877,
9136 0.04843707069017311,
9137 0.7584795309163317,
9138 0.5272168156082075,
9139 0.7036476259040368,
9140 0.0770587560211834]);
9141 arr.reshape(8, 8);
9142
9143 let mut result = Array::from(vec![-0.4744465994368886,
9144 0.1426994641498387,
9145 -0.44181908623718746,
9146 0.28401120699895743,
9147 0.15690481794140654,
9148 -0.5090411961308339,
9149 0.018802424672896945,
9150 0.03561163779587706,
9151 -0.4223750466099878,
9152 -0.10835512598134966,
9153 -0.6152330194270024,
9154 -0.09298934802855718,
9155 -0.46397973125165726,
9156 -0.4496535351465334,
9157 0.0857857813025722,
9158 0.19417180605203188,
9159 -0.17083131591289602,
9160 -0.012714802219167542,
9161 0.13532362766159367,
9162 -0.5823248026024548,
9163 -0.2944953296421249,
9164 0.08543969679666286,
9165 0.011878632548523615,
9166 0.10662072124087307,
9167 -0.21942838643334994,
9168 -0.0032082108350645067,
9169 -0.5449778744069858,
9170 -0.20252140066770197,
9171 -0.2359468266571043,
9172 -0.11600300310521283,
9173 -0.06453912917112004,
9174 -0.039064289812128505,
9175 -0.4380754259199442,
9176 -0.04301135005369627,
9177 -0.324395306401864,
9178 -0.3339686746899364,
9179 -0.5422795253464436,
9180 -0.27292034013468025,
9181 -0.12318968754475057,
9182 0.14527722045336722,
9183 0.22781514549971893,
9184 -0.6197280387889961,
9185 -0.33513057507405686,
9186 -0.21202086389991548,
9187 -0.41917373603104835,
9188 -0.10175700452967784,
9189 -0.2631454505315064,
9190 -0.40753721353882166,
9191 -0.2130422013036425,
9192 -0.19232038654678252,
9193 -0.29808536970400745,
9194 -0.19963713719574272,
9195 0.19216114565524678,
9196 0.18995877943829853,
9197 -0.1927594009815139,
9198 -0.6298553004048503,
9199 -0.12209739192338165,
9200 0.28359462211493935,
9201 0.3124956597164986,
9202 -0.599655485369116,
9203 0.11038697485704263,
9204 -0.12087574045108151,
9205 0.055555069844747784,
9206 -0.5710338000381057]);
9207 result.reshape(8, 8);
9208
9209 let rhs = -0.648092556059;
9210
9211 assert!(allclose(&(arr.add(rhs)), &result));
9212
9213 arr.add_inplace(rhs);
9214 assert!(allclose(&(arr), &result));
9215 }
9216
9217
9218
9219 #[test]
9220 fn test_scalar_add_8() {
9221
9222 let mut arr = Array::from(vec![0.4586775356310824,
9223 0.7002204713703478,
9224 0.7720542543970859,
9225 0.40482805672049604,
9226 0.052510490259575326,
9227 0.5520571953870373,
9228 0.024234330544996685,
9229 0.9371264819462378,
9230 0.3871065053718359,
9231 0.6023738389993859,
9232 0.4191855284848276,
9233 0.38976817512649575,
9234 0.529572603026883,
9235 0.02759798631740329,
9236 0.8414849021852067,
9237 0.4506447780038211,
9238 0.38640241887503735,
9239 0.27673717320310187,
9240 0.5714286844965489,
9241 0.5450559026541721,
9242 0.9917249918774653,
9243 0.8408671512656238,
9244 0.987490588396677,
9245 0.9116079157193353]);
9246 arr.reshape(4, 6);
9247
9248 let mut result = Array::from(vec![0.7424617741819709,
9249 0.9840047099212363,
9250 1.0558384929479745,
9251 0.6886122952713846,
9252 0.33629472881046385,
9253 0.8358414339379259,
9254 0.3080185690958852,
9255 1.2209107204971263,
9256 0.6708907439227244,
9257 0.8861580775502744,
9258 0.7029697670357161,
9259 0.6735524136773843,
9260 0.8133568415777715,
9261 0.3113822248682918,
9262 1.125269140736095,
9263 0.7344290165547096,
9264 0.6701866574259259,
9265 0.5605214117539904,
9266 0.8552129230474375,
9267 0.8288401412050607,
9268 1.2755092304283537,
9269 1.1246513898165125,
9270 1.2712748269475656,
9271 1.1953921542702237]);
9272 result.reshape(4, 6);
9273
9274 let rhs = 0.283784238551;
9275
9276 assert!(allclose(&(arr.add(rhs)), &result));
9277
9278 arr.add_inplace(rhs);
9279 assert!(allclose(&(arr), &result));
9280 }
9281
9282
9283
9284 #[test]
9285 fn test_scalar_add_9() {
9286
9287 let mut arr = Array::from(vec![0.45179439717779746,
9288 0.9066582618309699,
9289 0.7072602829298359,
9290 0.7347636554252458]);
9291 arr.reshape(4, 1);
9292
9293 let mut result = Array::from(vec![0.10681767302311318,
9294 0.5616815376762856,
9295 0.3622835587751516,
9296 0.3897869312705615]);
9297 result.reshape(4, 1);
9298
9299 let rhs = -0.344976724155;
9300
9301 assert!(allclose(&(arr.add(rhs)), &result));
9302
9303 arr.add_inplace(rhs);
9304 assert!(allclose(&(arr), &result));
9305 }
9306
9307
9308
9309 #[test]
9310 fn test_array_op_add_0() {
9311
9312 let mut arr1 = Array::from(vec![0.5292374491691589,
9313 0.6942721605300903,
9314 0.7879465222358704,
9315 0.1940249502658844,
9316 0.9599275588989258,
9317 0.1508907526731491,
9318 0.21195031702518463,
9319 0.011483190581202507,
9320 0.7558361291885376,
9321 0.5654648542404175,
9322 0.8437381982803345,
9323 0.16252118349075317,
9324 0.5444399118423462,
9325 0.5924404263496399,
9326 0.5894774794578552,
9327 0.8173068165779114,
9328 0.4974719285964966,
9329 0.506263256072998,
9330 0.14057034254074097,
9331 0.1987122744321823,
9332 0.7811152338981628,
9333 0.9682057499885559,
9334 0.4419597387313843,
9335 0.9235113859176636,
9336 0.6840105652809143,
9337 0.0571264773607254,
9338 0.5038227438926697,
9339 0.5125789642333984,
9340 0.361473023891449,
9341 0.7799157500267029]);
9342 arr1.reshape(5, 6);
9343
9344 let mut arr2 = Array::from(vec![0.4231114983558655,
9345 0.8525132536888123,
9346 0.6305864453315735,
9347 0.602831244468689,
9348 0.059981320053339005,
9349 0.8514574766159058,
9350 0.43011587858200073,
9351 0.7333865761756897,
9352 0.6444382071495056,
9353 0.5360978841781616,
9354 0.805327832698822,
9355 0.1458495855331421,
9356 0.36950308084487915,
9357 0.5650636553764343,
9358 0.017384890466928482,
9359 0.6433643698692322,
9360 0.48399919271469116,
9361 0.10224444419145584,
9362 0.2002507895231247,
9363 0.8062815070152283,
9364 0.8852312564849854,
9365 0.7486478090286255,
9366 0.7067756056785583,
9367 0.4174099862575531,
9368 0.9084565043449402,
9369 0.8913657069206238,
9370 0.9131410121917725,
9371 0.3868154287338257,
9372 0.010430347174406052,
9373 0.5083411931991577]);
9374 arr2.reshape(5, 6);
9375
9376 let mut result = Array::from(vec![0.9523489475250244,
9377 1.5467853546142578,
9378 1.4185329675674438,
9379 0.796856164932251,
9380 1.0199089050292969,
9381 1.0023481845855713,
9382 0.6420661807060242,
9383 0.7448697686195374,
9384 1.4002742767333984,
9385 1.101562738418579,
9386 1.6490659713745117,
9387 0.30837076902389526,
9388 0.9139429926872253,
9389 1.1575040817260742,
9390 0.6068623661994934,
9391 1.4606711864471436,
9392 0.9814711213111877,
9393 0.6085076928138733,
9394 0.34082114696502686,
9395 1.0049937963485718,
9396 1.666346549987793,
9397 1.7168536186218262,
9398 1.1487352848052979,
9399 1.340921401977539,
9400 1.5924670696258545,
9401 0.948492169380188,
9402 1.416963815689087,
9403 0.8993943929672241,
9404 0.37190335988998413,
9405 1.2882568836212158]);
9406 result.reshape(5, 6);
9407
9408 assert!(allclose(&arr1.add(&arr2), &result));
9409
9410 arr1.add_inplace(&arr2);
9411 assert!(allclose(&arr1, &result));
9412 }
9413
9414
9415
9416 #[test]
9417 fn test_array_op_sub_0() {
9418
9419 let mut arr1 = Array::from(vec![0.5292374491691589,
9420 0.6942721605300903,
9421 0.7879465222358704,
9422 0.1940249502658844,
9423 0.9599275588989258,
9424 0.1508907526731491,
9425 0.21195031702518463,
9426 0.011483190581202507,
9427 0.7558361291885376,
9428 0.5654648542404175,
9429 0.8437381982803345,
9430 0.16252118349075317,
9431 0.5444399118423462,
9432 0.5924404263496399,
9433 0.5894774794578552,
9434 0.8173068165779114,
9435 0.4974719285964966,
9436 0.506263256072998,
9437 0.14057034254074097,
9438 0.1987122744321823,
9439 0.7811152338981628,
9440 0.9682057499885559,
9441 0.4419597387313843,
9442 0.9235113859176636,
9443 0.6840105652809143,
9444 0.0571264773607254,
9445 0.5038227438926697,
9446 0.5125789642333984,
9447 0.361473023891449,
9448 0.7799157500267029]);
9449 arr1.reshape(5, 6);
9450
9451 let mut arr2 = Array::from(vec![0.4231114983558655,
9452 0.8525132536888123,
9453 0.6305864453315735,
9454 0.602831244468689,
9455 0.059981320053339005,
9456 0.8514574766159058,
9457 0.43011587858200073,
9458 0.7333865761756897,
9459 0.6444382071495056,
9460 0.5360978841781616,
9461 0.805327832698822,
9462 0.1458495855331421,
9463 0.36950308084487915,
9464 0.5650636553764343,
9465 0.017384890466928482,
9466 0.6433643698692322,
9467 0.48399919271469116,
9468 0.10224444419145584,
9469 0.2002507895231247,
9470 0.8062815070152283,
9471 0.8852312564849854,
9472 0.7486478090286255,
9473 0.7067756056785583,
9474 0.4174099862575531,
9475 0.9084565043449402,
9476 0.8913657069206238,
9477 0.9131410121917725,
9478 0.3868154287338257,
9479 0.010430347174406052,
9480 0.5083411931991577]);
9481 arr2.reshape(5, 6);
9482
9483 let mut result = Array::from(vec![0.10612595081329346,
9484 -0.15824109315872192,
9485 0.15736007690429688,
9486 -0.40880629420280457,
9487 0.8999462127685547,
9488 -0.7005667090415955,
9489 -0.2181655615568161,
9490 -0.721903383731842,
9491 0.11139792203903198,
9492 0.02936697006225586,
9493 0.03841036558151245,
9494 0.016671597957611084,
9495 0.17493683099746704,
9496 0.027376770973205566,
9497 0.572092592716217,
9498 0.1739424467086792,
9499 0.01347273588180542,
9500 0.4040188193321228,
9501 -0.05968044698238373,
9502 -0.6075692176818848,
9503 -0.10411602258682251,
9504 0.21955794095993042,
9505 -0.2648158669471741,
9506 0.5061013698577881,
9507 -0.22444593906402588,
9508 -0.8342392444610596,
9509 -0.4093182682991028,
9510 0.12576353549957275,
9511 0.3510426878929138,
9512 0.27157455682754517]);
9513 result.reshape(5, 6);
9514
9515 assert!(allclose(&arr1.sub(&arr2), &result));
9516
9517 arr1.sub_inplace(&arr2);
9518 assert!(allclose(&arr1, &result));
9519 }
9520
9521
9522
9523 #[test]
9524 fn test_array_op_times_0() {
9525
9526 let mut arr1 = Array::from(vec![0.5292374491691589,
9527 0.6942721605300903,
9528 0.7879465222358704,
9529 0.1940249502658844,
9530 0.9599275588989258,
9531 0.1508907526731491,
9532 0.21195031702518463,
9533 0.011483190581202507,
9534 0.7558361291885376,
9535 0.5654648542404175,
9536 0.8437381982803345,
9537 0.16252118349075317,
9538 0.5444399118423462,
9539 0.5924404263496399,
9540 0.5894774794578552,
9541 0.8173068165779114,
9542 0.4974719285964966,
9543 0.506263256072998,
9544 0.14057034254074097,
9545 0.1987122744321823,
9546 0.7811152338981628,
9547 0.9682057499885559,
9548 0.4419597387313843,
9549 0.9235113859176636,
9550 0.6840105652809143,
9551 0.0571264773607254,
9552 0.5038227438926697,
9553 0.5125789642333984,
9554 0.361473023891449,
9555 0.7799157500267029]);
9556 arr1.reshape(5, 6);
9557
9558 let mut arr2 = Array::from(vec![0.4231114983558655,
9559 0.8525132536888123,
9560 0.6305864453315735,
9561 0.602831244468689,
9562 0.059981320053339005,
9563 0.8514574766159058,
9564 0.43011587858200073,
9565 0.7333865761756897,
9566 0.6444382071495056,
9567 0.5360978841781616,
9568 0.805327832698822,
9569 0.1458495855331421,
9570 0.36950308084487915,
9571 0.5650636553764343,
9572 0.017384890466928482,
9573 0.6433643698692322,
9574 0.48399919271469116,
9575 0.10224444419145584,
9576 0.2002507895231247,
9577 0.8062815070152283,
9578 0.8852312564849854,
9579 0.7486478090286255,
9580 0.7067756056785583,
9581 0.4174099862575531,
9582 0.9084565043449402,
9583 0.8913657069206238,
9584 0.9131410121917725,
9585 0.3868154287338257,
9586 0.010430347174406052,
9587 0.5083411931991577]);
9588 arr2.reshape(5, 6);
9589
9590 let mut result = Array::from(vec![0.22392645478248596,
9591 0.591876208782196,
9592 0.49686840176582336,
9593 0.11696430295705795,
9594 0.057577721774578094,
9595 0.1284770667552948,
9596 0.09116319566965103,
9597 0.008421617560088634,
9598 0.48708969354629517,
9599 0.30314451456069946,
9600 0.6794858574867249,
9601 0.023703647777438164,
9602 0.20117221772670746,
9603 0.33476656675338745,
9604 0.010248001664876938,
9605 0.525826096534729,
9606 0.24077601730823517,
9607 0.05176260694861412,
9608 0.028149321675300598,
9609 0.1602180302143097,
9610 0.6914676427841187,
9611 0.7248451113700867,
9612 0.3123663663864136,
9613 0.38548287749290466,
9614 0.6213938593864441,
9615 0.05092058330774307,
9616 0.4600612223148346,
9617 0.1982734501361847,
9618 0.003770289244130254,
9619 0.3964633047580719]);
9620 result.reshape(5, 6);
9621
9622 assert!(allclose(&arr1.times(&arr2), &result));
9623
9624 arr1.times_inplace(&arr2);
9625 assert!(allclose(&arr1, &result));
9626 }
9627
9628
9629
9630 #[test]
9631 fn test_array_op_div_0() {
9632
9633 let mut arr1 = Array::from(vec![0.5292374491691589,
9634 0.6942721605300903,
9635 0.7879465222358704,
9636 0.1940249502658844,
9637 0.9599275588989258,
9638 0.1508907526731491,
9639 0.21195031702518463,
9640 0.011483190581202507,
9641 0.7558361291885376,
9642 0.5654648542404175,
9643 0.8437381982803345,
9644 0.16252118349075317,
9645 0.5444399118423462,
9646 0.5924404263496399,
9647 0.5894774794578552,
9648 0.8173068165779114,
9649 0.4974719285964966,
9650 0.506263256072998,
9651 0.14057034254074097,
9652 0.1987122744321823,
9653 0.7811152338981628,
9654 0.9682057499885559,
9655 0.4419597387313843,
9656 0.9235113859176636,
9657 0.6840105652809143,
9658 0.0571264773607254,
9659 0.5038227438926697,
9660 0.5125789642333984,
9661 0.361473023891449,
9662 0.7799157500267029]);
9663 arr1.reshape(5, 6);
9664
9665 let mut arr2 = Array::from(vec![0.4231114983558655,
9666 0.8525132536888123,
9667 0.6305864453315735,
9668 0.602831244468689,
9669 0.059981320053339005,
9670 0.8514574766159058,
9671 0.43011587858200073,
9672 0.7333865761756897,
9673 0.6444382071495056,
9674 0.5360978841781616,
9675 0.805327832698822,
9676 0.1458495855331421,
9677 0.36950308084487915,
9678 0.5650636553764343,
9679 0.017384890466928482,
9680 0.6433643698692322,
9681 0.48399919271469116,
9682 0.10224444419145584,
9683 0.2002507895231247,
9684 0.8062815070152283,
9685 0.8852312564849854,
9686 0.7486478090286255,
9687 0.7067756056785583,
9688 0.4174099862575531,
9689 0.9084565043449402,
9690 0.8913657069206238,
9691 0.9131410121917725,
9692 0.3868154287338257,
9693 0.010430347174406052,
9694 0.5083411931991577]);
9695 arr2.reshape(5, 6);
9696
9697 let mut result = Array::from(vec![1.25082266330719,
9698 0.8143828511238098,
9699 1.2495455741882324,
9700 0.32185617089271545,
9701 16.003774642944336,
9702 0.17721466720104218,
9703 0.4927749037742615,
9704 0.015657760202884674,
9705 1.1728605031967163,
9706 1.0547791719436646,
9707 1.047695279121399,
9708 1.1143068075180054,
9709 1.4734381437301636,
9710 1.0484490394592285,
9711 33.9074592590332,
9712 1.2703638076782227,
9713 1.0278363227844238,
9714 4.951498985290527,
9715 0.7019714713096619,
9716 0.24645520746707916,
9717 0.8823854923248291,
9718 1.293272614479065,
9719 0.6253183484077454,
9720 2.212480306625366,
9721 0.7529370784759521,
9722 0.06408870965242386,
9723 0.5517469048500061,
9724 1.3251254558563232,
9725 34.6558952331543,
9726 1.5342367887496948]);
9727 result.reshape(5, 6);
9728
9729 assert!(allclose(&arr1.div(&arr2), &result));
9730
9731 arr1.div_inplace(&arr2);
9732 assert!(allclose(&arr1, &result));
9733 }
9734
9735
9736
9737 #[test]
9738 fn test_array_op_add_1() {
9739
9740 let mut arr1 = Array::from(vec![0.8881012797355652,
9741 0.29694488644599915,
9742 0.3035637438297272,
9743 0.46961191296577454,
9744 0.7102128863334656,
9745 0.7828819751739502,
9746 0.7689284682273865,
9747 0.9182071089744568]);
9748 arr1.reshape(1, 8);
9749
9750 let mut arr2 = Array::from(vec![0.7185758352279663,
9751 0.09909920394420624,
9752 0.4448649287223816,
9753 0.47341388463974,
9754 0.5639866590499878,
9755 0.6206879019737244,
9756 0.07192548364400864,
9757 0.9532538652420044]);
9758 arr2.reshape(1, 8);
9759
9760 let mut result = Array::from(vec![1.6066770553588867,
9761 0.3960440754890442,
9762 0.7484287023544312,
9763 0.9430258274078369,
9764 1.2741994857788086,
9765 1.4035699367523193,
9766 0.8408539295196533,
9767 1.8714609146118164]);
9768 result.reshape(1, 8);
9769
9770 assert!(allclose(&arr1.add(&arr2), &result));
9771
9772 arr1.add_inplace(&arr2);
9773 assert!(allclose(&arr1, &result));
9774 }
9775
9776
9777
9778 #[test]
9779 fn test_array_op_sub_1() {
9780
9781 let mut arr1 = Array::from(vec![0.8881012797355652,
9782 0.29694488644599915,
9783 0.3035637438297272,
9784 0.46961191296577454,
9785 0.7102128863334656,
9786 0.7828819751739502,
9787 0.7689284682273865,
9788 0.9182071089744568]);
9789 arr1.reshape(1, 8);
9790
9791 let mut arr2 = Array::from(vec![0.7185758352279663,
9792 0.09909920394420624,
9793 0.4448649287223816,
9794 0.47341388463974,
9795 0.5639866590499878,
9796 0.6206879019737244,
9797 0.07192548364400864,
9798 0.9532538652420044]);
9799 arr2.reshape(1, 8);
9800
9801 let mut result = Array::from(vec![0.16952544450759888,
9802 0.1978456825017929,
9803 -0.14130118489265442,
9804 -0.003801971673965454,
9805 0.14622622728347778,
9806 0.16219407320022583,
9807 0.6970030069351196,
9808 -0.03504675626754761]);
9809 result.reshape(1, 8);
9810
9811 assert!(allclose(&arr1.sub(&arr2), &result));
9812
9813 arr1.sub_inplace(&arr2);
9814 assert!(allclose(&arr1, &result));
9815 }
9816
9817
9818
9819 #[test]
9820 fn test_array_op_times_1() {
9821
9822 let mut arr1 = Array::from(vec![0.8881012797355652,
9823 0.29694488644599915,
9824 0.3035637438297272,
9825 0.46961191296577454,
9826 0.7102128863334656,
9827 0.7828819751739502,
9828 0.7689284682273865,
9829 0.9182071089744568]);
9830 arr1.reshape(1, 8);
9831
9832 let mut arr2 = Array::from(vec![0.7185758352279663,
9833 0.09909920394420624,
9834 0.4448649287223816,
9835 0.47341388463974,
9836 0.5639866590499878,
9837 0.6206879019737244,
9838 0.07192548364400864,
9839 0.9532538652420044]);
9840 arr2.reshape(1, 8);
9841
9842 let mut result = Array::from(vec![0.6381680965423584,
9843 0.029427001252770424,
9844 0.1350448578596115,
9845 0.2223207950592041,
9846 0.40055060386657715,
9847 0.4859253764152527,
9848 0.05530555173754692,
9849 0.8752844929695129]);
9850 result.reshape(1, 8);
9851
9852 assert!(allclose(&arr1.times(&arr2), &result));
9853
9854 arr1.times_inplace(&arr2);
9855 assert!(allclose(&arr1, &result));
9856 }
9857
9858
9859
9860 #[test]
9861 fn test_array_op_div_1() {
9862
9863 let mut arr1 = Array::from(vec![0.8881012797355652,
9864 0.29694488644599915,
9865 0.3035637438297272,
9866 0.46961191296577454,
9867 0.7102128863334656,
9868 0.7828819751739502,
9869 0.7689284682273865,
9870 0.9182071089744568]);
9871 arr1.reshape(1, 8);
9872
9873 let mut arr2 = Array::from(vec![0.7185758352279663,
9874 0.09909920394420624,
9875 0.4448649287223816,
9876 0.47341388463974,
9877 0.5639866590499878,
9878 0.6206879019737244,
9879 0.07192548364400864,
9880 0.9532538652420044]);
9881 arr2.reshape(1, 8);
9882
9883 let mut result = Array::from(vec![1.235918641090393,
9884 2.9964406490325928,
9885 0.6823728084564209,
9886 0.9919690489768982,
9887 1.2592724561691284,
9888 1.2613134384155273,
9889 10.69062614440918,
9890 0.9632346034049988]);
9891 result.reshape(1, 8);
9892
9893 assert!(allclose(&arr1.div(&arr2), &result));
9894
9895 arr1.div_inplace(&arr2);
9896 assert!(allclose(&arr1, &result));
9897 }
9898
9899
9900
9901 #[test]
9902 fn test_array_op_add_2() {
9903
9904 let mut arr1 =
9905 Array::from(vec![0.18118929862976074, 0.03301256150007248, 0.40168774127960205]);
9906 arr1.reshape(3, 1);
9907
9908 let mut arr2 =
9909 Array::from(vec![0.8023808002471924, 0.3789193034172058, 0.4163742959499359]);
9910 arr2.reshape(3, 1);
9911
9912 let mut result =
9913 Array::from(vec![0.9835700988769531, 0.4119318723678589, 0.8180620670318604]);
9914 result.reshape(3, 1);
9915
9916 assert!(allclose(&arr1.add(&arr2), &result));
9917
9918 arr1.add_inplace(&arr2);
9919 assert!(allclose(&arr1, &result));
9920 }
9921
9922
9923
9924 #[test]
9925 fn test_array_op_sub_2() {
9926
9927 let mut arr1 =
9928 Array::from(vec![0.18118929862976074, 0.03301256150007248, 0.40168774127960205]);
9929 arr1.reshape(3, 1);
9930
9931 let mut arr2 =
9932 Array::from(vec![0.8023808002471924, 0.3789193034172058, 0.4163742959499359]);
9933 arr2.reshape(3, 1);
9934
9935 let mut result =
9936 Array::from(vec![-0.6211915016174316, -0.34590673446655273, -0.014686554670333862]);
9937 result.reshape(3, 1);
9938
9939 assert!(allclose(&arr1.sub(&arr2), &result));
9940
9941 arr1.sub_inplace(&arr2);
9942 assert!(allclose(&arr1, &result));
9943 }
9944
9945
9946
9947 #[test]
9948 fn test_array_op_times_2() {
9949
9950 let mut arr1 =
9951 Array::from(vec![0.18118929862976074, 0.03301256150007248, 0.40168774127960205]);
9952 arr1.reshape(3, 1);
9953
9954 let mut arr2 =
9955 Array::from(vec![0.8023808002471924, 0.3789193034172058, 0.4163742959499359]);
9956 arr2.reshape(3, 1);
9957
9958 let mut result =
9959 Array::from(vec![0.145382821559906, 0.012509096413850784, 0.16725245118141174]);
9960 result.reshape(3, 1);
9961
9962 assert!(allclose(&arr1.times(&arr2), &result));
9963
9964 arr1.times_inplace(&arr2);
9965 assert!(allclose(&arr1, &result));
9966 }
9967
9968
9969
9970 #[test]
9971 fn test_array_op_div_2() {
9972
9973 let mut arr1 =
9974 Array::from(vec![0.18118929862976074, 0.03301256150007248, 0.40168774127960205]);
9975 arr1.reshape(3, 1);
9976
9977 let mut arr2 =
9978 Array::from(vec![0.8023808002471924, 0.3789193034172058, 0.4163742959499359]);
9979 arr2.reshape(3, 1);
9980
9981 let mut result =
9982 Array::from(vec![0.2258145958185196, 0.08712293207645416, 0.964727520942688]);
9983 result.reshape(3, 1);
9984
9985 assert!(allclose(&arr1.div(&arr2), &result));
9986
9987 arr1.div_inplace(&arr2);
9988 assert!(allclose(&arr1, &result));
9989 }
9990
9991
9992
9993 #[test]
9994 fn test_array_op_add_3() {
9995
9996 let mut arr1 = Array::from(vec![0.4638933837413788,
9997 0.5166852474212646,
9998 0.6040269136428833,
9999 0.48605096340179443,
10000 0.9754371643066406,
10001 0.09661200642585754,
10002 0.5302534699440002,
10003 0.16749703884124756,
10004 0.51143479347229,
10005 0.8663506507873535,
10006 0.10709835588932037,
10007 0.915748119354248,
10008 0.4255952835083008,
10009 0.26459333300590515,
10010 0.526462972164154,
10011 0.7321544885635376,
10012 0.40716248750686646,
10013 0.13814333081245422,
10014 0.4818677008152008,
10015 0.7770387530326843,
10016 0.2103804051876068,
10017 0.004492859821766615,
10018 0.7736490368843079,
10019 0.11656702309846878,
10020 0.9824181199073792,
10021 0.6940855979919434,
10022 0.1370224505662918,
10023 0.46714478731155396,
10024 0.5641428828239441,
10025 0.4161204695701599,
10026 0.8921078443527222,
10027 0.3001706004142761,
10028 0.2636280953884125,
10029 0.5209411382675171,
10030 0.7548863887786865,
10031 0.8441078066825867,
10032 0.8554396629333496,
10033 0.034851253032684326,
10034 0.8351829648017883,
10035 0.8715921640396118]);
10036 arr1.reshape(8, 5);
10037
10038 let mut arr2 = Array::from(vec![0.4195884168148041,
10039 0.5114026665687561,
10040 0.2934894561767578,
10041 0.2409084439277649,
10042 0.4596225917339325,
10043 0.4888952672481537,
10044 0.6638343334197998,
10045 0.388359934091568,
10046 0.46549633145332336,
10047 0.5773903727531433,
10048 0.03631483390927315,
10049 0.9943253993988037,
10050 0.0273441094905138,
10051 0.020947275683283806,
10052 0.31343042850494385,
10053 0.07427830994129181,
10054 0.19509199261665344,
10055 0.1998319774866104,
10056 0.20672959089279175,
10057 0.3237887918949127,
10058 0.28872179985046387,
10059 0.36704495549201965,
10060 0.3148595988750458,
10061 0.8327291011810303,
10062 0.9654577374458313,
10063 0.9463678002357483,
10064 0.48835742473602295,
10065 0.9109439253807068,
10066 0.030691994354128838,
10067 0.9641919732093811,
10068 0.43064993619918823,
10069 0.446991503238678,
10070 0.2768392860889435,
10071 0.8910713791847229,
10072 0.23636873066425323,
10073 0.8908159136772156,
10074 0.7293870449066162,
10075 0.2140239179134369,
10076 0.7874829173088074,
10077 0.8699233531951904]);
10078 arr2.reshape(8, 5);
10079
10080 let mut result = Array::from(vec![0.8834818005561829,
10081 1.028087854385376,
10082 0.8975163698196411,
10083 0.7269594073295593,
10084 1.4350597858428955,
10085 0.5855072736740112,
10086 1.1940877437591553,
10087 0.5558569431304932,
10088 0.976931095123291,
10089 1.4437410831451416,
10090 0.14341318607330322,
10091 1.9100735187530518,
10092 0.45293939113616943,
10093 0.2855406105518341,
10094 0.8398934006690979,
10095 0.8064327836036682,
10096 0.6022545099258423,
10097 0.33797532320022583,
10098 0.6885973215103149,
10099 1.1008275747299194,
10100 0.4991022050380707,
10101 0.37153780460357666,
10102 1.0885086059570312,
10103 0.9492961168289185,
10104 1.9478758573532104,
10105 1.6404533386230469,
10106 0.6253798604011536,
10107 1.3780887126922607,
10108 0.5948348641395569,
10109 1.380312442779541,
10110 1.3227577209472656,
10111 0.7471621036529541,
10112 0.540467381477356,
10113 1.4120125770568848,
10114 0.9912551045417786,
10115 1.7349237203598022,
10116 1.5848267078399658,
10117 0.24887517094612122,
10118 1.6226658821105957,
10119 1.7415155172348022]);
10120 result.reshape(8, 5);
10121
10122 assert!(allclose(&arr1.add(&arr2), &result));
10123
10124 arr1.add_inplace(&arr2);
10125 assert!(allclose(&arr1, &result));
10126 }
10127
10128
10129
10130 #[test]
10131 fn test_array_op_sub_3() {
10132
10133 let mut arr1 = Array::from(vec![0.4638933837413788,
10134 0.5166852474212646,
10135 0.6040269136428833,
10136 0.48605096340179443,
10137 0.9754371643066406,
10138 0.09661200642585754,
10139 0.5302534699440002,
10140 0.16749703884124756,
10141 0.51143479347229,
10142 0.8663506507873535,
10143 0.10709835588932037,
10144 0.915748119354248,
10145 0.4255952835083008,
10146 0.26459333300590515,
10147 0.526462972164154,
10148 0.7321544885635376,
10149 0.40716248750686646,
10150 0.13814333081245422,
10151 0.4818677008152008,
10152 0.7770387530326843,
10153 0.2103804051876068,
10154 0.004492859821766615,
10155 0.7736490368843079,
10156 0.11656702309846878,
10157 0.9824181199073792,
10158 0.6940855979919434,
10159 0.1370224505662918,
10160 0.46714478731155396,
10161 0.5641428828239441,
10162 0.4161204695701599,
10163 0.8921078443527222,
10164 0.3001706004142761,
10165 0.2636280953884125,
10166 0.5209411382675171,
10167 0.7548863887786865,
10168 0.8441078066825867,
10169 0.8554396629333496,
10170 0.034851253032684326,
10171 0.8351829648017883,
10172 0.8715921640396118]);
10173 arr1.reshape(8, 5);
10174
10175 let mut arr2 = Array::from(vec![0.4195884168148041,
10176 0.5114026665687561,
10177 0.2934894561767578,
10178 0.2409084439277649,
10179 0.4596225917339325,
10180 0.4888952672481537,
10181 0.6638343334197998,
10182 0.388359934091568,
10183 0.46549633145332336,
10184 0.5773903727531433,
10185 0.03631483390927315,
10186 0.9943253993988037,
10187 0.0273441094905138,
10188 0.020947275683283806,
10189 0.31343042850494385,
10190 0.07427830994129181,
10191 0.19509199261665344,
10192 0.1998319774866104,
10193 0.20672959089279175,
10194 0.3237887918949127,
10195 0.28872179985046387,
10196 0.36704495549201965,
10197 0.3148595988750458,
10198 0.8327291011810303,
10199 0.9654577374458313,
10200 0.9463678002357483,
10201 0.48835742473602295,
10202 0.9109439253807068,
10203 0.030691994354128838,
10204 0.9641919732093811,
10205 0.43064993619918823,
10206 0.446991503238678,
10207 0.2768392860889435,
10208 0.8910713791847229,
10209 0.23636873066425323,
10210 0.8908159136772156,
10211 0.7293870449066162,
10212 0.2140239179134369,
10213 0.7874829173088074,
10214 0.8699233531951904]);
10215 arr2.reshape(8, 5);
10216
10217 let mut result = Array::from(vec![0.04430496692657471,
10218 0.005282580852508545,
10219 0.3105374574661255,
10220 0.24514251947402954,
10221 0.5158145427703857,
10222 -0.39228326082229614,
10223 -0.13358086347579956,
10224 -0.22086289525032043,
10225 0.045938462018966675,
10226 0.2889602780342102,
10227 0.07078352570533752,
10228 -0.07857728004455566,
10229 0.39825117588043213,
10230 0.2436460554599762,
10231 0.2130325436592102,
10232 0.657876193523407,
10233 0.212070494890213,
10234 -0.06168864667415619,
10235 0.27513810992240906,
10236 0.4532499611377716,
10237 -0.07834139466285706,
10238 -0.36255210638046265,
10239 0.4587894380092621,
10240 -0.7161620855331421,
10241 0.01696038246154785,
10242 -0.25228220224380493,
10243 -0.35133498907089233,
10244 -0.44379913806915283,
10245 0.5334509015083313,
10246 -0.5480715036392212,
10247 0.46145790815353394,
10248 -0.14682090282440186,
10249 -0.013211190700531006,
10250 -0.3701302409172058,
10251 0.5185176730155945,
10252 -0.046708106994628906,
10253 0.1260526180267334,
10254 -0.17917266488075256,
10255 0.04770004749298096,
10256 0.0016688108444213867]);
10257 result.reshape(8, 5);
10258
10259 assert!(allclose(&arr1.sub(&arr2), &result));
10260
10261 arr1.sub_inplace(&arr2);
10262 assert!(allclose(&arr1, &result));
10263 }
10264
10265
10266
10267 #[test]
10268 fn test_array_op_times_3() {
10269
10270 let mut arr1 = Array::from(vec![0.4638933837413788,
10271 0.5166852474212646,
10272 0.6040269136428833,
10273 0.48605096340179443,
10274 0.9754371643066406,
10275 0.09661200642585754,
10276 0.5302534699440002,
10277 0.16749703884124756,
10278 0.51143479347229,
10279 0.8663506507873535,
10280 0.10709835588932037,
10281 0.915748119354248,
10282 0.4255952835083008,
10283 0.26459333300590515,
10284 0.526462972164154,
10285 0.7321544885635376,
10286 0.40716248750686646,
10287 0.13814333081245422,
10288 0.4818677008152008,
10289 0.7770387530326843,
10290 0.2103804051876068,
10291 0.004492859821766615,
10292 0.7736490368843079,
10293 0.11656702309846878,
10294 0.9824181199073792,
10295 0.6940855979919434,
10296 0.1370224505662918,
10297 0.46714478731155396,
10298 0.5641428828239441,
10299 0.4161204695701599,
10300 0.8921078443527222,
10301 0.3001706004142761,
10302 0.2636280953884125,
10303 0.5209411382675171,
10304 0.7548863887786865,
10305 0.8441078066825867,
10306 0.8554396629333496,
10307 0.034851253032684326,
10308 0.8351829648017883,
10309 0.8715921640396118]);
10310 arr1.reshape(8, 5);
10311
10312 let mut arr2 = Array::from(vec![0.4195884168148041,
10313 0.5114026665687561,
10314 0.2934894561767578,
10315 0.2409084439277649,
10316 0.4596225917339325,
10317 0.4888952672481537,
10318 0.6638343334197998,
10319 0.388359934091568,
10320 0.46549633145332336,
10321 0.5773903727531433,
10322 0.03631483390927315,
10323 0.9943253993988037,
10324 0.0273441094905138,
10325 0.020947275683283806,
10326 0.31343042850494385,
10327 0.07427830994129181,
10328 0.19509199261665344,
10329 0.1998319774866104,
10330 0.20672959089279175,
10331 0.3237887918949127,
10332 0.28872179985046387,
10333 0.36704495549201965,
10334 0.3148595988750458,
10335 0.8327291011810303,
10336 0.9654577374458313,
10337 0.9463678002357483,
10338 0.48835742473602295,
10339 0.9109439253807068,
10340 0.030691994354128838,
10341 0.9641919732093811,
10342 0.43064993619918823,
10343 0.446991503238678,
10344 0.2768392860889435,
10345 0.8910713791847229,
10346 0.23636873066425323,
10347 0.8908159136772156,
10348 0.7293870449066162,
10349 0.2140239179134369,
10350 0.7874829173088074,
10351 0.8699233531951904]);
10352 arr2.reshape(8, 5);
10353
10354 let mut result = Array::from(vec![0.1946442872285843,
10355 0.2642342150211334,
10356 0.17727552354335785,
10357 0.1170937791466713,
10358 0.4483329653739929,
10359 0.04723315313458443,
10360 0.3520004451274872,
10361 0.06504914164543152,
10362 0.2380710244178772,
10363 0.5002225041389465,
10364 0.003889258950948715,
10365 0.9105516076087952,
10366 0.011637523770332336,
10367 0.0055425092577934265,
10368 0.1650095134973526,
10369 0.05438319966197014,
10370 0.07943414151668549,
10371 0.027605455368757248,
10372 0.09961631149053574,
10373 0.25159645080566406,
10374 0.06074140965938568,
10375 0.0016490815905854106,
10376 0.2435908317565918,
10377 0.09706874936819077,
10378 0.9484831690788269,
10379 0.6568602323532104,
10380 0.06691592931747437,
10381 0.4255427122116089,
10382 0.017314670607447624,
10383 0.40122002363204956,
10384 0.38418617844581604,
10385 0.1341737061738968,
10386 0.07298261672258377,
10387 0.46419572830200195,
10388 0.17843154072761536,
10389 0.7519446611404419,
10390 0.6239466071128845,
10391 0.007459001615643501,
10392 0.6576923131942749,
10393 0.7582184076309204]);
10394 result.reshape(8, 5);
10395
10396 assert!(allclose(&arr1.times(&arr2), &result));
10397
10398 arr1.times_inplace(&arr2);
10399 assert!(allclose(&arr1, &result));
10400 }
10401
10402
10403
10404 #[test]
10405 fn test_array_op_div_3() {
10406
10407 let mut arr1 = Array::from(vec![0.4638933837413788,
10408 0.5166852474212646,
10409 0.6040269136428833,
10410 0.48605096340179443,
10411 0.9754371643066406,
10412 0.09661200642585754,
10413 0.5302534699440002,
10414 0.16749703884124756,
10415 0.51143479347229,
10416 0.8663506507873535,
10417 0.10709835588932037,
10418 0.915748119354248,
10419 0.4255952835083008,
10420 0.26459333300590515,
10421 0.526462972164154,
10422 0.7321544885635376,
10423 0.40716248750686646,
10424 0.13814333081245422,
10425 0.4818677008152008,
10426 0.7770387530326843,
10427 0.2103804051876068,
10428 0.004492859821766615,
10429 0.7736490368843079,
10430 0.11656702309846878,
10431 0.9824181199073792,
10432 0.6940855979919434,
10433 0.1370224505662918,
10434 0.46714478731155396,
10435 0.5641428828239441,
10436 0.4161204695701599,
10437 0.8921078443527222,
10438 0.3001706004142761,
10439 0.2636280953884125,
10440 0.5209411382675171,
10441 0.7548863887786865,
10442 0.8441078066825867,
10443 0.8554396629333496,
10444 0.034851253032684326,
10445 0.8351829648017883,
10446 0.8715921640396118]);
10447 arr1.reshape(8, 5);
10448
10449 let mut arr2 = Array::from(vec![0.4195884168148041,
10450 0.5114026665687561,
10451 0.2934894561767578,
10452 0.2409084439277649,
10453 0.4596225917339325,
10454 0.4888952672481537,
10455 0.6638343334197998,
10456 0.388359934091568,
10457 0.46549633145332336,
10458 0.5773903727531433,
10459 0.03631483390927315,
10460 0.9943253993988037,
10461 0.0273441094905138,
10462 0.020947275683283806,
10463 0.31343042850494385,
10464 0.07427830994129181,
10465 0.19509199261665344,
10466 0.1998319774866104,
10467 0.20672959089279175,
10468 0.3237887918949127,
10469 0.28872179985046387,
10470 0.36704495549201965,
10471 0.3148595988750458,
10472 0.8327291011810303,
10473 0.9654577374458313,
10474 0.9463678002357483,
10475 0.48835742473602295,
10476 0.9109439253807068,
10477 0.030691994354128838,
10478 0.9641919732093811,
10479 0.43064993619918823,
10480 0.446991503238678,
10481 0.2768392860889435,
10482 0.8910713791847229,
10483 0.23636873066425323,
10484 0.8908159136772156,
10485 0.7293870449066162,
10486 0.2140239179134369,
10487 0.7874829173088074,
10488 0.8699233531951904]);
10489 arr2.reshape(8, 5);
10490
10491 let mut result = Array::from(vec![1.1055915355682373,
10492 1.0103296041488647,
10493 2.0580873489379883,
10494 2.01757550239563,
10495 2.1222567558288574,
10496 0.19761289656162262,
10497 0.7987737655639648,
10498 0.4312933087348938,
10499 1.0986870527267456,
10500 1.50045907497406,
10501 2.949162721633911,
10502 0.9209742546081543,
10503 15.564422607421875,
10504 12.631396293640137,
10505 1.6796804666519165,
10506 9.856907844543457,
10507 2.0870282649993896,
10508 0.6912974119186401,
10509 2.3309082984924316,
10510 2.399832248687744,
10511 0.728661298751831,
10512 0.012240624986588955,
10513 2.4571237564086914,
10514 0.1399819254875183,
10515 1.0175671577453613,
10516 0.7334205508232117,
10517 0.2805781960487366,
10518 0.5128139853477478,
10519 18.380783081054688,
10520 0.431574285030365,
10521 2.071538209915161,
10522 0.6715353727340698,
10523 0.9522784948348999,
10524 0.5846233367919922,
10525 3.193681240081787,
10526 0.9475670456886292,
10527 1.172819972038269,
10528 0.16283811628818512,
10529 1.0605727434158325,
10530 1.0019183158874512]);
10531 result.reshape(8, 5);
10532
10533 assert!(allclose(&arr1.div(&arr2), &result));
10534
10535 arr1.div_inplace(&arr2);
10536 assert!(allclose(&arr1, &result));
10537 }
10538
10539
10540
10541 #[test]
10542 fn test_array_op_add_4() {
10543
10544 let mut arr1 = Array::from(vec![0.7055813670158386,
10545 0.049010876566171646,
10546 0.1050436869263649,
10547 0.9104152321815491,
10548 0.10784147679805756,
10549 0.5316178798675537]);
10550 arr1.reshape(3, 2);
10551
10552 let mut arr2 = Array::from(vec![0.1656838208436966,
10553 0.7906498908996582,
10554 0.4941992461681366,
10555 0.9727036952972412,
10556 0.6521415114402771,
10557 0.9028323292732239]);
10558 arr2.reshape(3, 2);
10559
10560 let mut result = Array::from(vec![0.871265172958374,
10561 0.8396607637405396,
10562 0.5992429256439209,
10563 1.8831188678741455,
10564 0.7599830031394958,
10565 1.4344501495361328]);
10566 result.reshape(3, 2);
10567
10568 assert!(allclose(&arr1.add(&arr2), &result));
10569
10570 arr1.add_inplace(&arr2);
10571 assert!(allclose(&arr1, &result));
10572 }
10573
10574
10575
10576 #[test]
10577 fn test_array_op_sub_4() {
10578
10579 let mut arr1 = Array::from(vec![0.7055813670158386,
10580 0.049010876566171646,
10581 0.1050436869263649,
10582 0.9104152321815491,
10583 0.10784147679805756,
10584 0.5316178798675537]);
10585 arr1.reshape(3, 2);
10586
10587 let mut arr2 = Array::from(vec![0.1656838208436966,
10588 0.7906498908996582,
10589 0.4941992461681366,
10590 0.9727036952972412,
10591 0.6521415114402771,
10592 0.9028323292732239]);
10593 arr2.reshape(3, 2);
10594
10595 let mut result = Array::from(vec![0.5398975610733032,
10596 -0.7416390180587769,
10597 -0.3891555666923523,
10598 -0.06228846311569214,
10599 -0.5443000197410583,
10600 -0.37121444940567017]);
10601 result.reshape(3, 2);
10602
10603 assert!(allclose(&arr1.sub(&arr2), &result));
10604
10605 arr1.sub_inplace(&arr2);
10606 assert!(allclose(&arr1, &result));
10607 }
10608
10609
10610
10611 #[test]
10612 fn test_array_op_times_4() {
10613
10614 let mut arr1 = Array::from(vec![0.7055813670158386,
10615 0.049010876566171646,
10616 0.1050436869263649,
10617 0.9104152321815491,
10618 0.10784147679805756,
10619 0.5316178798675537]);
10620 arr1.reshape(3, 2);
10621
10622 let mut arr2 = Array::from(vec![0.1656838208436966,
10623 0.7906498908996582,
10624 0.4941992461681366,
10625 0.9727036952972412,
10626 0.6521415114402771,
10627 0.9028323292732239]);
10628 arr2.reshape(3, 2);
10629
10630 let mut result = Array::from(vec![0.11690341681241989,
10631 0.03875044360756874,
10632 0.05191251263022423,
10633 0.8855642676353455,
10634 0.07032790035009384,
10635 0.4799618124961853]);
10636 result.reshape(3, 2);
10637
10638 assert!(allclose(&arr1.times(&arr2), &result));
10639
10640 arr1.times_inplace(&arr2);
10641 assert!(allclose(&arr1, &result));
10642 }
10643
10644
10645
10646 #[test]
10647 fn test_array_op_div_4() {
10648
10649 let mut arr1 = Array::from(vec![0.7055813670158386,
10650 0.049010876566171646,
10651 0.1050436869263649,
10652 0.9104152321815491,
10653 0.10784147679805756,
10654 0.5316178798675537]);
10655 arr1.reshape(3, 2);
10656
10657 let mut arr2 = Array::from(vec![0.1656838208436966,
10658 0.7906498908996582,
10659 0.4941992461681366,
10660 0.9727036952972412,
10661 0.6521415114402771,
10662 0.9028323292732239]);
10663 arr2.reshape(3, 2);
10664
10665 let mut result = Array::from(vec![4.258601665496826,
10666 0.061988089233636856,
10667 0.21255330741405487,
10668 0.9359635710716248,
10669 0.16536514461040497,
10670 0.5888334512710571]);
10671 result.reshape(3, 2);
10672
10673 assert!(allclose(&arr1.div(&arr2), &result));
10674
10675 arr1.div_inplace(&arr2);
10676 assert!(allclose(&arr1, &result));
10677 }
10678
10679
10680
10681 #[test]
10682 fn test_array_op_add_5() {
10683
10684 let mut arr1 =
10685 Array::from(vec![0.9063590168952942, 0.42833206057548523, 0.2654511630535126]);
10686 arr1.reshape(1, 3);
10687
10688 let mut arr2 =
10689 Array::from(vec![0.9844111800193787, 0.9482954144477844, 0.5508551597595215]);
10690 arr2.reshape(1, 3);
10691
10692 let mut result =
10693 Array::from(vec![1.8907701969146729, 1.3766274452209473, 0.8163063526153564]);
10694 result.reshape(1, 3);
10695
10696 assert!(allclose(&arr1.add(&arr2), &result));
10697
10698 arr1.add_inplace(&arr2);
10699 assert!(allclose(&arr1, &result));
10700 }
10701
10702
10703
10704 #[test]
10705 fn test_array_op_sub_5() {
10706
10707 let mut arr1 =
10708 Array::from(vec![0.9063590168952942, 0.42833206057548523, 0.2654511630535126]);
10709 arr1.reshape(1, 3);
10710
10711 let mut arr2 =
10712 Array::from(vec![0.9844111800193787, 0.9482954144477844, 0.5508551597595215]);
10713 arr2.reshape(1, 3);
10714
10715 let mut result =
10716 Array::from(vec![-0.07805216312408447, -0.5199633836746216, -0.2854039967060089]);
10717 result.reshape(1, 3);
10718
10719 assert!(allclose(&arr1.sub(&arr2), &result));
10720
10721 arr1.sub_inplace(&arr2);
10722 assert!(allclose(&arr1, &result));
10723 }
10724
10725
10726
10727 #[test]
10728 fn test_array_op_times_5() {
10729
10730 let mut arr1 =
10731 Array::from(vec![0.9063590168952942, 0.42833206057548523, 0.2654511630535126]);
10732 arr1.reshape(1, 3);
10733
10734 let mut arr2 =
10735 Array::from(vec![0.9844111800193787, 0.9482954144477844, 0.5508551597595215]);
10736 arr2.reshape(1, 3);
10737
10738 let mut result =
10739 Array::from(vec![0.8922299742698669, 0.4061853289604187, 0.14622513949871063]);
10740 result.reshape(1, 3);
10741
10742 assert!(allclose(&arr1.times(&arr2), &result));
10743
10744 arr1.times_inplace(&arr2);
10745 assert!(allclose(&arr1, &result));
10746 }
10747
10748
10749
10750 #[test]
10751 fn test_array_op_div_5() {
10752
10753 let mut arr1 =
10754 Array::from(vec![0.9063590168952942, 0.42833206057548523, 0.2654511630535126]);
10755 arr1.reshape(1, 3);
10756
10757 let mut arr2 =
10758 Array::from(vec![0.9844111800193787, 0.9482954144477844, 0.5508551597595215]);
10759 arr2.reshape(1, 3);
10760
10761 let mut result =
10762 Array::from(vec![0.9207118153572083, 0.4516863226890564, 0.4818892180919647]);
10763 result.reshape(1, 3);
10764
10765 assert!(allclose(&arr1.div(&arr2), &result));
10766
10767 arr1.div_inplace(&arr2);
10768 assert!(allclose(&arr1, &result));
10769 }
10770
10771
10772
10773 #[test]
10774 fn test_array_op_add_6() {
10775
10776 let mut arr1 = Array::from(vec![0.23602057993412018,
10777 0.07694604992866516,
10778 0.982704222202301,
10779 0.7931925058364868,
10780 0.23201315104961395]);
10781 arr1.reshape(5, 1);
10782
10783 let mut arr2 = Array::from(vec![0.007808223832398653,
10784 0.6496497988700867,
10785 0.40739911794662476,
10786 0.8071744441986084,
10787 0.7914289832115173]);
10788 arr2.reshape(5, 1);
10789
10790 let mut result = Array::from(vec![0.24382880330085754,
10791 0.7265958786010742,
10792 1.3901033401489258,
10793 1.6003669500350952,
10794 1.0234421491622925]);
10795 result.reshape(5, 1);
10796
10797 assert!(allclose(&arr1.add(&arr2), &result));
10798
10799 arr1.add_inplace(&arr2);
10800 assert!(allclose(&arr1, &result));
10801 }
10802
10803
10804
10805 #[test]
10806 fn test_array_op_sub_6() {
10807
10808 let mut arr1 = Array::from(vec![0.23602057993412018,
10809 0.07694604992866516,
10810 0.982704222202301,
10811 0.7931925058364868,
10812 0.23201315104961395]);
10813 arr1.reshape(5, 1);
10814
10815 let mut arr2 = Array::from(vec![0.007808223832398653,
10816 0.6496497988700867,
10817 0.40739911794662476,
10818 0.8071744441986084,
10819 0.7914289832115173]);
10820 arr2.reshape(5, 1);
10821
10822 let mut result = Array::from(vec![0.2282123565673828,
10823 -0.5727037191390991,
10824 0.5753051042556763,
10825 -0.013981938362121582,
10826 -0.5594158172607422]);
10827 result.reshape(5, 1);
10828
10829 assert!(allclose(&arr1.sub(&arr2), &result));
10830
10831 arr1.sub_inplace(&arr2);
10832 assert!(allclose(&arr1, &result));
10833 }
10834
10835
10836
10837 #[test]
10838 fn test_array_op_times_6() {
10839
10840 let mut arr1 = Array::from(vec![0.23602057993412018,
10841 0.07694604992866516,
10842 0.982704222202301,
10843 0.7931925058364868,
10844 0.23201315104961395]);
10845 arr1.reshape(5, 1);
10846
10847 let mut arr2 = Array::from(vec![0.007808223832398653,
10848 0.6496497988700867,
10849 0.40739911794662476,
10850 0.8071744441986084,
10851 0.7914289832115173]);
10852 arr2.reshape(5, 1);
10853
10854 let mut result = Array::from(vec![0.0018429014598950744,
10855 0.04998798668384552,
10856 0.4003528356552124,
10857 0.640244722366333,
10858 0.18362192809581757]);
10859 result.reshape(5, 1);
10860
10861 assert!(allclose(&arr1.times(&arr2), &result));
10862
10863 arr1.times_inplace(&arr2);
10864 assert!(allclose(&arr1, &result));
10865 }
10866
10867
10868
10869 #[test]
10870 fn test_array_op_div_6() {
10871
10872 let mut arr1 = Array::from(vec![0.23602057993412018,
10873 0.07694604992866516,
10874 0.982704222202301,
10875 0.7931925058364868,
10876 0.23201315104961395]);
10877 arr1.reshape(5, 1);
10878
10879 let mut arr2 = Array::from(vec![0.007808223832398653,
10880 0.6496497988700867,
10881 0.40739911794662476,
10882 0.8071744441986084,
10883 0.7914289832115173]);
10884 arr2.reshape(5, 1);
10885
10886 let mut result = Array::from(vec![30.2271785736084,
10887 0.1184423491358757,
10888 2.4121413230895996,
10889 0.9826779365539551,
10890 0.2931572496891022]);
10891 result.reshape(5, 1);
10892
10893 assert!(allclose(&arr1.div(&arr2), &result));
10894
10895 arr1.div_inplace(&arr2);
10896 assert!(allclose(&arr1, &result));
10897 }
10898
10899
10900
10901 #[test]
10902 fn test_array_op_add_7() {
10903
10904 let mut arr1 =
10905 Array::from(vec![0.16539278626441956, 0.18947423994541168, 0.44509610533714294]);
10906 arr1.reshape(1, 3);
10907
10908 let mut arr2 =
10909 Array::from(vec![0.3894217014312744, 0.22505198419094086, 0.004766093101352453]);
10910 arr2.reshape(1, 3);
10911
10912 let mut result =
10913 Array::from(vec![0.5548144578933716, 0.41452622413635254, 0.44986221194267273]);
10914 result.reshape(1, 3);
10915
10916 assert!(allclose(&arr1.add(&arr2), &result));
10917
10918 arr1.add_inplace(&arr2);
10919 assert!(allclose(&arr1, &result));
10920 }
10921
10922
10923
10924 #[test]
10925 fn test_array_op_sub_7() {
10926
10927 let mut arr1 =
10928 Array::from(vec![0.16539278626441956, 0.18947423994541168, 0.44509610533714294]);
10929 arr1.reshape(1, 3);
10930
10931 let mut arr2 =
10932 Array::from(vec![0.3894217014312744, 0.22505198419094086, 0.004766093101352453]);
10933 arr2.reshape(1, 3);
10934
10935 let mut result =
10936 Array::from(vec![-0.22402891516685486, -0.035577744245529175, 0.44032999873161316]);
10937 result.reshape(1, 3);
10938
10939 assert!(allclose(&arr1.sub(&arr2), &result));
10940
10941 arr1.sub_inplace(&arr2);
10942 assert!(allclose(&arr1, &result));
10943 }
10944
10945
10946
10947 #[test]
10948 fn test_array_op_times_7() {
10949
10950 let mut arr1 =
10951 Array::from(vec![0.16539278626441956, 0.18947423994541168, 0.44509610533714294]);
10952 arr1.reshape(1, 3);
10953
10954 let mut arr2 =
10955 Array::from(vec![0.3894217014312744, 0.22505198419094086, 0.004766093101352453]);
10956 arr2.reshape(1, 3);
10957
10958 let mut result =
10959 Array::from(vec![0.06440754234790802, 0.04264155402779579, 0.0021213695872575045]);
10960 result.reshape(1, 3);
10961
10962 assert!(allclose(&arr1.times(&arr2), &result));
10963
10964 arr1.times_inplace(&arr2);
10965 assert!(allclose(&arr1, &result));
10966 }
10967
10968
10969
10970 #[test]
10971 fn test_array_op_div_7() {
10972
10973 let mut arr1 =
10974 Array::from(vec![0.16539278626441956, 0.18947423994541168, 0.44509610533714294]);
10975 arr1.reshape(1, 3);
10976
10977 let mut arr2 =
10978 Array::from(vec![0.3894217014312744, 0.22505198419094086, 0.004766093101352453]);
10979 arr2.reshape(1, 3);
10980
10981 let mut result =
10982 Array::from(vec![0.4247138500213623, 0.8419132232666016, 93.38804626464844]);
10983 result.reshape(1, 3);
10984
10985 assert!(allclose(&arr1.div(&arr2), &result));
10986
10987 arr1.div_inplace(&arr2);
10988 assert!(allclose(&arr1, &result));
10989 }
10990
10991
10992
10993 #[test]
10994 fn test_array_op_add_8() {
10995
10996 let mut arr1 = Array::from(vec![0.9972392320632935, 0.5522454977035522]);
10997 arr1.reshape(2, 1);
10998
10999 let mut arr2 = Array::from(vec![0.3432486057281494, 0.7847270369529724]);
11000 arr2.reshape(2, 1);
11001
11002 let mut result = Array::from(vec![1.3404878377914429, 1.3369724750518799]);
11003 result.reshape(2, 1);
11004
11005 assert!(allclose(&arr1.add(&arr2), &result));
11006
11007 arr1.add_inplace(&arr2);
11008 assert!(allclose(&arr1, &result));
11009 }
11010
11011
11012
11013 #[test]
11014 fn test_array_op_sub_8() {
11015
11016 let mut arr1 = Array::from(vec![0.9972392320632935, 0.5522454977035522]);
11017 arr1.reshape(2, 1);
11018
11019 let mut arr2 = Array::from(vec![0.3432486057281494, 0.7847270369529724]);
11020 arr2.reshape(2, 1);
11021
11022 let mut result = Array::from(vec![0.653990626335144, -0.23248153924942017]);
11023 result.reshape(2, 1);
11024
11025 assert!(allclose(&arr1.sub(&arr2), &result));
11026
11027 arr1.sub_inplace(&arr2);
11028 assert!(allclose(&arr1, &result));
11029 }
11030
11031
11032
11033 #[test]
11034 fn test_array_op_times_8() {
11035
11036 let mut arr1 = Array::from(vec![0.9972392320632935, 0.5522454977035522]);
11037 arr1.reshape(2, 1);
11038
11039 let mut arr2 = Array::from(vec![0.3432486057281494, 0.7847270369529724]);
11040 arr2.reshape(2, 1);
11041
11042 let mut result = Array::from(vec![0.34230098128318787, 0.4333619773387909]);
11043 result.reshape(2, 1);
11044
11045 assert!(allclose(&arr1.times(&arr2), &result));
11046
11047 arr1.times_inplace(&arr2);
11048 assert!(allclose(&arr1, &result));
11049 }
11050
11051
11052
11053 #[test]
11054 fn test_array_op_div_8() {
11055
11056 let mut arr1 = Array::from(vec![0.9972392320632935, 0.5522454977035522]);
11057 arr1.reshape(2, 1);
11058
11059 let mut arr2 = Array::from(vec![0.3432486057281494, 0.7847270369529724]);
11060 arr2.reshape(2, 1);
11061
11062 let mut result = Array::from(vec![2.90529727935791, 0.7037421464920044]);
11063 result.reshape(2, 1);
11064
11065 assert!(allclose(&arr1.div(&arr2), &result));
11066
11067 arr1.div_inplace(&arr2);
11068 assert!(allclose(&arr1, &result));
11069 }
11070
11071
11072
11073 #[test]
11074 fn test_array_op_add_9() {
11075
11076 let mut arr1 = Array::from(vec![0.881397008895874, 0.8563252687454224]);
11077 arr1.reshape(2, 1);
11078
11079 let mut arr2 = Array::from(vec![0.31069085001945496, 0.7450122833251953]);
11080 arr2.reshape(2, 1);
11081
11082 let mut result = Array::from(vec![1.1920878887176514, 1.6013375520706177]);
11083 result.reshape(2, 1);
11084
11085 assert!(allclose(&arr1.add(&arr2), &result));
11086
11087 arr1.add_inplace(&arr2);
11088 assert!(allclose(&arr1, &result));
11089 }
11090
11091
11092
11093 #[test]
11094 fn test_array_op_sub_9() {
11095
11096 let mut arr1 = Array::from(vec![0.881397008895874, 0.8563252687454224]);
11097 arr1.reshape(2, 1);
11098
11099 let mut arr2 = Array::from(vec![0.31069085001945496, 0.7450122833251953]);
11100 arr2.reshape(2, 1);
11101
11102 let mut result = Array::from(vec![0.5707061290740967, 0.11131298542022705]);
11103 result.reshape(2, 1);
11104
11105 assert!(allclose(&arr1.sub(&arr2), &result));
11106
11107 arr1.sub_inplace(&arr2);
11108 assert!(allclose(&arr1, &result));
11109 }
11110
11111
11112
11113 #[test]
11114 fn test_array_op_times_9() {
11115
11116 let mut arr1 = Array::from(vec![0.881397008895874, 0.8563252687454224]);
11117 arr1.reshape(2, 1);
11118
11119 let mut arr2 = Array::from(vec![0.31069085001945496, 0.7450122833251953]);
11120 arr2.reshape(2, 1);
11121
11122 let mut result = Array::from(vec![0.2738419771194458, 0.6379728317260742]);
11123 result.reshape(2, 1);
11124
11125 assert!(allclose(&arr1.times(&arr2), &result));
11126
11127 arr1.times_inplace(&arr2);
11128 assert!(allclose(&arr1, &result));
11129 }
11130
11131
11132
11133 #[test]
11134 fn test_array_op_div_9() {
11135
11136 let mut arr1 = Array::from(vec![0.881397008895874, 0.8563252687454224]);
11137 arr1.reshape(2, 1);
11138
11139 let mut arr2 = Array::from(vec![0.31069085001945496, 0.7450122833251953]);
11140 arr2.reshape(2, 1);
11141
11142 let mut result = Array::from(vec![2.8368940353393555, 1.1494109630584717]);
11143 result.reshape(2, 1);
11144
11145 assert!(allclose(&arr1.div(&arr2), &result));
11146
11147 arr1.div_inplace(&arr2);
11148 assert!(allclose(&arr1, &result));
11149 }
11150
11151
11152
11153}