Repository navigation
Expand file tree
/
Copy pathnp.linalg.gen.cs
More file actions
754 lines (731 loc) · 36.6 KB
/
Copy pathnp.linalg.gen.cs
File metadata and controls
754 lines (731 loc) · 36.6 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
// Copyright (c) 2019 by the SciSharp Team
// Code generated by CodeMinion: https://github.com/SciSharp/CodeMinion
using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using Python.Runtime;
using Numpy.Models;
namespace Numpy
{
public static partial class np
{
/// <summary>
/// Dot product of two arrays. Specifically,
/// </summary>
/// <param name="a">
/// First argument.
/// </param>
/// <param name="b">
/// Second argument.
/// </param>
/// <param name="@out">
/// Output argument. This must have the exact kind that would be returned
/// if it was not used. In particular, it must have the right type, must be
/// C-contiguous, and its dtype must be the dtype that would be returned
/// for dot(a,b). This is a performance feature. Therefore, if these
/// conditions are not met, an exception is raised, instead of attempting
/// to be flexible.
/// </param>
/// <returns>
/// Returns the dot product of a and b. If a and b are both
/// scalars or both 1-D arrays then a scalar is returned; otherwise
/// an array is returned.
/// If out is given, then it is returned.
/// </returns>
public static NDarray dot(NDarray a, NDarray b, NDarray @out = null)
=> NumPy.Instance.dot(a, b, @out:@out);
public static partial class linalg {
/// <summary>
/// Compute the dot product of two or more arrays in a single function call,
/// while automatically selecting the fastest evaluation order.
///
/// multi_dot chains numpy.dot and uses optimal parenthesization
/// of the matrices [1] [2]. Depending on the shapes of the matrices,
/// this can speed up the multiplication a lot.
///
/// If the first argument is 1-D it is treated as a row vector.
/// If the last argument is 1-D it is treated as a column vector.
/// The other arguments must be 2-D.
///
/// Think of multi_dot as:
///
/// Notes
///
/// The cost for a matrix multiplication can be calculated with the
/// following function:
///
/// Let’s assume we have three matrices
/// .
///
/// The costs for the two different parenthesizations are as follows:
///
/// References
/// </summary>
/// <param name="arrays">
/// If the first argument is 1-D it is treated as row vector.
/// If the last argument is 1-D it is treated as column vector.
/// The other arguments must be 2-D.
/// </param>
/// <returns>
/// Returns the dot product of the supplied arrays.
/// </returns>
public static NDarray multi_dot(NDarray[] arrays)
=> NumPy.Instance.linalg_multi_dot(arrays);
}
/// <summary>
/// Return the dot product of two vectors.
///
/// The vdot(a, b) function handles complex numbers differently than
/// dot(a, b). If the first argument is complex the complex conjugate
/// of the first argument is used for the calculation of the dot product.
///
/// Note that vdot handles multidimensional arrays differently than dot:
/// it does not perform a matrix product, but flattens input arguments
/// to 1-D vectors first. Consequently, it should only be used for vectors.
/// </summary>
/// <param name="a">
/// If a is complex the complex conjugate is taken before calculation
/// of the dot product.
/// </param>
/// <param name="b">
/// Second argument to the dot product.
/// </param>
/// <returns>
/// Dot product of a and b. Can be an int, float, or
/// complex depending on the types of a and b.
/// </returns>
public static NDarray vdot(NDarray a, NDarray b)
=> NumPy.Instance.vdot(a, b);
/// <summary>
/// Inner product of two arrays.
///
/// Ordinary inner product of vectors for 1-D arrays (without complex
/// conjugation), in higher dimensions a sum product over the last axes.
///
/// Notes
///
/// For vectors (1-D arrays) it computes the ordinary inner-product:
///
/// More generally, if ndim(a) = r > 0 and ndim(b) = s > 0:
///
/// or explicitly:
///
/// In addition a or b may be scalars, in which case:
/// </summary>
/// <param name="b">
/// If a and b are nonscalar, their last dimensions must match.
/// </param>
/// <param name="a">
/// If a and b are nonscalar, their last dimensions must match.
/// </param>
/// <returns>
/// out.shape = a.shape[:-1] + b.shape[:-1]
/// </returns>
public static NDarray inner(NDarray b, NDarray a)
=> NumPy.Instance.inner(b, a);
/// <summary>
/// Compute the outer product of two vectors.
///
/// Given two vectors, a = [a0, a1, ..., aM] and
/// b = [b0, b1, ..., bN],
/// the outer product [1] is:
///
/// References
/// </summary>
/// <param name="a">
/// First input vector. Input is flattened if
/// not already 1-dimensional.
/// </param>
/// <param name="b">
/// Second input vector. Input is flattened if
/// not already 1-dimensional.
/// </param>
/// <param name="@out">
/// A location where the result is stored
/// </param>
/// <returns>
/// out[i, j] = a[i] * b[j]
/// </returns>
public static NDarray outer(NDarray a, NDarray b, NDarray @out = null)
=> NumPy.Instance.outer(a, b, @out:@out);
/// <summary>
/// Matrix product of two arrays.
///
/// Notes
///
/// The behavior depends on the arguments in the following way.
///
/// matmul differs from dot in two important ways:
///
/// The matmul function implements the semantics of the @ operator introduced
/// in Python 3.5 following PEP465.
/// </summary>
/// <param name="x2">
/// Input arrays, scalars not allowed.
/// </param>
/// <param name="x1">
/// Input arrays, scalars not allowed.
/// </param>
/// <param name="@out">
/// A location into which the result is stored. If provided, it must have
/// a shape that matches the signature (n,k),(k,m)->(n,m). If not
/// provided or None, a freshly-allocated array is returned.
/// </param>
/// <returns>
/// The matrix product of the inputs.
/// This is a scalar only when both x1, x2 are 1-d vectors.
/// </returns>
public static NDarray matmul(NDarray x2, NDarray x1, NDarray @out = null)
=> NumPy.Instance.matmul(x2, x1, @out:@out);
/// <summary>
/// Compute tensor dot product along specified axes for arrays >= 1-D.
///
/// Given two tensors (arrays of dimension greater than or equal to one),
/// a and b, and an array_like object containing two array_like
/// objects, (a_axes, b_axes), sum the products of a’s and b’s
/// elements (components) over the axes specified by a_axes and
/// b_axes. The third argument can be a single non-negative
/// integer_like scalar, N; if it is such, then the last N
/// dimensions of a and the first N dimensions of b are summed
/// over.
///
/// Notes
///
/// When axes is integer_like, the sequence for evaluation will be: first
/// the -Nth axis in a and 0th axis in b, and the -1th axis in a and
/// Nth axis in b last.
///
/// When there is more than one axis to sum over - and they are not the last
/// (first) axes of a (b) - the argument axes should consist of
/// two sequences of the same length, with the first axis to sum over given
/// first in both sequences, the second axis second, and so forth.
/// </summary>
/// <param name="b">
/// Tensors to “dot”.
/// </param>
/// <param name="a">
/// Tensors to “dot”.
/// </param>
public static NDarray tensordot(NDarray b, NDarray a, int[] axes = null)
=> NumPy.Instance.tensordot(b, a, axes);
/// <summary>
/// Evaluates the Einstein summation convention on the operands.
///
/// Using the Einstein summation convention, many common multi-dimensional,
/// linear algebraic array operations can be represented in a simple fashion.
/// In implicit mode einsum computes these values.
///
/// In explicit mode, einsum provides further flexibility to compute
/// other array operations that might not be considered classical Einstein
/// summation operations, by disabling, or forcing summation over specified
/// subscript labels.
///
/// See the notes and examples for clarification.
///
/// Notes
///
/// The Einstein summation convention can be used to compute
/// many multi-dimensional, linear algebraic array operations. einsum
/// provides a succinct way of representing these.
///
/// A non-exhaustive list of these operations,
/// which can be computed by einsum, is shown below along with examples:
///
/// The subscripts string is a comma-separated list of subscript labels,
/// where each label refers to a dimension of the corresponding operand.
/// Whenever a label is repeated it is summed, so np.einsum('i,i', a, b)
/// is equivalent to np.inner(a,b). If a label
/// appears only once, it is not summed, so np.einsum('i', a) produces a
/// view of a with no changes. A further example np.einsum('ij,jk', a, b)
/// describes traditional matrix multiplication and is equivalent to
/// np.matmul(a,b). Repeated subscript labels in one
/// operand take the diagonal. For example, np.einsum('ii', a) is equivalent
/// to np.trace(a).
///
/// In implicit mode, the chosen subscripts are important
/// since the axes of the output are reordered alphabetically. This
/// means that np.einsum('ij', a) doesn’t affect a 2D array, while
/// np.einsum('ji', a) takes its transpose. Additionally,
/// np.einsum('ij,jk', a, b) returns a matrix multiplication, while,
/// np.einsum('ij,jh', a, b) returns the transpose of the
/// multiplication since subscript ‘h’ precedes subscript ‘i’.
///
/// In explicit mode the output can be directly controlled by
/// specifying output subscript labels. This requires the
/// identifier ‘->’ as well as the list of output subscript labels.
/// This feature increases the flexibility of the function since
/// summing can be disabled or forced when required. The call
/// np.einsum('i->', a) is like np.sum(a, axis=-1),
/// and np.einsum('ii->i', a) is like np.diag(a).
/// The difference is that einsum does not allow broadcasting by default.
/// Additionally np.einsum('ij,jh->ih', a, b) directly specifies the
/// order of the output subscript labels and therefore returns matrix
/// multiplication, unlike the example above in implicit mode.
///
/// To enable and control broadcasting, use an ellipsis. Default
/// NumPy-style broadcasting is done by adding an ellipsis
/// to the left of each term, like np.einsum('...ii->...i', a).
/// To take the trace along the first and last axes,
/// you can do np.einsum('i...i', a), or to do a matrix-matrix
/// product with the left-most indices instead of rightmost, one can do
/// np.einsum('ij...,jk...->ik...', a, b).
///
/// When there is only one operand, no axes are summed, and no output
/// parameter is provided, a view into the operand is returned instead
/// of a new array. Thus, taking the diagonal as np.einsum('ii->i', a)
/// produces a view (changed in version 1.10.0).
///
/// einsum also provides an alternative way to provide the subscripts
/// and operands as einsum(op0, sublist0, op1, sublist1, ..., [sublistout]).
/// If the output shape is not provided in this format einsum will be
/// calculated in implicit mode, otherwise it will be performed explicitly.
/// The examples below have corresponding einsum calls with the two
/// parameter methods.
///
/// Views returned from einsum are now writeable whenever the input array
/// is writeable. For example, np.einsum('ijk...->kji...', a) will now
/// have the same effect as np.swapaxes(a, 0, 2)
/// and np.einsum('ii->i', a) will return a writeable view of the diagonal
/// of a 2D array.
///
/// Added the optimize argument which will optimize the contraction order
/// of an einsum expression. For a contraction with three or more operands this
/// can greatly increase the computational efficiency at the cost of a larger
/// memory footprint during computation.
///
/// Typically a ‘greedy’ algorithm is applied which empirical tests have shown
/// returns the optimal path in the majority of cases. In some cases ‘optimal’
/// will return the superlative path through a more expensive, exhaustive search.
/// For iterative calculations it may be advisable to calculate the optimal path
/// once and reuse that path by supplying it as an argument. An example is given
/// below.
///
/// See numpy.einsum_path for more details.
/// </summary>
/// <param name="subscripts">
/// Specifies the subscripts for summation as comma separated list of
/// subscript labels. An implicit (classical Einstein summation)
/// calculation is performed unless the explicit indicator ‘->’ is
/// included as well as subscript labels of the precise output form.
/// </param>
/// <param name="operands">
/// These are the arrays for the operation.
/// </param>
/// <param name="@out">
/// If provided, the calculation is done into this array.
/// </param>
/// <param name="dtype">
/// If provided, forces the calculation to use the data type specified.
/// Note that you may have to also give a more liberal casting
/// parameter to allow the conversions. Default is None.
/// </param>
/// <param name="order">
/// Controls the memory layout of the output. ‘C’ means it should
/// be C contiguous. ‘F’ means it should be Fortran contiguous,
/// ‘A’ means it should be ‘F’ if the inputs are all ‘F’, ‘C’ otherwise.
/// ‘K’ means it should be as close to the layout as the inputs as
/// is possible, including arbitrarily permuted axes.
/// Default is ‘K’.
/// </param>
/// <param name="casting">
/// Controls what kind of data casting may occur. Setting this to
/// ‘unsafe’ is not recommended, as it can adversely affect accumulations.
///
/// Default is ‘safe’.
/// </param>
/// <param name="optimize">
/// Controls if intermediate optimization should occur. No optimization
/// will occur if False and True will default to the ‘greedy’ algorithm.
/// Also accepts an explicit contraction list from the np.einsum_path
/// function. See np.einsum_path for more details. Defaults to False.
/// </param>
/// <returns>
/// The calculation based on the Einstein summation convention.
/// </returns>
public static NDarray einsum(string subscripts, NDarray[] operands, NDarray @out = null, Dtype dtype = null, string order = null, string casting = "safe", object optimize = null)
=> NumPy.Instance.einsum(subscripts, operands, @out:@out, dtype:dtype, order:order, casting:casting, optimize:optimize);
/*
/// <summary>
/// Evaluates the lowest cost contraction order for an einsum expression by
/// considering the creation of intermediate arrays.
///
/// Notes
///
/// The resulting path indicates which terms of the input contraction should be
/// contracted first, the result of this contraction is then appended to the
/// end of the contraction list. This list can then be iterated over until all
/// intermediate contractions are complete.
/// </summary>
/// <param name="subscripts">
/// Specifies the subscripts for summation.
/// </param>
/// <param name="operands">
/// These are the arrays for the operation.
/// </param>
/// <param name="optimize">
/// Choose the type of path. If a tuple is provided, the second argument is
/// assumed to be the maximum intermediate size created. If only a single
/// argument is provided the largest input or output array size is used
/// as a maximum intermediate size.
///
/// Default is ‘greedy’.
/// </param>
/// <returns>
/// A tuple of:
/// path
/// A list representation of the einsum path.
/// string_repr
/// A printable representation of the einsum path.
/// </returns>
public static (list of tuples, string) einsum_path(string subscripts, NDarray[] operands, {bool optimize = "greedy")
=> NumPy.Instance.einsum_path(subscripts, operands, optimize);
*/
public static partial class linalg {
/// <summary>
/// Raise a square matrix to the (integer) power n.
///
/// For positive integers n, the power is computed by repeated matrix
/// squarings and matrix multiplications. If n == 0, the identity matrix
/// of the same shape as M is returned. If n < 0, the inverse
/// is computed and then raised to the abs(n).
/// </summary>
/// <param name="a">
/// Matrix to be “powered.”
/// </param>
/// <param name="n">
/// The exponent can be any integer or long integer, positive,
/// negative, or zero.
/// </param>
/// <returns>
/// The return value is the same shape and type as M;
/// if the exponent is positive or zero then the type of the
/// elements is the same as those of M. If the exponent is
/// negative the elements are floating-point.
/// </returns>
public static NDarray matrix_power(NDarray a, int n)
=> NumPy.Instance.linalg_matrix_power(a, n);
}
/// <summary>
/// Kronecker product of two arrays.
///
/// Computes the Kronecker product, a composite array made of blocks of the
/// second array scaled by the first.
///
/// Notes
///
/// The function assumes that the number of dimensions of a and b
/// are the same, if necessary prepending the smallest with ones.
/// If a.shape = (r0,r1,..,rN) and b.shape = (s0,s1,…,sN),
/// the Kronecker product has shape (r0*s0, r1*s1, …, rN*SN).
/// The elements are products of elements from a and b, organized
/// explicitly by:
///
/// where:
///
/// In the common 2-D case (N=1), the block structure can be visualized:
/// </summary>
public static NDarray kron(NDarray b, NDarray a)
=> NumPy.Instance.kron(b, a);
public static partial class linalg {
/// <summary>
/// Compute the qr factorization of a matrix.
///
/// Factor the matrix a as qr, where q is orthonormal and r is
/// upper-triangular.
///
/// Notes
///
/// This is an interface to the LAPACK routines dgeqrf, zgeqrf,
/// dorgqr, and zungqr.
///
/// For more information on the qr factorization, see for example:
/// https://en.wikipedia.org/wiki/QR_factorization
///
/// Subclasses of ndarray are preserved except for the ‘raw’ mode. So if
/// a is of type matrix, all the return values will be matrices too.
///
/// New ‘reduced’, ‘complete’, and ‘raw’ options for mode were added in
/// NumPy 1.8.0 and the old option ‘full’ was made an alias of ‘reduced’. In
/// addition the options ‘full’ and ‘economic’ were deprecated. Because
/// ‘full’ was the previous default and ‘reduced’ is the new default,
/// backward compatibility can be maintained by letting mode default.
/// The ‘raw’ option was added so that LAPACK routines that can multiply
/// arrays by q using the Householder reflectors can be used. Note that in
/// this case the returned arrays are of type np.double or np.cdouble and
/// the h array is transposed to be FORTRAN compatible. No routines using
/// the ‘raw’ return are currently exposed by numpy, but some are available
/// in lapack_lite and just await the necessary work.
/// </summary>
/// <param name="a">
/// Matrix to be factored.
/// </param>
/// <param name="mode">
/// If K = min(M, N), then
///
/// The options ‘reduced’, ‘complete, and ‘raw’ are new in numpy 1.8,
/// see the notes for more information. The default is ‘reduced’, and to
/// maintain backward compatibility with earlier versions of numpy both
/// it and the old default ‘full’ can be omitted. Note that array h
/// returned in ‘raw’ mode is transposed for calling Fortran. The
/// ‘economic’ mode is deprecated. The modes ‘full’ and ‘economic’ may
/// be passed using only the first letter for backwards compatibility,
/// but all others must be spelled out. See the Notes for more
/// explanation.
/// </param>
/// <returns>
/// A tuple of:
/// q
/// A matrix with orthonormal columns. When mode = ‘complete’ the
/// result is an orthogonal/unitary matrix depending on whether or not
/// a is real/complex. The determinant may be either +/- 1 in that
/// case.
/// r
/// The upper-triangular matrix.
/// (h, tau)
/// The array h contains the Householder reflectors that generate q
/// along with r. The tau array contains scaling factors for the
/// reflectors. In the deprecated ‘economic’ mode only h is returned.
/// </returns>
public static (NDarray, NDarray, NDarray) qr(NDarray a, string mode = "reduced")
=> NumPy.Instance.linalg_qr(a, mode:mode);
}
/*
public static partial class linalg {
/// <summary>
/// Compute the condition number of a matrix.
///
/// This function is capable of returning the condition number using
/// one of seven different norms, depending on the value of p (see
/// Parameters below).
///
/// Notes
///
/// The condition number of x is defined as the norm of x times the
/// norm of the inverse of x [1]; the norm can be the usual L2-norm
/// (root-of-sum-of-squares) or one of a number of other matrix norms.
///
/// References
/// </summary>
/// <param name="x">
/// The matrix whose condition number is sought.
/// </param>
/// <param name="p">
/// Order of the norm:
///
/// inf means the numpy.inf object, and the Frobenius norm is
/// the root-of-sum-of-squares norm.
/// </param>
/// <returns>
/// The condition number of the matrix. May be infinite.
/// </returns>
public static {float cond(NDarray x, {None p = null)
=> NumPy.Instance.linalg_cond(x, p:p);
}
*/
public static partial class linalg {
/// <summary>
/// Return matrix rank of array using SVD method
///
/// Rank of the array is the number of singular values of the array that are
/// greater than tol.
///
/// Notes
///
/// The default threshold to detect rank deficiency is a test on the magnitude
/// of the singular values of M. By default, we identify singular values less
/// than S.max() * max(M.shape) * eps as indicating rank deficiency (with
/// the symbols defined above). This is the algorithm MATLAB uses [1]. It also
/// appears in Numerical recipes in the discussion of SVD solutions for linear
/// least squares [2].
///
/// This default threshold is designed to detect rank deficiency accounting for
/// the numerical errors of the SVD computation. Imagine that there is a column
/// in M that is an exact (in floating point) linear combination of other
/// columns in M. Computing the SVD on M will not produce a singular value
/// exactly equal to 0 in general: any difference of the smallest SVD value from
/// 0 will be caused by numerical imprecision in the calculation of the SVD.
/// Our threshold for small SVD values takes this numerical imprecision into
/// account, and the default threshold will detect such numerical rank
/// deficiency. The threshold may declare a matrix M rank deficient even if
/// the linear combination of some columns of M is not exactly equal to
/// another column of M but only numerically very close to another column of
/// M.
///
/// We chose our default threshold because it is in wide use. Other thresholds
/// are possible. For example, elsewhere in the 2007 edition of Numerical
/// recipes there is an alternative threshold of S.max() *
/// np.finfo(M.dtype).eps / 2. * np.sqrt(m + n + 1.). The authors describe
/// this threshold as being based on “expected roundoff error” (p 71).
///
/// The thresholds above deal with floating point roundoff error in the
/// calculation of the SVD. However, you may have more information about the
/// sources of error in M that would make you consider other tolerance values
/// to detect effective rank deficiency. The most useful measure of the
/// tolerance depends on the operations you intend to use on your matrix. For
/// example, if your data come from uncertain measurements with uncertainties
/// greater than floating point epsilon, choosing a tolerance near that
/// uncertainty may be preferable. The tolerance may be absolute if the
/// uncertainties are absolute rather than relative.
///
/// References
/// </summary>
/// <param name="M">
/// input vector or stack of matrices
/// </param>
/// <param name="tol">
/// threshold below which SVD values are considered zero. If tol is
/// None, and S is an array with singular values for M, and
/// eps is the epsilon value for datatype of S, then tol is
/// set to S.max() * max(M.shape) * eps.
/// </param>
/// <param name="hermitian">
/// If True, M is assumed to be Hermitian (symmetric if real-valued),
/// enabling a more efficient method for finding singular values.
/// Defaults to False.
/// </param>
public static int matrix_rank(NDarray M, NDarray tol = null, bool? hermitian = false)
=> NumPy.Instance.linalg_matrix_rank(M, tol:tol, hermitian:hermitian);
}
public static partial class linalg {
/// <summary>
/// Compute the sign and (natural) logarithm of the determinant of an array.
///
/// If an array has a very small or very large determinant, then a call to
/// det may overflow or underflow. This routine is more robust against such
/// issues, because it computes the logarithm of the determinant rather than
/// the determinant itself.
///
/// Notes
///
/// Broadcasting rules apply, see the numpy.linalg documentation for
/// details.
///
/// The determinant is computed via LU factorization using the LAPACK
/// routine z/dgetrf.
/// </summary>
/// <param name="a">
/// Input array, has to be a square 2-D array.
/// </param>
/// <returns>
/// A tuple of:
/// sign
/// A number representing the sign of the determinant. For a real matrix,
/// this is 1, 0, or -1. For a complex matrix, this is a complex number
/// with absolute value 1 (i.e., it is on the unit circle), or else 0.
/// logdet
/// The natural log of the absolute value of the determinant.
/// </returns>
public static (NDarray, NDarray) slogdet(NDarray a)
=> NumPy.Instance.linalg_slogdet(a);
}
/// <summary>
/// Return the sum along diagonals of the array.
///
/// If a is 2-D, the sum along its diagonal with the given offset
/// is returned, i.e., the sum of elements a[i,i+offset] for all i.
///
/// If a has more than two dimensions, then the axes specified by axis1 and
/// axis2 are used to determine the 2-D sub-arrays whose traces are returned.
/// The shape of the resulting array is the same as that of a with axis1
/// and axis2 removed.
/// </summary>
/// <param name="a">
/// Input array, from which the diagonals are taken.
/// </param>
/// <param name="offset">
/// Offset of the diagonal from the main diagonal. Can be both positive
/// and negative. Defaults to 0.
/// </param>
/// <param name="axis2">
/// Axes to be used as the first and second axis of the 2-D sub-arrays
/// from which the diagonals should be taken. Defaults are the first two
/// axes of a.
/// </param>
/// <param name="axis1">
/// Axes to be used as the first and second axis of the 2-D sub-arrays
/// from which the diagonals should be taken. Defaults are the first two
/// axes of a.
/// </param>
/// <param name="dtype">
/// Determines the data-type of the returned array and of the accumulator
/// where the elements are summed. If dtype has the value None and a is
/// of integer type of precision less than the default integer
/// precision, then the default integer precision is used. Otherwise,
/// the precision is the same as that of a.
/// </param>
/// <param name="@out">
/// Array into which the output is placed. Its type is preserved and
/// it must be of the right shape to hold the output.
/// </param>
/// <returns>
/// If a is 2-D, the sum along the diagonal is returned. If a has
/// larger dimensions, then an array of sums along diagonals is returned.
/// </returns>
public static NDarray trace(NDarray a, int? offset = 0, int? axis2 = null, int? axis1 = null, Dtype dtype = null, NDarray @out = null)
=> NumPy.Instance.trace(a, offset:offset, axis2:axis2, axis1:axis1, dtype:dtype, @out:@out);
public static partial class linalg {
/// <summary>
/// Solve the tensor equation a x = b for x.
///
/// It is assumed that all indices of x are summed over in the product,
/// together with the rightmost indices of a, as is done in, for example,
/// tensordot(a, x, axes=b.ndim).
/// </summary>
/// <param name="a">
/// Coefficient tensor, of shape b.shape + Q. Q, a tuple, equals
/// the shape of that sub-tensor of a consisting of the appropriate
/// number of its rightmost indices, and must be such that
/// prod(Q) == prod(b.shape) (in which sense a is said to be
/// ‘square’).
/// </param>
/// <param name="b">
/// Right-hand tensor, which can be of any shape.
/// </param>
/// <param name="axes">
/// Axes in a to reorder to the right, before inversion.
/// If None (default), no reordering is done.
/// </param>
public static NDarray tensorsolve(NDarray a, NDarray b, int[] axes = null)
=> NumPy.Instance.linalg_tensorsolve(a, b, axes:axes);
}
public static partial class linalg {
/// <summary>
/// Compute the ‘inverse’ of an N-dimensional array.
///
/// The result is an inverse for a relative to the tensordot operation
/// tensordot(a, b, ind), i. e., up to floating-point accuracy,
/// tensordot(tensorinv(a), a, ind) is the “identity” tensor for the
/// tensordot operation.
/// </summary>
/// <param name="a">
/// Tensor to ‘invert’. Its shape must be ‘square’, i. e.,
/// prod(a.shape[:ind]) == prod(a.shape[ind:]).
/// </param>
/// <param name="ind">
/// Number of first indices that are involved in the inverse sum.
/// Must be a positive integer, default is 2.
/// </param>
/// <returns>
/// a’s tensordot inverse, shape a.shape[ind:] + a.shape[:ind].
/// </returns>
public static NDarray tensorinv(NDarray a, int? ind = 2)
=> NumPy.Instance.linalg_tensorinv(a, ind:ind);
}
public static partial class linalg {
/// <summary>
/// Generic Python-exception-derived object raised by linalg functions.
///
/// General purpose exception class, derived from Python’s exception.Exception
/// class, programmatically raised in linalg functions when a Linear
/// Algebra-related condition would prevent further correct execution of the
/// function.
/// </summary>
public static void LinAlgError()
=> NumPy.Instance.linalg_LinAlgError();
}
}
}