@@ -360,6 +360,14 @@ public ITorchTensor<byte> Addbmm(ITorchTensor<byte> batch1, ITorchTensor<byte> b
360
360
return new ByteTensor ( THSTensor_addbmm ( handle , batch1 . Handle , batch2 . Handle , beta , alpha ) ) ;
361
361
}
362
362
363
+ [ DllImport ( "libTorchSharp" ) ]
364
+ extern static IntPtr THSTensor_addmm ( IntPtr mat , IntPtr mat1 , IntPtr mat2 , float beta , float alpha ) ;
365
+
366
+ public ITorchTensor < byte > Addmm ( ITorchTensor < byte > mat1 , ITorchTensor < byte > mat2 , float beta , float alpha )
367
+ {
368
+ return new ByteTensor ( THSTensor_addmm ( handle , mat1 . Handle , mat2 . Handle , beta , alpha ) ) ;
369
+ }
370
+
363
371
[ DllImport ( "libTorchSharp" ) ]
364
372
extern static IntPtr THSTensor_argmax ( IntPtr src , long dimension , bool keep_dim ) ;
365
373
@@ -376,6 +384,14 @@ public ITorchTensor<byte> Baddbmm(ITorchTensor<byte> batch2, ITorchTensor<byte>
376
384
return new ByteTensor ( THSTensor_addbmm ( handle , batch2 . Handle , mat . Handle , beta , alpha ) ) ;
377
385
}
378
386
387
+ [ DllImport ( "libTorchSharp" ) ]
388
+ extern static IntPtr THSTensor_bmm ( IntPtr batch1 , IntPtr batch2 ) ;
389
+
390
+ public ITorchTensor < byte > Bmm ( ITorchTensor < byte > batch2 )
391
+ {
392
+ return new ByteTensor ( THSTensor_bmm ( handle , batch2 . Handle ) ) ;
393
+ }
394
+
379
395
[ DllImport ( "libTorchSharp" ) ]
380
396
extern static IntPtr THSTensor_eq ( IntPtr src , IntPtr trg ) ;
381
397
@@ -393,11 +409,19 @@ public ITorchTensor<byte> Exp()
393
409
}
394
410
395
411
[ DllImport ( "libTorchSharp" ) ]
396
- extern static IntPtr THSTensor_matMul ( IntPtr src , IntPtr target ) ;
412
+ extern static IntPtr THSTensor_matmul ( IntPtr src , IntPtr target ) ;
397
413
398
414
public ITorchTensor < byte > MatMul ( ITorchTensor < byte > target )
399
415
{
400
- return new ByteTensor ( THSTensor_matMul ( handle , target . Handle ) ) ;
416
+ return new ByteTensor ( THSTensor_matmul ( handle , target . Handle ) ) ;
417
+ }
418
+
419
+ [ DllImport ( "libTorchSharp" ) ]
420
+ extern static IntPtr THSTensor_mm ( IntPtr src , IntPtr target ) ;
421
+
422
+ public ITorchTensor < byte > Mm ( ITorchTensor < byte > target )
423
+ {
424
+ return new ByteTensor ( THSTensor_mm ( handle , target . Handle ) ) ;
401
425
}
402
426
403
427
[ DllImport ( "libTorchSharp" ) ]
@@ -848,6 +872,14 @@ public ITorchTensor<short> Addbmm(ITorchTensor<short> batch1, ITorchTensor<short
848
872
return new ShortTensor ( THSTensor_addbmm ( handle , batch1 . Handle , batch2 . Handle , beta , alpha ) ) ;
849
873
}
850
874
875
+ [ DllImport ( "libTorchSharp" ) ]
876
+ extern static IntPtr THSTensor_addmm ( IntPtr mat , IntPtr mat1 , IntPtr mat2 , float beta , float alpha ) ;
877
+
878
+ public ITorchTensor < short > Addmm ( ITorchTensor < short > mat1 , ITorchTensor < short > mat2 , float beta , float alpha )
879
+ {
880
+ return new ShortTensor ( THSTensor_addmm ( handle , mat1 . Handle , mat2 . Handle , beta , alpha ) ) ;
881
+ }
882
+
851
883
[ DllImport ( "libTorchSharp" ) ]
852
884
extern static IntPtr THSTensor_argmax ( IntPtr src , long dimension , bool keep_dim ) ;
853
885
@@ -864,6 +896,14 @@ public ITorchTensor<short> Baddbmm(ITorchTensor<short> batch2, ITorchTensor<shor
864
896
return new ShortTensor ( THSTensor_addbmm ( handle , batch2 . Handle , mat . Handle , beta , alpha ) ) ;
865
897
}
866
898
899
+ [ DllImport ( "libTorchSharp" ) ]
900
+ extern static IntPtr THSTensor_bmm ( IntPtr batch1 , IntPtr batch2 ) ;
901
+
902
+ public ITorchTensor < short > Bmm ( ITorchTensor < short > batch2 )
903
+ {
904
+ return new ShortTensor ( THSTensor_bmm ( handle , batch2 . Handle ) ) ;
905
+ }
906
+
867
907
[ DllImport ( "libTorchSharp" ) ]
868
908
extern static IntPtr THSTensor_eq ( IntPtr src , IntPtr trg ) ;
869
909
@@ -881,11 +921,19 @@ public ITorchTensor<short> Exp()
881
921
}
882
922
883
923
[ DllImport ( "libTorchSharp" ) ]
884
- extern static IntPtr THSTensor_matMul ( IntPtr src , IntPtr target ) ;
924
+ extern static IntPtr THSTensor_matmul ( IntPtr src , IntPtr target ) ;
885
925
886
926
public ITorchTensor < short > MatMul ( ITorchTensor < short > target )
887
927
{
888
- return new ShortTensor ( THSTensor_matMul ( handle , target . Handle ) ) ;
928
+ return new ShortTensor ( THSTensor_matmul ( handle , target . Handle ) ) ;
929
+ }
930
+
931
+ [ DllImport ( "libTorchSharp" ) ]
932
+ extern static IntPtr THSTensor_mm ( IntPtr src , IntPtr target ) ;
933
+
934
+ public ITorchTensor < short > Mm ( ITorchTensor < short > target )
935
+ {
936
+ return new ShortTensor ( THSTensor_mm ( handle , target . Handle ) ) ;
889
937
}
890
938
891
939
[ DllImport ( "libTorchSharp" ) ]
@@ -1336,6 +1384,14 @@ public ITorchTensor<int> Addbmm(ITorchTensor<int> batch1, ITorchTensor<int> batc
1336
1384
return new IntTensor ( THSTensor_addbmm ( handle , batch1 . Handle , batch2 . Handle , beta , alpha ) ) ;
1337
1385
}
1338
1386
1387
+ [ DllImport ( "libTorchSharp" ) ]
1388
+ extern static IntPtr THSTensor_addmm ( IntPtr mat , IntPtr mat1 , IntPtr mat2 , float beta , float alpha ) ;
1389
+
1390
+ public ITorchTensor < int > Addmm ( ITorchTensor < int > mat1 , ITorchTensor < int > mat2 , float beta , float alpha )
1391
+ {
1392
+ return new IntTensor ( THSTensor_addmm ( handle , mat1 . Handle , mat2 . Handle , beta , alpha ) ) ;
1393
+ }
1394
+
1339
1395
[ DllImport ( "libTorchSharp" ) ]
1340
1396
extern static IntPtr THSTensor_argmax ( IntPtr src , long dimension , bool keep_dim ) ;
1341
1397
@@ -1352,6 +1408,14 @@ public ITorchTensor<int> Baddbmm(ITorchTensor<int> batch2, ITorchTensor<int> mat
1352
1408
return new IntTensor ( THSTensor_addbmm ( handle , batch2 . Handle , mat . Handle , beta , alpha ) ) ;
1353
1409
}
1354
1410
1411
+ [ DllImport ( "libTorchSharp" ) ]
1412
+ extern static IntPtr THSTensor_bmm ( IntPtr batch1 , IntPtr batch2 ) ;
1413
+
1414
+ public ITorchTensor < int > Bmm ( ITorchTensor < int > batch2 )
1415
+ {
1416
+ return new IntTensor ( THSTensor_bmm ( handle , batch2 . Handle ) ) ;
1417
+ }
1418
+
1355
1419
[ DllImport ( "libTorchSharp" ) ]
1356
1420
extern static IntPtr THSTensor_eq ( IntPtr src , IntPtr trg ) ;
1357
1421
@@ -1369,11 +1433,19 @@ public ITorchTensor<int> Exp()
1369
1433
}
1370
1434
1371
1435
[ DllImport ( "libTorchSharp" ) ]
1372
- extern static IntPtr THSTensor_matMul ( IntPtr src , IntPtr target ) ;
1436
+ extern static IntPtr THSTensor_matmul ( IntPtr src , IntPtr target ) ;
1373
1437
1374
1438
public ITorchTensor < int > MatMul ( ITorchTensor < int > target )
1375
1439
{
1376
- return new IntTensor ( THSTensor_matMul ( handle , target . Handle ) ) ;
1440
+ return new IntTensor ( THSTensor_matmul ( handle , target . Handle ) ) ;
1441
+ }
1442
+
1443
+ [ DllImport ( "libTorchSharp" ) ]
1444
+ extern static IntPtr THSTensor_mm ( IntPtr src , IntPtr target ) ;
1445
+
1446
+ public ITorchTensor < int > Mm ( ITorchTensor < int > target )
1447
+ {
1448
+ return new IntTensor ( THSTensor_mm ( handle , target . Handle ) ) ;
1377
1449
}
1378
1450
1379
1451
[ DllImport ( "libTorchSharp" ) ]
@@ -1824,6 +1896,14 @@ public ITorchTensor<long> Addbmm(ITorchTensor<long> batch1, ITorchTensor<long> b
1824
1896
return new LongTensor ( THSTensor_addbmm ( handle , batch1 . Handle , batch2 . Handle , beta , alpha ) ) ;
1825
1897
}
1826
1898
1899
+ [ DllImport ( "libTorchSharp" ) ]
1900
+ extern static IntPtr THSTensor_addmm ( IntPtr mat , IntPtr mat1 , IntPtr mat2 , float beta , float alpha ) ;
1901
+
1902
+ public ITorchTensor < long > Addmm ( ITorchTensor < long > mat1 , ITorchTensor < long > mat2 , float beta , float alpha )
1903
+ {
1904
+ return new LongTensor ( THSTensor_addmm ( handle , mat1 . Handle , mat2 . Handle , beta , alpha ) ) ;
1905
+ }
1906
+
1827
1907
[ DllImport ( "libTorchSharp" ) ]
1828
1908
extern static IntPtr THSTensor_argmax ( IntPtr src , long dimension , bool keep_dim ) ;
1829
1909
@@ -1840,6 +1920,14 @@ public ITorchTensor<long> Baddbmm(ITorchTensor<long> batch2, ITorchTensor<long>
1840
1920
return new LongTensor ( THSTensor_addbmm ( handle , batch2 . Handle , mat . Handle , beta , alpha ) ) ;
1841
1921
}
1842
1922
1923
+ [ DllImport ( "libTorchSharp" ) ]
1924
+ extern static IntPtr THSTensor_bmm ( IntPtr batch1 , IntPtr batch2 ) ;
1925
+
1926
+ public ITorchTensor < long > Bmm ( ITorchTensor < long > batch2 )
1927
+ {
1928
+ return new LongTensor ( THSTensor_bmm ( handle , batch2 . Handle ) ) ;
1929
+ }
1930
+
1843
1931
[ DllImport ( "libTorchSharp" ) ]
1844
1932
extern static IntPtr THSTensor_eq ( IntPtr src , IntPtr trg ) ;
1845
1933
@@ -1857,11 +1945,19 @@ public ITorchTensor<long> Exp()
1857
1945
}
1858
1946
1859
1947
[ DllImport ( "libTorchSharp" ) ]
1860
- extern static IntPtr THSTensor_matMul ( IntPtr src , IntPtr target ) ;
1948
+ extern static IntPtr THSTensor_matmul ( IntPtr src , IntPtr target ) ;
1861
1949
1862
1950
public ITorchTensor < long > MatMul ( ITorchTensor < long > target )
1863
1951
{
1864
- return new LongTensor ( THSTensor_matMul ( handle , target . Handle ) ) ;
1952
+ return new LongTensor ( THSTensor_matmul ( handle , target . Handle ) ) ;
1953
+ }
1954
+
1955
+ [ DllImport ( "libTorchSharp" ) ]
1956
+ extern static IntPtr THSTensor_mm ( IntPtr src , IntPtr target ) ;
1957
+
1958
+ public ITorchTensor < long > Mm ( ITorchTensor < long > target )
1959
+ {
1960
+ return new LongTensor ( THSTensor_mm ( handle , target . Handle ) ) ;
1865
1961
}
1866
1962
1867
1963
[ DllImport ( "libTorchSharp" ) ]
@@ -2312,6 +2408,14 @@ public ITorchTensor<double> Addbmm(ITorchTensor<double> batch1, ITorchTensor<dou
2312
2408
return new DoubleTensor ( THSTensor_addbmm ( handle , batch1 . Handle , batch2 . Handle , beta , alpha ) ) ;
2313
2409
}
2314
2410
2411
+ [ DllImport ( "libTorchSharp" ) ]
2412
+ extern static IntPtr THSTensor_addmm ( IntPtr mat , IntPtr mat1 , IntPtr mat2 , float beta , float alpha ) ;
2413
+
2414
+ public ITorchTensor < double > Addmm ( ITorchTensor < double > mat1 , ITorchTensor < double > mat2 , float beta , float alpha )
2415
+ {
2416
+ return new DoubleTensor ( THSTensor_addmm ( handle , mat1 . Handle , mat2 . Handle , beta , alpha ) ) ;
2417
+ }
2418
+
2315
2419
[ DllImport ( "libTorchSharp" ) ]
2316
2420
extern static IntPtr THSTensor_argmax ( IntPtr src , long dimension , bool keep_dim ) ;
2317
2421
@@ -2328,6 +2432,14 @@ public ITorchTensor<double> Baddbmm(ITorchTensor<double> batch2, ITorchTensor<do
2328
2432
return new DoubleTensor ( THSTensor_addbmm ( handle , batch2 . Handle , mat . Handle , beta , alpha ) ) ;
2329
2433
}
2330
2434
2435
+ [ DllImport ( "libTorchSharp" ) ]
2436
+ extern static IntPtr THSTensor_bmm ( IntPtr batch1 , IntPtr batch2 ) ;
2437
+
2438
+ public ITorchTensor < double > Bmm ( ITorchTensor < double > batch2 )
2439
+ {
2440
+ return new DoubleTensor ( THSTensor_bmm ( handle , batch2 . Handle ) ) ;
2441
+ }
2442
+
2331
2443
[ DllImport ( "libTorchSharp" ) ]
2332
2444
extern static IntPtr THSTensor_eq ( IntPtr src , IntPtr trg ) ;
2333
2445
@@ -2345,11 +2457,19 @@ public ITorchTensor<double> Exp()
2345
2457
}
2346
2458
2347
2459
[ DllImport ( "libTorchSharp" ) ]
2348
- extern static IntPtr THSTensor_matMul ( IntPtr src , IntPtr target ) ;
2460
+ extern static IntPtr THSTensor_matmul ( IntPtr src , IntPtr target ) ;
2349
2461
2350
2462
public ITorchTensor < double > MatMul ( ITorchTensor < double > target )
2351
2463
{
2352
- return new DoubleTensor ( THSTensor_matMul ( handle , target . Handle ) ) ;
2464
+ return new DoubleTensor ( THSTensor_matmul ( handle , target . Handle ) ) ;
2465
+ }
2466
+
2467
+ [ DllImport ( "libTorchSharp" ) ]
2468
+ extern static IntPtr THSTensor_mm ( IntPtr src , IntPtr target ) ;
2469
+
2470
+ public ITorchTensor < double > Mm ( ITorchTensor < double > target )
2471
+ {
2472
+ return new DoubleTensor ( THSTensor_mm ( handle , target . Handle ) ) ;
2353
2473
}
2354
2474
2355
2475
[ DllImport ( "libTorchSharp" ) ]
@@ -2800,6 +2920,14 @@ public ITorchTensor<float> Addbmm(ITorchTensor<float> batch1, ITorchTensor<float
2800
2920
return new FloatTensor ( THSTensor_addbmm ( handle , batch1 . Handle , batch2 . Handle , beta , alpha ) ) ;
2801
2921
}
2802
2922
2923
+ [ DllImport ( "libTorchSharp" ) ]
2924
+ extern static IntPtr THSTensor_addmm ( IntPtr mat , IntPtr mat1 , IntPtr mat2 , float beta , float alpha ) ;
2925
+
2926
+ public ITorchTensor < float > Addmm ( ITorchTensor < float > mat1 , ITorchTensor < float > mat2 , float beta , float alpha )
2927
+ {
2928
+ return new FloatTensor ( THSTensor_addmm ( handle , mat1 . Handle , mat2 . Handle , beta , alpha ) ) ;
2929
+ }
2930
+
2803
2931
[ DllImport ( "libTorchSharp" ) ]
2804
2932
extern static IntPtr THSTensor_argmax ( IntPtr src , long dimension , bool keep_dim ) ;
2805
2933
@@ -2816,6 +2944,14 @@ public ITorchTensor<float> Baddbmm(ITorchTensor<float> batch2, ITorchTensor<floa
2816
2944
return new FloatTensor ( THSTensor_addbmm ( handle , batch2 . Handle , mat . Handle , beta , alpha ) ) ;
2817
2945
}
2818
2946
2947
+ [ DllImport ( "libTorchSharp" ) ]
2948
+ extern static IntPtr THSTensor_bmm ( IntPtr batch1 , IntPtr batch2 ) ;
2949
+
2950
+ public ITorchTensor < float > Bmm ( ITorchTensor < float > batch2 )
2951
+ {
2952
+ return new FloatTensor ( THSTensor_bmm ( handle , batch2 . Handle ) ) ;
2953
+ }
2954
+
2819
2955
[ DllImport ( "libTorchSharp" ) ]
2820
2956
extern static IntPtr THSTensor_eq ( IntPtr src , IntPtr trg ) ;
2821
2957
@@ -2833,11 +2969,19 @@ public ITorchTensor<float> Exp()
2833
2969
}
2834
2970
2835
2971
[ DllImport ( "libTorchSharp" ) ]
2836
- extern static IntPtr THSTensor_matMul ( IntPtr src , IntPtr target ) ;
2972
+ extern static IntPtr THSTensor_matmul ( IntPtr src , IntPtr target ) ;
2837
2973
2838
2974
public ITorchTensor < float > MatMul ( ITorchTensor < float > target )
2839
2975
{
2840
- return new FloatTensor ( THSTensor_matMul ( handle , target . Handle ) ) ;
2976
+ return new FloatTensor ( THSTensor_matmul ( handle , target . Handle ) ) ;
2977
+ }
2978
+
2979
+ [ DllImport ( "libTorchSharp" ) ]
2980
+ extern static IntPtr THSTensor_mm ( IntPtr src , IntPtr target ) ;
2981
+
2982
+ public ITorchTensor < float > Mm ( ITorchTensor < float > target )
2983
+ {
2984
+ return new FloatTensor ( THSTensor_mm ( handle , target . Handle ) ) ;
2841
2985
}
2842
2986
2843
2987
[ DllImport ( "libTorchSharp" ) ]
0 commit comments