[{"_1":2,"_22936":-5,"_22937":-5},"loaderData",{"_3":4,"_12":13},"root",{"_5":6,"_7":-5,"_8":9},"isAuthenticated",false,"user","features",{"_10":11},"billing",true,"routes/functions.$functionId",{"_14":15,"_41":42,"_344":345},"function",{"_16":17,"_18":19,"_20":21,"_22":23,"_24":25,"_28":29,"_30":31,"_37":38},"name","vtk.colormap","signature","vtk.colormap('name')","summary","Set VTK colormap","description","Sets the colormap for subsequent VTK visualizations. Available colormaps: 'viridis', 'rainbow', 'coolwarm', 'grayscale', 'jet', 'hot'.","params",[26],{"_16":16,"_22":27},"Colormap name","returns","null","examples",[32,35],{"_33":34},"code","vtk.colormap('coolwarm')",{"_33":36},"vtk.colormap('viridis'); vtk.volume(data, dims)","seeAlso",[39,40],"vtk.opacity","vtk.edges","package",{"_43":44,"_16":45,"_22":46,"_47":48,"_49":50,"_51":44,"_52":53},"id","vtk","3D Visualization (VTK)","Advanced 3D visualization functions powered by VTK.js for volumetric data, FEM meshes, and scientific visualization.","tier","free","icon","🧊","namespace","functions",[54,78,102,123,144,168,187,211,15,229,241,254,265,274,283,297,310,326],{"_16":55,"_18":56,"_20":57,"_22":58,"_24":59,"_28":70,"_30":71,"_37":74},"vtk.polydata","vtk.polydata(points, polys)\nvtk.polydata(points, polys, scalars)","Create PolyData geometry","Creates a VTK PolyData visualization from points and polygon connectivity. Points should be an Nx3 matrix of [x, y, z] coordinates. Polys defines polygon connectivity. Optional scalars provide per-point coloring.",[60,63,66],{"_16":61,"_22":62},"points","Nx3 matrix of point coordinates",{"_16":64,"_22":65},"polys","Polygon connectivity array (VTK format: [npts, p1, p2, ...])",{"_16":67,"_22":68,"_69":11},"scalars","Per-point scalar values for coloring","optional","null (renders VTK visualization inline)",[72],{"_33":73},"% Create a simple triangle\npoints = [0 0 0; 1 0 0; 0.5 1 0];\npolys = [3 0 1 2]; % triangle with 3 vertices\nvtk.polydata(points, polys)",[75,76,77],"vtk.volume","vtk.femgrid","vtk.sphere",{"_16":75,"_18":79,"_20":80,"_22":81,"_24":82,"_28":95,"_30":96,"_37":99},"vtk.volume(data, dims)\nvtk.volume(data, dims, spacing)\nvtk.volume(data, dims, spacing, origin)","Create volumetric visualization","Creates a VTK volume rendering from 3D scalar data. The data array contains voxel values in row-major order. Dims specifies [nx, ny, nz] dimensions. Optional spacing and origin control physical coordinates.",[83,86,89,92],{"_16":84,"_22":85},"data","Flat array of scalar values (nx*ny*nz elements)",{"_16":87,"_22":88},"dims","3-element vector [nx, ny, nz] specifying grid dimensions",{"_16":90,"_22":91,"_69":11},"spacing","3-element vector [dx, dy, dz] for voxel spacing (default: [1,1,1])",{"_16":93,"_22":94,"_69":11},"origin","3-element vector [x0, y0, z0] for grid origin (default: [0,0,0])","null (renders VTK volume inline)",[97],{"_33":98},"% Create a 3D Gaussian blob\n[X, Y, Z] = meshgrid(-2:0.1:2);\ndata = exp(-(X.^2 + Y.^2 + Z.^2));\nvtk.volume(data(:), size(data))",[100,101,55],"vtk.isosurface","vtk.slice",{"_16":100,"_18":103,"_20":104,"_22":105,"_24":106,"_28":118,"_30":119,"_37":122},"vtk.isosurface(data, dims, isovalue)\nvtk.isosurface(data, dims, spacing, origin, isovalue)","Extract and render isosurface","Extracts an isosurface from 3D volumetric data at the specified scalar value. Creates a surface representation of the contour where data equals the isovalue.",[107,109,111,113,115],{"_16":84,"_22":108},"Flat array of scalar values",{"_16":87,"_22":110},"3-element vector [nx, ny, nz]",{"_16":90,"_22":112,"_69":11},"Voxel spacing (default: [1,1,1])",{"_16":93,"_22":114,"_69":11},"Grid origin (default: [0,0,0])",{"_16":116,"_22":117},"isovalue","Scalar value for the isosurface","null (renders isosurface inline)",[120],{"_33":121},"% Extract isosurface from a sphere function\n[X, Y, Z] = meshgrid(-2:0.1:2);\ndata = X.^2 + Y.^2 + Z.^2;\nvtk.isosurface(data(:), size(data), 1.0) % sphere of radius 1",[75,55],{"_16":76,"_18":124,"_20":125,"_22":126,"_24":127,"_28":139,"_30":140,"_37":143},"vtk.femgrid(nodes, elements, elementTypes)\nvtk.femgrid(nodes, elements, elementTypes, scalars)","Visualize FEM unstructured grid","Creates a VTK unstructured grid visualization for finite element meshes. Nodes is an Nx3 matrix of coordinates. Elements defines cell connectivity. ElementTypes specifies VTK cell types (10=tetra, 12=hex, 5=tri, 9=quad).",[128,131,134,137],{"_16":129,"_22":130},"nodes","Nx3 matrix of node coordinates",{"_16":132,"_22":133},"elements","Cell connectivity in VTK format [npts, n1, n2, ...]",{"_16":135,"_22":136},"elementTypes","Array of VTK cell type codes for each element",{"_16":67,"_22":138,"_69":11},"Per-node or per-cell scalar field (e.g., stress, temperature)","null (renders FEM mesh inline)",[141],{"_33":142},"% Create a simple tetrahedral mesh\nnodes = [0 0 0; 1 0 0; 0.5 1 0; 0.5 0.5 1];\nelements = [4 0 1 2 3]; % one tetrahedron\ntypes = [10]; % VTK_TETRA\nvtk.femgrid(nodes, elements, types)",[55,75],{"_16":77,"_18":145,"_20":146,"_22":147,"_24":148,"_28":158,"_30":159,"_37":164},"vtk.sphere()\nvtk.sphere(radius)\nvtk.sphere(radius, center)\nvtk.sphere(radius, center, resolution)","Create sphere geometry","Creates a VTK sphere source with specified radius, center, and resolution. Useful for quick testing and demonstrations.",[149,152,155],{"_16":150,"_22":151,"_69":11},"radius","Sphere radius (default: 1)",{"_16":153,"_22":154,"_69":11},"center","3-element vector [x, y, z] for center (default: [0,0,0])",{"_16":156,"_22":157,"_69":11},"resolution","Number of phi/theta divisions (default: 32)","null (renders sphere inline)",[160,162],{"_33":161},"vtk.sphere() % unit sphere at origin",{"_33":163},"vtk.sphere(2, [1 0 0], 64) % radius 2, centered at (1,0,0), high resolution",[165,166,167],"vtk.cone","vtk.cube","vtk.cylinder",{"_16":165,"_18":169,"_20":170,"_22":171,"_24":172,"_28":180,"_30":181,"_37":186},"vtk.cone()\nvtk.cone(height, radius)\nvtk.cone(height, radius, center)","Create cone geometry","Creates a VTK cone source with specified height, radius, and center.",[173,176,178],{"_16":174,"_22":175,"_69":11},"height","Cone height (default: 1)",{"_16":150,"_22":177,"_69":11},"Base radius (default: 0.5)",{"_16":153,"_22":179,"_69":11},"3-element center position (default: [0,0,0])","null (renders cone inline)",[182,184],{"_33":183},"vtk.cone()",{"_33":185},"vtk.cone(2, 1, [0 0 1])",[77,166,167],{"_16":166,"_18":188,"_20":189,"_22":190,"_24":191,"_28":204,"_30":205,"_37":210},"vtk.cube()\nvtk.cube(size)\nvtk.cube(xLen, yLen, zLen)","Create cube/box geometry","Creates a VTK cube (box) source with specified dimensions.",[192,195,198,201],{"_16":193,"_22":194,"_69":11},"size","Uniform size for all dimensions (default: 1)",{"_16":196,"_22":197,"_69":11},"xLen","X dimension length",{"_16":199,"_22":200,"_69":11},"yLen","Y dimension length",{"_16":202,"_22":203,"_69":11},"zLen","Z dimension length","null (renders cube inline)",[206,208],{"_33":207},"vtk.cube()",{"_33":209},"vtk.cube(2, 1, 0.5) % rectangular box",[77,165,167],{"_16":167,"_18":212,"_20":213,"_22":214,"_24":215,"_28":222,"_30":223,"_37":228},"vtk.cylinder()\nvtk.cylinder(height, radius)\nvtk.cylinder(height, radius, resolution)","Create cylinder geometry","Creates a VTK cylinder source with specified height, radius, and resolution.",[216,218,220],{"_16":174,"_22":217,"_69":11},"Cylinder height (default: 1)",{"_16":150,"_22":219,"_69":11},"Cylinder radius (default: 0.5)",{"_16":156,"_22":221,"_69":11},"Number of facets around circumference (default: 32)","null (renders cylinder inline)",[224,226],{"_33":225},"vtk.cylinder()",{"_33":227},"vtk.cylinder(3, 0.5, 64)",[77,165,166],{"_16":39,"_18":230,"_20":231,"_22":232,"_24":233,"_28":29,"_30":237,"_37":240},"vtk.opacity(value)","Set VTK opacity","Sets the opacity (0-1) for subsequent VTK visualizations.",[234],{"_16":235,"_22":236},"value","Opacity value between 0 (transparent) and 1 (opaque)",[238],{"_33":239},"vtk.opacity(0.7)",[17,40],{"_16":40,"_18":242,"_20":243,"_22":244,"_24":245,"_28":29,"_30":249,"_37":252},"vtk.edges('on')\nvtk.edges('off')","Toggle edge visibility","Enables or disables edge rendering for surface meshes. Useful for FEM visualization.",[246],{"_16":247,"_22":248},"state","'on' or 'off'",[250],{"_33":251},"vtk.edges('on')",[17,253],"vtk.wireframe",{"_16":253,"_18":255,"_20":256,"_22":257,"_24":258,"_28":29,"_30":259,"_37":262},"vtk.wireframe()","Set wireframe rendering","Sets the rendering mode to wireframe for subsequent VTK visualizations.",[],[260],{"_33":261},"vtk.wireframe(); vtk.sphere()",[263,264,40],"vtk.surface","vtk.points",{"_16":263,"_18":266,"_20":267,"_22":268,"_24":269,"_28":29,"_30":270,"_37":273},"vtk.surface()","Set surface rendering","Sets the rendering mode to filled surface for subsequent VTK visualizations (default mode).",[],[271],{"_33":272},"vtk.surface(); vtk.sphere()",[253,264],{"_16":264,"_18":275,"_20":276,"_22":277,"_24":278,"_28":29,"_30":279,"_37":282},"vtk.points()","Set point rendering","Sets the rendering mode to points only for subsequent VTK visualizations.",[],[280],{"_33":281},"vtk.points(); vtk.sphere()",[253,263],{"_16":284,"_18":285,"_20":286,"_22":287,"_24":288,"_28":70,"_30":292,"_37":295},"vtk.mesh","vtk.mesh(mesh)","Visualize an MFEM mesh","Renders an MFEM mesh object directly. The mesh is exported to VTK format internally and displayed as an unstructured grid visualization. For solution visualization with scalar coloring, use vtk.gridfunction() instead.",[289],{"_16":290,"_22":291},"mesh","MFEM Mesh object (from mfem.mesh.makeCartesian2D, etc.)",[293],{"_33":294},"mesh = mfem.mesh.makeCartesian2D(10, 10, 'TRIANGLE', true, 1.0, 1.0)\nvtk.edges('on')\nvtk.mesh(mesh)",[296,76,17],"vtk.gridfunction",{"_16":298,"_18":299,"_20":300,"_22":301,"_24":302,"_28":305,"_30":306,"_37":309},"vtk.meshCoordinates","coords = vtk.meshCoordinates(mesh)","Get mesh vertex coordinates","Extracts the x, y, and z coordinates of all mesh vertices. Returns a struct with x, y, z arrays and the number of vertices.",[303],{"_16":290,"_22":304},"MFEM Mesh object","Struct with fields: x, y, z (NDArrays) and numVertices (number)",[307],{"_33":308},"mesh = mfem.mesh.makeCartesian2D(10, 10)\ncoords = vtk.meshCoordinates(mesh)\ndisp(coords.x) % x-coordinates of all vertices\ndisp(coords.y) % y-coordinates of all vertices",[284,296],{"_16":296,"_18":311,"_20":312,"_22":313,"_24":314,"_28":70,"_30":320,"_37":325},"vtk.gridfunction(mesh, gf)","Visualize MFEM GridFunction with scalar coloring","Renders an MFEM GridFunction on its mesh, with vertices colored by the solution values. Use vtk.colormap() to set the color scheme before calling this function.",[315,317],{"_16":290,"_22":316},"MFEM Mesh object (the mesh on which the GridFunction is defined)",{"_16":318,"_22":319},"gf","MFEM GridFunction object containing the finite element solution",[321,323],{"_33":322},"vtk.colormap('viridis')\nvtk.gridfunction(mesh, solution)",{"_33":324},"vtk.colormap('coolwarm')\nvtk.edges('on')\nvtk.gridfunction(mesh, x)",[284,17,40],{"_16":327,"_18":328,"_20":329,"_22":330,"_24":331,"_28":339,"_30":340,"_37":343},"vtk.displacement","vtk.displacement(mesh, u)\nvtk.displacement(mesh, u, scaleFactor)","Visualize displacement field on deformed mesh","Renders a vector displacement field by deforming the mesh and coloring by displacement magnitude. The scaleFactor amplifies the deformation for visualization of small displacements (default: 1).",[332,333,336],{"_16":290,"_22":304},{"_16":334,"_22":335},"u","Vector GridFunction containing displacement [ux, uy, uz] per node",{"_16":337,"_22":338,"_69":11},"scaleFactor","Deformation amplification factor (default: 1)","null (renders deformed mesh inline)",[341],{"_33":342},"vtk.colormap('coolwarm')\nvtk.displacement(mesh, u, 100) % amplify by 100x",[296,284],"allPackages",[346,1462,1821,2018,2629,3786,42,3987,4368,8221,8972,14887,15103,16536,18639,18901,19947,21021,22266],{"_43":347,"_16":348,"_22":349,"_47":48,"_49":350,"_52":351},"core","Core Functions","Essential functions for array creation, mathematics, aggregation, and manipulation. Always available.","🔧",[352,377,390,405,426,447,466,479,491,517,538,572,590,602,614,627,637,650,666,681,692,703,721,734,746,758,772,786,798,809,819,842,858,871,883,895,907,928,944,971,990,1001,1013,1024,1040,1054,1068,1085,1096,1107,1122,1138,1150,1162,1182,1194,1214,1233,1246,1260,1274,1287,1309,1327,1348,1361,1375,1393,1408,1421,1433,1444],{"_16":353,"_18":354,"_20":355,"_22":356,"_24":357,"_28":364,"_30":365,"_37":373},"zeros","Z = zeros(n)\nZ = zeros(m, n)","Create array of all zeros","Creates an array of zeros with the specified dimensions. A single argument `n` creates an n×n matrix.",[358,361],{"_16":359,"_22":360},"m","Number of rows",{"_16":362,"_22":363,"_69":11},"n","Number of columns","NDArray of zeros with the given shape",[366,370],{"_33":367,"_368":369},"zeros(3)","output","0 0 0\n0 0 0\n0 0 0",{"_33":371,"_368":372},"zeros(2, 4)","0 0 0 0\n0 0 0 0",[374,375,376],"ones","eye","rand",{"_16":374,"_18":378,"_20":379,"_22":380,"_24":381,"_28":384,"_30":385,"_37":389},"X = ones(n)\nX = ones(m, n)","Create array of all ones","Creates an array of ones with the specified dimensions. A single argument `n` creates an n×n matrix.",[382,383],{"_16":359,"_22":360},{"_16":362,"_22":363,"_69":11},"NDArray of ones with the given shape",[386],{"_33":387,"_368":388},"ones(2, 3)","1 1 1\n1 1 1",[353,375],{"_16":375,"_18":391,"_20":392,"_22":393,"_24":394,"_28":397,"_30":398,"_37":402},"I = eye(n)","Identity matrix","Creates an n×n identity matrix with ones on the diagonal and zeros elsewhere.",[395],{"_16":362,"_22":396},"Size of the square matrix","n×n identity NDArray",[399],{"_33":400,"_368":401},"eye(3)","1 0 0\n0 1 0\n0 0 1",[353,374,403,404],"diag","magic",{"_16":404,"_18":406,"_20":407,"_22":408,"_24":409,"_28":412,"_30":413,"_37":423},"M = magic(n)","Magic square","Creates an n×n magic square matrix where the sum of each row, column, and both main diagonals equals the same magic constant: n(n²+1)/2. For n=1 returns [1], for n=2 there is no magic square so returns [1 3; 4 2] (not a true magic square). Works for all n ≥ 1.",[410],{"_16":362,"_22":411},"Size of the magic square (n ≥ 1)","n×n magic square NDArray",[414,417,420],{"_33":415,"_368":416},"magic(3)","8 1 6\n3 5 7\n4 9 2",{"_33":418,"_368":419},"magic(4)","16 2 3 13\n 5 11 10 8\n 9 7 6 12\n 4 14 15 1",{"_33":421,"_368":422},"sum(magic(5))","65 65 65 65 65",[375,374,353,424,425],"pascal","hilb",{"_16":427,"_18":428,"_20":429,"_22":430,"_24":431,"_28":440,"_30":441,"_37":445},"linspace","v = linspace(a, b, n)","Generate linearly spaced vector","Returns a row vector of `n` evenly spaced points between `a` and `b` (inclusive).",[432,435,438],{"_16":433,"_22":434},"a","Start value",{"_16":436,"_22":437},"b","End value",{"_16":362,"_22":439},"Number of points","1×n NDArray",[442],{"_33":443,"_368":444},"linspace(0, 1, 5)","0 0.25 0.5 0.75 1",[446,353,374],"logspace",{"_16":446,"_18":448,"_20":449,"_22":450,"_24":451,"_28":440,"_30":458,"_37":465},"v = logspace(a, b)\nv = logspace(a, b, n)","Generate logarithmically spaced vector","Returns a row vector of `n` logarithmically spaced points between 10^a and 10^b. Default is 50 points.",[452,454,456],{"_16":433,"_22":453},"Exponent of start value (10^a)",{"_16":436,"_22":455},"Exponent of end value (10^b)",{"_16":362,"_22":457,"_69":11},"Number of points (default: 50)",[459,462],{"_33":460,"_368":461},"logspace(0, 2, 5)","1 3.1623 10 31.623 100",{"_33":463,"_368":464},"logspace(-2, 0, 3)","0.01 0.1 1",[427,353,374],{"_16":376,"_18":467,"_20":468,"_22":469,"_24":470,"_28":473,"_30":474,"_37":477},"R = rand(n)\nR = rand(m, n)","Uniformly distributed random numbers","Creates an array of uniformly distributed random numbers in the interval (0, 1).",[471,472],{"_16":359,"_22":360},{"_16":362,"_22":363,"_69":11},"NDArray of random values in (0, 1)",[475],{"_33":476},"rand(2, 3)",[478,353],"randn",{"_16":478,"_18":480,"_20":481,"_22":482,"_24":483,"_28":486,"_30":487,"_37":490},"R = randn(n)\nR = randn(m, n)","Normally distributed random numbers","Creates an array of random numbers drawn from the standard normal distribution (mean 0, variance 1).",[484,485],{"_16":359,"_22":360},{"_16":362,"_22":363,"_69":11},"NDArray of normally distributed random values",[488],{"_33":489},"randn(2, 3)",[376],{"_16":492,"_18":493,"_20":494,"_22":495,"_24":496,"_28":506,"_30":507,"_37":515},"meshgrid","[X, Y] = meshgrid(x, y)\n[X, Y] = meshgrid(v)\n[X, Y] = meshgrid(x, y, 'ij')","Create 2D coordinate matrices","Returns coordinate matrices from coordinate vectors. For vectors x and y, meshgrid returns 2D matrices X and Y where X has x values repeated across rows and Y has y values repeated down columns (MATLAB 'xy' indexing). With a single argument v, uses v for both x and y. An optional 'ij' argument switches to NumPy-style matrix indexing where X varies along the first dimension.",[497,500,503],{"_16":498,"_22":499},"x","X-coordinate vector",{"_16":501,"_22":502,"_69":11},"y","Y-coordinate vector (defaults to x if omitted)",{"_16":504,"_22":505,"_69":11},"indexing","Indexing mode: 'xy' (default, MATLAB style) or 'ij' (NumPy matrix style)","Two NDArrays [X, Y] of coordinate matrices",[508,510,512],{"_33":509},"[X, Y] = meshgrid(1:3, 1:2)",{"_33":511},"[X, Y] = meshgrid(-2:0.5:2)",{"_33":513,"_368":514},"[X, Y] = meshgrid(1:3, 1:5, 'ij')","% X is 3x5, Y is 3x5 (NumPy style)",[516,290,427],"surf",{"_16":518,"_18":519,"_20":520,"_22":521,"_24":522,"_28":525,"_30":526,"_37":536},"peaks","Z = peaks()\nZ = peaks(n)\n[X, Y, Z] = peaks(...)","Peaks function (test surface)","Generates a test surface with multiple peaks and valleys, commonly used for 3D visualization demos. The function is defined as: Z = 3*(1-X)^2*exp(-X^2-(Y+1)^2) - 10*(X/5-X^3-Y^5)*exp(-X^2-Y^2) - (1/3)*exp(-(X+1)^2-Y^2) evaluated over the range [-3, 3] for both X and Y.",[523],{"_16":362,"_22":524,"_69":11},"Grid size (default: 49). Returns an n×n matrix.","n×n NDArray of Z values, or [X, Y, Z] coordinate matrices",[527,530,533],{"_33":528,"_368":529},"surf(peaks())","% 49×49 surface plot",{"_33":531,"_368":532},"Z = peaks(30)","% 30×30 matrix",{"_33":534,"_368":535},"[X, Y, Z] = peaks(25)","% Returns all coordinate matrices",[516,290,492,537],"gallery",{"_16":537,"_18":539,"_20":540,"_22":541,"_24":542,"_28":551,"_30":552,"_37":568},"A = gallery(matname)\nA = gallery(matname, n)\nA = gallery(matname, n, ...)","Test matrices by name","Generates test matrices useful for testing numerical algorithms. The first argument is a string specifying the matrix type. Available types include: 'hilb' (Hilbert), 'invhilb' (inverse Hilbert), 'pascal', 'magic', 'lehmer', 'minij', 'moler', 'pei', 'kms', 'cauchy', 'circul', 'fiedler', 'tridiag', 'frank', 'grcar', 'hanowa', 'jordbloc', 'clement', 'triw', 'parter'.",[543,546,548],{"_16":544,"_22":545},"matname","Name of the test matrix type (string)",{"_16":362,"_22":547,"_69":11},"Size or first parameter (depends on matrix type)",{"_16":549,"_22":550,"_69":11},"...","Additional parameters (depends on matrix type)","Test matrix of the specified type",[553,556,559,562,565],{"_33":554,"_368":555},"gallery('hilb', 4)","4×4 Hilbert matrix",{"_33":557,"_368":558},"gallery('pascal', 5)","5×5 Pascal matrix",{"_33":560,"_368":561},"gallery('lehmer', 3)","1.0000 0.5000 0.3333\n0.5000 1.0000 0.6667\n0.3333 0.6667 1.0000",{"_33":563,"_368":564},"gallery('pei', 3, 2)","3×3 Pei matrix with alpha=2",{"_33":566,"_368":567},"gallery('kms', 4, 0.5)","4×4 KMS Toeplitz matrix with rho=0.5",[425,569,424,404,570,571],"invhilb","toeplitz","hankel",{"_16":573,"_18":574,"_20":575,"_22":576,"_24":577,"_28":581,"_30":582,"_37":586},"sin","Y = sin(X)","Sine of argument in radians","Computes the sine of each element. Operates element-wise on arrays.",[578],{"_16":579,"_22":580},"X","Input angle in radians (scalar or NDArray)","Sine values (same shape as input)",[583],{"_33":584,"_368":585},"sin(pi/2)","1",[587,588,589],"cos","tan","asin",{"_16":587,"_18":591,"_20":592,"_22":593,"_24":594,"_28":596,"_30":597,"_37":600},"Y = cos(X)","Cosine of argument in radians","Computes the cosine of each element. Operates element-wise on arrays.",[595],{"_16":579,"_22":580},"Cosine values (same shape as input)",[598],{"_33":599,"_368":585},"cos(0)",[573,588,601],"acos",{"_16":588,"_18":603,"_20":604,"_22":605,"_24":606,"_28":608,"_30":609,"_37":612},"Y = tan(X)","Tangent of argument in radians","Computes the tangent of each element. Operates element-wise on arrays.",[607],{"_16":579,"_22":580},"Tangent values (same shape as input)",[610],{"_33":611,"_368":585},"tan(pi/4)",[573,587,613],"atan",{"_16":589,"_18":615,"_20":616,"_22":617,"_24":618,"_28":621,"_30":622,"_37":626},"Y = asin(X)","Inverse sine (arcsine)","Computes the inverse sine of each element. Result is in radians in the range [-pi/2, pi/2].",[619],{"_16":579,"_22":620},"Input values in [-1, 1] (scalar or NDArray)","Angle in radians",[623],{"_33":624,"_368":625},"asin(1)","1.5708",[573,601,613],{"_16":601,"_18":628,"_20":629,"_22":630,"_24":631,"_28":621,"_30":633,"_37":636},"Y = acos(X)","Inverse cosine (arccosine)","Computes the inverse cosine of each element. Result is in radians in the range [0, pi].",[632],{"_16":579,"_22":620},[634],{"_33":635,"_368":625},"acos(0)",[587,589,613],{"_16":613,"_18":638,"_20":639,"_22":640,"_24":641,"_28":621,"_30":644,"_37":648},"Y = atan(X)","Inverse tangent (arctangent)","Computes the inverse tangent of each element. Result is in radians in the range (-pi/2, pi/2).",[642],{"_16":579,"_22":643},"Input value (scalar or NDArray)",[645],{"_33":646,"_368":647},"atan(1)","0.7854",[588,649,589],"atan2",{"_16":649,"_18":651,"_20":652,"_22":653,"_24":654,"_28":661,"_30":662,"_37":665},"Y = atan2(B, A)","Four-quadrant inverse tangent","Computes the four-quadrant inverse tangent of B/A, using the signs of both arguments to determine the quadrant.",[655,658],{"_16":656,"_22":657},"B","Y-coordinates (scalar or NDArray)",{"_16":659,"_22":660},"A","X-coordinates (scalar or NDArray)","Angle in radians in (-pi, pi]",[663],{"_33":664,"_368":647},"atan2(1, 1)",[613,573,587],{"_16":667,"_18":668,"_20":669,"_22":670,"_24":671,"_28":673,"_30":674,"_37":678},"sinh","Y = sinh(X)","Hyperbolic sine","Computes the hyperbolic sine of each element.",[672],{"_16":579,"_22":643},"Hyperbolic sine values",[675],{"_33":676,"_368":677},"sinh(0)","0",[679,680,573],"cosh","tanh",{"_16":679,"_18":682,"_20":683,"_22":684,"_24":685,"_28":687,"_30":688,"_37":691},"Y = cosh(X)","Hyperbolic cosine","Computes the hyperbolic cosine of each element.",[686],{"_16":579,"_22":643},"Hyperbolic cosine values",[689],{"_33":690,"_368":585},"cosh(0)",[667,680,587],{"_16":680,"_18":693,"_20":694,"_22":695,"_24":696,"_28":698,"_30":699,"_37":702},"Y = tanh(X)","Hyperbolic tangent","Computes the hyperbolic tangent of each element.",[697],{"_16":579,"_22":643},"Hyperbolic tangent values",[700],{"_33":701,"_368":677},"tanh(0)",[667,679,588],{"_16":704,"_18":705,"_20":706,"_22":707,"_24":708,"_28":711,"_30":712,"_37":718},"exp","Y = exp(X)","Exponential (e^x)","Computes e raised to the power of each element.",[709],{"_16":579,"_22":710},"Exponent values (scalar or NDArray)","Exponential values",[713,715],{"_33":714,"_368":585},"exp(0)",{"_33":716,"_368":717},"exp(1)","2.7183",[719,720],"log","log10",{"_16":719,"_18":722,"_20":723,"_22":724,"_24":725,"_28":728,"_30":729,"_37":732},"Y = log(X)","Natural logarithm","Computes the natural logarithm (base e) of each element.",[726],{"_16":579,"_22":727},"Input values > 0 (scalar or NDArray)","Natural log values",[730],{"_33":731,"_368":585},"log(exp(1))",[704,720,733],"log2",{"_16":720,"_18":735,"_20":736,"_22":737,"_24":738,"_28":740,"_30":741,"_37":745},"Y = log10(X)","Common logarithm (base 10)","Computes the base-10 logarithm of each element.",[739],{"_16":579,"_22":727},"Base-10 log values",[742],{"_33":743,"_368":744},"log10(100)","2",[719,733,704],{"_16":733,"_18":747,"_20":748,"_22":749,"_24":750,"_28":752,"_30":753,"_37":757},"Y = log2(X)","Base-2 logarithm","Computes the base-2 logarithm of each element.",[751],{"_16":579,"_22":727},"Base-2 log values",[754],{"_33":755,"_368":756},"log2(8)","3",[719,720,704],{"_16":759,"_18":760,"_20":761,"_22":762,"_24":763,"_28":766,"_30":767,"_37":770},"sqrt","Y = sqrt(X)","Square root","Computes the square root of each element.",[764],{"_16":579,"_22":765},"Input values >= 0 (scalar or NDArray)","Square root values",[768],{"_33":769,"_368":756},"sqrt(9)",[771,704],"abs",{"_16":771,"_18":773,"_20":774,"_22":775,"_24":776,"_28":778,"_30":779,"_37":783},"Y = abs(X)","Absolute value","Computes the absolute value of each element.",[777],{"_16":579,"_22":643},"Absolute values",[780],{"_33":781,"_368":782},"abs(-5)","5",[759,784,785],"floor","ceil",{"_16":784,"_18":787,"_20":788,"_22":789,"_24":790,"_28":792,"_30":793,"_37":796},"Y = floor(X)","Round toward negative infinity","Rounds each element to the nearest integer toward negative infinity.",[791],{"_16":579,"_22":643},"Rounded values",[794],{"_33":795,"_368":756},"floor(3.7)",[785,797,771],"round",{"_16":785,"_18":799,"_20":800,"_22":801,"_24":802,"_28":792,"_30":804,"_37":808},"Y = ceil(X)","Round toward positive infinity","Rounds each element to the nearest integer toward positive infinity.",[803],{"_16":579,"_22":643},[805],{"_33":806,"_368":807},"ceil(3.2)","4",[784,797,771],{"_16":797,"_18":810,"_20":811,"_22":812,"_24":813,"_28":792,"_30":815,"_37":818},"Y = round(X)","Round to nearest integer","Rounds each element to the nearest integer.",[814],{"_16":579,"_22":643},[816],{"_33":817,"_368":807},"round(3.5)",[784,785],{"_16":820,"_18":821,"_20":822,"_22":823,"_24":824,"_28":830,"_30":831,"_37":838},"sum","S = sum(A)\nS = sum(A, dim)","Sum of array elements","Returns the sum of the elements. With a dimension argument, sums along that dimension (1-indexed).",[825,827],{"_16":659,"_22":826},"Input array (scalar or NDArray)",{"_16":828,"_22":829,"_69":11},"dim","Dimension to sum along (1-indexed)","Sum value (scalar or NDArray)",[832,835],{"_33":833,"_368":834},"sum([1 2 3])","6",{"_33":836,"_368":837},"A = [1 2; 3 4]; sum(A, 1)","4 6",[839,840,841],"mean","min","max",{"_16":839,"_18":843,"_20":844,"_22":845,"_24":846,"_28":850,"_30":851,"_37":855},"M = mean(A)\nM = mean(A, dim)","Average of array elements","Returns the arithmetic mean. With a dimension argument, computes the mean along that dimension.",[847,848],{"_16":659,"_22":826},{"_16":828,"_22":849,"_69":11},"Dimension to average along (1-indexed)","Mean value (scalar or NDArray)",[852],{"_33":853,"_368":854},"mean([1 2 3 4])","2.5",[820,856,857],"std","var",{"_16":856,"_18":859,"_20":860,"_22":861,"_24":862,"_28":866,"_30":867,"_37":870},"S = std(A)\nS = std(A, dim)","Standard deviation","Returns the standard deviation of the elements. With a dimension argument, computes along that dimension.",[863,864],{"_16":659,"_22":826},{"_16":828,"_22":865,"_69":11},"Dimension (1-indexed)","Standard deviation (scalar or NDArray)",[868],{"_33":869,"_368":744},"std([2 4 4 4 5 5 7 9])",[857,839],{"_16":857,"_18":872,"_20":873,"_22":874,"_24":875,"_28":878,"_30":879,"_37":882},"V = var(A)\nV = var(A, dim)","Variance","Returns the variance of the elements. With a dimension argument, computes along that dimension.",[876,877],{"_16":659,"_22":826},{"_16":828,"_22":865,"_69":11},"Variance (scalar or NDArray)",[880],{"_33":881,"_368":807},"var([2 4 4 4 5 5 7 9])",[856,839],{"_16":840,"_18":884,"_20":885,"_22":886,"_24":887,"_28":890,"_30":891,"_37":894},"M = min(A)\nM = min(A, dim)","Minimum value","Returns the smallest element. With a dimension argument, returns the minimum along that dimension.",[888,889],{"_16":659,"_22":826},{"_16":828,"_22":865,"_69":11},"Minimum value (scalar or NDArray)",[892],{"_33":893,"_368":585},"min([3 1 4 1 5])",[841,820],{"_16":841,"_18":896,"_20":897,"_22":898,"_24":899,"_28":902,"_30":903,"_37":906},"M = max(A)\nM = max(A, dim)","Maximum value","Returns the largest element. With a dimension argument, returns the maximum along that dimension.",[900,901],{"_16":659,"_22":826},{"_16":828,"_22":865,"_69":11},"Maximum value (scalar or NDArray)",[904],{"_33":905,"_368":782},"max([3 1 4 1 5])",[840,820],{"_16":908,"_18":909,"_20":910,"_22":911,"_24":912,"_28":916,"_30":917,"_37":925},"any","B = any(A)\nB = any(A, dim)","Test if any elements are nonzero","Returns 1 if any element of A is nonzero, 0 otherwise. With a dimension argument, operates along that dimension.",[913,914],{"_16":659,"_22":826},{"_16":828,"_22":915,"_69":11},"Dimension to operate along (1-indexed)","1 if any element is nonzero, 0 otherwise",[918,920,922],{"_33":919,"_368":585},"any([0 0 1 0])",{"_33":921,"_368":677},"any([0 0 0])",{"_33":923,"_368":924},"A = [1 0; 0 0]; any(A, 1)","1 0",[926,927],"all","find",{"_16":926,"_18":929,"_20":930,"_22":931,"_24":932,"_28":935,"_30":936,"_37":943},"B = all(A)\nB = all(A, dim)","Test if all elements are nonzero","Returns 1 if all elements of A are nonzero, 0 otherwise. With a dimension argument, operates along that dimension.",[933,934],{"_16":659,"_22":826},{"_16":828,"_22":915,"_69":11},"1 if all elements are nonzero, 0 otherwise",[937,939,941],{"_33":938,"_368":585},"all([1 2 3])",{"_33":940,"_368":677},"all([1 0 3])",{"_33":942,"_368":924},"A = [1 1; 1 0]; all(A, 1)",[908,927],{"_16":927,"_18":945,"_20":946,"_22":947,"_24":948,"_28":956,"_30":957,"_37":970},"k = find(X)\nk = find(X, n)\nk = find(X, n, direction)","Find indices of nonzero elements","Returns the linear indices of nonzero elements in X. Optionally returns only the first or last n indices.",[949,951,953],{"_16":579,"_22":950},"Input array",{"_16":362,"_22":952,"_69":11},"Number of indices to return",{"_16":954,"_22":955,"_69":11},"direction","'first' (default) or 'last' - which indices to return","Vector of indices (1-based)",[958,961,964,967],{"_33":959,"_368":960},"find([1 0 3 0 5])","1 3 5",{"_33":962,"_368":963},"find([1 0 3 0 5], 2)","1 3",{"_33":965,"_368":966},"find([1 0 3 0 5], 2, 'last')","3 5",{"_33":968,"_368":969},"A = [1 2 3 4 5]; find(A > 3)","4 5",[908,926],{"_16":193,"_18":972,"_20":973,"_22":974,"_24":975,"_28":979,"_30":980,"_37":986},"s = size(A)\ns = size(A, dim)","Array dimensions","Returns the size of an array. With a dimension argument, returns the length of that dimension.",[976,977],{"_16":659,"_22":950},{"_16":828,"_22":978,"_69":11},"Dimension to query (1-indexed)","Size as NDArray or scalar",[981,984],{"_33":982,"_368":983},"A = zeros(3, 4); size(A)","3 4",{"_33":985,"_368":807},"size(A, 2)",[987,988,989],"length","numel","ndims",{"_16":987,"_18":991,"_20":992,"_22":993,"_24":994,"_28":996,"_30":997,"_37":1000},"n = length(A)","Length of largest array dimension","Returns the length of the largest dimension of the array.",[995],{"_16":659,"_22":950},"Scalar length",[998],{"_33":999,"_368":782},"length([1 2 3 4 5])",[193,988],{"_16":988,"_18":1002,"_20":1003,"_22":1004,"_24":1005,"_28":1007,"_30":1008,"_37":1012},"n = numel(A)","Number of array elements","Returns the total number of elements in the array.",[1006],{"_16":659,"_22":950},"Scalar count",[1009],{"_33":1010,"_368":1011},"A = zeros(3, 4); numel(A)","12",[193,987],{"_16":989,"_18":1014,"_20":1015,"_22":1016,"_24":1017,"_28":1019,"_30":1020,"_37":1023},"n = ndims(A)","Number of array dimensions","Returns the number of dimensions of the array.",[1018],{"_16":659,"_22":950},"Scalar dimension count",[1021],{"_33":1022,"_368":744},"A = zeros(3, 4); ndims(A)",[193,987],{"_16":1025,"_18":1026,"_20":1027,"_22":1028,"_24":1029,"_28":1033,"_30":1034,"_37":1038},"reshape","B = reshape(A, m, n)","Reshape array","Reshapes array A into an m-by-n matrix. The number of elements must not change.",[1030,1031,1032],{"_16":659,"_22":950},{"_16":359,"_22":360},{"_16":362,"_22":363},"Reshaped NDArray",[1035],{"_33":1036,"_368":1037},"reshape([1 2 3 4 5 6], 2, 3)","1 3 5\n2 4 6",[193,1039],"transpose",{"_16":1039,"_18":1041,"_20":1042,"_22":1043,"_24":1044,"_28":1047,"_30":1048,"_37":1052},"B = transpose(A)\nB = A'","Transpose matrix","Transposes a matrix (swaps rows and columns).",[1045],{"_16":659,"_22":1046},"Input matrix","Transposed NDArray",[1049],{"_33":1050,"_368":1051},"A = [1 2; 3 4]; A'","1 3\n2 4",[1025,1053],"flip",{"_16":403,"_18":1055,"_20":1056,"_22":1057,"_24":1058,"_28":1062,"_30":1063,"_37":1067},"D = diag(v)\nd = diag(A)","Create diagonal matrix or extract diagonal","If the input is a vector, creates a diagonal matrix. If the input is a matrix, extracts the diagonal.",[1059],{"_16":1060,"_22":1061},"v/A","Input vector or matrix","Diagonal matrix or diagonal vector",[1064],{"_33":1065,"_368":1066},"diag([1 2 3])","1 0 0\n0 2 0\n0 0 3",[375,353],{"_16":1053,"_18":1069,"_20":1070,"_22":1071,"_24":1072,"_28":1076,"_30":1077,"_37":1081},"B = flip(A)\nB = flip(A, dim)","Flip order of elements","Reverses the order of elements along the specified dimension (default: first non-singleton dimension).",[1073,1074],{"_16":659,"_22":950},{"_16":828,"_22":1075,"_69":11},"Dimension to flip along","Flipped NDArray",[1078],{"_33":1079,"_368":1080},"flip([1 2 3])","3 2 1",[1082,1083,1084],"fliplr","flipud","rot90",{"_16":1082,"_18":1086,"_20":1087,"_22":1088,"_24":1089,"_28":1076,"_30":1091,"_37":1095},"B = fliplr(A)","Flip array left to right","Flips a matrix left to right (reverses columns).",[1090],{"_16":659,"_22":1046},[1092],{"_33":1093,"_368":1094},"fliplr([1 2 3; 4 5 6])","3 2 1\n6 5 4",[1083,1053,1084],{"_16":1083,"_18":1097,"_20":1098,"_22":1099,"_24":1100,"_28":1076,"_30":1102,"_37":1106},"B = flipud(A)","Flip array up to down","Flips a matrix up to down (reverses rows).",[1101],{"_16":659,"_22":1046},[1103],{"_33":1104,"_368":1105},"flipud([1 2; 3 4])","3 4\n1 2",[1082,1053,1084],{"_16":1084,"_18":1108,"_20":1109,"_22":1110,"_24":1111,"_28":1116,"_30":1117,"_37":1121},"B = rot90(A)\nB = rot90(A, k)","Rotate array 90 degrees","Rotates the matrix 90 degrees counterclockwise. Optional argument k specifies the number of 90-degree rotations.",[1112,1113],{"_16":659,"_22":1046},{"_16":1114,"_22":1115,"_69":11},"k","Number of 90° rotations (default: 1)","Rotated NDArray",[1118],{"_33":1119,"_368":1120},"rot90([1 2; 3 4])","2 4\n1 3",[1053,1039],{"_16":1123,"_18":1124,"_20":1125,"_22":1126,"_24":1127,"_28":1131,"_30":1132,"_37":1136},"lower","s = lower(str)","Convert string to lowercase","Converts all uppercase characters in the string to lowercase.",[1128],{"_16":1129,"_22":1130},"str","Input string","Lowercase string",[1133],{"_33":1134,"_368":1135},"lower(\"Hello World\")","'hello world'",[1137],"upper",{"_16":1137,"_18":1139,"_20":1140,"_22":1141,"_24":1142,"_28":1144,"_30":1145,"_37":1149},"s = upper(str)","Convert string to uppercase","Converts all lowercase characters in the string to uppercase.",[1143],{"_16":1129,"_22":1130},"Uppercase string",[1146],{"_33":1147,"_368":1148},"upper(\"Hello World\")","'HELLO WORLD'",[1123],{"_16":1151,"_18":1152,"_20":1153,"_22":1154,"_24":1155,"_28":1157,"_30":1158,"_37":1161},"strlength","n = strlength(str)","Length of string","Returns the number of characters in the string.",[1156],{"_16":1129,"_22":1130},"Number of characters",[1159],{"_33":1160,"_368":782},"strlength(\"hello\")",[987],{"_16":1163,"_18":1164,"_20":1165,"_22":1166,"_24":1167,"_28":1174,"_30":1175,"_37":1180},"strcmp","tf = strcmp(s1, s2)","Compare strings","Returns 1 if the strings are identical, 0 otherwise.",[1168,1171],{"_16":1169,"_22":1170},"s1","First string",{"_16":1172,"_22":1173},"s2","Second string","1 if equal, 0 otherwise",[1176,1178],{"_33":1177,"_368":585},"strcmp(\"abc\", \"abc\")",{"_33":1179,"_368":677},"strcmp(\"abc\", \"def\")",[1181],"strcmpi",{"_16":1181,"_18":1183,"_20":1184,"_22":1185,"_24":1186,"_28":1189,"_30":1190,"_37":1193},"tf = strcmpi(s1, s2)","Compare strings (case-insensitive)","Returns 1 if the strings are identical ignoring case, 0 otherwise.",[1187,1188],{"_16":1169,"_22":1170},{"_16":1172,"_22":1173},"1 if equal (ignoring case), 0 otherwise",[1191],{"_33":1192,"_368":585},"strcmpi(\"Hello\", \"hello\")",[1163],{"_16":1195,"_18":1196,"_20":1197,"_22":1198,"_24":1199,"_28":1205,"_30":1206,"_37":1210},"strfind","k = strfind(str, pattern)","Find pattern in string","Returns the starting index of each occurrence of pattern in str. Returns empty array if not found.",[1200,1202],{"_16":1129,"_22":1201},"String to search in",{"_16":1203,"_22":1204},"pattern","Pattern to find","Array of starting indices",[1207],{"_33":1208,"_368":1209},"strfind(\"abcabc\", \"bc\")","[2, 5]",[1211,1212,1213],"contains","startsWith","endsWith",{"_16":1215,"_18":1216,"_20":1217,"_22":1218,"_24":1219,"_28":1227,"_30":1228,"_37":1232},"strrep","s = strrep(str, old, new)","Replace substring","Replaces all occurrences of old with new in str.",[1220,1221,1224],{"_16":1129,"_22":1130},{"_16":1222,"_22":1223},"old","Substring to replace",{"_16":1225,"_22":1226},"new","Replacement string","String with replacements made",[1229],{"_33":1230,"_368":1231},"strrep(\"hello world\", \"world\", \"there\")","'hello there'",[1195],{"_16":1234,"_18":1235,"_20":1236,"_22":1237,"_24":1238,"_28":1240,"_30":1241,"_37":1245},"strip","s = strip(str)","Remove leading and trailing whitespace","Removes leading and trailing whitespace characters from the string.",[1239],{"_16":1129,"_22":1130},"Trimmed string",[1242],{"_33":1243,"_368":1244},"strip(\" hello \")","'hello'",[],{"_16":1212,"_18":1247,"_20":1248,"_22":1249,"_24":1250,"_28":1255,"_30":1256,"_37":1259},"tf = startsWith(str, prefix)","Check if string starts with prefix","Returns 1 if str starts with prefix, 0 otherwise.",[1251,1252],{"_16":1129,"_22":1130},{"_16":1253,"_22":1254},"prefix","Prefix to check","1 if starts with prefix, 0 otherwise",[1257],{"_33":1258,"_368":585},"startsWith(\"hello\", \"hel\")",[1213,1211],{"_16":1213,"_18":1261,"_20":1262,"_22":1263,"_24":1264,"_28":1269,"_30":1270,"_37":1273},"tf = endsWith(str, suffix)","Check if string ends with suffix","Returns 1 if str ends with suffix, 0 otherwise.",[1265,1266],{"_16":1129,"_22":1130},{"_16":1267,"_22":1268},"suffix","Suffix to check","1 if ends with suffix, 0 otherwise",[1271],{"_33":1272,"_368":585},"endsWith(\"hello\", \"lo\")",[1212,1211],{"_16":1211,"_18":1275,"_20":1276,"_22":1277,"_24":1278,"_28":1282,"_30":1283,"_37":1286},"tf = contains(str, pattern)","Check if string contains pattern","Returns 1 if str contains pattern, 0 otherwise.",[1279,1280],{"_16":1129,"_22":1130},{"_16":1203,"_22":1281},"Pattern to search for","1 if contains pattern, 0 otherwise",[1284],{"_33":1285,"_368":585},"contains(\"hello world\", \"wor\")",[1212,1213,1195],{"_16":1288,"_18":1289,"_20":1290,"_22":1291,"_24":1292,"_28":1299,"_30":1300,"_37":1307},"sprintf","s = sprintf(format, A1, A2, ...)","Format data into string","Formats data according to format string. Supports %d (integer), %f (float), %s (string), %e (exponential).",[1293,1296],{"_16":1294,"_22":1295},"format","Format string with conversion specifiers",{"_16":1297,"_22":1298},"A1, A2, ...","Values to format","Formatted string",[1301,1304],{"_33":1302,"_368":1303},"sprintf(\"x = %d\", 42)","'x = 42'",{"_33":1305,"_368":1306},"sprintf(\"pi = %.4f\", pi)","'pi = 3.1416'",[1308],"disp",{"_16":1310,"_18":1311,"_20":1312,"_22":1313,"_24":1314,"_28":1317,"_30":1318,"_37":1325},"char","c = char(n)","Convert to character","Converts numeric code to character, or ensures input is a character array.",[1315],{"_16":362,"_22":1316},"Numeric ASCII/Unicode code or string","Character string",[1319,1322],{"_33":1320,"_368":1321},"char(65)","'A'",{"_33":1323,"_368":1324},"char([72 101 108 108 111])","'Hello'",[1326],"double",{"_16":1328,"_18":1329,"_20":1330,"_22":1331,"_24":1332,"_28":1338,"_30":1339,"_37":1346},"num2str","s = num2str(A)\ns = num2str(A, precision)","Convert number to string","Converts numeric array to string representation.",[1333,1335],{"_16":659,"_22":1334},"Numeric value or array",{"_16":1336,"_22":1337,"_69":11},"precision","Number of significant digits","String representation of number",[1340,1343],{"_33":1341,"_368":1342},"num2str(3.14159)","'3.1416'",{"_33":1344,"_368":1345},"num2str(pi, 10)","'3.141592654'",[1347,1288],"str2num",{"_16":1347,"_18":1349,"_20":1350,"_22":1351,"_24":1352,"_28":1355,"_30":1356,"_37":1360},"n = str2num(str)","Convert string to number","Converts string representation of number to numeric value.",[1353],{"_16":1129,"_22":1354},"String containing numeric value","Numeric value",[1357],{"_33":1358,"_368":1359},"str2num(\"3.14\")","3.14",[1328],{"_16":1362,"_18":1363,"_20":1364,"_22":1365,"_24":1366,"_28":1370,"_30":1371,"_37":1374},"strcat","s = strcat(s1, s2, ...)","Concatenate strings","Concatenates strings horizontally.",[1367],{"_16":1368,"_22":1369},"s1, s2, ...","Strings to concatenate","Concatenated string",[1372],{"_33":1373,"_368":1135},"strcat(\"hello\", \" \", \"world\")",[],{"_16":1376,"_18":1377,"_20":1378,"_22":1379,"_24":1380,"_28":1387,"_30":1388,"_37":1392},"strjoin","s = strjoin(strs, delimiter)","Join strings with delimiter","Joins an array of strings with the specified delimiter.",[1381,1384],{"_16":1382,"_22":1383},"strs","Cell array or string array",{"_16":1385,"_22":1386,"_69":11},"delimiter","Delimiter string (default: space)","Joined string",[1389],{"_33":1390,"_368":1391},"strjoin([\"a\", \"b\", \"c\"], \"-\")","'a-b-c'",[1362],{"_16":1394,"_18":1395,"_20":1396,"_22":1397,"_24":1398,"_28":1402,"_30":1403,"_37":1407},"strsplit","parts = strsplit(str, delimiter)","Split string at delimiter","Splits a string at each occurrence of delimiter.",[1399,1400],{"_16":1129,"_22":1130},{"_16":1385,"_22":1401,"_69":11},"Delimiter string (default: whitespace)","Array of substrings",[1404],{"_33":1405,"_368":1406},"strsplit(\"a-b-c\", \"-\")","['a', 'b', 'c']",[1376],{"_16":1308,"_18":1409,"_20":1410,"_22":1411,"_24":1412,"_28":1415,"_30":1416,"_37":1420},"disp(X)","Display value","Displays the value of a variable or expression without the variable name.",[1413],{"_16":579,"_22":1414},"Value to display","The input value (also displayed as output)",[1417],{"_33":1418,"_368":1419},"disp('hello')","hello",[],{"_16":1422,"_18":1422,"_20":1423,"_22":1424,"_24":1425,"_28":1426,"_30":1427,"_37":1431},"tic","Start stopwatch timer","Starts a stopwatch timer to measure elapsed time. Use with toc to measure execution time of code blocks. Multiple tic calls reset the timer.",[],"void",[1428],{"_33":1429,"_368":1430},"tic\nA = rand(100);\ntoc","Elapsed time is 0.012345 seconds.",[1432],"toc",{"_16":1432,"_18":1434,"_20":1435,"_22":1436,"_24":1437,"_28":1438,"_30":1439,"_37":1443},"t = toc","Read elapsed time from stopwatch","Reads the elapsed time in seconds since the most recent tic call. Prints the elapsed time and returns it as a number. Throws an error if called without a preceding tic.",[],"Elapsed time in seconds (scalar)",[1440],{"_33":1441,"_368":1442},"tic\nfor i = 1:100\n rand(10);\nend\nt = toc","Elapsed time is 0.005123 seconds.\nt = 0.005123",[1422],{"_16":1445,"_18":1446,"_20":1447,"_22":1448,"_24":1449,"_28":1453,"_30":1454,"_37":1461},"eval","eval(expression)\n[output1,...,outputN] = eval(expression)","Evaluate M-Code expression","Evaluates the M-Code contained in the string expression. Variables created or modified in the evaluated code affect the current workspace.",[1450],{"_16":1451,"_22":1452},"expression","String containing M-Code to evaluate","Result of the evaluated expression",[1455,1458],{"_33":1456,"_368":1457},"eval('x = 5')","x = 5",{"_33":1459,"_368":1460},"Z = eval('magic(3)')","Z = [8 1 6; 3 5 7; 4 9 2]",[],{"_43":1463,"_16":1464,"_22":1465,"_47":48,"_49":1466,"_52":1467},"linalg","Linear Algebra","Matrix decompositions, solvers, products, norms, and other linear algebra operations.","📐",[1468,1487,1503,1514,1531,1546,1561,1573,1588,1602,1613,1627,1638,1657,1668,1686,1700,1712,1730,1746,1761,1775,1791,1808],{"_16":1469,"_18":1470,"_20":1471,"_22":1472,"_24":1473,"_28":1476,"_30":1477,"_37":1483},"eig","D = eig(A)\n[V,D] = eig(A)","Eigenvalues and eigenvectors","With one output, returns a vector of eigenvalues. With two outputs, V contains eigenvectors as columns and D is a diagonal matrix of eigenvalues.",[1474],{"_16":659,"_22":1475},"Square matrix (n×n)","Eigenvalue vector, or [V, D] decomposition",[1478,1481],{"_33":1479,"_368":1480},"eig([2 1; 1 2])","3\n1",{"_33":1482},"[V,D] = eig([2 1; 1 2])",[1484,1485,1486],"svd","det","inv",{"_16":1488,"_18":1489,"_20":1490,"_22":1491,"_24":1492,"_28":1476,"_30":1495,"_37":1501},"eigh","D = eigh(A)\n[V, D] = eigh(A)","Eigenvalues and eigenvectors of symmetric matrix","Computes eigenvalues and eigenvectors of a symmetric or Hermitian matrix. Eigenvalues are always real and returned in ascending order. More efficient than eig() for symmetric matrices.",[1493],{"_16":659,"_22":1494},"Symmetric/Hermitian matrix (n×n)",[1496,1499],{"_33":1497,"_368":1498},"A = [2 1; 1 2];\nD = eigh(A)","1\n3",{"_33":1500},"[V, D] = eigh([2 1; 1 2])",[1469,1502,1484],"eigvalsh",{"_16":1502,"_18":1504,"_20":1505,"_22":1506,"_24":1507,"_28":1509,"_30":1510,"_37":1513},"D = eigvalsh(A)","Eigenvalues of symmetric matrix","Computes only the eigenvalues of a symmetric or Hermitian matrix. More efficient than eigh() when eigenvectors are not needed. Eigenvalues are returned in ascending order.",[1508],{"_16":659,"_22":1494},"Vector of eigenvalues in ascending order",[1511],{"_33":1512,"_368":1498},"eigvalsh([2 1; 1 2])",[1488,1469],{"_16":1484,"_18":1515,"_20":1516,"_22":1517,"_24":1518,"_28":1521,"_30":1522,"_37":1528},"S = svd(A)\n[U,S,V] = svd(A)","Singular value decomposition","With one output, returns singular values as a vector. With three outputs, returns the full U*S*V' decomposition where S is a diagonal matrix.",[1519],{"_16":659,"_22":1520},"Input matrix (m×n)","Singular value vector, or [U, S, V] decomposition",[1523,1526],{"_33":1524,"_368":1525},"svd([1 0; 0 2])","2\n1",{"_33":1527},"[U,S,V] = svd([1 0; 0 2])",[1469,1529,1530],"rank","norm",{"_16":1532,"_18":1533,"_20":1534,"_22":1535,"_24":1536,"_28":1538,"_30":1539,"_37":1544},"qr","R = qr(A)\n[Q,R] = qr(A)","QR decomposition","With one output, returns the upper-triangular R factor. With two outputs, returns Q (orthonormal) and R (upper-triangular).",[1537],{"_16":659,"_22":1520},"R matrix, or [Q, R] decomposition",[1540,1542],{"_33":1541,"_368":401},"qr(eye(3))",{"_33":1543},"[Q,R] = qr([1 2; 3 4])",[1484,1545,1469],"chol",{"_16":1547,"_18":1548,"_20":1549,"_22":1550,"_24":1551,"_28":1553,"_30":1554,"_37":1559},"lu","L = lu(A)\n[L,U,P] = lu(A)","LU decomposition with partial pivoting","Factorizes matrix A into lower triangular L (unit diagonal), upper triangular U, and permutation matrix P such that P*A = L*U. With one output, returns the lower triangular factor only.",[1552],{"_16":659,"_22":1520},"Lower triangular factor L, or [L, U, P] decomposition",[1555,1557],{"_33":1556},"[L,U,P] = lu([2 1; 4 3])",{"_33":1558},"L = lu([1 2; 3 4])",[1532,1484,1545,1560],"linsolve",{"_16":1545,"_18":1562,"_20":1563,"_22":1564,"_24":1565,"_28":1568,"_30":1569,"_37":1572},"R = chol(A)","Cholesky factorization","Computes the upper-triangular Cholesky factor R such that R'*R = A. The input must be a symmetric positive-definite matrix.",[1566],{"_16":659,"_22":1567},"Symmetric positive-definite matrix (n×n)","Upper-triangular Cholesky factor R",[1570],{"_33":1571},"chol([4 2; 2 3])",[1532,1484,1486],{"_16":1485,"_18":1574,"_20":1575,"_22":1576,"_24":1577,"_28":1579,"_30":1580,"_37":1586},"d = det(A)","Matrix determinant","Computes the determinant of a square matrix.",[1578],{"_16":659,"_22":1475},"Scalar determinant value",[1581,1584],{"_33":1582,"_368":1583},"det([1 2; 3 4])","-2",{"_33":1585,"_368":585},"det(eye(3))",[1486,1529,1587],"trace",{"_16":1486,"_18":1589,"_20":1590,"_22":1591,"_24":1592,"_28":1595,"_30":1596,"_37":1600},"B = inv(A)","Matrix inverse","Computes the multiplicative inverse of a square matrix so that A*B = eye(n). The matrix must be non-singular.",[1593],{"_16":659,"_22":1594},"Non-singular square matrix (n×n)","Inverse matrix (n×n)",[1597],{"_33":1598,"_368":1599},"inv([1 2; 3 4])","-2.0000 1.0000\n1.5000 -0.5000",[1485,1601,1560],"pinv",{"_16":1601,"_18":1603,"_20":1604,"_22":1605,"_24":1606,"_28":1608,"_30":1609,"_37":1612},"B = pinv(A)","Moore-Penrose pseudo-inverse","Computes the pseudo-inverse of a matrix. Works for non-square and singular matrices.",[1607],{"_16":659,"_22":1520},"Pseudo-inverse matrix (n×m)",[1610],{"_33":1611},"pinv([1 0; 0 0])",[1486,1560,1529],{"_16":1529,"_18":1614,"_20":1615,"_22":1616,"_24":1617,"_28":1619,"_30":1620,"_37":1625},"r = rank(A)","Matrix rank","Estimates the rank of a matrix using singular value decomposition. The rank is the number of singular values above a tolerance threshold.",[1618],{"_16":659,"_22":1046},"Scalar rank",[1621,1623],{"_33":1622,"_368":756},"rank(eye(3))",{"_33":1624,"_368":585},"rank([1 2; 2 4])",[1484,1485,1626],"cond",{"_16":1587,"_18":1628,"_20":1629,"_22":1630,"_24":1631,"_28":1633,"_30":1634,"_37":1637},"t = trace(A)","Sum of diagonal elements","Returns the sum of the elements on the main diagonal of a matrix.",[1632],{"_16":659,"_22":1046},"Scalar trace value",[1635],{"_33":1636,"_368":807},"trace(eye(4))",[403,1485,1469],{"_16":1530,"_18":1639,"_20":1640,"_22":1641,"_24":1642,"_28":1647,"_30":1648,"_37":1656},"n = norm(A)\nn = norm(A, p)\nn = norm(A, 'fro')","Matrix or vector norm","Computes the norm of a vector or matrix. For vectors, the default is the 2-norm (Euclidean). For matrices, the default is the Frobenius norm. An optional second argument specifies the norm order (1, 2, etc.) or type ('fro' for Frobenius, 'nuc' for nuclear).",[1643,1644],{"_16":659,"_22":1061},{"_16":1645,"_22":1646,"_69":11},"p","Norm order or type: number (1, 2, Inf), or string ('fro', 'nuc')","Scalar norm value",[1649,1651,1654],{"_33":1650,"_368":782},"norm([3 4])",{"_33":1652,"_368":1653},"norm([3 4], 1)","7",{"_33":1655},"norm([1 2; 3 4], 'fro')",[1626,1529,1485],{"_16":1626,"_18":1658,"_20":1659,"_22":1660,"_24":1661,"_28":1663,"_30":1664,"_37":1667},"c = cond(A)","Condition number","Computes the condition number of a matrix using the ratio of the largest to smallest singular value. A large condition number indicates a nearly singular matrix.",[1662],{"_16":659,"_22":1046},"Scalar condition number",[1665],{"_33":1666,"_368":585},"cond(eye(3))",[1530,1529,1485],{"_16":1669,"_18":1670,"_20":1671,"_22":1672,"_24":1673,"_28":1678,"_30":1679,"_37":1684},"lstsq","x = lstsq(A, b)\n[x, residuals, rank, s] = lstsq(A, b)","Least-squares solution to linear equation","Computes the least-squares solution to the equation A*x = b. Returns the solution that minimizes ||A*x - b||. With one output, returns the solution vector x. With four outputs, also returns residuals, rank, and singular values.",[1674,1676],{"_16":659,"_22":1675},"Coefficient matrix (m×n)",{"_16":436,"_22":1677},"Ordinate values (m×1) or (m×k)","Solution vector x, or [x, residuals, rank, s]",[1680,1682],{"_33":1681},"A = [1 0; 1 1; 1 2]; b = [1; 2; 3];\nx = lstsq(A, b)",{"_33":1683},"[x, res, rnk, s] = lstsq(A, b)",[1685,1601,1532],"mldivide",{"_16":1560,"_18":1687,"_20":1688,"_22":1689,"_24":1690,"_28":1695,"_30":1696,"_37":1699},"x = linsolve(A, b)","Solve linear system Ax = b","Solves the linear system A*x = b for x, where A is a square matrix and b is a column vector or matrix.",[1691,1693],{"_16":659,"_22":1692},"Coefficient matrix (n×n)",{"_16":436,"_22":1694},"Right-hand side vector or matrix","Solution vector or matrix x",[1697],{"_33":1698},"A = [1 2; 3 4]; b = [5; 6]; linsolve(A, b)",[1685,1486,1485],{"_16":1685,"_18":1701,"_20":1702,"_22":1703,"_24":1704,"_28":1695,"_30":1708,"_37":1711},"x = mldivide(A, b)","Matrix left division (A\\b)","Solves the linear system A*x = b. Equivalent to the backslash operator `A\\b`. For square A, this uses direct solving. Prefer this over `inv(A)*b` for numerical stability.",[1705,1707],{"_16":659,"_22":1706},"Coefficient matrix",{"_16":436,"_22":1694},[1709],{"_33":1710},"A = [1 2; 3 4]; b = [5; 6]; mldivide(A, b)",[1560,1486],{"_16":1713,"_18":1714,"_20":1715,"_22":1716,"_24":1717,"_28":1722,"_30":1723,"_37":1726},"matmul","C = matmul(A, B)","Matrix multiplication","Matrix multiplication of two arrays. For 2-D arrays, performs standard matrix multiplication. For N-D arrays, broadcasts over batch dimensions and multiplies the last two dimensions.",[1718,1720],{"_16":659,"_22":1719},"First array (..., M, K)",{"_16":656,"_22":1721},"Second array (..., K, N)","Matrix product (..., M, N)",[1724],{"_33":1725},"matmul([1 2; 3 4], [5 6; 7 8])",[1727,1728,1729],"dot","kron","mpower",{"_16":1727,"_18":1731,"_20":1732,"_22":1733,"_24":1734,"_28":1739,"_30":1740,"_37":1744},"c = dot(a, b)","Dot product","Computes the dot product of two arrays. For 1-D arrays, returns the inner product. For 2-D arrays, performs matrix multiplication.",[1735,1737],{"_16":433,"_22":1736},"First input array",{"_16":436,"_22":1738},"Second input array","Dot product result",[1741],{"_33":1742,"_368":1743},"dot([1 2 3], [4 5 6])","32",[1745,1728],"cross",{"_16":1745,"_18":1747,"_20":1748,"_22":1749,"_24":1750,"_28":1755,"_30":1756,"_37":1760},"c = cross(a, b)","Cross product","Computes the cross product of two 3-element vectors.",[1751,1753],{"_16":433,"_22":1752},"First 3-element vector",{"_16":436,"_22":1754},"Second 3-element vector","3-element cross product vector",[1757],{"_33":1758,"_368":1759},"cross([1 0 0], [0 1 0])","0 0 1",[1727,1728],{"_16":1728,"_18":1762,"_20":1763,"_22":1764,"_24":1765,"_28":1770,"_30":1771,"_37":1774},"K = kron(A, B)","Kronecker tensor product","Computes the Kronecker product of two matrices. Each element of A is multiplied by the entire matrix B.",[1766,1768],{"_16":659,"_22":1767},"First input matrix",{"_16":656,"_22":1769},"Second input matrix","Kronecker product matrix",[1772],{"_33":1773},"kron([1 0; 0 1], [1 2; 3 4])",[1727,1745],{"_16":1776,"_18":1777,"_20":1778,"_22":1779,"_24":1780,"_28":1785,"_30":1786,"_37":1790},"outer","C = outer(a, b)","Outer product","Computes the outer product of two vectors, resulting in a matrix where C(i,j) = a(i)*b(j).",[1781,1783],{"_16":433,"_22":1782},"First vector (m-element)",{"_16":436,"_22":1784},"Second vector (n-element)","Outer product matrix (m x n)",[1787],{"_33":1788,"_368":1789},"outer([1 2 3], [4 5])","4 5\n8 10\n12 15",[1727,1745,1728],{"_16":1792,"_18":1793,"_20":1794,"_22":1795,"_24":1796,"_28":1803,"_30":1804,"_37":1807},"einsum","C = einsum(subscripts, A, B, ...)","Einstein summation convention","Evaluates the Einstein summation convention on the operands. The subscripts string specifies index contractions (e.g., \"ij,jk->ik\" for matrix multiplication).",[1797,1800],{"_16":1798,"_22":1799},"subscripts","Subscript string (e.g., \"ij,jk->ik\")",{"_16":1801,"_22":1802},"A,B,...","Input arrays","Result array according to subscripts",[1805],{"_33":1806},"einsum('ij,jk->ik', A, B)",[1727,1713],{"_16":1729,"_18":1809,"_20":1810,"_22":1811,"_24":1812,"_28":1816,"_30":1817,"_37":1820},"B = mpower(A, n)","Matrix power","Raises a square matrix to an integer power. Negative exponents compute the inverse raised to the absolute power.",[1813,1814],{"_16":659,"_22":1475},{"_16":362,"_22":1815},"Integer exponent","Matrix raised to power n",[1818],{"_33":1819,"_368":401},"mpower(eye(3), 2)",[1486,1485],{"_43":1822,"_16":1823,"_22":1824,"_47":48,"_49":1825,"_52":1826},"fft","Fourier Analysis","Fast Fourier Transform, inverse transforms, frequency utilities, and window functions for spectral analysis.","〰️",[1827,1847,1864,1877,1889,1901,1913,1926,1938,1953,1971,1982,1993,2004],{"_16":1822,"_18":1828,"_20":1829,"_22":1830,"_24":1831,"_28":1836,"_30":1837,"_37":1842},"Y = fft(X)\nY = fft(X, n)","Fast Fourier Transform","Computes the one-dimensional discrete Fourier Transform using the FFT algorithm. If `n` is specified, the input is either truncated or zero-padded to length `n` before transforming.",[1832,1834],{"_16":579,"_22":1833},"Input signal (vector or array)",{"_16":362,"_22":1835,"_69":11},"Transform length (zero-pads or truncates)","Complex-valued frequency-domain representation",[1838,1840],{"_33":1839},"fft([1 2 3 4])",{"_33":1841},"fft([1 0 1 0], 8)",[1843,1844,1845,1846],"ifft","fft2","fftshift","fftfreq",{"_16":1843,"_18":1848,"_20":1849,"_22":1850,"_24":1851,"_28":1857,"_30":1858,"_37":1861},"x = ifft(Y)\nx = ifft(Y, n)","Inverse Fast Fourier Transform","Computes the one-dimensional inverse discrete Fourier Transform. Recovers the original time-domain signal from its frequency-domain representation.",[1852,1855],{"_16":1853,"_22":1854},"Y","Frequency-domain input",{"_16":362,"_22":1856,"_69":11},"Transform length","Time-domain signal",[1859],{"_33":1860},"ifft(fft([1 2 3 4]))",[1822,1862,1863],"ifft2","ifftn",{"_16":1844,"_18":1865,"_20":1866,"_22":1867,"_24":1868,"_28":1871,"_30":1872,"_37":1875},"Y = fft2(X)","2-D Fast Fourier Transform","Computes the two-dimensional discrete Fourier Transform. Useful for image processing and 2-D signal analysis.",[1869],{"_16":579,"_22":1870},"Input 2-D array","2-D frequency-domain representation",[1873],{"_33":1874},"fft2(eye(4))",[1862,1822,1876],"fftn",{"_16":1862,"_18":1878,"_20":1879,"_22":1880,"_24":1881,"_28":1884,"_30":1885,"_37":1888},"x = ifft2(Y)","2-D inverse FFT","Computes the two-dimensional inverse discrete Fourier Transform.",[1882],{"_16":1853,"_22":1883},"Frequency-domain 2-D input","Spatial-domain 2-D signal",[1886],{"_33":1887},"ifft2(fft2(eye(4)))",[1844,1843,1863],{"_16":1876,"_18":1890,"_20":1891,"_22":1892,"_24":1893,"_28":1896,"_30":1897,"_37":1900},"Y = fftn(X)","N-dimensional FFT","Computes the N-dimensional discrete Fourier Transform over all axes of the input array.",[1894],{"_16":579,"_22":1895},"Input N-D array","N-D frequency-domain representation",[1898],{"_33":1899},"fftn(ones(4, 4))",[1863,1822,1844],{"_16":1863,"_18":1902,"_20":1903,"_22":1904,"_24":1905,"_28":1908,"_30":1909,"_37":1912},"x = ifftn(Y)","N-dimensional inverse FFT","Computes the N-dimensional inverse discrete Fourier Transform.",[1906],{"_16":1853,"_22":1907},"Frequency-domain N-D input","Spatial-domain N-D signal",[1910],{"_33":1911},"ifftn(fftn(ones(4, 4)))",[1876,1843,1862],{"_16":1845,"_18":1914,"_20":1915,"_22":1916,"_24":1917,"_28":1920,"_30":1921,"_37":1924},"Y = fftshift(X)","Shift zero-frequency component to center","Rearranges the output of `fft` by shifting the zero-frequency component to the center of the array. Useful for visualizing the Fourier transform with the DC component in the middle.",[1918],{"_16":579,"_22":1919},"Input array (typically output of fft)","Shifted array",[1922],{"_33":1923},"fftshift(fft([1 2 3 4 5 6 7 8]))",[1925,1822,1846],"ifftshift",{"_16":1925,"_18":1927,"_20":1928,"_22":1929,"_24":1930,"_28":1933,"_30":1934,"_37":1937},"Y = ifftshift(X)","Inverse of fftshift","Undoes the effect of `fftshift`. Shifts the zero-frequency component back to the beginning of the array.",[1931],{"_16":579,"_22":1932},"Shifted input array","Unshifted array",[1935],{"_33":1936},"ifftshift(fftshift([1 2 3 4]))",[1845,1822],{"_16":1846,"_18":1939,"_20":1940,"_22":1941,"_24":1942,"_28":1948,"_30":1949,"_37":1952},"f = fftfreq(n)\nf = fftfreq(n, d)","DFT sample frequencies","Returns the discrete Fourier Transform sample frequencies. For a signal of length `n` with sample spacing `d`, the frequencies are `[0, 1, ..., n/2-1, -n/2, ..., -1] / (d*n)` for even `n`.",[1943,1945],{"_16":362,"_22":1944},"Window length (number of samples)",{"_16":1946,"_22":1947,"_69":11},"d","Sample spacing (default: 1.0)","Array of sample frequencies",[1950],{"_33":1951},"fftfreq(8, 0.1)",[1822,1845],{"_16":1954,"_18":1955,"_20":1956,"_22":1957,"_24":1958,"_28":1962,"_30":1963,"_37":1966},"bartlett","w = bartlett(M)","Bartlett (triangular) window","Returns an M-point Bartlett window. Similar to a triangular window but with zero-valued endpoints. Useful for spectral analysis with reduced spectral leakage.",[1959],{"_16":1960,"_22":1961},"M","Number of points in the window","M-point Bartlett window vector",[1964],{"_33":1965},"bartlett(8)",[1967,1968,1969,1970],"hamming","hanning","blackman","kaiser",{"_16":1969,"_18":1972,"_20":1973,"_22":1974,"_24":1975,"_28":1977,"_30":1978,"_37":1981},"w = blackman(M)","Blackman window","Returns an M-point Blackman window. Designed to have close to minimal spectral leakage. Has wider main lobe but lower side lobes than Hamming or Hanning.",[1976],{"_16":1960,"_22":1961},"M-point Blackman window vector",[1979],{"_33":1980},"blackman(8)",[1967,1968,1954,1970],{"_16":1967,"_18":1983,"_20":1984,"_22":1985,"_24":1986,"_28":1988,"_30":1989,"_37":1992},"w = hamming(M)","Hamming window","Returns an M-point Hamming window. A raised-cosine window with coefficients optimized to minimize the nearest side lobe. Formula: w(n) = 0.54 - 0.46*cos(2*pi*n/(M-1)).",[1987],{"_16":1960,"_22":1961},"M-point Hamming window vector",[1990],{"_33":1991},"hamming(8)",[1968,1969,1954,1970],{"_16":1968,"_18":1994,"_20":1995,"_22":1996,"_24":1997,"_28":1999,"_30":2000,"_37":2003},"w = hanning(M)","Hanning (Hann) window","Returns an M-point Hanning window (also known as Hann window). A raised-cosine window. Formula: w(n) = 0.5*(1 - cos(2*pi*n/(M-1))).",[1998],{"_16":1960,"_22":1961},"M-point Hanning window vector",[2001],{"_33":2002},"hanning(8)",[1967,1969,1954,1970],{"_16":1970,"_18":2005,"_20":2006,"_22":2007,"_24":2008,"_28":2013,"_30":2014,"_37":2017},"w = kaiser(M, beta)","Kaiser window","Returns an M-point Kaiser window with shape parameter beta. The Kaiser window approximates the DPSS window and provides a flexible trade-off between main-lobe width and side-lobe level. Common beta values: 0 (rectangular), 5 (similar to Hamming), 6 (similar to Hanning), 8.6 (similar to Blackman).",[2009,2010],{"_16":1960,"_22":1961},{"_16":2011,"_22":2012},"beta","Shape parameter controlling the trade-off","M-point Kaiser window vector",[2015],{"_33":2016},"kaiser(8, 5)",[1967,1968,1969,1954],{"_43":2019,"_16":2020,"_22":2021,"_47":48,"_49":2022,"_52":2023},"plotting","Data Visualization","M-Code-style plotting functions for inline Chart.js visualizations.","📊",[2024,2044,2058,2069,2080,2095,2109,2133,2159,2197,2211,2222,2237,2248,2258,2270,2284,2300,2313,2327,2337,2351,2361,2373,2385,2396,2406,2415,2424,2436,2452,2465,2484,2504,2517,2527,2548,2573,2593,2614],{"_16":2025,"_18":2026,"_20":2027,"_22":2028,"_24":2029,"_28":2034,"_30":2035,"_37":2038},"plot","plot(y)\nplot(x, y)","2-D line plot","Creates a line chart. Successive plot() calls add datasets to the same chart; call figure to start a new chart. If one argument is given, it is treated as y-values with x = 1:n. With two arguments, x and y are paired.",[2030,2032],{"_16":498,"_22":2031,"_69":11},"X-axis data (NDArray or scalar)",{"_16":501,"_22":2033},"Y-axis data (NDArray or scalar)","null (renders chart inline)",[2036],{"_33":2037},"x = linspace(0, 2*pi, 50);\nplot(x, sin(x))",[2039,2040,2041,2042,2043],"scatter","bar","loglog","semilogx","semilogy",{"_16":2041,"_18":2045,"_20":2046,"_22":2047,"_24":2048,"_28":2051,"_30":2052,"_37":2057},"loglog(y)\nloglog(x, y)","Log-log scale plot","Creates a 2-D line plot with logarithmic scales on both the x-axis and y-axis. Useful for visualizing power-law relationships and data spanning multiple orders of magnitude.",[2049,2050],{"_16":498,"_22":2031,"_69":11},{"_16":501,"_22":2033},"Line handle",[2053,2055],{"_33":2054},"x = 1:100;\ny = x.^2;\nloglog(x, y)",{"_33":2056},"x = logspace(0, 3, 50);\nloglog(x, x.^(-1.5))",[2025,2042,2043],{"_16":2042,"_18":2059,"_20":2060,"_22":2061,"_24":2062,"_28":2051,"_30":2065,"_37":2068},"semilogx(y)\nsemilogx(x, y)","Semi-logarithmic plot (log x-axis)","Creates a 2-D line plot with a logarithmic scale on the x-axis and a linear scale on the y-axis.",[2063,2064],{"_16":498,"_22":2031,"_69":11},{"_16":501,"_22":2033},[2066],{"_33":2067},"x = logspace(0, 3, 50);\nsemilogx(x, log10(x))",[2025,2041,2043],{"_16":2043,"_18":2070,"_20":2071,"_22":2072,"_24":2073,"_28":2051,"_30":2076,"_37":2079},"semilogy(y)\nsemilogy(x, y)","Semi-logarithmic plot (log y-axis)","Creates a 2-D line plot with a linear scale on the x-axis and a logarithmic scale on the y-axis. Useful for exponential data.",[2074,2075],{"_16":498,"_22":2031,"_69":11},{"_16":501,"_22":2033},[2077],{"_33":2078},"x = 1:10;\ny = 10.^x;\nsemilogy(x, y)",[2025,2041,2042],{"_16":2040,"_18":2081,"_20":2082,"_22":2083,"_24":2084,"_28":2034,"_30":2089,"_37":2092},"bar(y)\nbar(x, y)","Bar chart","Creates a vertical bar chart.",[2085,2087],{"_16":498,"_22":2086,"_69":11},"Category positions or labels (NDArray)",{"_16":501,"_22":2088},"Bar heights (NDArray)",[2090],{"_33":2091},"bar([3 7 2 5])",[2025,2093,2094],"histogram","pie",{"_16":2039,"_18":2096,"_20":2097,"_22":2098,"_24":2099,"_28":2034,"_30":2104,"_37":2107},"scatter(x, y)","Scatter plot","Creates a scatter plot of y versus x.",[2100,2102],{"_16":498,"_22":2101},"X-coordinates (NDArray)",{"_16":501,"_22":2103},"Y-coordinates (NDArray)",[2105],{"_33":2106},"scatter(rand(20, 1), rand(20, 1))",[2025,2040,2108],"spy",{"_16":2108,"_18":2110,"_20":2111,"_22":2112,"_24":2113,"_28":2034,"_30":2123,"_37":2130},"spy(S)\nspy(S, linespec)\nspy(S, markersize)","Visualize sparsity pattern","Generates a graphical representation of the sparsity pattern of a matrix S. Nonzero values are displayed as markers at their (column, row) positions. The x-axis label shows \"nz = N\" where N is the number of nonzero elements.",[2114,2117,2120],{"_16":2115,"_22":2116},"S","Input matrix (sparse or full)",{"_16":2118,"_22":2119,"_69":11},"linespec","Line specification for marker style (e.g., 'ro' for red circles)",{"_16":2121,"_22":2122,"_69":11},"markersize","Marker size in points (default: auto-scaled based on matrix size)",[2124,2126,2128],{"_33":2125},"A = eye(10);\nspy(A)",{"_33":2127},"B = rand(20, 20) > 0.8;\nspy(B)",{"_33":2129},"spy(magic(10) > 50, 'ro', 8)",[2039,2131,927,2132],"imagesc","nnz",{"_16":2134,"_18":2135,"_20":2136,"_22":2137,"_24":2138,"_28":2152,"_30":2153,"_37":2158},"quiver","quiver(U, V)\nquiver(X, Y, U, V)\nquiver(..., scale)","2-D quiver (velocity) plot","Plots arrows to visualize vector fields. Each arrow starts at position (X, Y) and points in direction (U, V). When only U and V are provided, arrows are placed on an auto-generated grid. The optional scale factor controls arrow length (default: 1, set to 0 to disable auto-scaling).",[2139,2141,2143,2146,2149],{"_16":579,"_22":2140,"_69":11},"Arrow base X-coordinates (matrix or vector)",{"_16":1853,"_22":2142,"_69":11},"Arrow base Y-coordinates (matrix or vector)",{"_16":2144,"_22":2145},"U","Arrow X-direction components (matrix or vector)",{"_16":2147,"_22":2148},"V","Arrow Y-direction components (matrix or vector)",{"_16":2150,"_22":2151,"_69":11},"scale","Arrow scaling factor (default: 1, 0 disables auto-scaling)","Graphics handle",[2154,2156],{"_33":2155},"[X, Y] = meshgrid(1:5, 1:5);\nquiver(X, Y, ones(5), ones(5))",{"_33":2157},"U = cos(linspace(0, 2*pi, 25));\nV = sin(linspace(0, 2*pi, 25));\nquiver(U, V)",[2025,2039,492],{"_16":2160,"_18":2161,"_20":2162,"_22":2163,"_24":2164,"_28":2152,"_30":2187,"_37":2194},"fill","fill(X, Y)\nfill(X, Y, C)\nfill(..., Name, Value)","Filled 2-D polygon","Creates a filled polygon with vertices at the coordinates (X, Y). The polygon is automatically closed by connecting the last vertex to the first. Color can be specified as a short name ('r'), long name ('red'), or RGB triplet [r g b] with values in range [0,1].",[2165,2167,2169,2172,2175,2178,2181,2184],{"_16":579,"_22":2166},"X-coordinates of polygon vertices (vector)",{"_16":1853,"_22":2168},"Y-coordinates of polygon vertices (vector)",{"_16":2170,"_22":2171,"_69":11},"C","Color specification: short name, long name, or RGB triplet",{"_16":2173,"_22":2174,"_69":11},"FaceColor","Fill color (Name-Value pair)",{"_16":2176,"_22":2177,"_69":11},"FaceAlpha","Fill transparency 0-1 (Name-Value pair)",{"_16":2179,"_22":2180,"_69":11},"EdgeColor","Edge color or 'none' (Name-Value pair)",{"_16":2182,"_22":2183,"_69":11},"LineWidth","Edge line width (Name-Value pair)",{"_16":2185,"_22":2186,"_69":11},"LineStyle","Edge line style: '-', '--', ':', '-.', 'none' (Name-Value pair)",[2188,2190,2192],{"_33":2189},"fill([0 1 0.5], [0 0 1], 'r')",{"_33":2191},"x = cos(linspace(0, 2*pi, 6));\ny = sin(linspace(0, 2*pi, 6));\nfill(x, y, 'b', 'FaceAlpha', 0.5)",{"_33":2193},"fill([0 1 1 0], [0 0 1 1], [0.2 0.6 0.8], 'EdgeColor', 'none')",[2025,2195,2196],"patch","area",{"_16":2093,"_18":2198,"_20":2199,"_22":2200,"_24":2201,"_28":2034,"_30":2207,"_37":2210},"histogram(data)\nhistogram(data, numBins)","Histogram","Creates a histogram of the data, auto-binned into the specified number of bins (default 10).",[2202,2204],{"_16":84,"_22":2203},"Input data (NDArray)",{"_16":2205,"_22":2206,"_69":11},"numBins","Number of bins (default: 10)",[2208],{"_33":2209},"histogram(randn(100, 1))",[2040,2025],{"_16":2094,"_18":2212,"_20":2213,"_22":2214,"_24":2215,"_28":2034,"_30":2218,"_37":2221},"pie(data)","Pie chart","Creates a pie chart from the data values.",[2216],{"_16":84,"_22":2217},"Slice values (NDArray)",[2219],{"_33":2220},"pie([30 20 50])",[2040,2093],{"_16":2223,"_18":2224,"_20":2225,"_22":2226,"_24":2227,"_28":29,"_30":2230,"_37":2233},"title","title(str)","Add title to current chart","Sets the title of the most recently created chart.",[2228],{"_16":1129,"_22":2229},"Title string",[2231],{"_33":2232},"plot([1 4 9 16]);\ntitle('Squares')",[2234,2235,2236],"xlabel","ylabel","legend",{"_16":2234,"_18":2238,"_20":2239,"_22":2240,"_24":2241,"_28":29,"_30":2244,"_37":2247},"xlabel(str)","Label x-axis","Sets the x-axis label of the most recently created chart.",[2242],{"_16":1129,"_22":2243},"Label string",[2245],{"_33":2246},"xlabel('Time (s)')",[2235,2223],{"_16":2235,"_18":2249,"_20":2250,"_22":2251,"_24":2252,"_28":29,"_30":2254,"_37":2257},"ylabel(str)","Label y-axis","Sets the y-axis label of the most recently created chart.",[2253],{"_16":1129,"_22":2243},[2255],{"_33":2256},"ylabel('Amplitude')",[2234,2223],{"_16":2236,"_18":2259,"_20":2260,"_22":2261,"_24":2262,"_28":29,"_30":2266,"_37":2269},"legend('label1', 'label2', ...)","Add legend to current chart","Adds a legend to the most recently created chart with the given labels.",[2263],{"_16":2264,"_22":2265},"labels","One or more string labels",[2267],{"_33":2268},"legend('sin', 'cos')",[2223,2234,2235],{"_16":2271,"_18":2272,"_20":2273,"_22":2274,"_24":2275,"_28":29,"_30":2278,"_37":2281},"figure","figure\nfigure(n)","Create a new figure","Starts a new figure so the next plotting command creates a fresh chart. Without arguments, creates a new figure with auto-incremented ID. With argument n, switches to figure n.",[2276],{"_16":362,"_22":2277,"_69":11},"Figure number",[2279],{"_33":2280},"plot([1 2 3]);\nfigure();\nplot([4 5 6])",[2025,2040,2039,2282,2283],"gcf","clf",{"_16":2285,"_18":2286,"_20":2287,"_22":2288,"_24":2289,"_28":29,"_30":2294,"_37":2297},"xlim","xlim([min max])","Set x-axis limits","Sets the minimum and maximum values for the x-axis of the current chart.",[2290,2292],{"_16":840,"_22":2291},"Minimum x value",{"_16":841,"_22":2293},"Maximum x value",[2295],{"_33":2296},"plot([1 2 3 4]);\nxlim([0 5])",[2298,2299],"ylim","axis",{"_16":2298,"_18":2301,"_20":2302,"_22":2303,"_24":2304,"_28":29,"_30":2309,"_37":2312},"ylim([min max])","Set y-axis limits","Sets the minimum and maximum values for the y-axis of the current chart.",[2305,2307],{"_16":840,"_22":2306},"Minimum y value",{"_16":841,"_22":2308},"Maximum y value",[2310],{"_33":2311},"plot([1 2 3 4]);\nylim([0 5])",[2285,2299],{"_16":2314,"_18":2315,"_20":2316,"_22":2317,"_24":2318,"_28":29,"_30":2322,"_37":2325},"xticks","xticks(values)","Set x-axis tick values","Sets custom tick mark positions on the x-axis.",[2319],{"_16":2320,"_22":2321},"values","Vector of tick positions",[2323],{"_33":2324},"plot([1 2 3 4]);\nxticks([1 2 3 4])",[2326,2285],"yticks",{"_16":2326,"_18":2328,"_20":2329,"_22":2330,"_24":2331,"_28":29,"_30":2333,"_37":2336},"yticks(values)","Set y-axis tick values","Sets custom tick mark positions on the y-axis.",[2332],{"_16":2320,"_22":2321},[2334],{"_33":2335},"bar([10 20 30]);\nyticks([0 10 20 30])",[2314,2298],{"_16":2338,"_18":2339,"_20":2340,"_22":2341,"_24":2342,"_28":29,"_30":2346,"_37":2349},"xtickangle","xtickangle(angle)","Rotate x-axis tick labels","Sets the rotation angle (in degrees) for x-axis tick labels.",[2343],{"_16":2344,"_22":2345},"angle","Rotation angle in degrees",[2347],{"_33":2348},"bar([1 2 3]);\nxtickangle(45)",[2350,2314],"ytickangle",{"_16":2350,"_18":2352,"_20":2353,"_22":2354,"_24":2355,"_28":29,"_30":2357,"_37":2360},"ytickangle(angle)","Rotate y-axis tick labels","Sets the rotation angle (in degrees) for y-axis tick labels.",[2356],{"_16":2344,"_22":2345},[2358],{"_33":2359},"bar([1 2 3]);\nytickangle(90)",[2338,2326],{"_16":2362,"_18":2363,"_20":2364,"_22":2365,"_24":2366,"_28":29,"_30":2369,"_37":2372},"grid","grid\ngrid('on')\ngrid('off')","Toggle grid lines","Controls the visibility of grid lines on the current chart.",[2367],{"_16":247,"_22":2368,"_69":11},"'on' or 'off' (default: toggle)",[2370],{"_33":2371},"plot([1 2 3]);\ngrid('on')",[2299,2285,2298],{"_16":2299,"_18":2374,"_20":2375,"_22":2376,"_24":2377,"_28":29,"_30":2381,"_37":2384},"axis([xmin xmax ymin ymax])","Set axis limits and scaling","Sets the limits for both x and y axes simultaneously.",[2378],{"_16":2379,"_22":2380},"limits","4-element vector [xmin xmax ymin ymax]",[2382],{"_33":2383},"plot([1 2 3]);\naxis([0 4 0 4])",[2285,2298,2362],{"_16":2386,"_18":2387,"_20":2388,"_22":2389,"_24":2390,"_28":29,"_30":2392,"_37":2395},"hold","hold\nhold('on')\nhold('off')","Hold current plot","Controls whether new plot commands add to or replace the current chart. When hold is on, successive plot commands add datasets to the same chart.",[2391],{"_16":247,"_22":2368,"_69":11},[2393],{"_33":2394},"plot([1 2 3]);\nhold('on');\nbar([2 3 4])",[2271,2025],{"_16":2282,"_18":2397,"_20":2398,"_22":2399,"_24":2400,"_28":2401,"_30":2402,"_37":2404},"f = gcf","Get current figure","Returns the handle (ID) of the current figure.",[],"Figure ID number",[2403],{"_33":2397},[2271,2405,2283],"gca",{"_16":2405,"_18":2407,"_20":2408,"_22":2409,"_24":2410,"_28":2411,"_30":2412,"_37":2414},"ax = gca","Get current axes","Returns the handle (ID) of the current axes (same as gcf in this implementation).",[],"Axes ID number",[2413],{"_33":2407},[2282,2271],{"_16":2283,"_18":2283,"_20":2416,"_22":2417,"_24":2418,"_28":29,"_30":2419,"_37":2422},"Clear current figure","Clears all charts from the current figure, resetting its state.",[],[2420],{"_33":2421},"plot([1 2 3]);\nclf()",[2423,2271],"close",{"_16":2423,"_18":2425,"_20":2426,"_22":2427,"_24":2428,"_28":29,"_30":2432,"_37":2435},"close\nclose(fig)","Close figure","Closes the current figure or the specified figure by ID.",[2429],{"_16":2430,"_22":2431,"_69":11},"fig","Figure ID to close",[2433],{"_33":2434},"close()",[2283,2271],{"_16":2437,"_18":2438,"_20":2439,"_22":2440,"_24":2441,"_28":29,"_30":2448,"_37":2451},"text","text(x, y, str)","Add text annotation","Adds a text annotation at the specified (x, y) coordinates in data units.",[2442,2444,2446],{"_16":498,"_22":2443},"X-coordinate",{"_16":501,"_22":2445},"Y-coordinate",{"_16":1129,"_22":2447},"Text string",[2449],{"_33":2450},"plot([1 2 3]);\ntext(2, 2.5, 'Peak')",[2223,2234,2235],{"_16":2453,"_18":2454,"_20":2455,"_22":2456,"_24":2457,"_28":29,"_30":2461,"_37":2464},"yyaxis","yyaxis('left')\nyyaxis('right')","Control dual y-axes","Activates either the left or right y-axis for subsequent plotting commands, enabling dual y-axis charts.",[2458],{"_16":2459,"_22":2460},"side","'left' or 'right'",[2462],{"_33":2463},"plot([1 2 3]);\nyyaxis('right');\nplot([10 20 30])",[2235,2298],{"_16":2466,"_18":2467,"_20":2468,"_22":2469,"_24":2470,"_28":29,"_30":2480,"_37":2483},"subplot","subplot(rows, cols, index)","Create subplot grid","Creates a grid of charts with the specified number of rows and columns, and activates the subplot at the given index (1-based).",[2471,2474,2477],{"_16":2472,"_22":2473},"rows","Number of rows in grid",{"_16":2475,"_22":2476},"cols","Number of columns in grid",{"_16":2478,"_22":2479},"index","1-based position in grid (row-major order)",[2481],{"_33":2482},"subplot(2, 2, 1);\nplot([1 2 3]);\nsubplot(2, 2, 2);\nbar([4 5 6])",[2271,2025],{"_16":290,"_18":2485,"_20":2486,"_22":2487,"_24":2488,"_28":2498,"_30":2499,"_37":2502},"mesh(Z)\nmesh(X, Y, Z)\nmesh(X, Y, Z, C)","3-D wireframe mesh surface","Creates a 3D wireframe mesh surface plot. With one argument, Z provides the heights with X and Y auto-generated as indices. With three arguments, X, Y, and Z define the surface coordinates. The optional C argument provides a color matrix.",[2489,2491,2493,2496],{"_16":579,"_22":2490,"_69":11},"X-coordinate matrix (auto-generated if omitted)",{"_16":1853,"_22":2492,"_69":11},"Y-coordinate matrix (auto-generated if omitted)",{"_16":2494,"_22":2495},"Z","Height matrix (required)",{"_16":2170,"_22":2497,"_69":11},"Color data matrix (defaults to Z)","null (renders 3D chart inline)",[2500],{"_33":2501},"[X, Y] = meshgrid(-2:0.2:2);\nZ = X .* exp(-X.^2 - Y.^2);\nmesh(X, Y, Z)",[516,492,2503],"zlabel",{"_16":516,"_18":2505,"_20":2506,"_22":2507,"_24":2508,"_28":2498,"_30":2513,"_37":2516},"surf(Z)\nsurf(X, Y, Z)\nsurf(X, Y, Z, C)","3-D shaded surface plot","Creates a 3D surface plot with filled faces. With one argument, Z provides the heights with X and Y auto-generated as indices. With three arguments, X, Y, and Z define the surface coordinates. The optional C argument provides a color matrix.",[2509,2510,2511,2512],{"_16":579,"_22":2490,"_69":11},{"_16":1853,"_22":2492,"_69":11},{"_16":2494,"_22":2495},{"_16":2170,"_22":2497,"_69":11},[2514],{"_33":2515},"[X, Y] = meshgrid(-2:0.2:2);\nZ = X .* exp(-X.^2 - Y.^2);\nsurf(X, Y, Z)",[290,492,2503],{"_16":2503,"_18":2518,"_20":2519,"_22":2520,"_24":2521,"_28":29,"_30":2523,"_37":2526},"zlabel(str)","Label z-axis","Sets the z-axis label of the most recently created 3D chart.",[2522],{"_16":1129,"_22":2243},[2524],{"_33":2525},"[X, Y] = meshgrid(-2:0.2:2);\nZ = X .* exp(-X.^2 - Y.^2);\nsurf(X, Y, Z);\nzlabel('Height')",[2234,2235,2223,290,516],{"_16":2528,"_18":2529,"_20":2530,"_22":2531,"_24":2532,"_28":2539,"_30":2540,"_37":2547},"view","view(az, el)\nview([az el])\nview(2)\nview(3)\n[az, el] = view","Set 3D view angle","Sets the camera viewing angle for 3D plots (mesh, surf). Azimuth is the angle of rotation around the z-axis measured from the negative y-axis (counterclockwise positive). Elevation is the angle from the x-y plane (-90 to 90 degrees). view(2) sets a top-down 2D view (az=0, el=90). view(3) sets the default 3D view (az=-37.5, el=30).",[2533,2536],{"_16":2534,"_22":2535,"_69":11},"az","Azimuth angle in degrees",{"_16":2537,"_22":2538,"_69":11},"el","Elevation angle in degrees","With no arguments, returns [az, el] of current view",[2541,2543,2545],{"_33":2542},"[X, Y] = meshgrid(-2:0.2:2);\nZ = X .* exp(-X.^2 - Y.^2);\nsurf(X, Y, Z);\nview(45, 30)",{"_33":2544},"[X, Y] = meshgrid(-2:0.2:2);\nZ = sin(X) .* cos(Y);\nsurf(X, Y, Z);\nview(2) % Top-down view",{"_33":2546},"[X, Y] = meshgrid(-2:0.2:2);\nZ = X.^2 - Y.^2;\nmesh(X, Y, Z);\nview(3) % Default 3D view",[290,516,2503],{"_16":2131,"_18":2549,"_20":2550,"_22":2551,"_24":2552,"_28":2562,"_30":2563,"_37":2570},"imagesc(C)\nimagesc(x, y, C)\nimagesc(..., clims)","Display matrix as scaled image","Displays a matrix C as an image with scaled colors. Each element of C maps to a color in the colormap, with the minimum value mapping to the first color and maximum to the last. Optional x and y vectors specify the coordinates of the columns and rows.",[2553,2555,2557,2559],{"_16":498,"_22":2554,"_69":11},"X-axis coordinates for columns (2-element vector or full vector)",{"_16":501,"_22":2556,"_69":11},"Y-axis coordinates for rows (2-element vector or full vector)",{"_16":2170,"_22":2558},"Data matrix to display",{"_16":2560,"_22":2561,"_69":11},"clims","Color limits [cmin cmax]","null (renders heatmap inline)",[2564,2566,2568],{"_33":2565},"A = magic(5);\nimagesc(A)",{"_33":2567},"A = peaks(50);\nimagesc(A)\ncolorbar",{"_33":2569},"imagesc([0 10], [0 5], rand(10, 20))\ntitle('Random data')",[2571,2572,290,516],"colorbar","colormap",{"_16":2571,"_18":2574,"_20":2575,"_22":2576,"_24":2577,"_28":2581,"_30":2582,"_37":2591},"colorbar\ncolorbar('off')\ncolorbar('location')\nc = colorbar","Add colorbar to current chart","Displays a colorbar showing the color scale for the current heatmap, mesh, or surf plot. Supports location options ('eastoutside', 'westoutside', 'northoutside', 'southoutside') and can return a handle for further property manipulation using set().",[2578],{"_16":2579,"_22":2580,"_69":11},"location","Location string: 'eastoutside' (default), 'westoutside', 'northoutside', 'southoutside', or 'off'","Colorbar handle (when assigned to variable)",[2583,2585,2587,2589],{"_33":2584},"imagesc(peaks(30));\ncolorbar",{"_33":2586},"surf(peaks(30));\ncolorbar('southoutside')",{"_33":2588},"imagesc(rand(20));\nc = colorbar;\nset(c, 'Title', 'Values')",{"_33":2590},"mesh(peaks);\ncolorbar('off')",[2131,2572,290,516,2592],"set",{"_16":2572,"_18":2594,"_20":2595,"_22":2596,"_24":2597,"_28":2603,"_30":2604,"_37":2613},"colormap(name)\ncolormap(map)\ncmap = colormap","Set or get colormap for current figure","Sets the colormap used for pseudocolor plots like imagesc, mesh, and surf. With no arguments, returns the current colormap as an Mx3 RGB matrix (default 256 rows). With a string argument, sets to a named colormap. With an Mx3 matrix argument, sets a custom colormap where each row is [R G B] with values in range [0,1].",[2598,2600],{"_16":16,"_22":2599,"_69":11},"Colormap name: viridis (default), jet, hot, cool, gray, grayscale, parula, turbo, coolwarm, rainbow, bone, copper, spring, summer, autumn, winter",{"_16":2601,"_22":2602,"_69":11},"map","Mx3 matrix of RGB values (each in [0,1])","Mx3 RGB matrix (query mode) or null (set mode)",[2605,2607,2609,2611],{"_33":2606},"imagesc(peaks(30));\ncolormap('jet');\ncolorbar",{"_33":2608},"surf(peaks(25));\ncolormap('hot')",{"_33":2610},"cmap = colormap % returns 256x3 matrix",{"_33":2612},"colormap([0 0 1; 1 1 1; 1 0 0]) % custom blue-white-red",[2131,2571,290,516],{"_16":2615,"_18":2616,"_20":2617,"_22":2618,"_24":2619,"_28":29,"_30":2623,"_37":2628},"shading","shading faceted\nshading flat\nshading interp","Set surface shading mode","Controls the color shading of surface and mesh plots. 'faceted' uses flat coloring with black mesh lines overlaid (default). 'flat' uses flat coloring without mesh lines. 'interp' uses smooth interpolated colors across the surface.",[2620],{"_16":2621,"_22":2622},"mode","Shading mode: 'faceted' (default), 'flat', or 'interp'",[2624,2626],{"_33":2625},"surf(peaks(30));\nshading interp",{"_33":2627},"[X, Y] = meshgrid(-2:0.2:2);\nZ = X .* exp(-X.^2 - Y.^2);\nsurf(X, Y, Z);\nshading flat;\ncolorbar",[516,290,2572,2571],{"_43":2630,"_16":2631,"_22":2632,"_47":48,"_49":2633,"_52":2634},"poly","Polynomial Functions","Polynomial operations across power, Chebyshev, Legendre, Hermite, HermiteE, and Laguerre bases with fitting, evaluation, calculus, arithmetic, and conversion utilities.","∑",[2635,2655,2673,2688,2703,2719,2740,2754,2767,2780,2795,2809,2820,2831,2847,2862,2876,2888,2905,2920,2936,2947,2958,2971,2986,2996,3007,3016,3028,3041,3051,3059,3071,3083,3097,3112,3124,3134,3147,3156,3165,3174,3184,3195,3203,3211,3221,3231,3242,3257,3267,3277,3289,3298,3308,3317,3327,3338,3346,3354,3364,3374,3385,3398,3408,3418,3430,3439,3449,3458,3468,3479,3487,3495,3505,3515,3526,3541,3551,3561,3573,3582,3592,3601,3611,3622,3630,3638,3648,3658,3669,3679,3687,3695,3703,3711,3728,3741,3757,3773],{"_16":2636,"_18":2637,"_20":2638,"_22":2639,"_24":2640,"_28":2646,"_30":2647,"_37":2651},"polyval","y = polyval(x, c)","Evaluate power series polynomial","Evaluates a power series polynomial at point x using Horner's method. Coefficients are in ascending order: c(1) + c(2)*x + c(3)*x^2 + ...",[2641,2643],{"_16":498,"_22":2642},"Point at which to evaluate",{"_16":2644,"_22":2645},"c","Coefficient array in ascending order [c0, c1, c2, ...]","Polynomial value at x",[2648],{"_33":2649,"_368":2650},"polyval(2, [1 2 3])","17",[2652,2653,2654],"polyfit","polyder","polyint",{"_16":2656,"_18":2657,"_20":2658,"_22":2659,"_24":2660,"_28":2667,"_30":2668,"_37":2671},"polyval2d","z = polyval2d(x, y, c)","Evaluate 2-D power series polynomial","Evaluates a 2-D power series polynomial on x-y pairs.",[2661,2663,2665],{"_16":498,"_22":2662},"x coordinates",{"_16":501,"_22":2664},"y coordinates",{"_16":2644,"_22":2666},"2-D coefficient array","Polynomial values at (x, y) pairs",[2669],{"_33":2670},"polyval2d([1 2], [1 2], [1 0; 0 1])",[2636,2672],"polyval3d",{"_16":2672,"_18":2674,"_20":2675,"_22":2676,"_24":2677,"_28":2685,"_30":2686,"_37":2687},"w = polyval3d(x, y, z, c)","Evaluate 3-D power series polynomial","Evaluates a 3-D power series polynomial on x-y-z triples.",[2678,2679,2680,2683],{"_16":498,"_22":2662},{"_16":501,"_22":2664},{"_16":2681,"_22":2682},"z","z coordinates",{"_16":2644,"_22":2684},"3-D coefficient array","Polynomial values at (x, y, z) triples",[],[2636,2656],{"_16":2653,"_18":2689,"_20":2690,"_22":2691,"_24":2692,"_28":2697,"_30":2698,"_37":2702},"dc = polyder(c)\ndc = polyder(c, m)","Power series derivative","Differentiates a power series polynomial m times. Default m = 1.",[2693,2695],{"_16":2644,"_22":2694},"Coefficient array in ascending order",{"_16":359,"_22":2696,"_69":11},"Number of derivatives (default: 1)","Differentiated coefficient array",[2699],{"_33":2700,"_368":2701},"polyder([1 2 3])","[2 6]",[2654,2636],{"_16":2654,"_18":2704,"_20":2705,"_22":2706,"_24":2707,"_28":2713,"_30":2714,"_37":2718},"ic = polyint(c)\nic = polyint(c, m)\nic = polyint(c, m, k)","Power series integral","Integrates a power series polynomial m times with integration constants k. Default m = 1, k = [0].",[2708,2709,2711],{"_16":2644,"_22":2694},{"_16":359,"_22":2710,"_69":11},"Number of integrations (default: 1)",{"_16":1114,"_22":2712,"_69":11},"Integration constants (default: all zero)","Integrated coefficient array",[2715],{"_33":2716,"_368":2717},"polyint([2 6])","[0 2 3]",[2653,2636],{"_16":2720,"_18":2721,"_20":2722,"_22":2723,"_24":2724,"_28":2731,"_30":2732,"_37":2736},"polymul","c = polymul(c1, c2)","Multiply two power series polynomials","Multiplies two power series coefficient arrays using convolution.",[2725,2728],{"_16":2726,"_22":2727},"c1","First coefficient array",{"_16":2729,"_22":2730},"c2","Second coefficient array","Product coefficient array",[2733],{"_33":2734,"_368":2735},"polymul([1 1], [1 1])","[1 2 1]",[2737,2738,2739],"polydiv","polyadd","polysub",{"_16":2737,"_18":2741,"_20":2742,"_22":2743,"_24":2744,"_28":2749,"_30":2750,"_37":2753},"[q, r] = polydiv(c1, c2)","Divide two power series polynomials","Divides two power series coefficient arrays. Returns quotient and remainder.",[2745,2747],{"_16":2726,"_22":2746},"Dividend coefficient array",{"_16":2729,"_22":2748},"Divisor coefficient array","Quotient and remainder coefficient arrays",[2751],{"_33":2752},"polydiv([1 2 1], [1 1])",[2720,2738,2739],{"_16":2738,"_18":2755,"_20":2756,"_22":2757,"_24":2758,"_28":2761,"_30":2762,"_37":2766},"c = polyadd(c1, c2)","Add two power series polynomials","Adds two power series coefficient arrays.",[2759,2760],{"_16":2726,"_22":2727},{"_16":2729,"_22":2730},"Sum coefficient array",[2763],{"_33":2764,"_368":2765},"polyadd([1 2], [3 4])","[4 6]",[2739,2720,2737],{"_16":2739,"_18":2768,"_20":2769,"_22":2770,"_24":2771,"_28":2774,"_30":2775,"_37":2779},"c = polysub(c1, c2)","Subtract two power series polynomials","Subtracts two power series coefficient arrays.",[2772,2773],{"_16":2726,"_22":2727},{"_16":2729,"_22":2730},"Difference coefficient array",[2776],{"_33":2777,"_368":2778},"polysub([3 4], [1 2])","[2 2]",[2738,2720,2737],{"_16":2781,"_18":2782,"_20":2783,"_22":2784,"_24":2785,"_28":2790,"_30":2791,"_37":2794},"polypow","c = polypow(c, n)","Raise power series polynomial to a power","Raises a power series polynomial to a non-negative integer power.",[2786,2788],{"_16":2644,"_22":2787},"Coefficient array",{"_16":362,"_22":2789},"Non-negative integer power","Resulting coefficient array",[2792],{"_33":2793,"_368":2735},"polypow([1 1], 2)",[2720],{"_16":2796,"_18":2797,"_20":2798,"_22":2799,"_24":2800,"_28":2802,"_30":2803,"_37":2806},"polyroots","r = polyroots(c)","Find power series polynomial roots","Finds roots of a power series polynomial using companion matrix eigenvalues.",[2801],{"_16":2644,"_22":2694},"Array of roots",[2804],{"_33":2805},"polyroots([-1 0 1])",[2807,2808],"polyfromroots","polycompanion",{"_16":2807,"_18":2810,"_20":2811,"_22":2812,"_24":2813,"_28":2694,"_30":2816,"_37":2819},"c = polyfromroots(r)","Construct power series from roots","Constructs a power series polynomial from its roots.",[2814],{"_16":2815,"_22":2802},"r",[2817],{"_33":2818},"polyfromroots([1 -1])",[2796],{"_16":2808,"_18":2821,"_20":2822,"_22":2823,"_24":2824,"_28":2826,"_30":2827,"_37":2830},"C = polycompanion(c)","Power series companion matrix","Generates the companion matrix for a power series polynomial.",[2825],{"_16":2644,"_22":2787},"Companion matrix",[2828],{"_33":2829},"polycompanion([-1 0 1])",[2796],{"_16":2832,"_18":2833,"_20":2834,"_22":2835,"_24":2836,"_28":2842,"_30":2843,"_37":2846},"polyvander","V = polyvander(x, deg)","Power series Vandermonde matrix","Generates a Vandermonde matrix of the given degree for the given sample points.",[2837,2839],{"_16":498,"_22":2838},"Sample points",{"_16":2840,"_22":2841},"deg","Degree of polynomial","Vandermonde matrix",[2844],{"_33":2845},"polyvander([1 2 3], 2)",[2652],{"_16":2652,"_18":2848,"_20":2849,"_22":2850,"_24":2851,"_28":2694,"_30":2858,"_37":2861},"c = polyfit(x, y, deg)","Least-squares power series fit","Fits a power series polynomial of the given degree to data using least squares.",[2852,2854,2856],{"_16":498,"_22":2853},"x values",{"_16":501,"_22":2855},"y values",{"_16":2840,"_22":2857},"Degree of fitting polynomial",[2859],{"_33":2860},"polyfit([0 1 2 3], [0 1 4 9], 2)",[2636,2832],{"_16":2863,"_18":2864,"_20":2865,"_22":2866,"_24":2867,"_28":2870,"_30":2871,"_37":2875},"roots","r = roots(p)","Polynomial roots (M-Code convention)","Finds roots of a polynomial specified by descending-order coefficients [a_n, ..., a_1, a_0].",[2868],{"_16":1645,"_22":2869},"Coefficient vector in descending order","Column vector of roots",[2872],{"_33":2873,"_368":2874},"roots([1 0 -1])","[1; -1]",[2630,2796],{"_16":2630,"_18":2877,"_20":2878,"_22":2879,"_24":2880,"_28":2869,"_30":2883,"_37":2887},"p = poly(r)","Polynomial from roots (M-Code convention)","Constructs polynomial coefficients in descending order from a vector of roots.",[2881],{"_16":2815,"_22":2882},"Vector of roots",[2884],{"_33":2885,"_368":2886},"poly([1 -1])","[1 0 -1]",[2863,2807],{"_16":2889,"_18":2890,"_20":2891,"_22":2892,"_24":2893,"_28":2899,"_30":2900,"_37":2903},"conv","w = conv(u, v)","Convolution / polynomial multiplication (M-Code convention)","Convolves two vectors, equivalent to polynomial multiplication with descending-order coefficients.",[2894,2896],{"_16":334,"_22":2895},"First input vector (descending order)",{"_16":2897,"_22":2898},"v","Second input vector (descending order)","Convolution result (descending order)",[2901],{"_33":2902,"_368":2735},"conv([1 1], [1 1])",[2904,2720],"deconv",{"_16":2904,"_18":2906,"_20":2907,"_22":2908,"_24":2909,"_28":2914,"_30":2915,"_37":2919},"[q, r] = deconv(b, a)","Deconvolution / polynomial division (M-Code convention)","Deconvolves two vectors, equivalent to polynomial long division with descending-order coefficients.",[2910,2912],{"_16":436,"_22":2911},"Dividend vector (descending order)",{"_16":433,"_22":2913},"Divisor vector (descending order)","Quotient vector (descending order)",[2916],{"_33":2917,"_368":2918},"deconv([1 2 1], [1 1])","[1 1]",[2889,2737],{"_16":2921,"_18":2922,"_20":2923,"_22":2924,"_24":2925,"_28":2646,"_30":2929,"_37":2932},"chebval","y = chebval(x, c)","Evaluate Chebyshev polynomial","Evaluates a Chebyshev polynomial at point x using Clenshaw's algorithm. Coefficients: c(1)*T_0 + c(2)*T_1 + c(3)*T_2 + ...",[2926,2927],{"_16":498,"_22":2642},{"_16":2644,"_22":2928},"Chebyshev coefficient array",[2930],{"_33":2931},"chebval(0.5, [1 2 3])",[2933,2934,2935],"chebfit","chebder","chebint",{"_16":2937,"_18":2938,"_20":2939,"_22":2940,"_24":2941,"_28":2667,"_30":2945,"_37":2946},"chebval2d","z = chebval2d(x, y, c)","Evaluate 2-D Chebyshev polynomial","Evaluates a 2-D Chebyshev polynomial on x-y pairs.",[2942,2943,2944],{"_16":498,"_22":2662},{"_16":501,"_22":2664},{"_16":2644,"_22":2666},[],[2921],{"_16":2934,"_18":2948,"_20":2949,"_22":2950,"_24":2951,"_28":2697,"_30":2954,"_37":2957},"dc = chebder(c)\ndc = chebder(c, m)","Chebyshev derivative","Differentiates a Chebyshev polynomial m times.",[2952,2953],{"_16":2644,"_22":2928},{"_16":359,"_22":2696,"_69":11},[2955],{"_33":2956},"chebder([1 2 3])",[2935,2921],{"_16":2935,"_18":2959,"_20":2960,"_22":2961,"_24":2962,"_28":2713,"_30":2967,"_37":2970},"ic = chebint(c)\nic = chebint(c, m)\nic = chebint(c, m, k)","Chebyshev integral","Integrates a Chebyshev polynomial m times with integration constants k.",[2963,2964,2965],{"_16":2644,"_22":2928},{"_16":359,"_22":2710,"_69":11},{"_16":1114,"_22":2966,"_69":11},"Integration constants",[2968],{"_33":2969},"chebint([2 6])",[2934,2921],{"_16":2972,"_18":2973,"_20":2974,"_22":2975,"_24":2976,"_28":2731,"_30":2979,"_37":2982},"chebmul","c = chebmul(c1, c2)","Multiply two Chebyshev polynomials","Multiplies two Chebyshev coefficient arrays.",[2977,2978],{"_16":2726,"_22":2727},{"_16":2729,"_22":2730},[2980],{"_33":2981},"chebmul([1 1], [1 1])",[2983,2984,2985],"chebdiv","chebadd","chebsub",{"_16":2983,"_18":2987,"_20":2988,"_22":2989,"_24":2990,"_28":2993,"_30":2994,"_37":2995},"[q, r] = chebdiv(c1, c2)","Divide two Chebyshev polynomials","Divides two Chebyshev coefficient arrays. Returns quotient and remainder.",[2991,2992],{"_16":2726,"_22":2746},{"_16":2729,"_22":2748},"Quotient and remainder",[],[2972],{"_16":2984,"_18":2997,"_20":2998,"_22":2999,"_24":3000,"_28":2761,"_30":3003,"_37":3006},"c = chebadd(c1, c2)","Add two Chebyshev polynomials","Adds two Chebyshev coefficient arrays.",[3001,3002],{"_16":2726,"_22":2727},{"_16":2729,"_22":2730},[3004],{"_33":3005},"chebadd([1 2], [3 4])",[2985,2972],{"_16":2985,"_18":3008,"_20":3009,"_22":3010,"_24":3011,"_28":2774,"_30":3014,"_37":3015},"c = chebsub(c1, c2)","Subtract two Chebyshev polynomials","Subtracts two Chebyshev coefficient arrays.",[3012,3013],{"_16":2726,"_22":2727},{"_16":2729,"_22":2730},[],[2984,2972],{"_16":3017,"_18":3018,"_20":3019,"_22":3020,"_24":3021,"_28":2790,"_30":3024,"_37":3027},"chebpow","c = chebpow(c, n)","Raise Chebyshev polynomial to a power","Raises a Chebyshev polynomial to a non-negative integer power.",[3022,3023],{"_16":2644,"_22":2787},{"_16":362,"_22":2789},[3025],{"_33":3026},"chebpow([1 1], 2)",[2972],{"_16":3029,"_18":3030,"_20":3031,"_22":3032,"_24":3033,"_28":2802,"_30":3035,"_37":3038},"chebroots","r = chebroots(c)","Find Chebyshev polynomial roots","Finds roots of a Chebyshev polynomial using companion matrix eigenvalues.",[3034],{"_16":2644,"_22":2928},[3036],{"_33":3037},"chebroots([1 0 -1])",[3039,3040],"chebfromroots","chebcompanion",{"_16":3039,"_18":3042,"_20":3043,"_22":3044,"_24":3045,"_28":2928,"_30":3047,"_37":3050},"c = chebfromroots(r)","Construct Chebyshev polynomial from roots","Constructs Chebyshev coefficient array from roots.",[3046],{"_16":2815,"_22":2802},[3048],{"_33":3049},"chebfromroots([1 -1])",[3029],{"_16":3040,"_18":3052,"_20":3053,"_22":3054,"_24":3055,"_28":2826,"_30":3057,"_37":3058},"C = chebcompanion(c)","Chebyshev companion matrix","Generates the companion matrix for a Chebyshev polynomial.",[3056],{"_16":2644,"_22":2928},[],[3029],{"_16":3060,"_18":3061,"_20":3062,"_22":3063,"_24":3064,"_28":2842,"_30":3067,"_37":3070},"chebvander","V = chebvander(x, deg)","Chebyshev Vandermonde matrix","Generates a Chebyshev Vandermonde matrix for the given sample points and degree.",[3065,3066],{"_16":498,"_22":2838},{"_16":2840,"_22":2841},[3068],{"_33":3069},"chebvander([0 0.5 1], 2)",[2933],{"_16":2933,"_18":3072,"_20":3073,"_22":3074,"_24":3075,"_28":2928,"_30":3079,"_37":3082},"c = chebfit(x, y, deg)","Least-squares Chebyshev fit","Fits a Chebyshev polynomial of the given degree to data using least squares.",[3076,3077,3078],{"_16":498,"_22":2853},{"_16":501,"_22":2855},{"_16":2840,"_22":2857},[3080],{"_33":3081},"chebfit([0 0.5 1], [1 1.5 2], 1)",[2921,3060],{"_16":3084,"_18":3085,"_20":3086,"_22":3087,"_24":3088,"_28":3091,"_30":3092,"_37":3095},"cheb2poly","p = cheb2poly(c)","Convert Chebyshev to power series","Converts Chebyshev coefficients to power series coefficients.",[3089],{"_16":2644,"_22":3090},"Chebyshev coefficients","Power series coefficients",[3093],{"_33":3094},"cheb2poly([1 0 1])",[3096],"poly2cheb",{"_16":3098,"_18":3099,"_20":3100,"_22":3101,"_24":3102,"_28":2646,"_30":3106,"_37":3109},"legval","y = legval(x, c)","Evaluate Legendre polynomial","Evaluates a Legendre polynomial at point x.",[3103,3104],{"_16":498,"_22":2642},{"_16":2644,"_22":3105},"Legendre coefficient array",[3107],{"_33":3108},"legval(0.5, [1 2 3])",[3110,3111],"legfit","legder",{"_16":3111,"_18":3113,"_20":3114,"_22":3115,"_24":3116,"_28":2697,"_30":3119,"_37":3122},"dc = legder(c)\ndc = legder(c, m)","Legendre derivative","Differentiates a Legendre polynomial m times.",[3117,3118],{"_16":2644,"_22":3105},{"_16":359,"_22":2696,"_69":11},[3120],{"_33":3121},"legder([1 2 3])",[3123,3098],"legint",{"_16":3123,"_18":3125,"_20":3126,"_22":3127,"_24":3128,"_28":2713,"_30":3132,"_37":3133},"ic = legint(c)\nic = legint(c, m)\nic = legint(c, m, k)","Legendre integral","Integrates a Legendre polynomial m times.",[3129,3130,3131],{"_16":2644,"_22":3105},{"_16":359,"_22":2710,"_69":11},{"_16":1114,"_22":2966,"_69":11},[],[3111,3098],{"_16":3135,"_18":3136,"_20":3137,"_22":3138,"_24":3139,"_28":2731,"_30":3142,"_37":3143},"legmul","c = legmul(c1, c2)","Multiply two Legendre polynomials","Multiplies two Legendre coefficient arrays.",[3140,3141],{"_16":2726,"_22":2727},{"_16":2729,"_22":2730},[],[3144,3145,3146],"legdiv","legadd","legsub",{"_16":3144,"_18":3148,"_20":3149,"_22":3150,"_24":3151,"_28":2993,"_30":3154,"_37":3155},"[q, r] = legdiv(c1, c2)","Divide two Legendre polynomials","Divides two Legendre coefficient arrays.",[3152,3153],{"_16":2726,"_22":2746},{"_16":2729,"_22":2748},[],[3135],{"_16":3145,"_18":3157,"_20":3158,"_22":3159,"_24":3160,"_28":2761,"_30":3163,"_37":3164},"c = legadd(c1, c2)","Add two Legendre polynomials","Adds two Legendre coefficient arrays.",[3161,3162],{"_16":2726,"_22":2727},{"_16":2729,"_22":2730},[],[3146,3135],{"_16":3146,"_18":3166,"_20":3167,"_22":3168,"_24":3169,"_28":2774,"_30":3172,"_37":3173},"c = legsub(c1, c2)","Subtract two Legendre polynomials","Subtracts two Legendre coefficient arrays.",[3170,3171],{"_16":2726,"_22":2727},{"_16":2729,"_22":2730},[],[3145,3135],{"_16":3175,"_18":3176,"_20":3177,"_22":3178,"_24":3179,"_28":2790,"_30":3182,"_37":3183},"legpow","c = legpow(c, n)","Raise Legendre polynomial to a power","Raises a Legendre polynomial to a non-negative integer power.",[3180,3181],{"_16":2644,"_22":2787},{"_16":362,"_22":2789},[],[3135],{"_16":3185,"_18":3186,"_20":3187,"_22":3188,"_24":3189,"_28":2802,"_30":3191,"_37":3192},"legroots","r = legroots(c)","Find Legendre polynomial roots","Finds roots of a Legendre polynomial.",[3190],{"_16":2644,"_22":3105},[],[3193,3194],"legfromroots","legcompanion",{"_16":3193,"_18":3196,"_20":3197,"_22":3198,"_24":3199,"_28":3105,"_30":3201,"_37":3202},"c = legfromroots(r)","Construct Legendre polynomial from roots","Constructs Legendre coefficient array from roots.",[3200],{"_16":2815,"_22":2802},[],[3185],{"_16":3194,"_18":3204,"_20":3205,"_22":3206,"_24":3207,"_28":2826,"_30":3209,"_37":3210},"C = legcompanion(c)","Legendre companion matrix","Generates the companion matrix for a Legendre polynomial.",[3208],{"_16":2644,"_22":3105},[],[3185],{"_16":3212,"_18":3213,"_20":3214,"_22":3215,"_24":3216,"_28":2842,"_30":3219,"_37":3220},"legvander","V = legvander(x, deg)","Legendre Vandermonde matrix","Generates a Legendre Vandermonde matrix.",[3217,3218],{"_16":498,"_22":2838},{"_16":2840,"_22":2841},[],[3110],{"_16":3110,"_18":3222,"_20":3223,"_22":3224,"_24":3225,"_28":3105,"_30":3229,"_37":3230},"c = legfit(x, y, deg)","Least-squares Legendre fit","Fits a Legendre polynomial of the given degree to data using least squares.",[3226,3227,3228],{"_16":498,"_22":2853},{"_16":501,"_22":2855},{"_16":2840,"_22":2857},[],[3098,3212],{"_16":3232,"_18":3233,"_20":3234,"_22":3235,"_24":3236,"_28":3091,"_30":3239,"_37":3240},"leg2poly","p = leg2poly(c)","Convert Legendre to power series","Converts Legendre coefficients to power series coefficients.",[3237],{"_16":2644,"_22":3238},"Legendre coefficients",[],[3241],"poly2leg",{"_16":3243,"_18":3244,"_20":3245,"_22":3246,"_24":3247,"_28":2646,"_30":3251,"_37":3254},"hermval","y = hermval(x, c)","Evaluate Hermite polynomial","Evaluates a physicist's Hermite polynomial at point x.",[3248,3249],{"_16":498,"_22":2642},{"_16":2644,"_22":3250},"Hermite coefficient array",[3252],{"_33":3253},"hermval(1, [1 2 3])",[3255,3256],"hermfit","hermder",{"_16":3256,"_18":3258,"_20":3259,"_22":3260,"_24":3261,"_28":2697,"_30":3264,"_37":3265},"dc = hermder(c)\ndc = hermder(c, m)","Hermite derivative","Differentiates a Hermite polynomial m times.",[3262,3263],{"_16":2644,"_22":3250},{"_16":359,"_22":2696,"_69":11},[],[3266,3243],"hermint",{"_16":3266,"_18":3268,"_20":3269,"_22":3270,"_24":3271,"_28":2713,"_30":3275,"_37":3276},"ic = hermint(c)\nic = hermint(c, m)\nic = hermint(c, m, k)","Hermite integral","Integrates a Hermite polynomial m times.",[3272,3273,3274],{"_16":2644,"_22":3250},{"_16":359,"_22":2710,"_69":11},{"_16":1114,"_22":2966,"_69":11},[],[3256,3243],{"_16":3278,"_18":3279,"_20":3280,"_22":3281,"_24":3282,"_28":2731,"_30":3285,"_37":3286},"hermmul","c = hermmul(c1, c2)","Multiply two Hermite polynomials","Multiplies two Hermite coefficient arrays.",[3283,3284],{"_16":2726,"_22":2727},{"_16":2729,"_22":2730},[],[3287,3288],"hermdiv","hermadd",{"_16":3287,"_18":3290,"_20":3291,"_22":3292,"_24":3293,"_28":2993,"_30":3296,"_37":3297},"[q, r] = hermdiv(c1, c2)","Divide two Hermite polynomials","Divides two Hermite coefficient arrays.",[3294,3295],{"_16":2726,"_22":2746},{"_16":2729,"_22":2748},[],[3278],{"_16":3288,"_18":3299,"_20":3300,"_22":3301,"_24":3302,"_28":2761,"_30":3305,"_37":3306},"c = hermadd(c1, c2)","Add two Hermite polynomials","Adds two Hermite coefficient arrays.",[3303,3304],{"_16":2726,"_22":2727},{"_16":2729,"_22":2730},[],[3307,3278],"hermsub",{"_16":3307,"_18":3309,"_20":3310,"_22":3311,"_24":3312,"_28":2774,"_30":3315,"_37":3316},"c = hermsub(c1, c2)","Subtract two Hermite polynomials","Subtracts two Hermite coefficient arrays.",[3313,3314],{"_16":2726,"_22":2727},{"_16":2729,"_22":2730},[],[3288,3278],{"_16":3318,"_18":3319,"_20":3320,"_22":3321,"_24":3322,"_28":2790,"_30":3325,"_37":3326},"hermpow","c = hermpow(c, n)","Raise Hermite polynomial to a power","Raises a Hermite polynomial to a non-negative integer power.",[3323,3324],{"_16":2644,"_22":2787},{"_16":362,"_22":2789},[],[3278],{"_16":3328,"_18":3329,"_20":3330,"_22":3331,"_24":3332,"_28":2802,"_30":3334,"_37":3335},"hermroots","r = hermroots(c)","Find Hermite polynomial roots","Finds roots of a Hermite polynomial.",[3333],{"_16":2644,"_22":3250},[],[3336,3337],"hermfromroots","hermcompanion",{"_16":3336,"_18":3339,"_20":3340,"_22":3341,"_24":3342,"_28":3250,"_30":3344,"_37":3345},"c = hermfromroots(r)","Construct Hermite polynomial from roots","Constructs Hermite coefficient array from roots.",[3343],{"_16":2815,"_22":2802},[],[3328],{"_16":3337,"_18":3347,"_20":3348,"_22":3349,"_24":3350,"_28":2826,"_30":3352,"_37":3353},"C = hermcompanion(c)","Hermite companion matrix","Generates the companion matrix for a Hermite polynomial.",[3351],{"_16":2644,"_22":3250},[],[3328],{"_16":3355,"_18":3356,"_20":3357,"_22":3358,"_24":3359,"_28":2842,"_30":3362,"_37":3363},"hermvander","V = hermvander(x, deg)","Hermite Vandermonde matrix","Generates a Hermite Vandermonde matrix.",[3360,3361],{"_16":498,"_22":2838},{"_16":2840,"_22":2841},[],[3255],{"_16":3255,"_18":3365,"_20":3366,"_22":3367,"_24":3368,"_28":3250,"_30":3372,"_37":3373},"c = hermfit(x, y, deg)","Least-squares Hermite fit","Fits a Hermite polynomial of the given degree to data using least squares.",[3369,3370,3371],{"_16":498,"_22":2853},{"_16":501,"_22":2855},{"_16":2840,"_22":2857},[],[3243,3355],{"_16":3375,"_18":3376,"_20":3377,"_22":3378,"_24":3379,"_28":3091,"_30":3382,"_37":3383},"herm2poly","p = herm2poly(c)","Convert Hermite to power series","Converts Hermite coefficients to power series coefficients.",[3380],{"_16":2644,"_22":3381},"Hermite coefficients",[],[3384],"poly2herm",{"_16":3386,"_18":3387,"_20":3388,"_22":3389,"_24":3390,"_28":2646,"_30":3394,"_37":3395},"hermeval","y = hermeval(x, c)","Evaluate probabilist's Hermite polynomial","Evaluates a probabilist's Hermite (HermiteE) polynomial at point x.",[3391,3392],{"_16":498,"_22":2642},{"_16":2644,"_22":3393},"HermiteE coefficient array",[],[3396,3397],"hermefit","hermeder",{"_16":3397,"_18":3399,"_20":3400,"_22":3401,"_24":3402,"_28":2697,"_30":3405,"_37":3406},"dc = hermeder(c)\ndc = hermeder(c, m)","HermiteE derivative","Differentiates a HermiteE polynomial m times.",[3403,3404],{"_16":2644,"_22":3393},{"_16":359,"_22":2696,"_69":11},[],[3407,3386],"hermeint",{"_16":3407,"_18":3409,"_20":3410,"_22":3411,"_24":3412,"_28":2713,"_30":3416,"_37":3417},"ic = hermeint(c)\nic = hermeint(c, m)\nic = hermeint(c, m, k)","HermiteE integral","Integrates a HermiteE polynomial m times.",[3413,3414,3415],{"_16":2644,"_22":3393},{"_16":359,"_22":2710,"_69":11},{"_16":1114,"_22":2966,"_69":11},[],[3397,3386],{"_16":3419,"_18":3420,"_20":3421,"_22":3422,"_24":3423,"_28":2731,"_30":3426,"_37":3427},"hermemul","c = hermemul(c1, c2)","Multiply two HermiteE polynomials","Multiplies two HermiteE coefficient arrays.",[3424,3425],{"_16":2726,"_22":2727},{"_16":2729,"_22":2730},[],[3428,3429],"hermediv","hermeadd",{"_16":3428,"_18":3431,"_20":3432,"_22":3433,"_24":3434,"_28":2993,"_30":3437,"_37":3438},"[q, r] = hermediv(c1, c2)","Divide two HermiteE polynomials","Divides two HermiteE coefficient arrays.",[3435,3436],{"_16":2726,"_22":2746},{"_16":2729,"_22":2748},[],[3419],{"_16":3429,"_18":3440,"_20":3441,"_22":3442,"_24":3443,"_28":2761,"_30":3446,"_37":3447},"c = hermeadd(c1, c2)","Add two HermiteE polynomials","Adds two HermiteE coefficient arrays.",[3444,3445],{"_16":2726,"_22":2727},{"_16":2729,"_22":2730},[],[3448,3419],"hermesub",{"_16":3448,"_18":3450,"_20":3451,"_22":3452,"_24":3453,"_28":2774,"_30":3456,"_37":3457},"c = hermesub(c1, c2)","Subtract two HermiteE polynomials","Subtracts two HermiteE coefficient arrays.",[3454,3455],{"_16":2726,"_22":2727},{"_16":2729,"_22":2730},[],[3429,3419],{"_16":3459,"_18":3460,"_20":3461,"_22":3462,"_24":3463,"_28":2790,"_30":3466,"_37":3467},"hermepow","c = hermepow(c, n)","Raise HermiteE polynomial to a power","Raises a HermiteE polynomial to a non-negative integer power.",[3464,3465],{"_16":2644,"_22":2787},{"_16":362,"_22":2789},[],[3419],{"_16":3469,"_18":3470,"_20":3471,"_22":3472,"_24":3473,"_28":2802,"_30":3475,"_37":3476},"hermeroots","r = hermeroots(c)","Find HermiteE polynomial roots","Finds roots of a HermiteE polynomial.",[3474],{"_16":2644,"_22":3393},[],[3477,3478],"hermefromroots","hermecompanion",{"_16":3477,"_18":3480,"_20":3481,"_22":3482,"_24":3483,"_28":3393,"_30":3485,"_37":3486},"c = hermefromroots(r)","Construct HermiteE polynomial from roots","Constructs HermiteE coefficient array from roots.",[3484],{"_16":2815,"_22":2802},[],[3469],{"_16":3478,"_18":3488,"_20":3489,"_22":3490,"_24":3491,"_28":2826,"_30":3493,"_37":3494},"C = hermecompanion(c)","HermiteE companion matrix","Generates the companion matrix for a HermiteE polynomial.",[3492],{"_16":2644,"_22":3393},[],[3469],{"_16":3496,"_18":3497,"_20":3498,"_22":3499,"_24":3500,"_28":2842,"_30":3503,"_37":3504},"hermevander","V = hermevander(x, deg)","HermiteE Vandermonde matrix","Generates a HermiteE Vandermonde matrix.",[3501,3502],{"_16":498,"_22":2838},{"_16":2840,"_22":2841},[],[3396],{"_16":3396,"_18":3506,"_20":3507,"_22":3508,"_24":3509,"_28":3393,"_30":3513,"_37":3514},"c = hermefit(x, y, deg)","Least-squares HermiteE fit","Fits a HermiteE polynomial of the given degree to data using least squares.",[3510,3511,3512],{"_16":498,"_22":2853},{"_16":501,"_22":2855},{"_16":2840,"_22":2857},[],[3386,3496],{"_16":3516,"_18":3517,"_20":3518,"_22":3519,"_24":3520,"_28":3091,"_30":3523,"_37":3524},"herme2poly","p = herme2poly(c)","Convert HermiteE to power series","Converts HermiteE coefficients to power series coefficients.",[3521],{"_16":2644,"_22":3522},"HermiteE coefficients",[],[3525],"poly2herme",{"_16":3527,"_18":3528,"_20":3529,"_22":3530,"_24":3531,"_28":2646,"_30":3535,"_37":3538},"lagval","y = lagval(x, c)","Evaluate Laguerre polynomial","Evaluates a Laguerre polynomial at point x.",[3532,3533],{"_16":498,"_22":2642},{"_16":2644,"_22":3534},"Laguerre coefficient array",[3536],{"_33":3537},"lagval(1, [1 2 3])",[3539,3540],"lagfit","lagder",{"_16":3540,"_18":3542,"_20":3543,"_22":3544,"_24":3545,"_28":2697,"_30":3548,"_37":3549},"dc = lagder(c)\ndc = lagder(c, m)","Laguerre derivative","Differentiates a Laguerre polynomial m times.",[3546,3547],{"_16":2644,"_22":3534},{"_16":359,"_22":2696,"_69":11},[],[3550,3527],"lagint",{"_16":3550,"_18":3552,"_20":3553,"_22":3554,"_24":3555,"_28":2713,"_30":3559,"_37":3560},"ic = lagint(c)\nic = lagint(c, m)\nic = lagint(c, m, k)","Laguerre integral","Integrates a Laguerre polynomial m times.",[3556,3557,3558],{"_16":2644,"_22":3534},{"_16":359,"_22":2710,"_69":11},{"_16":1114,"_22":2966,"_69":11},[],[3540,3527],{"_16":3562,"_18":3563,"_20":3564,"_22":3565,"_24":3566,"_28":2731,"_30":3569,"_37":3570},"lagmul","c = lagmul(c1, c2)","Multiply two Laguerre polynomials","Multiplies two Laguerre coefficient arrays.",[3567,3568],{"_16":2726,"_22":2727},{"_16":2729,"_22":2730},[],[3571,3572],"lagdiv","lagadd",{"_16":3571,"_18":3574,"_20":3575,"_22":3576,"_24":3577,"_28":2993,"_30":3580,"_37":3581},"[q, r] = lagdiv(c1, c2)","Divide two Laguerre polynomials","Divides two Laguerre coefficient arrays.",[3578,3579],{"_16":2726,"_22":2746},{"_16":2729,"_22":2748},[],[3562],{"_16":3572,"_18":3583,"_20":3584,"_22":3585,"_24":3586,"_28":2761,"_30":3589,"_37":3590},"c = lagadd(c1, c2)","Add two Laguerre polynomials","Adds two Laguerre coefficient arrays.",[3587,3588],{"_16":2726,"_22":2727},{"_16":2729,"_22":2730},[],[3591,3562],"lagsub",{"_16":3591,"_18":3593,"_20":3594,"_22":3595,"_24":3596,"_28":2774,"_30":3599,"_37":3600},"c = lagsub(c1, c2)","Subtract two Laguerre polynomials","Subtracts two Laguerre coefficient arrays.",[3597,3598],{"_16":2726,"_22":2727},{"_16":2729,"_22":2730},[],[3572,3562],{"_16":3602,"_18":3603,"_20":3604,"_22":3605,"_24":3606,"_28":2790,"_30":3609,"_37":3610},"lagpow","c = lagpow(c, n)","Raise Laguerre polynomial to a power","Raises a Laguerre polynomial to a non-negative integer power.",[3607,3608],{"_16":2644,"_22":2787},{"_16":362,"_22":2789},[],[3562],{"_16":3612,"_18":3613,"_20":3614,"_22":3615,"_24":3616,"_28":2802,"_30":3618,"_37":3619},"lagroots","r = lagroots(c)","Find Laguerre polynomial roots","Finds roots of a Laguerre polynomial.",[3617],{"_16":2644,"_22":3534},[],[3620,3621],"lagfromroots","lagcompanion",{"_16":3620,"_18":3623,"_20":3624,"_22":3625,"_24":3626,"_28":3534,"_30":3628,"_37":3629},"c = lagfromroots(r)","Construct Laguerre polynomial from roots","Constructs Laguerre coefficient array from roots.",[3627],{"_16":2815,"_22":2802},[],[3612],{"_16":3621,"_18":3631,"_20":3632,"_22":3633,"_24":3634,"_28":2826,"_30":3636,"_37":3637},"C = lagcompanion(c)","Laguerre companion matrix","Generates the companion matrix for a Laguerre polynomial.",[3635],{"_16":2644,"_22":3534},[],[3612],{"_16":3639,"_18":3640,"_20":3641,"_22":3642,"_24":3643,"_28":2842,"_30":3646,"_37":3647},"lagvander","V = lagvander(x, deg)","Laguerre Vandermonde matrix","Generates a Laguerre Vandermonde matrix.",[3644,3645],{"_16":498,"_22":2838},{"_16":2840,"_22":2841},[],[3539],{"_16":3539,"_18":3649,"_20":3650,"_22":3651,"_24":3652,"_28":3534,"_30":3656,"_37":3657},"c = lagfit(x, y, deg)","Least-squares Laguerre fit","Fits a Laguerre polynomial of the given degree to data using least squares.",[3653,3654,3655],{"_16":498,"_22":2853},{"_16":501,"_22":2855},{"_16":2840,"_22":2857},[],[3527,3639],{"_16":3659,"_18":3660,"_20":3661,"_22":3662,"_24":3663,"_28":3091,"_30":3666,"_37":3667},"lag2poly","p = lag2poly(c)","Convert Laguerre to power series","Converts Laguerre coefficients to power series coefficients.",[3664],{"_16":2644,"_22":3665},"Laguerre coefficients",[],[3668],"poly2lag",{"_16":3096,"_18":3670,"_20":3671,"_22":3672,"_24":3673,"_28":3090,"_30":3675,"_37":3678},"cc = poly2cheb(c)","Convert power series to Chebyshev","Converts power series coefficients to Chebyshev coefficients.",[3674],{"_16":2644,"_22":3091},[3676],{"_33":3677},"poly2cheb([1 0 1])",[3084],{"_16":3241,"_18":3680,"_20":3681,"_22":3682,"_24":3683,"_28":3238,"_30":3685,"_37":3686},"lc = poly2leg(c)","Convert power series to Legendre","Converts power series coefficients to Legendre coefficients.",[3684],{"_16":2644,"_22":3091},[],[3232],{"_16":3384,"_18":3688,"_20":3689,"_22":3690,"_24":3691,"_28":3381,"_30":3693,"_37":3694},"hc = poly2herm(c)","Convert power series to Hermite","Converts power series coefficients to Hermite coefficients.",[3692],{"_16":2644,"_22":3091},[],[3375],{"_16":3525,"_18":3696,"_20":3697,"_22":3698,"_24":3699,"_28":3522,"_30":3701,"_37":3702},"hc = poly2herme(c)","Convert power series to HermiteE","Converts power series coefficients to HermiteE coefficients.",[3700],{"_16":2644,"_22":3091},[],[3516],{"_16":3668,"_18":3704,"_20":3705,"_22":3706,"_24":3707,"_28":3665,"_30":3709,"_37":3710},"lc = poly2lag(c)","Convert power series to Laguerre","Converts power series coefficients to Laguerre coefficients.",[3708],{"_16":2644,"_22":3091},[],[3659],{"_16":3712,"_18":3713,"_20":3714,"_22":3715,"_24":3716,"_28":3721,"_30":3722,"_37":3726},"trimcoef","ct = trimcoef(c)\nct = trimcoef(c, tol)","Remove small trailing coefficients","Removes trailing elements with absolute value less than or equal to tol.",[3717,3718],{"_16":2644,"_22":2787},{"_16":3719,"_22":3720,"_69":11},"tol","Tolerance (default: 0)","Trimmed coefficient array",[3723],{"_33":3724,"_368":3725},"trimcoef([1 2 3 0 0])","[1 2 3]",[3727],"trimseq",{"_16":3727,"_18":3729,"_20":3730,"_22":3731,"_24":3732,"_28":3735,"_30":3736,"_37":3740},"ct = trimseq(c)","Remove trailing zeros","Removes trailing zeros from a coefficient sequence.",[3733],{"_16":2644,"_22":3734},"Coefficient sequence","Trimmed sequence",[3737],{"_33":3738,"_368":3739},"trimseq([1 2 0 0])","[1 2]",[3712],{"_16":3742,"_18":3743,"_20":3744,"_22":3745,"_24":3746,"_28":3749,"_30":3750,"_37":3754},"getdomain","d = getdomain(x)","Get domain from data points","Returns the minimum and maximum of the data as the domain [min, max].",[3747],{"_16":498,"_22":3748},"Data points","[min, max] domain",[3751],{"_33":3752,"_368":3753},"getdomain([1 2 3 4 5])","[1 5]",[3755,3756],"mapdomain","mapparms",{"_16":3755,"_18":3758,"_20":3759,"_22":3760,"_24":3761,"_28":3768,"_30":3769,"_37":3772},"y = mapdomain(x, old, new)","Map values between domains","Maps x from the old domain to the new domain using a linear transformation.",[3762,3764,3766],{"_16":498,"_22":3763},"Values to map",{"_16":1222,"_22":3765},"Original domain [min, max]",{"_16":1225,"_22":3767},"Target domain [min, max]","Mapped values",[3770],{"_33":3771,"_368":677},"mapdomain(0.5, [0 1], [-1 1])",[3756,3742],{"_16":3756,"_18":3774,"_20":3775,"_22":3776,"_24":3777,"_28":3780,"_30":3781,"_37":3785},"[off, scl] = mapparms(old, new)","Get linear mapping parameters","Returns [offset, scale] such that new = offset + scale * old.",[3778,3779],{"_16":1222,"_22":3765},{"_16":1225,"_22":3767},"[offset, scale]",[3782],{"_33":3783,"_368":3784},"mapparms([0 1], [-1 1])","[-1 2]",[3755,3742],{"_43":3787,"_16":3788,"_22":3789,"_47":48,"_49":3790,"_52":3791},"symbolic","Symbolic Mathematics","MATLAB-compatible symbolic mathematics functions for creating symbolic variables, solving equations, expanding expressions, and more. Powered by SymEngine via symngwasm.","🔣",[3792,3817,3835,3854,3874,3891,3906,3932,3953,3974],{"_16":3793,"_18":3794,"_20":3795,"_22":3796,"_24":3797,"_28":3801,"_30":3802,"_37":3813},"sym","x = sym(s)\nx = sym(n)","Create symbolic variable or expression","Creates a symbolic variable from a string name or converts a number to a symbolic number. Supports both function syntax sym('x') and command syntax sym x.\n\nWhen given a simple variable name, creates a symbolic variable. When given an expression string, parses it into a symbolic expression.",[3798],{"_16":3799,"_22":3800},"s","Variable name (string) or numeric value to convert","Symbolic variable or expression",[3803,3805,3807,3810],{"_33":3804,"_368":498},"x = sym('x')",{"_33":3806,"_368":498},"sym x",{"_33":3808,"_368":3809},"f = sym('x^2 + 2*x + 1')","x^2 + 2*x + 1",{"_33":3811,"_368":3812},"half = sym(1/2)","1/2",[3814,3815,3816],"syms","solve","expand",{"_16":3814,"_18":3818,"_20":3819,"_22":3820,"_24":3821,"_28":3825,"_30":3826,"_37":3833},"syms x y z\nsyms('x', 'y', 'z')","Create multiple symbolic variables","Creates multiple symbolic variables and assigns them to the workspace. Supports both command syntax syms x y z and function syntax syms('x', 'y', 'z').\n\nEach variable name becomes a symbolic variable in the current workspace.",[3822],{"_16":3823,"_22":3824},"vars","Variable names (space-separated for command syntax, or multiple string arguments)","Creates variables in workspace (no return value)",[3827,3830],{"_33":3828,"_368":3829},"syms x y z","% Creates x, y, z as symbolic variables",{"_33":3831,"_368":3832},"syms('a', 'b')","% Creates a, b as symbolic variables",[3793,3815,3834],"subs",{"_16":3815,"_18":3836,"_20":3837,"_22":3838,"_24":3839,"_28":3845,"_30":3846,"_37":3853},"S = solve(eqn, var)\nS = solve(eqn)","Solve symbolic equation","Solves a symbolic equation for the specified variable. The equation can be an expression (assumed equal to zero) or an equation created with ==.\n\nReturns an array of solutions. For polynomial equations, includes all roots (real and complex).",[3840,3843],{"_16":3841,"_22":3842},"eqn","Symbolic equation or expression (assumed = 0)",{"_16":857,"_22":3844,"_69":11},"Variable to solve for","Array of symbolic solutions",[3847,3850],{"_33":3848,"_368":3849},"syms x; solve(x^2 - 1, x)","[-1, 1]",{"_33":3851,"_368":3852},"syms x; solve(x^2 + x - 6, x)","[-3, 2]",[3793,3814,3816,3834],{"_16":3834,"_18":3855,"_20":3856,"_22":3857,"_24":3858,"_28":3866,"_30":3867,"_37":3873},"g = subs(f, old, new)\ng = subs(f, var, value)","Substitute in symbolic expression","Substitutes old with new in the symbolic expression f. Can substitute a variable with a value or an expression with another expression.\n\nUseful for evaluating symbolic expressions at specific values or simplifying by replacement.",[3859,3862,3864],{"_16":3860,"_22":3861},"f","Symbolic expression",{"_16":1222,"_22":3863},"Symbol or expression to replace",{"_16":1225,"_22":3865},"Replacement value or expression","Expression with substitution applied",[3868,3870],{"_33":3869,"_368":782},"syms x; subs(x^2 + 1, x, 2)",{"_33":3871,"_368":3872},"syms x y; subs(x + y, x, y^2)","y^2 + y",[3793,3815,3816],{"_16":3816,"_18":3875,"_20":3876,"_22":3877,"_24":3878,"_28":3881,"_30":3882,"_37":3888},"g = expand(f)","Expand symbolic expression","Expands products and powers in the symbolic expression. Distributes multiplication over addition and expands powers of sums.\n\nExample: expand((x+1)^2) returns x^2 + 2*x + 1",[3879],{"_16":3860,"_22":3880},"Symbolic expression to expand","Expanded expression",[3883,3885],{"_33":3884,"_368":3809},"syms x; expand((x + 1)^2)",{"_33":3886,"_368":3887},"syms x y; expand((x + y)*(x - y))","x^2 - y^2",[3793,3889,3890],"simplify","factor",{"_16":3889,"_18":3892,"_20":3893,"_22":3894,"_24":3895,"_28":3898,"_30":3899,"_37":3904},"g = simplify(f)","Simplify symbolic expression","Simplifies a symbolic expression using various algebraic rules. Combines like terms, cancels common factors, and applies trigonometric identities.",[3896],{"_16":3860,"_22":3897},"Symbolic expression to simplify","Simplified expression",[3900,3902],{"_33":3901,"_368":498},"syms x; simplify(x^2/x)",{"_33":3903,"_368":585},"syms x; simplify(sin(x)^2 + cos(x)^2)",[3816,3890,3905],"collect",{"_16":3907,"_18":3908,"_20":3909,"_22":3910,"_24":3911,"_28":3918,"_30":3919,"_37":3929},"diff","df = diff(f, x)\ndf = diff(f, x, n)","Symbolic differentiation","Computes the symbolic derivative of f with respect to x. If n is specified, computes the nth derivative.\n\nSupports all elementary functions including trigonometric, exponential, and logarithmic.",[3912,3914,3916],{"_16":3860,"_22":3913},"Symbolic expression to differentiate",{"_16":498,"_22":3915},"Variable to differentiate with respect to",{"_16":362,"_22":3917,"_69":11},"Order of derivative (default: 1)","Derivative expression",[3920,3923,3926],{"_33":3921,"_368":3922},"syms x; diff(x^3, x)","3*x^2",{"_33":3924,"_368":3925},"syms x; diff(sin(x), x)","cos(x)",{"_33":3927,"_368":3928},"syms x; diff(x^3, x, 2)","6*x",[3930,3931,3793],"int","taylor",{"_16":3931,"_18":3933,"_20":3934,"_22":3935,"_24":3936,"_28":3944,"_30":3945,"_37":3952},"T = taylor(f, x)\nT = taylor(f, x, a)\nT = taylor(f, x, a, n)","Taylor series expansion","Computes the Taylor series expansion of f around the point a (default 0). Returns a polynomial approximation with n terms (default 6).\n\nThe result is a symbolic polynomial representing the truncated Taylor series.",[3937,3938,3940,3942],{"_16":3860,"_22":3880},{"_16":498,"_22":3939},"Expansion variable",{"_16":433,"_22":3941,"_69":11},"Expansion point (default: 0)",{"_16":362,"_22":3943,"_69":11},"Number of terms (default: 6)","Taylor polynomial",[3946,3949],{"_33":3947,"_368":3948},"syms x; taylor(exp(x), x, 0, 4)","1 + x + x^2/2 + x^3/6",{"_33":3950,"_368":3951},"syms x; taylor(sin(x), x)","x - x^3/6 + x^5/120",[3907,3816,3793],{"_16":3954,"_18":3955,"_20":3956,"_22":3957,"_24":3958,"_28":3964,"_30":3965,"_37":3972},"assume","assume(x, prop)\nassume x prop","Set assumption on symbolic variable","Sets an assumption on a symbolic variable. Assumptions affect simplification and solving.\n\nCommon assumptions: positive, negative, real, integer, rational",[3959,3961],{"_16":498,"_22":3960},"Symbolic variable",{"_16":3962,"_22":3963},"prop","Property to assume (e.g., 'positive', 'real', 'integer')","Nothing (modifies variable in place)",[3966,3969],{"_33":3967,"_368":3968},"syms x; assume(x, 'positive')","% x is now assumed positive",{"_33":3970,"_368":3971},"assume x real","% x is now assumed real",[3973,3793,3814],"assumptions",{"_16":3973,"_18":3975,"_20":3976,"_22":3977,"_24":3978,"_28":3981,"_30":3982,"_37":3986},"a = assumptions(x)","Get assumptions on symbolic variable","Returns the current assumptions on a symbolic variable as a string.",[3979],{"_16":498,"_22":3980},"Symbolic variable to query","String describing assumptions",[3983],{"_33":3984,"_368":3985},"syms x; assume(x, 'positive'); assumptions(x)","'positive'",[3954,3793,3814],{"_43":3988,"_16":3989,"_22":3990,"_47":48,"_49":3991,"_52":3992},"sparse","Sparse Matrices","Sparse matrix creation, manipulation, and iterative solvers for large-scale linear systems.","🔳",[3993,4021,4033,4050,4063,4075,4092,4108,4122,4136,4151,4162,4174,4185,4197,4212,4227,4252,4266,4280,4296,4312,4325,4342,4356],{"_16":3988,"_18":3994,"_20":3995,"_22":3996,"_24":3997,"_28":4008,"_30":4009,"_37":4016},"S = sparse(A)\nS = sparse(m, n)\nS = sparse(i, j, v)\nS = sparse(i, j, v, m, n)","Create sparse matrix","Creates a sparse matrix. With one argument, converts a dense matrix to sparse CSR format. With two arguments (m,n), creates an empty m-by-n sparse matrix. With three arguments (i,j,v), creates a sparse matrix from row indices i, column indices j, and values v. With five arguments, additionally specifies the m-by-n dimensions.",[3998,4001,4004,4006,4007],{"_16":3999,"_22":4000},"A/i","Dense matrix, or row index vector (1-based)",{"_16":4002,"_22":4003,"_69":11},"j/n","Column index vector (1-based), or number of columns",{"_16":2897,"_22":4005,"_69":11},"Values vector",{"_16":359,"_22":360,"_69":11},{"_16":362,"_22":363,"_69":11},"Sparse matrix (CSR format)",[4010,4012,4014],{"_33":4011},"S = sparse(eye(5))",{"_33":4013},"S = sparse([1 2 3], [1 2 3], [10 20 30], 3, 3)",{"_33":4015},"S = sparse(5, 5) % empty 5x5 sparse",[4017,4018,4019,4020],"speye","sprand","full","issparse",{"_16":4017,"_18":4022,"_20":4023,"_22":4024,"_24":4025,"_28":4023,"_30":4029,"_37":4032},"S = speye(n)\nS = speye(m, n)","Sparse identity matrix","Creates a sparse identity matrix. speye(n) creates an n-by-n sparse identity. speye(m,n) creates an m-by-n sparse matrix with ones on the main diagonal.",[4026,4028],{"_16":359,"_22":4027},"Size (or number of rows)",{"_16":362,"_22":363,"_69":11},[4030],{"_33":4031},"I = speye(100)",[3988,375,4018],{"_16":4018,"_18":4034,"_20":4035,"_22":4036,"_24":4037,"_28":4043,"_30":4044,"_37":4047},"S = sprand(m, n, density)","Sparse uniformly distributed random matrix","Generates an m-by-n sparse matrix with approximately density*m*n uniformly distributed nonzero entries on [0,1).",[4038,4039,4040],{"_16":359,"_22":360},{"_16":362,"_22":363},{"_16":4041,"_22":4042},"density","Approximate density (0 to 1)","Sparse random matrix",[4045],{"_33":4046},"S = sprand(100, 100, 0.05)",[4048,4049,3988],"sprandn","sprandsym",{"_16":4048,"_18":4051,"_20":4052,"_22":4053,"_24":4054,"_28":4058,"_30":4059,"_37":4062},"S = sprandn(m, n, density)","Sparse normally distributed random matrix","Generates an m-by-n sparse matrix with approximately density*m*n normally distributed nonzero entries.",[4055,4056,4057],{"_16":359,"_22":360},{"_16":362,"_22":363},{"_16":4041,"_22":4042},"Sparse random matrix with normal distribution",[4060],{"_33":4061},"S = sprandn(100, 100, 0.05)",[4018,4049,3988],{"_16":4049,"_18":4064,"_20":4065,"_22":4066,"_24":4067,"_28":4065,"_30":4071,"_37":4074},"S = sprandsym(n, density)","Sparse symmetric random matrix","Generates an n-by-n sparse symmetric random matrix with approximately density*n*n/2 nonzero entries.",[4068,4070],{"_16":362,"_22":4069},"Matrix size",{"_16":4041,"_22":4042},[4072],{"_33":4073},"S = sprandsym(50, 0.1)",[4018,4048],{"_16":4076,"_18":4077,"_20":4078,"_22":4079,"_24":4080,"_28":4087,"_30":4088,"_37":4091},"spdiags","S = spdiags(B, d, m, n)","Sparse matrix formed from diagonals","Creates a sparse m-by-n matrix by placing the columns of B along the diagonals specified by d. Each column of B is placed along the corresponding diagonal in d.",[4081,4083,4085,4086],{"_16":656,"_22":4082},"Matrix whose columns are the diagonals",{"_16":1946,"_22":4084},"Vector of diagonal positions (0 = main, positive = above, negative = below)",{"_16":359,"_22":360},{"_16":362,"_22":363},"Sparse matrix with specified diagonals",[4089],{"_33":4090},"e = ones(5,1);\nS = spdiags([-e 2*e -e], [-1 0 1], 5, 5)",[3988,4017,403],{"_16":4093,"_18":4094,"_20":4095,"_22":4096,"_24":4097,"_28":4103,"_30":4104,"_37":4107},"spalloc","S = spalloc(m, n, nz)","Allocate space for sparse matrix","Creates an m-by-n all-zero sparse matrix with space preallocated for nz nonzero elements. Returns an empty sparse matrix (JS sparse matrices auto-resize).",[4098,4099,4100],{"_16":359,"_22":360},{"_16":362,"_22":363},{"_16":4101,"_22":4102},"nz","Number of nonzero elements to allocate (hint)","Empty sparse matrix",[4105],{"_33":4106},"S = spalloc(10, 10, 50)",[3988,4017],{"_16":4109,"_18":4110,"_20":4111,"_22":4112,"_24":4113,"_28":4117,"_30":4118,"_37":4121},"spconvert","S = spconvert(D)","Import sparse matrix from triplet data","Converts a matrix D with rows [i j v] into a sparse matrix. Row indices are in column 1, column indices in column 2, values in column 3. The last row may specify the matrix dimensions as [m n 0].",[4114],{"_16":4115,"_22":4116},"D","Dense matrix with columns [i, j, v]","Sparse matrix",[4119],{"_33":4120},"D = [1 1 10; 2 2 20; 3 3 30];\nS = spconvert(D)",[3988,927],{"_16":4020,"_18":4123,"_20":4124,"_22":4125,"_24":4126,"_28":4129,"_30":4130,"_37":4135},"tf = issparse(S)","Determine if matrix is sparse","Returns true (1) if S is a sparse matrix, false (0) otherwise.",[4127],{"_16":2115,"_22":4128},"Input value to test","Logical 1 or 0",[4131,4133],{"_33":4132,"_368":585},"issparse(speye(5))",{"_33":4134,"_368":677},"issparse(eye(5))",[3988,4019],{"_16":2132,"_18":4137,"_20":4138,"_22":4139,"_24":4140,"_28":4143,"_30":4144,"_37":4148},"n = nnz(S)","Number of nonzero matrix elements","Returns the number of nonzero elements in sparse matrix S, or the number of nonzero elements in a full matrix.",[4141],{"_16":2115,"_22":4142},"Sparse or full matrix","Number of nonzeros",[4145],{"_33":4146,"_368":4147},"nnz(speye(100))","100",[4149,4150,4020],"nonzeros","nzmax",{"_16":4149,"_18":4152,"_20":4153,"_22":4154,"_24":4155,"_28":4157,"_30":4158,"_37":4161},"v = nonzeros(S)","Nonzero matrix elements","Returns a column vector of the nonzero elements in sparse matrix S.",[4156],{"_16":2115,"_22":4117},"Column vector of nonzero values",[4159],{"_33":4160},"nonzeros(sparse([1 0; 0 2]))",[2132,927,4150],{"_16":4150,"_18":4163,"_20":4164,"_22":4165,"_24":4166,"_28":4168,"_30":4169,"_37":4173},"n = nzmax(S)","Amount of storage allocated for nonzero elements","Returns the amount of storage allocated for nonzero matrix elements. Returns the same as nnz(S) since JS arrays auto-resize.",[4167],{"_16":2115,"_22":4117},"Allocated storage size",[4170],{"_33":4171,"_368":4172},"nzmax(speye(10))","10",[2132,4149],{"_16":4019,"_18":4175,"_20":4176,"_22":4177,"_24":4178,"_28":4180,"_30":4181,"_37":4184},"A = full(S)","Convert sparse matrix to full storage","Converts a sparse matrix S to full (dense) matrix form. If S is already a full matrix, returns it unchanged.",[4179],{"_16":2115,"_22":4142},"Full (dense) matrix",[4182],{"_33":4183},"full(speye(3))",[3988,4020,2108],{"_16":4186,"_18":4187,"_20":4188,"_22":4189,"_24":4190,"_28":4192,"_30":4193,"_37":4196},"spones","R = spones(S)","Replace nonzero sparse matrix elements with ones","Returns a matrix with the same sparsity pattern as S but with all nonzero values replaced by 1.",[4191],{"_16":2115,"_22":4117},"Sparse matrix with ones at nonzero positions",[4194],{"_33":4195},"full(spones(sparse([1 0; 0 5])))",[2132,4149,3988],{"_16":4198,"_18":4199,"_20":4200,"_22":4201,"_24":4202,"_28":4207,"_30":4208,"_37":4211},"spfun","F = spfun(func, S)","Apply function to nonzero sparse matrix elements","Applies the function func to the nonzero elements of sparse matrix S. The sparsity pattern is preserved.",[4203,4206],{"_16":4204,"_22":4205},"func","Function handle to apply (e.g., @sqrt, @exp)",{"_16":2115,"_22":4117},"Sparse matrix with function applied to nonzeros",[4209],{"_33":4210},"full(spfun(@sqrt, sparse([4 0; 0 9])))",[4186,4149],{"_16":4213,"_18":4214,"_20":4215,"_22":4216,"_24":4217,"_28":4223,"_30":4224,"_37":4226},"spparms","spparms\nspparms(key)\nspparms(key, value)","Set parameters for sparse matrix routines","Gets or sets parameters for sparse matrix routines. This is a compatibility stub that accepts but ignores configuration.",[4218,4221],{"_16":4219,"_22":4220,"_69":11},"key","Parameter name",{"_16":235,"_22":4222,"_69":11},"Parameter value","Current parameter values, or null",[4225],{"_33":4213},[3988],{"_16":4228,"_18":4229,"_20":4230,"_22":4231,"_24":4232,"_28":4245,"_30":4246,"_37":4249},"gmres","x = gmres(A, b)\nx = gmres(A, b, restart, tol, maxit)\n[x, flag, relres, iter] = gmres(...)","Generalized minimum residual method","Solves the linear system Ax = b using the GMRES iterative method. Suitable for general (non-symmetric) sparse systems.",[4233,4235,4237,4240,4242],{"_16":659,"_22":4234},"Sparse coefficient matrix (n x n)",{"_16":436,"_22":4236},"Right-hand side vector",{"_16":4238,"_22":4239,"_69":11},"restart","Restart parameter (default 20)",{"_16":3719,"_22":4241,"_69":11},"Convergence tolerance (default 1e-6)",{"_16":4243,"_22":4244,"_69":11},"maxit","Maximum iterations","Solution vector x, or [x, flag, relres, iter]",[4247],{"_33":4248},"A = speye(3); b = [1;2;3];\nx = gmres(A, b)",[4250,4251,3988],"bicgstab","pcg",{"_16":4250,"_18":4253,"_20":4254,"_22":4255,"_24":4256,"_28":4245,"_30":4262,"_37":4265},"x = bicgstab(A, b)\n[x, flag, relres, iter] = bicgstab(A, b, tol, maxit)","BiConjugate Gradients Stabilized method","Solves the linear system Ax = b using the BiCGSTAB iterative method. Works for general (non-symmetric) sparse matrices.",[4257,4259,4260,4261],{"_16":659,"_22":4258},"Sparse coefficient matrix",{"_16":436,"_22":4236},{"_16":3719,"_22":4241,"_69":11},{"_16":4243,"_22":4244,"_69":11},[4263],{"_33":4264},"x = bicgstab(A, b)",[4228,4251],{"_16":4251,"_18":4267,"_20":4268,"_22":4269,"_24":4270,"_28":4245,"_30":4276,"_37":4279},"x = pcg(A, b)\n[x, flag, relres, iter] = pcg(A, b, tol, maxit)","Preconditioned conjugate gradients","Solves the symmetric positive definite linear system Ax = b using the Preconditioned Conjugate Gradient method.",[4271,4273,4274,4275],{"_16":659,"_22":4272},"Symmetric positive definite sparse matrix",{"_16":436,"_22":4236},{"_16":3719,"_22":4241,"_69":11},{"_16":4243,"_22":4244,"_69":11},[4277],{"_33":4278},"x = pcg(A, b)",[4228,4250],{"_16":4281,"_18":4282,"_20":4283,"_22":4284,"_24":4285,"_28":4291,"_30":4292,"_37":4295},"lsqr","x = lsqr(A, b)\n[x, flag] = lsqr(A, b, tol, maxit)","Least-squares solution via iterative method","Solves the least-squares problem min ||Ax - b||_2 using an iterative method. Delegates to conjugate gradients on the normal equations.",[4286,4288,4289,4290],{"_16":659,"_22":4287},"Sparse matrix (possibly non-square)",{"_16":436,"_22":4236},{"_16":3719,"_22":4241,"_69":11},{"_16":4243,"_22":4244,"_69":11},"Solution vector x, or [x, flag]",[4293],{"_33":4294},"x = lsqr(A, b)",[4251,4228],{"_16":4297,"_18":4298,"_20":4299,"_22":4300,"_24":4301,"_28":4306,"_30":4307,"_37":4310},"eigs","d = eigs(A, k)\n[V, D] = eigs(A, k)","Largest eigenvalues and eigenvectors of sparse matrix","Finds the k largest eigenvalues and optionally eigenvectors of a sparse matrix using ARPACK.",[4302,4304],{"_16":659,"_22":4303},"Sparse matrix or LinearOperator",{"_16":1114,"_22":4305,"_69":11},"Number of eigenvalues (default 6)","Eigenvalues vector, or [V, D] decomposition",[4308],{"_33":4309},"d = eigs(speye(10), 3)",[1469,4311],"svds",{"_16":4311,"_18":4313,"_20":4314,"_22":4315,"_24":4316,"_28":4320,"_30":4321,"_37":4324},"s = svds(A, k)\n[U, S, V] = svds(A, k)","Largest singular values of sparse matrix","Computes the k largest singular values and optionally singular vectors of a sparse matrix.",[4317,4318],{"_16":659,"_22":4117},{"_16":1114,"_22":4319,"_69":11},"Number of singular values (default 6)","Singular values vector, or [U, S, V] decomposition",[4322],{"_33":4323},"s = svds(A, 3)",[1484,4297],{"_16":4326,"_18":4327,"_20":4328,"_22":4329,"_24":4330,"_28":4336,"_30":4337,"_37":4340},"ilu","[L, U] = ilu(A)\n[L, U] = ilu(A, setup)","Incomplete LU factorization","Computes the incomplete LU factorization of sparse matrix A, suitable for use as a preconditioner in iterative solvers.",[4331,4333],{"_16":659,"_22":4332},"Sparse square matrix",{"_16":4334,"_22":4335,"_69":11},"setup","Options struct with type and droptol","[L, U] incomplete factors",[4338],{"_33":4339},"[L, U] = ilu(speye(5))",[4341,4251,4228],"ichol",{"_16":4341,"_18":4343,"_20":4344,"_22":4345,"_24":4346,"_28":4351,"_30":4352,"_37":4355},"L = ichol(A)\nL = ichol(A, opts)","Incomplete Cholesky factorization","Computes the incomplete Cholesky factorization of a symmetric positive definite sparse matrix A. Useful as a preconditioner for pcg.",[4347,4348],{"_16":659,"_22":4272},{"_16":4349,"_22":4350,"_69":11},"opts","Options struct","Lower triangular incomplete factor L",[4353],{"_33":4354},"L = ichol(speye(5))",[4326,4251],{"_16":4357,"_18":4358,"_20":4359,"_22":4360,"_24":4361,"_28":4363,"_30":4364,"_37":4367},"sprank","r = sprank(A)","Structural rank of sparse matrix","Returns the structural rank of sparse matrix A, which is an upper bound on the numerical rank. Uses a greedy maximum matching algorithm.",[4362],{"_16":659,"_22":4117},"Structural rank (integer)",[4365],{"_33":4366,"_368":782},"sprank(speye(5))",[2132,3988],{"_43":4369,"_16":4370,"_22":4371,"_47":48,"_49":4372,"_51":4373,"_52":4374},"mfem-generated","Finite Element (MFEM)","Finite element library powered by MFEM compiled to WebAssembly. Provides mesh generation, finite element spaces, bilinear/linear forms, coefficients, and iterative solvers.","🔷","mfem",[4375,4388,4402,4411,4427,4445,4459,4468,4477,4489,4496,4505,4514,4523,4533,4541,4551,4568,4579,4586,4599,4607,4619,4629,4641,4651,4659,4667,4676,4685,4696,4715,4732,4747,4759,4771,4780,4793,4808,4819,4832,4842,4851,4864,4873,4885,4894,4902,4912,4921,4933,4942,4953,4962,4971,4985,4996,5005,5014,5023,5032,5044,5055,5065,5074,5087,5098,5111,5122,5133,5142,5152,5161,5171,5182,5191,5199,5207,5216,5224,5232,5240,5248,5258,5270,5281,5289,5296,5304,5313,5320,5329,5337,5345,5352,5360,5368,5378,5387,5395,5403,5411,5420,5430,5438,5452,5463,5475,5487,5499,5510,5518,5526,5534,5546,5553,5569,5580,5591,5602,5612,5622,5632,5645,5655,5664,5675,5686,5696,5705,5715,5727,5742,5752,5764,5773,5788,5800,5810,5821,5831,5841,5850,5861,5876,5894,5905,5916,5929,5941,5953,5963,5974,5985,5995,6006,6015,6023,6031,6044,6057,6066,6079,6088,6100,6110,6119,6129,6138,6146,6158,6166,6174,6182,6190,6201,6207,6214,6220,6226,6233,6239,6245,6252,6259,6266,6272,6278,6285,6294,6305,6314,6323,6331,6338,6349,6358,6368,6378,6391,6398,6413,6420,6429,6437,6450,6460,6470,6478,6492,6502,6509,6516,6523,6530,6545,6555,6562,6568,6575,6587,6598,6608,6618,6632,6641,6651,6660,6667,6674,6682,6689,6700,6706,6714,6721,6729,6736,6747,6754,6761,6768,6778,6787,6793,6803,6810,6816,6822,6829,6836,6843,6850,6856,6862,6869,6881,6889,6897,6905,6917,6928,6937,6946,6955,6964,6973,6982,6991,7000,7013,7022,7031,7038,7050,7061,7073,7085,7105,7123,7135,7148,7159,7169,7180,7189,7200,7213,7224,7235,7248,7256,7271,7284,7293,7301,7309,7317,7326,7334,7345,7357,7365,7372,7382,7393,7404,7416,7424,7434,7443,7454,7464,7476,7483,7493,7502,7509,7516,7523,7530,7537,7544,7551,7558,7565,7572,7579,7586,7593,7603,7610,7617,7624,7633,7640,7647,7654,7661,7668,7675,7682,7689,7696,7703,7710,7718,7727,7734,7746,7754,7765,7773,7783,7793,7800,7807,7814,7823,7830,7837,7844,7851,7858,7867,7875,7882,7889,7897,7905,7913,7920,7927,7933,7940,7946,7952,7959,7968,7976,7985,7991,7998,8004,8010,8021,8029,8040,8056,8066,8079,8090,8100,8106,8113,8120,8127,8134,8141,8147,8155,8165,8174,8181,8188,8201,8211],{"_16":4376,"_18":4377,"_20":4378,"_22":4379,"_24":4380,"_28":1426,"_30":4387},"mfem.bilinearForms.addBoundaryMassIntegrator","mfem.bilinearForms.addBoundaryMassIntegrator(blf, coeff?)","Add a boundary mass integrator to the bilinear form.\r","Add a boundary mass integrator to the bilinear form.\r\n\r\nComputes: ∫_∂Ω c * u * v ds",[4381,4384],{"_16":4382,"_22":4383,"_69":6},"blf","- BilinearForm instance",{"_16":4385,"_22":4386,"_69":11},"coeff","- Optional scalar coefficient",[],{"_16":4389,"_18":4390,"_20":4391,"_22":4392,"_24":4393,"_28":1426,"_30":4401},"mfem.bilinearForms.addConvectionIntegrator","mfem.bilinearForms.addConvectionIntegrator(blf, velocity, alpha?)","Add a convection integrator (v · ∇u) to the bilinear form.\r","Add a convection integrator (v · ∇u) to the bilinear form.\r\n\r\nComputes: ∫ α * (β · ∇u) * v dx",[4394,4395,4398],{"_16":4382,"_22":4383,"_69":6},{"_16":4396,"_22":4397,"_69":6},"velocity","- Vector coefficient for velocity field",{"_16":4399,"_22":4400,"_69":11},"alpha","- Scaling factor (defaults to 1.0)",[],{"_16":4403,"_18":4404,"_20":4405,"_22":4406,"_24":4407,"_28":1426,"_30":4410},"mfem.bilinearForms.addCurlCurlIntegrator","mfem.bilinearForms.addCurlCurlIntegrator(blf, coeff?)","Add a curl-curl integrator (∇×u · ∇×v) to the bilinear form.\r","Add a curl-curl integrator (∇×u · ∇×v) to the bilinear form.\r\nUsed for H(curl) finite element spaces.\r\n\r\nComputes: ∫ c * (∇×u) · (∇×v) dx",[4408,4409],{"_16":4382,"_22":4383,"_69":6},{"_16":4385,"_22":4386,"_69":11},[],{"_16":4412,"_18":4413,"_20":4414,"_22":4415,"_24":4416,"_28":1426,"_30":4426},"mfem.bilinearForms.addDGDiffusionIntegrator","mfem.bilinearForms.addDGDiffusionIntegrator(blf, coeff, sigma, kappa)","Add DG diffusion integrator for interior penalty method.\r","Add DG diffusion integrator for interior penalty method.\r\nAdds integrators for both interior and boundary faces.",[4417,4418,4420,4423],{"_16":4382,"_22":4383,"_69":6},{"_16":4385,"_22":4419,"_69":6},"- Diffusion coefficient (optional)",{"_16":4421,"_22":4422,"_69":6},"sigma","- Symmetry parameter (-1 = SIPG, 0 = IIPG, 1 = NIPG)",{"_16":4424,"_22":4425,"_69":6},"kappa","- Penalty parameter (typically 10 * p^2 / h)",[],{"_16":4428,"_18":4429,"_20":4430,"_22":4431,"_24":4432,"_28":1426,"_30":4444},"mfem.bilinearForms.addDGElasticityIntegrator","mfem.bilinearForms.addDGElasticityIntegrator(blf, lambda, mu, alpha?, kappa?)","Add a discontinuous Galerkin (DG) elasticity integrator.\r","Add a discontinuous Galerkin (DG) elasticity integrator.\r\n\r\nUsed for elasticity problems with discontinuous Galerkin methods\r\nwhere displacement jumps occur across element boundaries.\r\nThis adds interior face integrators for the DG formulation.",[4433,4434,4437,4440,4442],{"_16":4382,"_22":4383,"_69":6},{"_16":4435,"_22":4436,"_69":6},"lambda","- Lamé first parameter",{"_16":4438,"_22":4439,"_69":6},"mu","- Shear modulus",{"_16":4399,"_22":4441,"_69":11},"- Symmetry parameter (default: -1.0 for symmetric form)",{"_16":4424,"_22":4443,"_69":11},"- Penalty parameter for stability",[],{"_16":4446,"_18":4447,"_20":4448,"_22":4449,"_24":4450,"_28":1426,"_30":4458},"mfem.bilinearForms.addDGTraceIntegrator","mfem.bilinearForms.addDGTraceIntegrator(blf, coeff?, alpha?, beta?)","Add DG trace integrator for face terms.\r","Add DG trace integrator for face terms.\r\nUsed for upwinding in DG advection problems.",[4451,4452,4454,4456],{"_16":4382,"_22":4383,"_69":6},{"_16":4385,"_22":4453,"_69":11},"- Optional coefficient (VectorCoefficient)",{"_16":4399,"_22":4455,"_69":11},"- Upwinding parameter (default: 0)",{"_16":2011,"_22":4457,"_69":11},"- Penalty parameter (default: 0)",[],{"_16":4460,"_18":4461,"_20":4462,"_22":4463,"_24":4464,"_28":1426,"_30":4467},"mfem.bilinearForms.addDiffusionIntegrator","mfem.bilinearForms.addDiffusionIntegrator(blf, coeff?)","Add a diffusion integrator (∇u · ∇v) to the bilinear form.\r","Add a diffusion integrator (∇u · ∇v) to the bilinear form.\r\n\r\nComputes: ∫ c * ∇u · ∇v dx",[4465,4466],{"_16":4382,"_22":4383,"_69":6},{"_16":4385,"_22":4386,"_69":11},[],{"_16":4469,"_18":4470,"_20":4471,"_22":4472,"_24":4473,"_28":1426,"_30":4476},"mfem.bilinearForms.addDivDivIntegrator","mfem.bilinearForms.addDivDivIntegrator(blf, coeff?)","Add a div-div integrator (∇·u)(∇·v) to the bilinear form.\r","Add a div-div integrator (∇·u)(∇·v) to the bilinear form.\r\nUsed for H(div) finite element spaces.\r\n\r\nComputes: ∫ c * (∇·u)(∇·v) dx",[4474,4475],{"_16":4382,"_22":4383,"_69":6},{"_16":4385,"_22":4386,"_69":11},[],{"_16":4478,"_18":4479,"_20":4480,"_22":4481,"_24":4482,"_28":1426,"_30":4488},"mfem.bilinearForms.addElasticityIntegrator","mfem.bilinearForms.addElasticityIntegrator(blf, lambda, mu)","Add a linear elasticity integrator to the bilinear form.\r","Add a linear elasticity integrator to the bilinear form.\r\n\r\nImplements the bilinear form for linear elasticity:\r\na(u,v) = ∫ λ(∇·u)(∇·v) + 2μ ε(u):ε(v) dx\r\n\r\nwhere:\r\n- λ (lambda) is the first Lamé parameter\r\n- μ (mu) is the second Lamé parameter (shear modulus)\r\n- ε is the strain tensor: ε(u) = (∇u + (∇u)ᵀ)/2",[4483,4484,4486],{"_16":4382,"_22":4383,"_69":6},{"_16":4435,"_22":4485,"_69":6},"- Lamé first parameter (scalar coefficient)",{"_16":4438,"_22":4487,"_69":6},"- Shear modulus / Lamé second parameter (scalar coefficient)",[],{"_16":4490,"_18":4491,"_20":4492,"_22":4492,"_24":4493,"_28":1426,"_30":4495},"mfem.bilinearForms.addGradientIntegrator","mfem.bilinearForms.addGradientIntegrator(blf)","Add a gradient integrator to the bilinear form.",[4494],{"_16":4382,"_22":4383,"_69":6},[],{"_16":4497,"_18":4498,"_20":4499,"_22":4500,"_24":4501,"_28":1426,"_30":4504},"mfem.bilinearForms.addMassIntegrator","mfem.bilinearForms.addMassIntegrator(blf, coeff?)","Add a mass integrator (u, v) to the bilinear form.\r","Add a mass integrator (u, v) to the bilinear form.\r\n\r\nComputes: ∫ c * u * v dx",[4502,4503],{"_16":4382,"_22":4383,"_69":6},{"_16":4385,"_22":4386,"_69":11},[],{"_16":4506,"_18":4507,"_20":4508,"_22":4509,"_24":4510,"_28":1426,"_30":4513},"mfem.bilinearForms.addVectorDiffusionIntegrator","mfem.bilinearForms.addVectorDiffusionIntegrator(blf, coeff?)","Add a vector diffusion integrator to the bilinear form.\r","Add a vector diffusion integrator to the bilinear form.\r\nFor vector-valued finite element functions.",[4511,4512],{"_16":4382,"_22":4383,"_69":6},{"_16":4385,"_22":4386,"_69":11},[],{"_16":4515,"_18":4516,"_20":4517,"_22":4518,"_24":4519,"_28":1426,"_30":4522},"mfem.bilinearForms.addVectorMassIntegrator","mfem.bilinearForms.addVectorMassIntegrator(blf, coeff?)","Add a vector mass integrator (u · v) to the bilinear form.\r","Add a vector mass integrator (u · v) to the bilinear form.\r\nFor vector-valued finite element functions.\r\n\r\nComputes: ∫ c * u · v dx",[4520,4521],{"_16":4382,"_22":4383,"_69":6},{"_16":4385,"_22":4386,"_69":11},[],{"_16":4524,"_18":4525,"_20":4526,"_22":4526,"_24":4527,"_28":1426,"_30":4532},"mfem.bilinearForms.assemble","mfem.bilinearForms.assemble(blf, skipZeros?)","Assemble bilinear form into sparse matrix.",[4528,4529],{"_16":4382,"_22":4383,"_69":6},{"_16":4530,"_22":4531,"_69":11},"skipZeros","- If true, skip storing zeros in the matrix (default: true)",[],{"_16":4534,"_18":4535,"_20":4536,"_22":4537,"_24":4538,"_28":1426,"_30":4540},"mfem.bilinearForms.assemblePartial","mfem.bilinearForms.assemblePartial(blf)","Partial assembly for matrix-free operations.\r","Partial assembly for matrix-free operations.\r\nSets the assembly level to PARTIAL and then assembles.",[4539],{"_16":4382,"_22":4383,"_69":6},[],{"_16":4542,"_18":4543,"_20":4544,"_22":4544,"_24":4545,"_28":4549,"_30":4550},"mfem.bilinearForms.create","mfem.bilinearForms.create(fespace)","Create a bilinear form on a finite element space.",[4546],{"_16":4547,"_22":4548,"_69":6},"fespace","- FiniteElementSpace instance","Promise",[],{"_16":4552,"_18":4553,"_20":4554,"_22":4555,"_24":4556,"_28":1426,"_30":4567},"mfem.bilinearForms.eliminateEssentialBC","mfem.bilinearForms.eliminateEssentialBC(blf, essentialDofs, sol, rhs)","Eliminate essential BCs from system.\r","Eliminate essential BCs from system.\r\nModifies the RHS vector in place for non-homogeneous boundary conditions.",[4557,4558,4561,4564],{"_16":4382,"_22":4383,"_69":6},{"_16":4559,"_22":4560,"_69":6},"essentialDofs","- Essential DOF indices",{"_16":4562,"_22":4563,"_69":6},"sol","- Solution vector with boundary values",{"_16":4565,"_22":4566,"_69":6},"rhs","- Right-hand side vector (modified in place)",[],{"_16":4569,"_18":4570,"_20":4571,"_22":4572,"_24":4573,"_28":4577,"_30":4578},"mfem.bilinearForms.formSystemMatrix","mfem.bilinearForms.formSystemMatrix(blf, essentialDofs)","Form system matrix with essential BC elimination.\r","Form system matrix with essential BC elimination.\r\nWorks with static condensation if enabled.",[4574,4576],{"_16":4382,"_22":4575,"_69":6},"- BilinearForm instance (must be assembled first)",{"_16":4559,"_22":4560,"_69":6},"SparseMatrix",[],{"_16":4580,"_18":4581,"_20":4582,"_22":4582,"_24":4583,"_28":4577,"_30":4585},"mfem.bilinearForms.getMatrix","mfem.bilinearForms.getMatrix(blf)","Get assembled sparse matrix from a bilinear form.",[4584],{"_16":4382,"_22":4575,"_69":6},[],{"_16":4587,"_18":4588,"_20":4589,"_22":4589,"_24":4590,"_28":4597,"_30":4598},"mfem.bilinearForms.createMixed","mfem.bilinearForms.createMixed(trialFES, testFES)","Create a mixed bilinear form on trial and test spaces.",[4591,4594],{"_16":4592,"_22":4593,"_69":6},"trialFES","- Trial FiniteElementSpace",{"_16":4595,"_22":4596,"_69":6},"testFES","- Test FiniteElementSpace","Promise",[],{"_16":4600,"_18":4601,"_20":4602,"_22":4602,"_24":4603,"_28":4549,"_30":4606},"mfem.bilinearForms.BilinearForm.create","mfem.bilinearForms.BilinearForm.create(fespace)","Creates a new bilinear form on the specified finite element space.",[4604],{"_16":4547,"_22":4605,"_69":6},"- The finite element space",[],{"_16":4608,"_18":4609,"_20":4610,"_22":4610,"_24":4611,"_28":4597,"_30":4618},"mfem.bilinearForms.MixedBilinearForm.create","mfem.bilinearForms.MixedBilinearForm.create(trialFespace, testFespace)","Creates a new mixed bilinear form.",[4612,4615],{"_16":4613,"_22":4614,"_69":6},"trialFespace","- The trial finite element space",{"_16":4616,"_22":4617,"_69":6},"testFespace","- The test finite element space",[],{"_16":4620,"_18":4621,"_20":4622,"_22":4622,"_24":4623,"_28":4627,"_30":4628},"mfem.block.BlockMatrix.createSquare","mfem.block.BlockMatrix.createSquare(offsets)","Create a square BlockMatrix with the same offsets for rows and columns.",[4624],{"_16":4625,"_22":4626,"_69":6},"offsets","- Block offsets array (used for both rows and columns)","Promise",[],{"_16":4630,"_18":4631,"_20":4632,"_22":4632,"_24":4633,"_28":4627,"_30":4640},"mfem.block.BlockMatrix.create","mfem.block.BlockMatrix.create(rowOffsets, colOffsets)","Create a rectangular BlockMatrix with different row and column offsets.",[4634,4637],{"_16":4635,"_22":4636,"_69":6},"rowOffsets","- Row block offsets array",{"_16":4638,"_22":4639,"_69":6},"colOffsets","- Column block offsets array",[],{"_16":4642,"_18":4643,"_20":4644,"_22":4645,"_24":4646,"_28":4627,"_30":4650},"mfem.block.BlockMatrix.fromPointer","mfem.block.BlockMatrix.fromPointer(ptr)","Creates a BlockMatrix from an existing WASM pointer.\r","Creates a BlockMatrix from an existing WASM pointer.\r\nUse with caution - the caller is responsible for pointer validity.",[4647],{"_16":4648,"_22":4649,"_69":6},"ptr","- WASM pointer to an existing MFEM BlockMatrix",[],{"_16":4652,"_18":4653,"_20":4654,"_22":4654,"_24":4655,"_28":4657,"_30":4658},"mfem.block.BlockOperator.createSquare","mfem.block.BlockOperator.createSquare(offsets)","Create a square BlockOperator with the same offsets for rows and columns.",[4656],{"_16":4625,"_22":4626,"_69":6},"Promise",[],{"_16":4660,"_18":4661,"_20":4662,"_22":4662,"_24":4663,"_28":4657,"_30":4666},"mfem.block.BlockOperator.create","mfem.block.BlockOperator.create(rowOffsets, colOffsets)","Create a rectangular BlockOperator with different row and column offsets.",[4664,4665],{"_16":4635,"_22":4636,"_69":6},{"_16":4638,"_22":4639,"_69":6},[],{"_16":4668,"_18":4669,"_20":4670,"_22":4671,"_24":4672,"_28":4657,"_30":4675},"mfem.block.BlockOperator.fromPointer","mfem.block.BlockOperator.fromPointer(ptr)","Creates a BlockOperator from an existing WASM pointer.\r","Creates a BlockOperator from an existing WASM pointer.\r\nUse with caution - the caller is responsible for pointer validity.",[4673],{"_16":4648,"_22":4674,"_69":6},"- WASM pointer to an existing MFEM BlockOperator",[],{"_16":4677,"_18":4678,"_20":4679,"_22":4679,"_24":4680,"_28":4683,"_30":4684},"mfem.block.BlockVector.create","mfem.block.BlockVector.create(offsets)","Create a new BlockVector with the specified block offsets.",[4681],{"_16":4625,"_22":4682,"_69":6},"- Array where offsets[i+1] - offsets[i] defines block i size","Promise",[],{"_16":4686,"_18":4687,"_20":4688,"_22":4689,"_24":4690,"_28":4683,"_30":4695},"mfem.block.BlockVector.fromPointer","mfem.block.BlockVector.fromPointer(ptr, offsets)","Creates a BlockVector from an existing WASM pointer.\r","Creates a BlockVector from an existing WASM pointer.\r\nUse with caution - the caller is responsible for pointer validity.",[4691,4693],{"_16":4648,"_22":4692,"_69":6},"- WASM pointer to an existing MFEM BlockVector",{"_16":4625,"_22":4694,"_69":6},"- Block offsets array",[],{"_16":4697,"_18":4698,"_20":4699,"_22":4699,"_24":4700,"_28":4713,"_30":4714},"mfem.boundaryConditions.addBoundaryRobinIntegrator","mfem.boundaryConditions.addBoundaryRobinIntegrator(blf, lf, alpha, g, bdrAttrs)","Add Robin boundary condition integrator (legacy name)",[4701,4703,4706,4708,4710],{"_16":4382,"_22":4702,"_69":6},"BilinearForm",{"_16":4704,"_22":4705,"_69":6},"lf","LinearForm",{"_16":4399,"_22":4707,"_69":6},"number | CoefficientLike_15",{"_16":4709,"_22":4707,"_69":6},"g",{"_16":4711,"_22":4712,"_69":6},"bdrAttrs","number[]","Promise",[],{"_16":4716,"_18":4717,"_20":4718,"_22":4719,"_24":4720,"_28":4713,"_30":4731},"mfem.boundaryConditions.addRobinBC","mfem.boundaryConditions.addRobinBC(bf, lf, alpha, g, bdrAttrs)","Add Robin boundary condition: alpha*u + du/dn = g\r","Add Robin boundary condition: alpha*u + du/dn = g\r\n\r\nThis function adds the necessary integrators to both the bilinear form\r\nand linear form to implement Robin boundary conditions on specified\r\nboundary attributes.",[4721,4723,4725,4727,4729],{"_16":4722,"_22":4383,"_69":6},"bf",{"_16":4704,"_22":4724,"_69":6},"- LinearForm instance",{"_16":4399,"_22":4726,"_69":6},"- Coefficient for u term (scalar value or CoefficientLike)",{"_16":4709,"_22":4728,"_69":6},"- RHS coefficient g (scalar value or CoefficientLike)",{"_16":4711,"_22":4730,"_69":6},"- Array of boundary attributes where Robin BC applies",[],{"_16":4733,"_18":4734,"_20":4735,"_22":4736,"_24":4737,"_28":1426,"_30":4746},"mfem.boundaryConditions.applyEssentialBC","mfem.boundaryConditions.applyEssentialBC(blf, essentialDofs, x, b)","Apply essential boundary conditions to a linear system.\r","Apply essential boundary conditions to a linear system.\r\nThis modifies the RHS vector to account for known Dirichlet values.",[4738,4740,4742,4744],{"_16":4382,"_22":4739,"_69":6},"- BilinearForm instance (system matrix)",{"_16":4559,"_22":4741,"_69":6},"- Array of essential DOF indices",{"_16":498,"_22":4743,"_69":6},"- GridFunction with Dirichlet values set",{"_16":436,"_22":4745,"_69":6},"- LinearForm (RHS) to modify",[],{"_16":4748,"_18":4749,"_20":4750,"_22":4751,"_24":4752,"_28":4757,"_30":4758},"mfem.boundaryConditions.createBdrMarkerArray","mfem.boundaryConditions.createBdrMarkerArray(mesh, bdrAttrs)","Create a boundary marker array from a mesh and list of boundary attributes.\r","Create a boundary marker array from a mesh and list of boundary attributes.\r\n\r\nThis function creates an array where each element corresponds to a boundary\r\nattribute. The value is 1 if the attribute is in the given list, 0 otherwise.",[4753,4755],{"_16":290,"_22":4754,"_69":6},"- Mesh instance",{"_16":4711,"_22":4756,"_69":6},"- Array of boundary attribute numbers to mark (1-based)","Int32Array",[],{"_16":4760,"_18":4761,"_20":4762,"_22":4763,"_24":4764,"_28":1426,"_30":4770},"mfem.boundaryConditions.eliminateEssentialBC","mfem.boundaryConditions.eliminateEssentialBC(blf, essentialDofs, diagPolicy?)","Eliminate essential boundary conditions from a bilinear form.\r","Eliminate essential boundary conditions from a bilinear form.\r\nModifies the system matrix to enforce the essential BCs.",[4765,4766,4767],{"_16":4382,"_22":4383,"_69":6},{"_16":4559,"_22":4741,"_69":6},{"_16":4768,"_22":4769,"_69":11},"diagPolicy","- Diagonal policy (default: DIAG_ONE)",[],{"_16":4772,"_18":4773,"_20":4774,"_22":4774,"_24":4775,"_28":4712,"_30":4779},"mfem.boundaryConditions.getEssentialTrueDofs","mfem.boundaryConditions.getEssentialTrueDofs(fespace, bdrAttrs)","Get essential true DOF indices for given boundary attributes.",[4776,4777],{"_16":4547,"_22":4548,"_69":6},{"_16":4711,"_22":4778,"_69":6},"- Array of boundary attribute numbers",[],{"_16":4781,"_18":4782,"_20":4783,"_22":4784,"_24":4785,"_28":4791,"_30":4792},"mfem.boundaryConditions.getPeriodicDofMapping","mfem.boundaryConditions.getPeriodicDofMapping(fespace, options)","Get periodic DOF correspondence for a finite element space.\r","Get periodic DOF correspondence for a finite element space.\r\n\r\nThis function computes which DOFs are identified as equivalent due to\r\nperiodicity, based on the provided translation vectors. DOFs whose\r\ncoordinates differ by a translation vector (within tolerance) are\r\nidentified as master/slave pairs.\r\n\r\n**Note:** In MFEM, periodic DOF identification is often handled internally\r\nthrough mesh vertex mapping when `Mesh::MakePeriodic` is called. This\r\nfunction provides explicit DOF mapping when needed for custom handling.",[4786,4788],{"_16":4547,"_22":4787,"_69":6},"- FiniteElementSpace (typically on a periodic mesh)",{"_16":4789,"_22":4790,"_69":6},"options","- Configuration including translation vectors and tolerance","Promise",[],{"_16":4794,"_18":4795,"_20":4796,"_22":4797,"_24":4798,"_28":4806,"_30":4807},"mfem.boundaryConditions.createPeriodicMesh","mfem.boundaryConditions.createPeriodicMesh(mesh, translations, tol?)","Create a periodic mesh from translation vectors.\r","Create a periodic mesh from translation vectors.\r\n\r\nThis function identifies vertices that should be treated as equivalent\r\nunder the given translations and creates a new mesh with these vertices\r\nmerged. The result is a mesh suitable for periodic boundary conditions.",[4799,4801,4804],{"_16":290,"_22":4800,"_69":6},"- Original mesh",{"_16":4802,"_22":4803,"_69":6},"translations","- Array of translation vectors defining periodicity.\r\n For 2D: `[[Lx, 0], [0, Ly]]` for x and y periodicity\r\n For 3D: `[[Lx, 0, 0], [0, Ly, 0], [0, 0, Lz]]`",{"_16":3719,"_22":4805,"_69":11},"- Tolerance for vertex matching (relative to mesh diameter).\r\n Default is 1e-8.","Promise",[],{"_16":4809,"_18":4810,"_20":4811,"_22":4811,"_24":4812,"_28":4815,"_30":4818},"mfem.boundaryConditions.makePeriodic","mfem.boundaryConditions.makePeriodic(_fespace, _mesh)","Create periodic finite element space (legacy name).",[4813,4816],{"_16":4814,"_22":4815,"_69":6},"_fespace","unknown",{"_16":4817,"_22":4815,"_69":6},"_mesh",[],{"_16":4820,"_18":4821,"_20":4822,"_22":4823,"_24":4824,"_28":4830,"_30":4831},"mfem.boundaryConditions.createPeriodicVertexMapping","mfem.boundaryConditions.createPeriodicVertexMapping(mesh, translations, tol?)","Create periodic vertex mapping from translation vectors.\r","Create periodic vertex mapping from translation vectors.\r\n\r\nThis function identifies which vertices should be treated as equivalent\r\nunder the given translations. The returned mapping array can be used\r\nwith `makePeriodic` for advanced use cases.\r\n\r\nFor most use cases, prefer `createPeriodicMesh` which handles both\r\nthe mapping and mesh creation in one step.",[4825,4827,4829],{"_16":290,"_22":4826,"_69":6},"- Mesh to analyze",{"_16":4802,"_22":4828,"_69":6},"- Array of translation vectors defining periodicity",{"_16":3719,"_22":4805,"_69":11},"Promise",[],{"_16":4833,"_18":4834,"_20":4835,"_22":4835,"_24":4836,"_28":1426,"_30":4841},"mfem.boundaryConditions.makePeriodicVertices","mfem.boundaryConditions.makePeriodicVertices(_mesh, _v2v)","Set periodic vertex mapping on mesh (legacy name).",[4837,4838],{"_16":4817,"_22":4815,"_69":6},{"_16":4839,"_22":4840,"_69":6},"_v2v","number[][]",[],{"_16":4843,"_18":4844,"_20":4845,"_22":4845,"_24":4846,"_28":4849,"_30":4850},"mfem.coefficients.constant","mfem.coefficients.constant(value)","Create a constant scalar coefficient.",[4847],{"_16":235,"_22":4848,"_69":6},"- Constant value","Promise",[],{"_16":4852,"_18":4853,"_20":4854,"_22":4854,"_24":4855,"_28":4862,"_30":4863},"mfem.coefficients.crossProduct","mfem.coefficients.crossProduct(v1, v2)","Create a cross product coefficient from two vector coefficients.",[4856,4859],{"_16":4857,"_22":4858,"_69":6},"v1","- First vector coefficient (must be 3D)",{"_16":4860,"_22":4861,"_69":6},"v2","- Second vector coefficient (must be 3D)","Promise",[],{"_16":4865,"_18":4866,"_20":4867,"_22":4867,"_24":4868,"_28":4871,"_30":4872},"mfem.coefficients.curl","mfem.coefficients.curl(gf)","Create a curl vector coefficient from a vector GridFunction.",[4869],{"_16":318,"_22":4870,"_69":6},"- Vector GridFunction instance","Promise",[],{"_16":4874,"_18":4875,"_20":4876,"_22":4876,"_24":4877,"_28":4883,"_30":4884},"mfem.coefficients.delta","mfem.coefficients.delta(center, weight?)","Create a Dirac delta coefficient (point source).",[4878,4880],{"_16":153,"_22":4879,"_69":6},"- Center point of the delta function",{"_16":4881,"_22":4882,"_69":11},"weight","- Weight (scale) of the delta function (defaults to 1.0)","Promise",[],{"_16":4886,"_18":4887,"_20":4888,"_22":4888,"_24":4889,"_28":4892,"_30":4893},"mfem.coefficients.diagonal","mfem.coefficients.diagonal(values)","Create a diagonal matrix coefficient from an array of values.",[4890],{"_16":2320,"_22":4891,"_69":6},"- Array of diagonal values","Promise",[],{"_16":4895,"_18":4896,"_20":4897,"_22":4897,"_24":4898,"_28":4900,"_30":4901},"mfem.coefficients.divergence","mfem.coefficients.divergence(gf)","Create a divergence scalar coefficient from a vector GridFunction.",[4899],{"_16":318,"_22":4870,"_69":6},"Promise",[],{"_16":4903,"_18":4904,"_20":4905,"_22":4905,"_24":4906,"_28":4910,"_30":4911},"mfem.coefficients.functionCoefficient","mfem.coefficients.functionCoefficient(fn)","Create a coefficient from a JavaScript function.",[4907],{"_16":4908,"_22":4909,"_69":6},"fn","- Function (x, y, z) => number","Promise",[],{"_16":4913,"_18":4914,"_20":4915,"_22":4915,"_24":4916,"_28":4919,"_30":4920},"mfem.coefficients.gradient","mfem.coefficients.gradient(gf)","Create a gradient vector coefficient from a scalar GridFunction.",[4917],{"_16":318,"_22":4918,"_69":6},"- Scalar GridFunction instance","Promise",[],{"_16":4922,"_18":4923,"_20":4924,"_22":4924,"_24":4925,"_28":4931,"_30":4932},"mfem.coefficients.gridFunctionCoefficient","mfem.coefficients.gridFunctionCoefficient(gf, component?)","Create a coefficient from a GridFunction.",[4926,4928],{"_16":318,"_22":4927,"_69":6},"- GridFunction instance",{"_16":4929,"_22":4930,"_69":11},"component","- Component to use (1-based, for vector GridFunctions)","Promise",[],{"_16":4934,"_18":4935,"_20":4936,"_22":4936,"_24":4937,"_28":4940,"_30":4941},"mfem.coefficients.identity","mfem.coefficients.identity(dim)","Create an identity matrix coefficient.",[4938],{"_16":828,"_22":4939,"_69":6},"- Dimension of the identity matrix","Promise",[],{"_16":4943,"_18":4944,"_20":4945,"_22":4945,"_24":4946,"_28":4951,"_30":4952},"mfem.coefficients.innerProduct","mfem.coefficients.innerProduct(v1, v2)","Create an inner product coefficient from two vector coefficients.",[4947,4949],{"_16":4857,"_22":4948,"_69":6},"- First vector coefficient",{"_16":4860,"_22":4950,"_69":6},"- Second vector coefficient","Promise",[],{"_16":4954,"_18":4955,"_20":4956,"_22":4956,"_24":4957,"_28":4960,"_30":4961},"mfem.coefficients.inverse","mfem.coefficients.inverse(m)","Create an inverse of a matrix coefficient.",[4958],{"_16":359,"_22":4959,"_69":6},"- Matrix coefficient to invert","Promise",[],{"_16":4963,"_18":4964,"_20":4965,"_22":4965,"_24":4966,"_28":4969,"_30":4970},"mfem.coefficients.matrixConstant","mfem.coefficients.matrixConstant(values)","Create a constant matrix coefficient.",[4967],{"_16":2320,"_22":4968,"_69":6},"- 2D array of values (row-major)","Promise",[],{"_16":4972,"_18":4973,"_20":4974,"_22":4974,"_24":4975,"_28":4983,"_30":4984},"mfem.coefficients.matrixFunction","mfem.coefficients.matrixFunction(fn, height, width?)","Create a matrix coefficient from a JavaScript function.",[4976,4978,4980],{"_16":4908,"_22":4977,"_69":6},"- Function (x, y, z) => number[][]",{"_16":174,"_22":4979,"_69":6},"- Number of rows",{"_16":4981,"_22":4982,"_69":11},"width","- Number of columns (defaults to height)","Promise",[],{"_16":4986,"_18":4987,"_20":4988,"_22":4988,"_24":4989,"_28":4994,"_30":4995},"mfem.coefficients.matrixProduct","mfem.coefficients.matrixProduct(a, b)","Create a matrix product coefficient from two matrix coefficients.",[4990,4992],{"_16":433,"_22":4991,"_69":6},"- First matrix coefficient",{"_16":436,"_22":4993,"_69":6},"- Second matrix coefficient","Promise",[],{"_16":4997,"_18":4998,"_20":4999,"_22":4999,"_24":5000,"_28":5003,"_30":5004},"mfem.coefficients.normalizedVector","mfem.coefficients.normalizedVector(v)","Create a normalized vector coefficient from a vector coefficient.",[5001],{"_16":2897,"_22":5002,"_69":6},"- Vector coefficient to normalize","Promise",[],{"_16":5006,"_18":5007,"_20":5008,"_22":5008,"_24":5009,"_28":5012,"_30":5013},"mfem.coefficients.outerProduct","mfem.coefficients.outerProduct(a, b)","Create an outer product coefficient from two vector coefficients.",[5010,5011],{"_16":433,"_22":4948,"_69":6},{"_16":436,"_22":4950,"_69":6},"Promise",[],{"_16":5015,"_18":5016,"_20":5017,"_22":5017,"_24":5018,"_28":5021,"_30":5022},"mfem.coefficients.piecewiseConstant","mfem.coefficients.piecewiseConstant(values)","Create a piecewise constant coefficient by element attribute.",[5019],{"_16":2320,"_22":5020,"_69":6},"- Map of attribute number (1-based) to value","Promise",[],{"_16":5024,"_18":5025,"_20":5026,"_22":5026,"_24":5027,"_28":5030,"_30":5031},"mfem.coefficients.position","mfem.coefficients.position(dim?)","Create a position vector coefficient that returns the spatial position x.",[5028],{"_16":828,"_22":5029,"_69":11},"- Spatial dimension (1, 2, or 3). Defaults to 3.","Promise",[],{"_16":5033,"_18":5034,"_20":5035,"_22":5035,"_24":5036,"_28":5042,"_30":5043},"mfem.coefficients.power","mfem.coefficients.power(c, exponent)","Create a power of a coefficient.",[5037,5039],{"_16":2644,"_22":5038,"_69":6},"- Base coefficient",{"_16":5040,"_22":5041,"_69":6},"exponent","- Exponent value","Promise",[],{"_16":5045,"_18":5046,"_20":5047,"_22":5047,"_24":5048,"_28":5053,"_30":5054},"mfem.coefficients.product","mfem.coefficients.product(c1, c2)","Create a product of two coefficients.",[5049,5051],{"_16":2726,"_22":5050,"_69":6},"- First coefficient",{"_16":2729,"_22":5052,"_69":6},"- Second coefficient","Promise",[],{"_16":5056,"_18":5057,"_20":5058,"_22":5058,"_24":5059,"_28":5063,"_30":5064},"mfem.coefficients.quadratureFunctionCoefficient","mfem.coefficients.quadratureFunctionCoefficient(qf)","Create a coefficient from a scalar quadrature function.",[5060],{"_16":5061,"_22":5062,"_69":6},"qf","- The quadrature function (vdim=1)","Promise",[],{"_16":5066,"_18":5067,"_20":5068,"_22":5068,"_24":5069,"_28":5072,"_30":5073},"mfem.coefficients.vectorQuadratureFunctionCoefficient","mfem.coefficients.vectorQuadratureFunctionCoefficient(qf)","Create a vector coefficient from a quadrature function.",[5070],{"_16":5061,"_22":5071,"_69":6},"- The quadrature function","Promise",[],{"_16":5075,"_18":5076,"_20":5077,"_22":5077,"_24":5078,"_28":5085,"_30":5086},"mfem.coefficients.restricted","mfem.coefficients.restricted(baseCoeff, attributes)","Create a restricted coefficient from a base coefficient.",[5079,5082],{"_16":5080,"_22":5081,"_69":6},"baseCoeff","- The base coefficient to restrict",{"_16":5083,"_22":5084,"_69":6},"attributes","- Array of mesh attributes where the coefficient is active (1-based)","Promise",[],{"_16":5088,"_18":5089,"_20":5090,"_22":5090,"_24":5091,"_28":5096,"_30":5097},"mfem.coefficients.scalarVectorProduct","mfem.coefficients.scalarVectorProduct(s, v)","Create a scalar-vector product coefficient.",[5092,5094],{"_16":3799,"_22":5093,"_69":6},"- Scalar coefficient",{"_16":2897,"_22":5095,"_69":6},"- Vector coefficient","Promise",[],{"_16":5099,"_18":5100,"_20":5101,"_22":5101,"_24":5102,"_28":5109,"_30":5110},"mfem.coefficients.sum","mfem.coefficients.sum(c1, c2, alpha?, beta?)","Create a sum of two coefficients.",[5103,5104,5105,5107],{"_16":2726,"_22":5050,"_69":6},{"_16":2729,"_22":5052,"_69":6},{"_16":4399,"_22":5106,"_69":11},"- Scale factor for c1 (default 1.0)",{"_16":2011,"_22":5108,"_69":11},"- Scale factor for c2 (default 1.0)","Promise",[],{"_16":5112,"_18":5113,"_20":5114,"_22":5114,"_24":5115,"_28":5120,"_30":5121},"mfem.coefficients.symmetric","mfem.coefficients.symmetric(fn, dim)","Create a symmetric matrix coefficient from a JavaScript function.",[5116,5118],{"_16":4908,"_22":5117,"_69":6},"- Function (position: number[]) => number[][]",{"_16":828,"_22":5119,"_69":6},"- Dimension of the symmetric matrix","Promise",[],{"_16":5123,"_18":5124,"_20":5125,"_22":5125,"_24":5126,"_28":5131,"_30":5132},"mfem.coefficients.transformed","mfem.coefficients.transformed(coeff, fn)","Create a transformed coefficient that applies a function to another coefficient.",[5127,5129],{"_16":4385,"_22":5128,"_69":6},"- Source coefficient to transform",{"_16":4908,"_22":5130,"_69":6},"- Transformation function (value) => transformedValue","Promise",[],{"_16":5134,"_18":5135,"_20":5136,"_22":5136,"_24":5137,"_28":5140,"_30":5141},"mfem.coefficients.transpose","mfem.coefficients.transpose(m)","Create a transpose of a matrix coefficient.",[5138],{"_16":359,"_22":5139,"_69":6},"- Matrix coefficient to transpose","Promise",[],{"_16":5143,"_18":5144,"_20":5145,"_22":5145,"_24":5146,"_28":5150,"_30":5151},"mfem.coefficients.vectorArray","mfem.coefficients.vectorArray(coeffs)","Create a vector coefficient from an array of scalar coefficients.",[5147],{"_16":5148,"_22":5149,"_69":6},"coeffs","- Array of scalar coefficients for each component","Promise",[],{"_16":5153,"_18":5154,"_20":5155,"_22":5155,"_24":5156,"_28":5159,"_30":5160},"mfem.coefficients.vectorConstant","mfem.coefficients.vectorConstant(values)","Create a constant vector coefficient.",[5157],{"_16":2320,"_22":5158,"_69":6},"- Array of constant values","Promise",[],{"_16":5162,"_18":5163,"_20":5164,"_22":5164,"_24":5165,"_28":5169,"_30":5170},"mfem.coefficients.vectorDelta","mfem.coefficients.vectorDelta(center, direction)","Create a vector Dirac delta coefficient (directional point source).",[5166,5167],{"_16":153,"_22":4879,"_69":6},{"_16":954,"_22":5168,"_69":6},"- Direction vector of the source","Promise",[],{"_16":5172,"_18":5173,"_20":5174,"_22":5174,"_24":5175,"_28":5180,"_30":5181},"mfem.coefficients.vectorFunction","mfem.coefficients.vectorFunction(fn, dim?)","Create a vector coefficient from a JavaScript function.",[5176,5178],{"_16":4908,"_22":5177,"_69":6},"- Function (x, y, z) => number[]",{"_16":828,"_22":5179,"_69":11},"- Output vector dimension (defaults to 3)","Promise",[],{"_16":5183,"_18":5184,"_20":5185,"_22":5185,"_24":5186,"_28":5189,"_30":5190},"mfem.coefficients.vectorRotProduct","mfem.coefficients.vectorRotProduct(a, b)","Create a 2D cross product (rotation product) of two vector coefficients.",[5187,5188],{"_16":433,"_22":4948,"_69":6},{"_16":436,"_22":4950,"_69":6},"Promise",[],{"_16":5192,"_18":5193,"_20":5194,"_22":5194,"_24":5195,"_28":4849,"_30":5198},"mfem.coefficients.ConstantCoefficient.create","mfem.coefficients.ConstantCoefficient.create(value)","Creates a new constant coefficient with the specified value.",[5196],{"_16":235,"_22":5197,"_69":6},"- The constant value",[],{"_16":5200,"_18":5201,"_20":5202,"_22":5202,"_24":5203,"_28":4871,"_30":5206},"mfem.coefficients.CurlCoefficient.create","mfem.coefficients.CurlCoefficient.create(gf)","Creates a new curl coefficient from a vector GridFunction.",[5204],{"_16":318,"_22":5205,"_69":6},"- The vector GridFunction whose curl to compute",[],{"_16":5208,"_18":5209,"_20":5210,"_22":5210,"_24":5211,"_28":4883,"_30":5215},"mfem.coefficients.DeltaCoefficient.create","mfem.coefficients.DeltaCoefficient.create(center, weight?)","Creates a new delta coefficient (point source).",[5212,5214],{"_16":153,"_22":5213,"_69":6},"- Center point of the delta function [x] or [x, y] or [x, y, z]",{"_16":4881,"_22":4882,"_69":11},[],{"_16":5217,"_18":5218,"_20":5219,"_22":5219,"_24":5220,"_28":4892,"_30":5223},"mfem.coefficients.DiagonalMatrixCoefficient.create","mfem.coefficients.DiagonalMatrixCoefficient.create(values)","Creates a new diagonal matrix coefficient.",[5221],{"_16":2320,"_22":5222,"_69":6},"- Array of diagonal values. The length determines the matrix dimension.",[],{"_16":5225,"_18":5226,"_20":5227,"_22":5227,"_24":5228,"_28":4900,"_30":5231},"mfem.coefficients.DivergenceCoefficient.create","mfem.coefficients.DivergenceCoefficient.create(gf)","Creates a new divergence coefficient from a vector GridFunction.",[5229],{"_16":318,"_22":5230,"_69":6},"- The vector GridFunction whose divergence to compute",[],{"_16":5233,"_18":5234,"_20":5235,"_22":5235,"_24":5236,"_28":4910,"_30":5239},"mfem.coefficients.FunctionCoefficient.create","mfem.coefficients.FunctionCoefficient.create(fn)","Creates a new function coefficient with the specified evaluation function.",[5237],{"_16":4908,"_22":5238,"_69":6},"- Function that takes (x, y, z) coordinates and returns a scalar value",[],{"_16":5241,"_18":5242,"_20":5243,"_22":5243,"_24":5244,"_28":4919,"_30":5247},"mfem.coefficients.GradientCoefficient.create","mfem.coefficients.GradientCoefficient.create(gf)","Creates a new gradient coefficient from a scalar GridFunction.",[5245],{"_16":318,"_22":5246,"_69":6},"- The scalar GridFunction whose gradient to compute",[],{"_16":5249,"_18":5250,"_20":5251,"_22":5251,"_24":5252,"_28":4931,"_30":5257},"mfem.coefficients.GridFunctionCoefficient.create","mfem.coefficients.GridFunctionCoefficient.create(gf, component?)","Creates a new GridFunction coefficient.",[5253,5255],{"_16":318,"_22":5254,"_69":6},"- The GridFunction to evaluate",{"_16":4929,"_22":5256,"_69":11},"- Component to use for vector GridFunctions (1-based, default 1)",[],{"_16":5259,"_18":5260,"_20":5261,"_22":5261,"_24":5262,"_28":4969,"_30":5269},"mfem.coefficients.MatrixConstantCoefficient.create","mfem.coefficients.MatrixConstantCoefficient.create(values, height?, width?)","Creates a new constant matrix coefficient with the specified values.",[5263,5265,5267],{"_16":2320,"_22":5264,"_69":6},"- 2D array of values (row-major) or 1D array with explicit dimensions",{"_16":174,"_22":5266,"_69":11},"- Number of rows (required if values is 1D array)",{"_16":4981,"_22":5268,"_69":11},"- Number of columns (required if values is 1D array)",[],{"_16":5271,"_18":5272,"_20":5273,"_22":5273,"_24":5274,"_28":4983,"_30":5280},"mfem.coefficients.MatrixFunctionCoefficient.create","mfem.coefficients.MatrixFunctionCoefficient.create(fn, height, width?)","Creates a new matrix function coefficient.",[5275,5277,5278],{"_16":4908,"_22":5276,"_69":6},"- Function that takes (x, y, z) and returns a 2D array",{"_16":174,"_22":4979,"_69":6},{"_16":4981,"_22":5279,"_69":11},"- Number of columns (defaults to height for square matrices)",[],{"_16":5282,"_18":5283,"_20":5284,"_22":5284,"_24":5285,"_28":4994,"_30":5288},"mfem.coefficients.MatrixProductCoefficient.create","mfem.coefficients.MatrixProductCoefficient.create(a, b)","Creates a new matrix product coefficient: A * B",[5286,5287],{"_16":433,"_22":4991,"_69":6},{"_16":436,"_22":4993,"_69":6},[],{"_16":5290,"_18":5291,"_20":5292,"_22":5292,"_24":5293,"_28":5003,"_30":5295},"mfem.coefficients.NormalizedVectorCoefficient.create","mfem.coefficients.NormalizedVectorCoefficient.create(v)","Creates a new normalized vector coefficient: v / ||v||",[5294],{"_16":2897,"_22":5002,"_69":6},[],{"_16":5297,"_18":5298,"_20":5299,"_22":5299,"_24":5300,"_28":5021,"_30":5303},"mfem.coefficients.PWConstCoefficient.create","mfem.coefficients.PWConstCoefficient.create(values)","Creates a new piecewise constant coefficient.",[5301],{"_16":2320,"_22":5302,"_69":6},"- Array of values for each attribute (index i corresponds to attribute i+1)",[],{"_16":5305,"_18":5306,"_20":5307,"_22":5307,"_24":5308,"_28":5021,"_30":5312},"mfem.coefficients.PWConstCoefficient.createFromMap","mfem.coefficients.PWConstCoefficient.createFromMap(attrValues)","Creates a new piecewise constant coefficient from a Map.",[5309],{"_16":5310,"_22":5311,"_69":6},"attrValues","- Map of attribute numbers (1-based) to values",[],{"_16":5314,"_18":5315,"_20":5316,"_22":5316,"_24":5317,"_28":5030,"_30":5319},"mfem.coefficients.PositionVectorCoefficient.create","mfem.coefficients.PositionVectorCoefficient.create(dim?)","Creates a new position vector coefficient.",[5318],{"_16":828,"_22":5029,"_69":11},[],{"_16":5321,"_18":5322,"_20":5323,"_22":5323,"_24":5324,"_28":5042,"_30":5328},"mfem.coefficients.PowerCoefficient.create","mfem.coefficients.PowerCoefficient.create(c, exponent)","Creates a new power coefficient: c^p",[5325,5326],{"_16":2644,"_22":5038,"_69":6},{"_16":5040,"_22":5327,"_69":6},"- Power exponent",[],{"_16":5330,"_18":5331,"_20":5332,"_22":5332,"_24":5333,"_28":5053,"_30":5336},"mfem.coefficients.ProductCoefficient.create","mfem.coefficients.ProductCoefficient.create(c1, c2)","Creates a new product coefficient: c1 * c2",[5334,5335],{"_16":2726,"_22":5050,"_69":6},{"_16":2729,"_22":5052,"_69":6},[],{"_16":5338,"_18":5339,"_20":5340,"_22":5340,"_24":5341,"_28":5063,"_30":5344},"mfem.coefficients.QuadratureFunctionCoefficient.create","mfem.coefficients.QuadratureFunctionCoefficient.create(qf)","Creates a new coefficient from a scalar quadrature function.",[5342],{"_16":5061,"_22":5343,"_69":6},"- The quadrature function (must have vdim=1)",[],{"_16":5346,"_18":5347,"_20":5348,"_22":5348,"_24":5349,"_28":5072,"_30":5351},"mfem.coefficients.VectorQuadratureFunctionCoefficient.create","mfem.coefficients.VectorQuadratureFunctionCoefficient.create(qf)","Creates a new vector coefficient from a quadrature function.",[5350],{"_16":5061,"_22":5071,"_69":6},[],{"_16":5353,"_18":5354,"_20":5355,"_22":5355,"_24":5356,"_28":5085,"_30":5359},"mfem.coefficients.RestrictedCoefficient.create","mfem.coefficients.RestrictedCoefficient.create(baseCoeff, attributes)","Creates a new restricted coefficient.",[5357,5358],{"_16":5080,"_22":5081,"_69":6},{"_16":5083,"_22":5084,"_69":6},[],{"_16":5361,"_18":5362,"_20":5363,"_22":5363,"_24":5364,"_28":5096,"_30":5367},"mfem.coefficients.ScalarVectorProductCoefficient.create","mfem.coefficients.ScalarVectorProductCoefficient.create(s, v)","Creates a new scalar-vector product coefficient: s * v",[5365,5366],{"_16":3799,"_22":5093,"_69":6},{"_16":2897,"_22":5095,"_69":6},[],{"_16":5369,"_18":5370,"_20":5371,"_22":5371,"_24":5372,"_28":5109,"_30":5377},"mfem.coefficients.SumCoefficient.create","mfem.coefficients.SumCoefficient.create(c1, c2, alpha?, beta?)","Creates a new sum coefficient: alpha * c1 + beta * c2",[5373,5374,5375,5376],{"_16":2726,"_22":5050,"_69":6},{"_16":2729,"_22":5052,"_69":6},{"_16":4399,"_22":5106,"_69":11},{"_16":2011,"_22":5108,"_69":11},[],{"_16":5379,"_18":5380,"_20":5381,"_22":5381,"_24":5382,"_28":5120,"_30":5386},"mfem.coefficients.SymmetricMatrixCoefficient.create","mfem.coefficients.SymmetricMatrixCoefficient.create(fn, dim)","Creates a new symmetric matrix function coefficient.",[5383,5385],{"_16":4908,"_22":5384,"_69":6},"- Function that takes position [x, y, z] and returns a symmetric 2D array",{"_16":828,"_22":5119,"_69":6},[],{"_16":5388,"_18":5389,"_20":5390,"_22":5390,"_24":5391,"_28":5131,"_30":5394},"mfem.coefficients.TransformedCoefficient.create","mfem.coefficients.TransformedCoefficient.create(coeff, fn)","Creates a new transformed coefficient: F(Q)",[5392,5393],{"_16":4385,"_22":5128,"_69":6},{"_16":4908,"_22":5130,"_69":6},[],{"_16":5396,"_18":5397,"_20":5398,"_22":5398,"_24":5399,"_28":5150,"_30":5402},"mfem.coefficients.VectorArrayCoefficient.create","mfem.coefficients.VectorArrayCoefficient.create(dim)","Creates a new vector array coefficient of the specified dimension.",[5400],{"_16":828,"_22":5401,"_69":6},"- Vector dimension",[],{"_16":5404,"_18":5405,"_20":5406,"_22":5406,"_24":5407,"_28":5159,"_30":5410},"mfem.coefficients.VectorConstantCoefficient.create","mfem.coefficients.VectorConstantCoefficient.create(values)","Creates a new constant vector coefficient with the specified values.",[5408],{"_16":2320,"_22":5409,"_69":6},"- Array of constant values for each component",[],{"_16":5412,"_18":5413,"_20":5414,"_22":5414,"_24":5415,"_28":5169,"_30":5419},"mfem.coefficients.VectorDeltaCoefficient.create","mfem.coefficients.VectorDeltaCoefficient.create(center, direction)","Creates a new vector delta coefficient (directional point source).",[5416,5417],{"_16":153,"_22":5213,"_69":6},{"_16":954,"_22":5418,"_69":6},"- Direction vector of the source (must match spatial dimension)",[],{"_16":5421,"_18":5422,"_20":5423,"_22":5423,"_24":5424,"_28":5180,"_30":5429},"mfem.coefficients.VectorFunctionCoefficient.create","mfem.coefficients.VectorFunctionCoefficient.create(fn, dim)","Creates a new vector function coefficient.",[5425,5427],{"_16":4908,"_22":5426,"_69":6},"- Function that takes (x, y, z) and returns a vector",{"_16":828,"_22":5428,"_69":6},"- Output vector dimension",[],{"_16":5431,"_18":5432,"_20":5433,"_22":5433,"_24":5434,"_28":5189,"_30":5437},"mfem.coefficients.VectorRotProductCoefficient.create","mfem.coefficients.VectorRotProductCoefficient.create(a, b)","Creates a new VectorRotProductCoefficient: A_x * B_y - A_y * B_x",[5435,5436],{"_16":433,"_22":4948,"_69":6},{"_16":436,"_22":4950,"_69":6},[],{"_16":5439,"_18":5440,"_20":5441,"_22":5442,"_24":5443,"_28":5450,"_30":5451},"mfem.eigenvalue.getEigenvalues","mfem.eigenvalue.getEigenvalues(solver, numEigs?)","Get computed eigenvalues after solve.\r","Get computed eigenvalues after solve.\r\n\r\nCall this after solve() to retrieve the computed eigenvalues.\r\nIf numEigs is not specified, returns all converged eigenvalues.",[5444,5447],{"_16":5445,"_22":5446,"_69":6},"solver","- LOBPCG solver instance with solved eigenvalues",{"_16":5448,"_22":5449,"_69":11},"numEigs","- Number of eigenvalues to retrieve (defaults to number of converged)","Float64Array",[],{"_16":5453,"_18":5454,"_20":5455,"_22":5456,"_24":5457,"_28":5461,"_30":5462},"mfem.eigenvalue.getEigenvectors","mfem.eigenvalue.getEigenvectors(eigenvectorMatrix)","getEigenvectors","",[5458],{"_16":5459,"_22":5460,"_69":6},"eigenvectorMatrix","DenseMatrix","Float64Array[]",[],{"_16":5464,"_18":5465,"_20":5466,"_22":5467,"_24":5468,"_28":1426,"_30":5474},"mfem.eigenvalue.setNumModes","mfem.eigenvalue.setNumModes(solver, numModes)","Set the number of eigenvalues/eigenvectors to compute.\r","Set the number of eigenvalues/eigenvectors to compute.\r\n\r\nThis should match the number of columns in the eigenvector DenseMatrix\r\npassed to solve().",[5469,5471],{"_16":5445,"_22":5470,"_69":6},"- LOBPCG solver instance",{"_16":5472,"_22":5473,"_69":6},"numModes","- Number of eigenpairs to compute",[],{"_16":5476,"_18":5477,"_20":5478,"_22":5479,"_24":5480,"_28":1426,"_30":5486},"mfem.eigenvalue.setOperators","mfem.eigenvalue.setOperators(solver, A, B?)","Set A and B operators for generalized eigenvalue problem Ax = λBx.\r","Set A and B operators for generalized eigenvalue problem Ax = λBx.\r\n\r\nFor standard eigenvalue problems (Ax = λx), only pass A.\r\nFor generalized problems (Ax = λBx), pass both A and B.",[5481,5482,5484],{"_16":5445,"_22":5470,"_69":6},{"_16":659,"_22":5483,"_69":6},"- Stiffness matrix/operator A (e.g., SparseMatrix, BilinearForm)",{"_16":656,"_22":5485,"_69":11},"- Mass matrix/operator B for generalized problem (optional)",[],{"_16":5488,"_18":5489,"_20":5490,"_22":5491,"_24":5492,"_28":1426,"_30":5498},"mfem.eigenvalue.solve","mfem.eigenvalue.solve(solver, eigenvectors)","Solve the eigenvalue problem using LOBPCG.\r","Solve the eigenvalue problem using LOBPCG.\r\n\r\nSolves: Ax = λBx (generalized) or Ax = λx (standard if B is not set)\r\n\r\nThe eigenvectors will be stored as columns in the provided DenseMatrix.\r\nThe matrix should be pre-allocated with dimensions [nDofs × numModes].",[5493,5495],{"_16":5445,"_22":5494,"_69":6},"- LOBPCG solver instance (must have operators set)",{"_16":5496,"_22":5497,"_69":6},"eigenvectors","- DenseMatrix to store computed eigenvectors (columns are eigenvectors)",[],{"_16":5500,"_18":5501,"_20":5502,"_22":5503,"_24":5504,"_28":5508,"_30":5509},"mfem.eigenvalue.DenseMatrix.create","mfem.eigenvalue.DenseMatrix.create(height, width)","Creates a new dense matrix of specified dimensions.\r","Creates a new dense matrix of specified dimensions.\r\nElements are uninitialized.",[5505,5506],{"_16":174,"_22":4979,"_69":6},{"_16":4981,"_22":5507,"_69":6},"- Number of columns","Promise",[],{"_16":5511,"_18":5512,"_20":5513,"_22":5513,"_24":5514,"_28":5508,"_30":5517},"mfem.eigenvalue.DenseMatrix.zeros","mfem.eigenvalue.DenseMatrix.zeros(height, width)","Creates a zero matrix of specified dimensions.",[5515,5516],{"_16":174,"_22":4979,"_69":6},{"_16":4981,"_22":5507,"_69":6},[],{"_16":5519,"_18":5520,"_20":5521,"_22":5521,"_24":5522,"_28":5508,"_30":5525},"mfem.eigenvalue.DenseMatrix.identity","mfem.eigenvalue.DenseMatrix.identity(n)","Creates an identity matrix of size n x n.",[5523],{"_16":362,"_22":5524,"_69":6},"- Matrix dimension",[],{"_16":5527,"_18":5528,"_20":5529,"_22":5529,"_24":5530,"_28":5508,"_30":5533},"mfem.eigenvalue.DenseMatrix.fromArray","mfem.eigenvalue.DenseMatrix.fromArray(data)","Creates a DenseMatrix from a 2D array.",[5531],{"_16":84,"_22":5532,"_69":6},"- 2D array in row-major order (data[row][col])",[],{"_16":5535,"_18":5536,"_20":5537,"_22":5538,"_24":5539,"_28":5508,"_30":5545},"mfem.eigenvalue.DenseMatrix.fromPointer","mfem.eigenvalue.DenseMatrix.fromPointer(ptr, ownsMemory?)","Creates a DenseMatrix from an existing WASM pointer.\r","Creates a DenseMatrix from an existing WASM pointer.\r\nUse with caution - the caller is responsible for pointer validity.",[5540,5542],{"_16":4648,"_22":5541,"_69":6},"- WASM pointer to an existing MFEM DenseMatrix",{"_16":5543,"_22":5544,"_69":11},"ownsMemory","- Whether this wrapper owns the memory (default: false)",[],{"_16":5547,"_18":5548,"_20":5549,"_22":5549,"_24":5550,"_28":5551,"_30":5552},"mfem.eigenvalue.LOBPCGSolver.create","mfem.eigenvalue.LOBPCGSolver.create()","Creates a new LOBPCG solver.",[],"Promise",[],{"_16":5554,"_18":5555,"_20":5556,"_22":5557,"_24":5558,"_28":5567,"_30":5568},"mfem.fespace.createDG","mfem.fespace.createDG(mesh, order, vdim?)","Creates a Discontinuous Galerkin (DG) finite element space.\r","Creates a Discontinuous Galerkin (DG) finite element space.\r\n\r\nThis is an alias for . DG spaces are L2 spaces used in\r\nDiscontinuous Galerkin methods, where numerical fluxes connect elements.\r\n\r\nDG methods are popular for:\r\n- Hyperbolic conservation laws\r\n- Advection-dominated transport\r\n- Problems with sharp gradients or shocks\r\n- hp-adaptivity",[5559,5561,5564],{"_16":290,"_22":5560,"_69":6},"- The mesh on which to define the space",{"_16":5562,"_22":5563,"_69":6},"order","- Polynomial order (0 = piecewise constant, 1 = linear, etc.)",{"_16":5565,"_22":5566,"_69":11},"vdim","- Vector dimension (default 1 for scalar fields)","Promise",[],{"_16":5570,"_18":5571,"_20":5572,"_22":5573,"_24":5574,"_28":5567,"_30":5579},"mfem.fespace.createH1","mfem.fespace.createH1(mesh, order, vdim?)","Creates an H1 (continuous Lagrange) finite element space.\r","Creates an H1 (continuous Lagrange) finite element space.\r\n\r\nH1 spaces use continuous piecewise polynomial functions that are globally\r\nconforming in H1 (functions with square-integrable first derivatives).\r\nThey are the most common choice for:\r\n- Scalar problems (heat transfer, Poisson equation)\r\n- Vector problems (elasticity, Stokes flow)",[5575,5576,5578],{"_16":290,"_22":5560,"_69":6},{"_16":5562,"_22":5577,"_69":6},"- Polynomial order (1 = linear, 2 = quadratic, 3 = cubic, etc.)",{"_16":5565,"_22":5566,"_69":11},[],{"_16":5581,"_18":5582,"_20":5583,"_22":5584,"_24":5585,"_28":5567,"_30":5590},"mfem.fespace.createH1Positive","mfem.fespace.createH1Positive(mesh, order, vdim?)","Creates an H1 finite element space with positive (Bernstein) basis.\r","Creates an H1 finite element space with positive (Bernstein) basis.\r\n\r\nBernstein basis functions are non-negative and form a partition of unity,\r\nmaking them ideal for applications requiring positivity preservation:\r\n- Concentration fields that must remain positive\r\n- Probability distributions\r\n- NURBS-like representations\r\n\r\nThe space has the same approximation properties as standard H1 but with\r\ndifferent basis function properties.",[5586,5587,5589],{"_16":290,"_22":5560,"_69":6},{"_16":5562,"_22":5588,"_69":6},"- Polynomial order (1 = linear, 2 = quadratic, etc.)",{"_16":5565,"_22":5566,"_69":11},[],{"_16":5592,"_18":5593,"_20":5594,"_22":5595,"_24":5596,"_28":5567,"_30":5601},"mfem.fespace.createHcurl","mfem.fespace.createHcurl(mesh, order)","Creates an H(curl) (Nedelec) finite element space.\r","Creates an H(curl) (Nedelec) finite element space.\r\n\r\nH(curl) spaces are designed for vector fields where the curl is well-defined\r\nand square-integrable. They are essential for:\r\n- Electromagnetics (electric field, magnetic vector potential)\r\n- Maxwell's equations\r\n- Edge element discretizations\r\n\r\nThe tangential component is continuous across element faces while the\r\nnormal component may be discontinuous.",[5597,5599],{"_16":290,"_22":5598,"_69":6},"- The mesh on which to define the space (must be 2D or 3D)",{"_16":5562,"_22":5600,"_69":6},"- Polynomial order (1 = lowest order Nedelec, etc.)",[],{"_16":5603,"_18":5604,"_20":5605,"_22":5606,"_24":5607,"_28":5567,"_30":5611},"mfem.fespace.createHdiv","mfem.fespace.createHdiv(mesh, order)","Creates an H(div) (Raviart-Thomas) finite element space.\r","Creates an H(div) (Raviart-Thomas) finite element space.\r\n\r\nH(div) spaces are designed for vector fields where the divergence is\r\nwell-defined and square-integrable. They are essential for:\r\n- Fluid flow (velocity fields)\r\n- Mixed finite element methods\r\n- Darcy flow and porous media\r\n- Magnetic flux density in electromagnetics\r\n\r\nThe normal component is continuous across element faces while the\r\ntangential component may be discontinuous.",[5608,5609],{"_16":290,"_22":5598,"_69":6},{"_16":5562,"_22":5610,"_69":6},"- Polynomial order (0 = lowest order RT, etc.)",[],{"_16":5613,"_18":5614,"_20":5615,"_22":5616,"_24":5617,"_28":5567,"_30":5621},"mfem.fespace.createL2","mfem.fespace.createL2(mesh, order, vdim?)","Creates an L2 (discontinuous) finite element space.\r","Creates an L2 (discontinuous) finite element space.\r\n\r\nL2 spaces use piecewise polynomial functions with no continuity constraints\r\nacross element boundaries. This allows for:\r\n- Discontinuous Galerkin (DG) methods\r\n- Higher accuracy for advection-dominated problems\r\n- Local conservation properties\r\n- Representation of discontinuous fields\r\n\r\nL2 spaces have more DOFs than H1 spaces for the same mesh and order,\r\nas each element has its own independent polynomial representation.",[5618,5619,5620],{"_16":290,"_22":5560,"_69":6},{"_16":5562,"_22":5563,"_69":6},{"_16":5565,"_22":5566,"_69":11},[],{"_16":5623,"_18":5624,"_20":5625,"_22":5626,"_24":5627,"_28":5567,"_30":5631},"mfem.fespace.createND","mfem.fespace.createND(mesh, order)","Creates a Nedelec (ND) finite element space.\r","Creates a Nedelec (ND) finite element space.\r\n\r\nThis is an alias for . Nedelec elements are edge elements\r\nthat conform to H(curl), named after Jean-Claude Nédélec who introduced them.\r\n\r\nCommon applications:\r\n- Electric field in electromagnetics\r\n- Magnetic vector potential\r\n- Any vector field where curl is the primary differential operator",[5628,5629],{"_16":290,"_22":5598,"_69":6},{"_16":5562,"_22":5630,"_69":6},"- Polynomial order (1 = lowest order, etc.)",[],{"_16":5633,"_18":5634,"_20":5635,"_22":5636,"_24":5637,"_28":5643,"_30":5644},"mfem.fespace.createNURBS","mfem.fespace.createNURBS(mesh, order?, vdim?)","Creates a NURBS finite element space.\r","Creates a NURBS finite element space.\r\n\r\nNURBS (Non-Uniform Rational B-Splines) spaces are used for isogeometric\r\nanalysis (IGA), where the same basis functions used for CAD geometry\r\nrepresentation are used for the finite element analysis. This provides\r\nexact geometry representation and higher continuity across elements.\r\n\r\nThe mesh must be a NURBS mesh (created from NURBS patch data). Standard\r\nmeshes created with `makeCartesian2D` or similar functions cannot be used.",[5638,5640,5642],{"_16":290,"_22":5639,"_69":6},"- A NURBS mesh instance (must have NURBS extension)",{"_16":5562,"_22":5641,"_69":11},"- Polynomial order. Use -1 or 0 for variable order (uses\r\n the mesh's native NURBS order from each patch)",{"_16":5565,"_22":5566,"_69":11},"FiniteElementSpace",[],{"_16":5646,"_18":5647,"_20":5648,"_22":5649,"_24":5650,"_28":5567,"_30":5654},"mfem.fespace.createRT","mfem.fespace.createRT(mesh, order)","Creates a Raviart-Thomas (RT) finite element space.\r","Creates a Raviart-Thomas (RT) finite element space.\r\n\r\nThis is an alias for . Raviart-Thomas elements are face\r\nelements that conform to H(div), named after Pierre-Arnaud Raviart and\r\nJean-Marie Thomas who introduced them.\r\n\r\nCommon applications:\r\n- Velocity in mixed formulations\r\n- Flux variables in conservation laws\r\n- Magnetic flux density",[5651,5652],{"_16":290,"_22":5598,"_69":6},{"_16":5562,"_22":5653,"_69":6},"- Polynomial order (0 = lowest order, etc.)",[],{"_16":5656,"_18":5657,"_20":5658,"_22":5659,"_24":5660,"_28":5662,"_30":5663},"mfem.fespace.getAllDofCoordinates","mfem.fespace.getAllDofCoordinates(fespace)","Gets the physical coordinates for all degrees of freedom in a finite element space.\r","Gets the physical coordinates for all degrees of freedom in a finite element space.\r\n\r\nThis function iterates over all elements in the mesh and collects the physical\r\ncoordinates of each DOF. For DOFs shared between elements, the coordinates from\r\nthe first encountered element are used.\r\n\r\n**Performance note:** This function allocates temporary WASM memory and iterates\r\nover all elements. For large meshes, consider caching the result.",[5661],{"_16":4547,"_22":4605,"_69":6},"Promise>",[],{"_16":5665,"_18":5666,"_20":5667,"_22":5668,"_24":5669,"_28":4712,"_30":5674},"mfem.fespace.getBoundaryDofs","mfem.fespace.getBoundaryDofs(fespace, bdrAttr)","Gets the DOF indices on a boundary with a specific attribute.\r","Gets the DOF indices on a boundary with a specific attribute.\r\n\r\nReturns the true (global) DOF indices that lie on boundary elements\r\nwith the specified attribute. This is useful for applying Dirichlet\r\nboundary conditions on specific parts of the domain boundary.",[5670,5671],{"_16":4547,"_22":4605,"_69":6},{"_16":5672,"_22":5673,"_69":6},"bdrAttr","- The boundary attribute (1-based, as defined in the mesh)",[],{"_16":5676,"_18":5677,"_20":5678,"_22":5679,"_24":5680,"_28":4757,"_30":5685},"mfem.fespace.getDofMap","mfem.fespace.getDofMap(fespace, elemIndex)","Gets the DOF indices for a specific element.\r","Gets the DOF indices for a specific element.\r\n\r\nReturns the global DOF indices associated with the specified element.\r\nThis is useful for assembling local element contributions into global\r\nmatrices and vectors.",[5681,5682],{"_16":4547,"_22":4605,"_69":6},{"_16":5683,"_22":5684,"_69":6},"elemIndex","- The element index (0-based)",[],{"_16":5687,"_18":5688,"_20":5689,"_22":5690,"_24":5691,"_28":4712,"_30":5695},"mfem.fespace.getEssentialDofs","mfem.fespace.getEssentialDofs(fespace, bdrAttrs)","Gets the essential (Dirichlet) DOF indices for specified boundary attributes.\r","Gets the essential (Dirichlet) DOF indices for specified boundary attributes.\r\n\r\nReturns the true (global) DOF indices that should be constrained for\r\nDirichlet boundary conditions on the specified boundary attributes.\r\nMultiple boundary attributes can be specified to get DOFs from several\r\nboundary regions at once.",[5692,5693],{"_16":4547,"_22":4605,"_69":6},{"_16":4711,"_22":5694,"_69":6},"- Array of boundary attributes (1-based, as defined in the mesh)",[],{"_16":5697,"_18":5698,"_20":5699,"_22":5700,"_24":5701,"_28":5703,"_30":5704},"mfem.fespace.order","mfem.fespace.order(fespace)","Gets the maximum polynomial order of the finite element space.\r","Gets the maximum polynomial order of the finite element space.\r\n\r\nFor spaces with variable order (hp-adaptivity), this returns the\r\nmaximum order across all elements.",[5702],{"_16":4547,"_22":4605,"_69":6},"number",[],{"_16":5706,"_18":5707,"_20":5572,"_22":5708,"_24":5709,"_28":5567,"_30":5714},"mfem.fespace.FiniteElementSpace.createH1","mfem.fespace.FiniteElementSpace.createH1(mesh, order, vdim?)","Creates an H1 (continuous Lagrange) finite element space.\r\n\r\nH1 spaces use continuous piecewise polynomial functions. They are the most\r\ncommon choice for scalar problems like heat transfer, and for vector problems\r\nlike elasticity.\r\n\r\n**Basis functions:**\r\n- Order 1: Linear (nodal values at vertices)\r\n- Order 2: Quadratic (nodal values at vertices and edge midpoints)\r\n- Order p: Polynomial of degree p",[5710,5711,5712],{"_16":290,"_22":5560,"_69":6},{"_16":5562,"_22":5588,"_69":6},{"_16":5565,"_22":5713,"_69":11},"- Vector dimension (default 1 for scalar fields, 2 or 3 for vector fields)",[],{"_16":5716,"_18":5717,"_20":5718,"_22":5719,"_24":5720,"_28":5703,"_30":5726},"mfem.gridfunction.computeError","mfem.gridfunction.computeError(gf, exactValue)","Computes the L2 error between a grid function and a constant exact solution.\r","Computes the L2 error between a grid function and a constant exact solution.\r\n\r\nThe L2 error is defined as:\r\n```\r\n||u - u_exact||_L2 = sqrt( ∫_Ω |u(x) - u_exact|² dx )\r\n```\r\n\r\nThis is useful for verifying solutions against known manufactured solutions\r\nor for convergence studies.",[5721,5723],{"_16":318,"_22":5722,"_69":6},"- GridFunction (numerical solution)",{"_16":5724,"_22":5725,"_69":6},"exactValue","- The constant exact solution value",[],{"_16":5728,"_18":5729,"_20":5730,"_22":5731,"_24":5732,"_28":5703,"_30":5741},"mfem.gridfunction.computeH1Error","mfem.gridfunction.computeH1Error(gf, coeffPtr?, dcoeffPtr?)","Computes the H1 error between a grid function and an exact solution.\r","Computes the H1 error between a grid function and an exact solution.\r\n\r\nThe H1 error combines the L2 error of the function and its gradient:\r\n||u - u_exact||_H1 = sqrt(||u - u_exact||²_L2 + ||∇u - ∇u_exact||²_L2)\r\n\r\nYou can provide either or both of:\r\n- The exact solution coefficient (for the L2 part)\r\n- The gradient of the exact solution (for the gradient part)",[5733,5735,5738],{"_16":318,"_22":5734,"_69":6},"- The grid function (numerical solution)",{"_16":5736,"_22":5737,"_69":11},"coeffPtr","- Pointer to Coefficient for exact solution (or 0 to skip L2 part)",{"_16":5739,"_22":5740,"_69":11},"dcoeffPtr","- Pointer to VectorCoefficient for exact gradient (or 0 to skip gradient part)",[],{"_16":5743,"_18":5744,"_20":5745,"_22":5746,"_24":5747,"_28":5703,"_30":5751},"mfem.gridfunction.computeL2ErrorCoeff","mfem.gridfunction.computeL2ErrorCoeff(gf, coeffPtr)","Computes the L2 error between a grid function and an exact solution\r","Computes the L2 error between a grid function and an exact solution\r\nrepresented as a scalar coefficient.\r\n\r\nThe L2 error is defined as:\r\n||u - u_exact||_L2 = sqrt(∫ |u(x) - u_exact(x)|² dx)",[5748,5749],{"_16":318,"_22":5734,"_69":6},{"_16":5736,"_22":5750,"_69":6},"- Pointer to a Coefficient representing the exact solution",[],{"_16":5753,"_18":5754,"_20":5755,"_22":5756,"_24":5757,"_28":5703,"_30":5763},"mfem.gridfunction.computeL2ErrorVCoeff","mfem.gridfunction.computeL2ErrorVCoeff(gf, vcoeffPtr)","Computes the L2 error between a vector grid function and an exact solution\r","Computes the L2 error between a vector grid function and an exact solution\r\nrepresented as a vector coefficient.\r\n\r\nThe L2 error is defined as:\r\n||u - u_exact||_L2 = sqrt(∫ |u(x) - u_exact(x)|² dx)\r\n\r\nwhere |·| is the Euclidean norm of the vector difference.",[5758,5760],{"_16":318,"_22":5759,"_69":6},"- The vector grid function (numerical solution)",{"_16":5761,"_22":5762,"_69":6},"vcoeffPtr","- Pointer to a VectorCoefficient representing the exact solution",[],{"_16":5765,"_18":5766,"_20":5767,"_22":5768,"_24":5769,"_28":5703,"_30":5772},"mfem.gridfunction.computeMaxError","mfem.gridfunction.computeMaxError(gf, coeffPtr)","Computes the maximum (L-infinity) error between a grid function and\r","Computes the maximum (L-infinity) error between a grid function and\r\nan exact solution represented as a coefficient.\r\n\r\nThe max error is defined as:\r\n||u - u_exact||_L∞ = max_x |u(x) - u_exact(x)|\r\n\r\nThis is useful for checking pointwise accuracy of a solution.",[5770,5771],{"_16":318,"_22":5734,"_69":6},{"_16":5736,"_22":5750,"_69":6},[],{"_16":5774,"_18":5775,"_20":5776,"_22":5777,"_24":5778,"_28":5703,"_30":5787},"mfem.gridfunction.computeW11Error","mfem.gridfunction.computeW11Error(gf, coeffPtr?, dcoeffPtr?, normType?)","Computes the W^{1,1} error between a grid function and an exact solution.\r","Computes the W^{1,1} error between a grid function and an exact solution.\r\n\r\nThe W^{1,1} norm uses L1 integrals instead of L2:\r\n||u - u_exact||_{W^{1,1}} = ∫ |u - u_exact| dx + ∫ |∇u - ∇u_exact| dx\r\n\r\nThis error measure is more robust to outliers than L2-based errors.",[5779,5780,5782,5784],{"_16":318,"_22":5734,"_69":6},{"_16":5736,"_22":5781,"_69":11},"- Pointer to Coefficient for exact solution (or 0 to skip)",{"_16":5739,"_22":5783,"_69":11},"- Pointer to VectorCoefficient for exact gradient (or 0 to skip)",{"_16":5785,"_22":5786,"_69":11},"normType","- Which components to include (default: BOTH)",[],{"_16":5789,"_18":5790,"_20":5791,"_22":5792,"_24":5793,"_28":5798,"_30":5799},"mfem.gridfunction.fromBinary","mfem.gridfunction.fromBinary(fespace, data)","Loads a grid function from a base64-encoded binary string with an existing FE space.\r","Loads a grid function from a base64-encoded binary string with an existing FE space.\r\n\r\nThis is the inverse of . The base64 string is decoded\r\nand parsed as an MFEM format grid function. You must provide the\r\nFiniteElementSpace that matches the saved data.",[5794,5796],{"_16":4547,"_22":5795,"_69":6},"- The finite element space for the grid function",{"_16":84,"_22":5797,"_69":6},"- Base64-encoded string containing grid function data","Promise",[],{"_16":5801,"_18":5802,"_20":5803,"_22":5804,"_24":5805,"_28":5798,"_30":5809},"mfem.gridfunction.fromBinaryWithMesh","mfem.gridfunction.fromBinaryWithMesh(mesh, data)","Loads a grid function from a base64-encoded binary string with auto-detected FE space.\r","Loads a grid function from a base64-encoded binary string with auto-detected FE space.\r\n\r\nThis is the inverse of . The base64 string is decoded\r\nand parsed as an MFEM format grid function. The FE space is automatically\r\nreconstructed from the saved header information.\r\n\r\nThe returned GridFunction owns its FESpace.",[5806,5808],{"_16":290,"_22":5807,"_69":6},"- The mesh for the grid function",{"_16":84,"_22":5797,"_69":6},[],{"_16":5811,"_18":5812,"_20":5813,"_22":5814,"_24":5815,"_28":5798,"_30":5820},"mfem.gridfunction.fromCoefficient","mfem.gridfunction.fromCoefficient(fespace, value)","Creates a new grid function initialized with a constant value.\r","Creates a new grid function initialized with a constant value.\r\n\r\nThis is a convenience function that creates a grid function and projects\r\na constant coefficient onto it. For more complex coefficients, create a\r\ngrid function manually and use projection functions.",[5816,5818],{"_16":4547,"_22":5817,"_69":6},"- The finite element space on which to define the function",{"_16":235,"_22":5819,"_69":6},"- The constant value to project",[],{"_16":5822,"_18":5823,"_20":5824,"_22":5825,"_24":5826,"_28":5798,"_30":5830},"mfem.gridfunction.fromFunction","mfem.gridfunction.fromFunction(fespace, fn)","Creates a new grid function initialized by evaluating a function at DOF locations.\r","Creates a new grid function initialized by evaluating a function at DOF locations.\r\n\r\nThe function is evaluated at the physical coordinates of each degree of freedom\r\n(node) in the finite element space. For Lagrange elements, these are the nodal\r\ninterpolation points.\r\n\r\n**Note:** This performs nodal interpolation, not L2 projection. For smoother\r\nresults with non-smooth functions, consider using L2 projection methods.",[5827,5828],{"_16":4547,"_22":5817,"_69":6},{"_16":4908,"_22":5829,"_69":6},"- Function that takes coordinates [x, y?, z?] and returns a scalar value",[],{"_16":5832,"_18":5833,"_20":5834,"_22":5835,"_24":5836,"_28":5798,"_30":5840},"mfem.gridfunction.fromMFEM","mfem.gridfunction.fromMFEM(fespace, data)","Loads a grid function from an MFEM format string into an existing GridFunction.\r","Loads a grid function from an MFEM format string into an existing GridFunction.\r\n\r\nThe GridFunction must already have an associated FiniteElementSpace that\r\nmatches the data being loaded. Use this when you already know the FE type\r\nand have created the space.",[5837,5838],{"_16":4547,"_22":5795,"_69":6},{"_16":84,"_22":5839,"_69":6},"- MFEM format grid function string",[],{"_16":5842,"_18":5843,"_20":5844,"_22":5845,"_24":5846,"_28":5798,"_30":5849},"mfem.gridfunction.fromMFEMWithMesh","mfem.gridfunction.fromMFEMWithMesh(mesh, data)","Creates a grid function from an MFEM format string with auto-detected FE space.\r","Creates a grid function from an MFEM format string with auto-detected FE space.\r\n\r\nThis function parses the FE collection information from the saved data header\r\nand automatically creates the appropriate FiniteElementSpace. Use this when\r\nloading a solution where you don't know the FE type in advance.\r\n\r\nThe returned GridFunction owns its FESpace, which will be destroyed when\r\nthe GridFunction is destroyed.",[5847,5848],{"_16":290,"_22":5807,"_69":6},{"_16":84,"_22":5839,"_69":6},[],{"_16":5851,"_18":5852,"_20":5853,"_22":5854,"_24":5855,"_28":5450,"_30":5860},"mfem.gridfunction.getAllNodalValues","mfem.gridfunction.getAllNodalValues(gf, vdim?)","Gets the values of a grid function at all vertices of the mesh.\r","Gets the values of a grid function at all vertices of the mesh.\r\n\r\nThis returns one value per vertex for the entire mesh, which is useful\r\nfor visualization or post-processing. For vector-valued grid functions,\r\nyou can specify which component to extract.",[5856,5858],{"_16":318,"_22":5857,"_69":6},"- The grid function to evaluate",{"_16":5565,"_22":5859,"_69":11},"- Vector component to extract (1-based, default 1 for scalar)",[],{"_16":5862,"_18":5863,"_20":5864,"_22":5865,"_24":5866,"_28":4712,"_30":5875},"mfem.gridfunction.getCurl","mfem.gridfunction.getCurl(gf, elemIdx, ip)","Computes the curl of a vector grid function at a point within an element.\r","Computes the curl of a vector grid function at a point within an element.\r\n\r\nThe curl is computed in physical coordinates:\r\n- In 3D: curl = [∂Fz/∂y - ∂Fy/∂z, ∂Fx/∂z - ∂Fz/∂x, ∂Fy/∂x - ∂Fx/∂y]\r\n- In 2D: curl is a scalar (z-component of the 3D curl)\r\n\r\nThis is typically used with H(curl) finite element spaces (Nedelec elements).",[5867,5869,5872],{"_16":318,"_22":5868,"_69":6},"- Vector GridFunction (e.g., from H(curl) space)",{"_16":5870,"_22":5871,"_69":6},"elemIdx","- Index of the element containing the point (0-based)",{"_16":5873,"_22":5874,"_69":6},"ip","- Integration point in reference coordinates",[],{"_16":5877,"_18":5878,"_20":5879,"_22":5880,"_24":5881,"_28":1426,"_30":5893},"mfem.gridfunction.getDerivative","mfem.gridfunction.getDerivative(gf, comp, derComp, destGf)","Computes the derivative of a grid function component in a specified direction\r","Computes the derivative of a grid function component in a specified direction\r\nand projects it onto another grid function.\r\n\r\nThis computes ∂u_comp/∂x_derComp where comp is the component of a\r\nvector-valued function and derComp is the spatial direction.",[5882,5884,5887,5890],{"_16":318,"_22":5883,"_69":6},"- The source grid function",{"_16":5885,"_22":5886,"_69":6},"comp","- Component to differentiate (1-based: 1, 2, or 3)",{"_16":5888,"_22":5889,"_69":6},"derComp","- Direction of differentiation (1=x, 2=y, 3=z)",{"_16":5891,"_22":5892,"_69":6},"destGf","- Destination grid function (must be pre-created on same mesh)",[],{"_16":5895,"_18":5896,"_20":5897,"_22":5898,"_24":5899,"_28":5703,"_30":5904},"mfem.gridfunction.getDivergence","mfem.gridfunction.getDivergence(gf, elemIdx, ip)","Computes the divergence of a vector grid function at a point within an element.\r","Computes the divergence of a vector grid function at a point within an element.\r\n\r\nThe divergence is computed in physical coordinates:\r\ndiv(F) = ∂Fx/∂x + ∂Fy/∂y + ∂Fz/∂z\r\n\r\nThis is typically used with H(div) finite element spaces (Raviart-Thomas elements).",[5900,5902,5903],{"_16":318,"_22":5901,"_69":6},"- Vector GridFunction (e.g., from H(div) space)",{"_16":5870,"_22":5871,"_69":6},{"_16":5873,"_22":5874,"_69":6},[],{"_16":5906,"_18":5907,"_20":5908,"_22":5909,"_24":5910,"_28":4712,"_30":5915},"mfem.gridfunction.getGradient","mfem.gridfunction.getGradient(gf, elemIdx, ip)","Computes the gradient of a scalar grid function at a point within an element.\r","Computes the gradient of a scalar grid function at a point within an element.\r\n\r\nThe gradient is computed in physical (not reference) coordinates. The result\r\nis a vector with components [∂f/∂x, ∂f/∂y, ∂f/∂z] (depending on dimension).",[5911,5913,5914],{"_16":318,"_22":5912,"_69":6},"- Scalar GridFunction to differentiate",{"_16":5870,"_22":5871,"_69":6},{"_16":5873,"_22":5874,"_69":6},[],{"_16":5917,"_18":5918,"_20":5919,"_22":5920,"_24":5921,"_28":5927,"_30":5928},"mfem.gridfunction.getGradients","mfem.gridfunction.getGradients(gf, elemIdx, points)","Computes gradients of a grid function at multiple integration points\r","Computes gradients of a grid function at multiple integration points\r\nwithin an element.\r\n\r\nThis is more efficient than calling multiple times\r\nwhen you need gradients at many points in the same element.",[5922,5923,5925],{"_16":318,"_22":5857,"_69":6},{"_16":5870,"_22":5924,"_69":6},"- Element index (0-based)",{"_16":61,"_22":5926,"_69":6},"- Array of integration points in reference element coordinates","GradientsResult",[],{"_16":5930,"_18":5931,"_20":5932,"_22":5933,"_24":5934,"_28":5939,"_30":5940},"mfem.gridfunction.getHessian","mfem.gridfunction.getHessian(gf, elemIdx, ip)","Computes the Hessian matrix of a grid function at a point within an element.\r","Computes the Hessian matrix of a grid function at a point within an element.\r\n\r\nThe Hessian is the matrix of second partial derivatives:\r\n```\r\nH = | ∂²u/∂x² ∂²u/∂x∂y ∂²u/∂x∂z |\r\n | ∂²u/∂y∂x ∂²u/∂y² ∂²u/∂y∂z |\r\n | ∂²u/∂z∂x ∂²u/∂z∂y ∂²u/∂z² |\r\n```",[5935,5936,5937],{"_16":318,"_22":5857,"_69":6},{"_16":5870,"_22":5924,"_69":6},{"_16":5873,"_22":5938,"_69":6},"- Integration point in reference element coordinates","HessianResult",[],{"_16":5942,"_18":5943,"_20":5944,"_22":5945,"_24":5946,"_28":5703,"_30":5952},"mfem.gridfunction.getLaplacian","mfem.gridfunction.getLaplacian(gf, elemIdx, ip, vdim?)","Computes the Laplacian of a grid function at a point within an element.\r","Computes the Laplacian of a grid function at a point within an element.\r\n\r\nThe Laplacian is the sum of second partial derivatives:\r\nΔu = ∂²u/∂x² + ∂²u/∂y² + ∂²u/∂z²",[5947,5948,5949,5950],{"_16":318,"_22":5857,"_69":6},{"_16":5870,"_22":5924,"_69":6},{"_16":5873,"_22":5938,"_69":6},{"_16":5565,"_22":5951,"_69":11},"- Vector component (1-based, default 1 for scalar)",[],{"_16":5954,"_18":5955,"_20":5956,"_22":5957,"_24":5958,"_28":4712,"_30":5962},"mfem.gridfunction.getNodalValues","mfem.gridfunction.getNodalValues(gf, elemIdx, vdim?)","Gets the values of a grid function at the vertices of a specific element.\r","Gets the values of a grid function at the vertices of a specific element.\r\n\r\nThis is simpler than using for extracting vertex values,\r\nas it directly returns all nodal values for an element without requiring\r\nintegration point coordinates.",[5959,5960,5961],{"_16":318,"_22":5857,"_69":6},{"_16":5870,"_22":5924,"_69":6},{"_16":5565,"_22":5859,"_69":11},[],{"_16":5964,"_18":5965,"_20":5966,"_22":5967,"_24":5968,"_28":5703,"_30":5973},"mfem.gridfunction.getValue","mfem.gridfunction.getValue(gf, elemIdx, ip)","Evaluates a grid function at a point within a specific element.\r","Evaluates a grid function at a point within a specific element.\r\n\r\nThe point is specified in reference (local) coordinates of the element.\r\nFor most elements, these coordinates range from 0 to 1.",[5969,5971,5972],{"_16":318,"_22":5970,"_69":6},"- GridFunction to evaluate",{"_16":5870,"_22":5871,"_69":6},{"_16":5873,"_22":5874,"_69":6},[],{"_16":5975,"_18":5976,"_20":5977,"_22":5978,"_24":5979,"_28":5450,"_30":5984},"mfem.gridfunction.getVectorFieldNodalValues","mfem.gridfunction.getVectorFieldNodalValues(gf, component)","Gets the values of a specific component of a vector-valued grid function\r","Gets the values of a specific component of a vector-valued grid function\r\nat all vertices of the mesh.\r\n\r\nThis is useful for extracting individual components (e.g., x-velocity,\r\ny-velocity) from a vector field for visualization or analysis.",[5980,5982],{"_16":318,"_22":5981,"_69":6},"- The vector GridFunction to evaluate",{"_16":4929,"_22":5983,"_69":6},"- Component index (1-based: 1=x, 2=y, 3=z)",[],{"_16":5986,"_18":5987,"_20":5988,"_22":5989,"_24":5990,"_28":4712,"_30":5994},"mfem.gridfunction.getVectorValue","mfem.gridfunction.getVectorValue(gf, elemIdx, ip)","Evaluates a vector-valued grid function at a point within an element.\r","Evaluates a vector-valued grid function at a point within an element.\r\n\r\nThis is the vector analog of . It returns all components\r\nof the vector field at the specified point.",[5991,5992,5993],{"_16":318,"_22":5981,"_69":6},{"_16":5870,"_22":5924,"_69":6},{"_16":5873,"_22":5938,"_69":6},[],{"_16":5996,"_18":5997,"_20":5998,"_22":5999,"_24":6000,"_28":6004,"_30":6005},"mfem.gridfunction.getVectorValues","mfem.gridfunction.getVectorValues(gf, elemIdx, points)","Evaluates a vector-valued grid function at multiple integration points within an element.\r","Evaluates a vector-valued grid function at multiple integration points within an element.\r\n\r\nThis is more efficient than calling multiple times\r\nwhen you need values at many points in the same element.",[6001,6002,6003],{"_16":318,"_22":5981,"_69":6},{"_16":5870,"_22":5924,"_69":6},{"_16":61,"_22":5926,"_69":6},"VectorValuesResult",[],{"_16":6007,"_18":6008,"_20":6009,"_22":6010,"_24":6011,"_28":5703,"_30":6014},"mfem.gridfunction.normH1","mfem.gridfunction.normH1(gf)","Computes the H1 norm of a grid function.\r","Computes the H1 norm of a grid function.\r\n\r\nThe H1 norm is defined as:\r\n```\r\n||u||_H1 = sqrt( ||u||²_L2 + ||∇u||²_L2 )\r\n = sqrt( ∫_Ω |u(x)|² dx + ∫_Ω |∇u(x)|² dx )\r\n```\r\n\r\nThis norm measures both the function values and their derivatives,\r\nmaking it suitable for error analysis in elliptic PDEs.\r\n\r\n**Note:** This function returns the H1 seminorm (gradient norm only).\r\nTo get the full H1 norm, combine with the L2 norm:\r\n`sqrt(normL2(gf)**2 + normH1(gf)**2)`",[6012],{"_16":318,"_22":6013,"_69":6},"- GridFunction to compute norm of",[],{"_16":6016,"_18":6017,"_20":6018,"_22":6019,"_24":6020,"_28":5703,"_30":6022},"mfem.gridfunction.normL2","mfem.gridfunction.normL2(gf)","Computes the L2 norm of a grid function.\r","Computes the L2 norm of a grid function.\r\n\r\nThe L2 norm is defined as:\r\n```\r\n||u||_L2 = sqrt( ∫_Ω |u(x)|² dx )\r\n```\r\n\r\nThis is computed using numerical quadrature over all elements in the mesh.",[6021],{"_16":318,"_22":6013,"_69":6},[],{"_16":6024,"_18":6025,"_20":6026,"_22":6027,"_24":6028,"_28":5703,"_30":6030},"mfem.gridfunction.normLinf","mfem.gridfunction.normLinf(gf)","Computes the L-infinity (maximum) norm of a grid function.\r","Computes the L-infinity (maximum) norm of a grid function.\r\n\r\nThe L-infinity norm is defined as:\r\n```\r\n||u||_∞ = max |u(x)| over all x in Ω\r\n```\r\n\r\nIn practice, this is computed as the maximum absolute value of the DOF coefficients.",[6029],{"_16":318,"_22":6013,"_69":6},[],{"_16":6032,"_18":6033,"_20":6034,"_22":6035,"_24":6036,"_28":1426,"_30":6043},"mfem.gridfunction.projectBdrCoefficient","mfem.gridfunction.projectBdrCoefficient(gf, value, bdrAttrs)","Projects a constant value onto boundary DOFs for specified boundary attributes.\r","Projects a constant value onto boundary DOFs for specified boundary attributes.\r\n\r\nThis sets the DOF values on the specified boundaries to the given constant value.\r\nIt is useful for applying Dirichlet boundary conditions where the boundary\r\nvalue is known.\r\n\r\nOnly DOFs that lie on boundary elements with the specified attributes are modified.\r\nInterior DOFs remain unchanged.",[6037,6039,6041],{"_16":318,"_22":6038,"_69":6},"- GridFunction to modify",{"_16":235,"_22":6040,"_69":6},"- The constant value to project on boundary",{"_16":4711,"_22":6042,"_69":6},"- Array of boundary attributes (1-based) to apply the value to",[],{"_16":6045,"_18":6046,"_20":6047,"_22":6048,"_24":6049,"_28":1426,"_30":6056},"mfem.gridfunction.projectBdrVectorCoefficient","mfem.gridfunction.projectBdrVectorCoefficient(gf, vcoeffPtr, bdrAttrs)","Projects a vector coefficient onto boundary DOFs of a grid function.\r","Projects a vector coefficient onto boundary DOFs of a grid function.\r\n\r\nThis sets the values of the grid function at boundary DOFs to match\r\nthe given vector coefficient. Interior DOFs are not modified.",[6050,6052,6054],{"_16":318,"_22":6051,"_69":6},"- The grid function to modify",{"_16":5761,"_22":6053,"_69":6},"- Pointer to a VectorCoefficient in WASM memory",{"_16":4711,"_22":6055,"_69":6},"- Array of boundary attribute markers (1 = apply, 0 = skip)",[],{"_16":6058,"_18":6059,"_20":6060,"_22":6061,"_24":6062,"_28":1426,"_30":6065},"mfem.gridfunction.projectCoefficient","mfem.gridfunction.projectCoefficient(gf, value)","Projects a constant coefficient onto a grid function.\r","Projects a constant coefficient onto a grid function.\r\n\r\nThis sets all DOF values such that the grid function represents\r\nthe constant function f(x) = value everywhere in the domain.\r\nThis is equivalent to calling `gf.projectConstant(value)`.",[6063,6064],{"_16":318,"_22":6038,"_69":6},{"_16":235,"_22":5819,"_69":6},[],{"_16":6067,"_18":6068,"_20":6069,"_22":6070,"_24":6071,"_28":1426,"_30":6078},"mfem.gridfunction.projectDiscCoefficient","mfem.gridfunction.projectDiscCoefficient(gf, coeffPtr, avgType?)","Projects a discontinuous coefficient onto a grid function with averaging.\r","Projects a discontinuous coefficient onto a grid function with averaging.\r\n\r\nWhen a coefficient has different values on different sides of an element\r\ninterface, this function uses the specified averaging type to determine\r\nthe value at shared DOFs.",[6072,6073,6075],{"_16":318,"_22":6051,"_69":6},{"_16":5736,"_22":6074,"_69":6},"- Pointer to a Coefficient in WASM memory",{"_16":6076,"_22":6077,"_69":11},"avgType","- Averaging type for interface values (default: ARITHMETIC)",[],{"_16":6080,"_18":6081,"_20":6082,"_22":6083,"_24":6084,"_28":4713,"_30":6087},"mfem.gridfunction.projectFunction","mfem.gridfunction.projectFunction(gf, fn)","Projects a JavaScript function onto a grid function using nodal interpolation.\r","Projects a JavaScript function onto a grid function using nodal interpolation.\r\n\r\nThe function is evaluated at the physical coordinates of each degree of freedom\r\nto determine the DOF values. For standard Lagrange elements, this corresponds\r\nto interpolation at the nodal points.\r\n\r\n**Note:** This function is async because it needs to compute DOF coordinates.",[6085,6086],{"_16":318,"_22":6038,"_69":6},{"_16":4908,"_22":5829,"_69":6},[],{"_16":6089,"_18":6090,"_20":6091,"_22":6092,"_24":6093,"_28":1426,"_30":6099},"mfem.gridfunction.projectGridFunction","mfem.gridfunction.projectGridFunction(destGf, srcGf)","Projects a source grid function onto a destination grid function.\r","Projects a source grid function onto a destination grid function.\r\n\r\nThis is useful for transferring solutions between different finite element\r\nspaces on the same mesh, or for initializing a grid function from an\r\nexisting solution.",[6094,6096],{"_16":5891,"_22":6095,"_69":6},"- The destination grid function to modify",{"_16":6097,"_22":6098,"_69":6},"srcGf","- The source grid function to project from",[],{"_16":6101,"_18":6102,"_20":6103,"_22":6104,"_24":6105,"_28":6108,"_30":6109},"mfem.gridfunction.save","mfem.gridfunction.save(gf)","Exports a grid function to MFEM format string.\r","Exports a grid function to MFEM format string.\r\n\r\nThe returned string can be saved to a file and later loaded back using\r\nMFEM's GridFunction constructor that takes a mesh and input stream.\r\n\r\nThe format includes the finite element collection type, ordering,\r\nand all DOF values.",[6106],{"_16":318,"_22":6107,"_69":6},"- GridFunction to export","string",[],{"_16":6111,"_18":6112,"_20":6113,"_22":6114,"_24":6115,"_28":6108,"_30":6118},"mfem.gridfunction.toBinary","mfem.gridfunction.toBinary(gf)","Exports a grid function to a base64-encoded binary string.\r","Exports a grid function to a base64-encoded binary string.\r\n\r\nThis provides a compact representation of the grid function suitable for\r\nstorage in JSON, localStorage, or transmission. The grid function is first\r\nserialized to MFEM format (including FE space info) and then base64-encoded.",[6116],{"_16":318,"_22":6117,"_69":6},"- The grid function to export",[],{"_16":6120,"_18":6121,"_20":6122,"_22":6123,"_24":6124,"_28":6108,"_30":6128},"mfem.gridfunction.toVTK","mfem.gridfunction.toVTK(gf, options?)","Exports a grid function to VTK format string for visualization.\r","Exports a grid function to VTK format string for visualization.\r\n\r\nThe returned string contains VTK data for the grid function values.\r\n**Note:** This exports only the field data. For complete VTK output,\r\nyou also need to export the mesh using `mesh.toVTK()`.\r\n\r\nFor visualization in ParaView or similar tools, combine the mesh\r\nand field data into a complete VTK file.",[6125,6126],{"_16":318,"_22":6107,"_69":6},{"_16":4789,"_22":6127,"_69":11},"- Export options",[],{"_16":6130,"_18":6131,"_20":6132,"_22":6133,"_24":6134,"_28":5450,"_30":6137},"mfem.gridfunction.getTrueDofs","mfem.gridfunction.getTrueDofs(gf)","Gets the true DOF values from a grid function.\r","Gets the true DOF values from a grid function.\r\n\r\nFor conforming meshes, this returns the same as `getData()`.\r\nFor non-conforming meshes, this returns only the independent DOF values,\r\nwhich may be fewer than the total number of DOFs.",[6135],{"_16":318,"_22":6136,"_69":6},"- The grid function to query",[],{"_16":6139,"_18":6140,"_20":6141,"_22":6142,"_24":6143,"_28":5703,"_30":6145},"mfem.gridfunction.getTrueVectorSize","mfem.gridfunction.getTrueVectorSize(gf)","Gets the size of the true DOF vector.\r","Gets the size of the true DOF vector.\r\n\r\nFor conforming meshes, this equals the total number of DOFs.\r\nFor non-conforming meshes, this may be smaller.",[6144],{"_16":318,"_22":6136,"_69":6},[],{"_16":6147,"_18":6148,"_20":6149,"_22":6150,"_24":6151,"_28":1426,"_30":6157},"mfem.gridfunction.setFromTrueDofs","mfem.gridfunction.setFromTrueDofs(gf, trueDofs)","Sets grid function values from true DOF values.\r","Sets grid function values from true DOF values.\r\n\r\nThis applies the prolongation operator to populate all DOFs from\r\nthe independent true DOFs. For conforming meshes, this is equivalent\r\nto `setData()`. For non-conforming meshes, this properly distributes\r\nvalues to hanging nodes.",[6152,6154],{"_16":318,"_22":6153,"_69":6},"- The grid function to update",{"_16":6155,"_22":6156,"_69":6},"trueDofs","- Array of true DOF values",[],{"_16":6159,"_18":6160,"_20":6161,"_22":6162,"_24":6163,"_28":1426,"_30":6165},"mfem.gridfunction.setTrueVector","mfem.gridfunction.setTrueVector(gf)","Extracts true DOFs from the grid function to internal storage.\r","Extracts true DOFs from the grid function to internal storage.\r\n\r\nFor conforming meshes, this is a no-op. For non-conforming meshes\r\n(with hanging nodes), this extracts the independent DOF values.\r\nCall this before solving to prepare the true DOF vector.",[6164],{"_16":318,"_22":6153,"_69":6},[],{"_16":6167,"_18":6168,"_20":6169,"_22":6170,"_24":6171,"_28":5798,"_30":6173},"mfem.gridfunction.GridFunction.create","mfem.gridfunction.GridFunction.create(fespace)","Creates a new grid function on the specified finite element space.\r","Creates a new grid function on the specified finite element space.\r\n\r\nThe grid function is initialized with unspecified values. Use\r\n| projectConstant() or\r\n| setData() to initialize the values.",[6172],{"_16":4547,"_22":5817,"_69":6},[],{"_16":6175,"_18":6176,"_20":6177,"_22":6177,"_24":6178,"_28":5450,"_30":6181},"mfem.linalg.createDoubleArray","mfem.linalg.createDoubleArray(size)","Create a zero-initialized Float64Array.",[6179],{"_16":193,"_22":6180,"_69":6},"- Array size",[],{"_16":6183,"_18":6184,"_20":6185,"_22":6186,"_24":6187,"_28":4757,"_30":6189},"mfem.linalg.createIntArray","mfem.linalg.createIntArray(size)","Array utility functions for creating typed arrays.\r","Array utility functions for creating typed arrays.\r\n\r\nThese are pure JavaScript utilities that don't require WASM.",[6188],{"_16":193,"_22":6180,"_69":6},[],{"_16":6191,"_18":6192,"_20":6193,"_22":6194,"_24":6195,"_28":4757,"_30":6200},"mfem.linalg.createMarkerArray","mfem.linalg.createMarkerArray(size, markedIndices)","Create a marker array (0/1 values) with specified indices marked as 1.\r","Create a marker array (0/1 values) with specified indices marked as 1.\r\n\r\nThis is useful for creating boundary marker arrays or element selection arrays.",[6196,6197],{"_16":193,"_22":6180,"_69":6},{"_16":6198,"_22":6199,"_69":6},"markedIndices","- Indices to mark as 1",[],{"_16":6202,"_18":6203,"_20":4622,"_22":4622,"_24":6204,"_28":4627,"_30":6206},"mfem.linalg.BlockMatrix.createSquare","mfem.linalg.BlockMatrix.createSquare(offsets)",[6205],{"_16":4625,"_22":4626,"_69":6},[],{"_16":6208,"_18":6209,"_20":4632,"_22":4632,"_24":6210,"_28":4627,"_30":6213},"mfem.linalg.BlockMatrix.create","mfem.linalg.BlockMatrix.create(rowOffsets, colOffsets)",[6211,6212],{"_16":4635,"_22":4636,"_69":6},{"_16":4638,"_22":4639,"_69":6},[],{"_16":6215,"_18":6216,"_20":4644,"_22":4645,"_24":6217,"_28":4627,"_30":6219},"mfem.linalg.BlockMatrix.fromPointer","mfem.linalg.BlockMatrix.fromPointer(ptr)",[6218],{"_16":4648,"_22":4649,"_69":6},[],{"_16":6221,"_18":6222,"_20":4654,"_22":4654,"_24":6223,"_28":4657,"_30":6225},"mfem.linalg.BlockOperator.createSquare","mfem.linalg.BlockOperator.createSquare(offsets)",[6224],{"_16":4625,"_22":4626,"_69":6},[],{"_16":6227,"_18":6228,"_20":4662,"_22":4662,"_24":6229,"_28":4657,"_30":6232},"mfem.linalg.BlockOperator.create","mfem.linalg.BlockOperator.create(rowOffsets, colOffsets)",[6230,6231],{"_16":4635,"_22":4636,"_69":6},{"_16":4638,"_22":4639,"_69":6},[],{"_16":6234,"_18":6235,"_20":4670,"_22":4671,"_24":6236,"_28":4657,"_30":6238},"mfem.linalg.BlockOperator.fromPointer","mfem.linalg.BlockOperator.fromPointer(ptr)",[6237],{"_16":4648,"_22":4674,"_69":6},[],{"_16":6240,"_18":6241,"_20":4679,"_22":4679,"_24":6242,"_28":4683,"_30":6244},"mfem.linalg.BlockVector.create","mfem.linalg.BlockVector.create(offsets)",[6243],{"_16":4625,"_22":4682,"_69":6},[],{"_16":6246,"_18":6247,"_20":4688,"_22":4689,"_24":6248,"_28":4683,"_30":6251},"mfem.linalg.BlockVector.fromPointer","mfem.linalg.BlockVector.fromPointer(ptr, offsets)",[6249,6250],{"_16":4648,"_22":4692,"_69":6},{"_16":4625,"_22":4694,"_69":6},[],{"_16":6253,"_18":6254,"_20":5502,"_22":5503,"_24":6255,"_28":5508,"_30":6258},"mfem.linalg.DenseMatrix.create","mfem.linalg.DenseMatrix.create(height, width)",[6256,6257],{"_16":174,"_22":4979,"_69":6},{"_16":4981,"_22":5507,"_69":6},[],{"_16":6260,"_18":6261,"_20":5513,"_22":5513,"_24":6262,"_28":5508,"_30":6265},"mfem.linalg.DenseMatrix.zeros","mfem.linalg.DenseMatrix.zeros(height, width)",[6263,6264],{"_16":174,"_22":4979,"_69":6},{"_16":4981,"_22":5507,"_69":6},[],{"_16":6267,"_18":6268,"_20":5521,"_22":5521,"_24":6269,"_28":5508,"_30":6271},"mfem.linalg.DenseMatrix.identity","mfem.linalg.DenseMatrix.identity(n)",[6270],{"_16":362,"_22":5524,"_69":6},[],{"_16":6273,"_18":6274,"_20":5529,"_22":5529,"_24":6275,"_28":5508,"_30":6277},"mfem.linalg.DenseMatrix.fromArray","mfem.linalg.DenseMatrix.fromArray(data)",[6276],{"_16":84,"_22":5532,"_69":6},[],{"_16":6279,"_18":6280,"_20":5537,"_22":5538,"_24":6281,"_28":5508,"_30":6284},"mfem.linalg.DenseMatrix.fromPointer","mfem.linalg.DenseMatrix.fromPointer(ptr, ownsMemory?)",[6282,6283],{"_16":4648,"_22":5541,"_69":6},{"_16":5543,"_22":5544,"_69":11},[],{"_16":6286,"_18":6287,"_20":6288,"_22":6288,"_24":6289,"_28":6292,"_30":6293},"mfem.linalg.SparseMatrix.create","mfem.linalg.SparseMatrix.create(height, width)","Creates a new empty sparse matrix of the specified dimensions.",[6290,6291],{"_16":174,"_22":4979,"_69":6},{"_16":4981,"_22":5507,"_69":6},"Promise",[],{"_16":6295,"_18":6296,"_20":6297,"_22":6298,"_24":6299,"_28":6292,"_30":6304},"mfem.linalg.SparseMatrix.fromPointer","mfem.linalg.SparseMatrix.fromPointer(ptr, ownsMemory?)","Creates a SparseMatrix from an existing WASM pointer.\r","Creates a SparseMatrix from an existing WASM pointer.\r\nUse with caution - the caller is responsible for pointer validity.",[6300,6302],{"_16":4648,"_22":6301,"_69":6},"- WASM pointer to an existing MFEM SparseMatrix",{"_16":5543,"_22":6303,"_69":11},"- If true, destroy() will free the memory; if false, it won't",[],{"_16":6306,"_18":6307,"_20":6308,"_22":6308,"_24":6309,"_28":6312,"_30":6313},"mfem.linalg.Vector.create","mfem.linalg.Vector.create(size)","Creates a new vector of the specified size.",[6310],{"_16":193,"_22":6311,"_69":6},"- The number of elements in the vector","Promise",[],{"_16":6315,"_18":6316,"_20":6317,"_22":6318,"_24":6319,"_28":6312,"_30":6322},"mfem.linalg.Vector.fromPointer","mfem.linalg.Vector.fromPointer(ptr)","Creates a Vector from an existing WASM pointer.\r","Creates a Vector from an existing WASM pointer.\r\nUse with caution - the caller is responsible for pointer validity.",[6320],{"_16":4648,"_22":6321,"_69":6},"- WASM pointer to an existing MFEM Vector",[],{"_16":6324,"_18":6325,"_20":6326,"_22":6326,"_24":6327,"_28":5703,"_30":6330},"mfem.linear.getFinalNorm","mfem.linear.getFinalNorm(solver)","Get the final residual norm from the last solve.",[6328],{"_16":5445,"_22":6329,"_69":6},"- Iterative solver instance",[],{"_16":6332,"_18":6333,"_20":6334,"_22":6334,"_24":6335,"_28":5703,"_30":6337},"mfem.linear.getNumIterations","mfem.linear.getNumIterations(solver)","Get the number of iterations from the last solve.",[6336],{"_16":5445,"_22":6329,"_69":6},[],{"_16":6339,"_18":6340,"_20":6341,"_22":6341,"_24":6342,"_28":1426,"_30":6348},"mfem.linear.mult","mfem.linear.mult(solver, b, x)","Solve the linear system Ax = b.",[6343,6344,6346],{"_16":5445,"_22":6329,"_69":6},{"_16":436,"_22":6345,"_69":6},"- Right-hand side vector",{"_16":498,"_22":6347,"_69":6},"- Solution vector (modified in place)",[],{"_16":6350,"_18":6351,"_20":6352,"_22":6352,"_24":6353,"_28":1426,"_30":6357},"mfem.linear.setMaxIterations","mfem.linear.setMaxIterations(solver, max)","Set maximum number of iterations for an iterative solver.",[6354,6355],{"_16":5445,"_22":6329,"_69":6},{"_16":841,"_22":6356,"_69":6},"- Maximum iterations",[],{"_16":6359,"_18":6360,"_20":6361,"_22":6361,"_24":6362,"_28":1426,"_30":6367},"mfem.linear.setPreconditioner","mfem.linear.setPreconditioner(solver, prec)","Set preconditioner for an iterative solver.",[6363,6364],{"_16":5445,"_22":6329,"_69":6},{"_16":6365,"_22":6366,"_69":6},"prec","- Preconditioner (Solver)",[],{"_16":6369,"_18":6370,"_20":6371,"_22":6371,"_24":6372,"_28":1426,"_30":6377},"mfem.linear.setPrintLevel","mfem.linear.setPrintLevel(solver, level)","Set verbosity level for an iterative solver.",[6373,6374],{"_16":5445,"_22":6329,"_69":6},{"_16":6375,"_22":6376,"_69":6},"level","- Print level (0=silent, 1=summary, 2=iteration details)",[],{"_16":6379,"_18":6380,"_20":6381,"_22":6381,"_24":6382,"_28":1426,"_30":6390},"mfem.linear.setTolerance","mfem.linear.setTolerance(solver, rtol, atol?)","Set convergence tolerances for an iterative solver.",[6383,6384,6387],{"_16":5445,"_22":6329,"_69":6},{"_16":6385,"_22":6386,"_69":6},"rtol","- Relative tolerance",{"_16":6388,"_22":6389,"_69":11},"atol","- Absolute tolerance (optional)",[],{"_16":6392,"_18":6393,"_20":6394,"_22":6394,"_24":6395,"_28":6396,"_30":6397},"mfem.linear.BiCGSTABSolver.create","mfem.linear.BiCGSTABSolver.create()","Creates a new BiCGSTAB solver.",[],"Promise",[],{"_16":6399,"_18":6400,"_20":6401,"_22":6401,"_24":6402,"_28":6411,"_30":6412},"mfem.linear.BlockILU.create","mfem.linear.BlockILU.create(matrixPtr, blockSize?, options?)","Creates a new BlockILU preconditioner.",[6403,6406,6409],{"_16":6404,"_22":6405,"_69":6},"matrixPtr","- Pointer to SparseMatrix or Operator",{"_16":6407,"_22":6408,"_69":11},"blockSize","- Block size for ILU factorization. Default: 1",{"_16":4789,"_22":6410,"_69":11},"- Optional configuration options","Promise",[],{"_16":6414,"_18":6415,"_20":6416,"_22":6416,"_24":6417,"_28":6418,"_30":6419},"mfem.linear.CGSolver.create","mfem.linear.CGSolver.create()","Creates a new CG solver.",[],"Promise",[],{"_16":6421,"_18":6422,"_20":6423,"_22":6423,"_24":6424,"_28":6427,"_30":6428},"mfem.linear.ChebyshevSmoother.create","mfem.linear.ChebyshevSmoother.create(options)","Creates a new Chebyshev smoother with explicit maximum eigenvalue.",[6425],{"_16":4789,"_22":6426,"_69":6},"- Smoother configuration options","Promise",[],{"_16":6430,"_18":6431,"_20":6432,"_22":6433,"_24":6434,"_28":6427,"_30":6436},"mfem.linear.ChebyshevSmoother.createAuto","mfem.linear.ChebyshevSmoother.createAuto(options)","Creates a new Chebyshev smoother with automatic eigenvalue estimation.\r","Creates a new Chebyshev smoother with automatic eigenvalue estimation.\r\nUses power iteration to estimate the maximum eigenvalue.",[6435],{"_16":4789,"_22":6426,"_69":6},[],{"_16":6438,"_18":6439,"_20":6440,"_22":6440,"_24":6441,"_28":6448,"_30":6449},"mfem.linear.DirectSubBlockSolver.create","mfem.linear.DirectSubBlockSolver.create(APtr, blockDofPtr)","Creates a new DirectSubBlockSolver.",[6442,6445],{"_16":6443,"_22":6444,"_69":6},"APtr","- Pointer to the system SparseMatrix",{"_16":6446,"_22":6447,"_69":6},"blockDofPtr","- Pointer to SparseMatrix defining block-DOF membership","Promise",[],{"_16":6451,"_18":6452,"_20":6453,"_22":6453,"_24":6454,"_28":6458,"_30":6459},"mfem.linear.DSmoother.create","mfem.linear.DSmoother.create(matrixPtr, options?)","Creates a new DSmoother.",[6455,6457],{"_16":6404,"_22":6456,"_69":6},"- Pointer to SparseMatrix",{"_16":4789,"_22":6410,"_69":11},"Promise",[],{"_16":6461,"_18":6462,"_20":6463,"_22":6463,"_24":6464,"_28":6468,"_30":6469},"mfem.linear.FGMRESSolver.create","mfem.linear.FGMRESSolver.create(kdim?)","Creates a new Flexible GMRES solver.",[6465],{"_16":6466,"_22":6467,"_69":11},"kdim","- Krylov space dimension (restart parameter, default 50)","Promise",[],{"_16":6471,"_18":6472,"_20":6473,"_22":6473,"_24":6474,"_28":6476,"_30":6477},"mfem.linear.GMRESSolver.create","mfem.linear.GMRESSolver.create(kdim?)","Creates a new GMRES solver.",[6475],{"_16":6466,"_22":6467,"_69":11},"Promise",[],{"_16":6479,"_18":6480,"_20":6481,"_22":6481,"_24":6482,"_28":6490,"_30":6491},"mfem.linear.GSSmoother.create","mfem.linear.GSSmoother.create(matrixPtr, type?, iterations?)","Creates a new Gauss-Seidel smoother.",[6483,6484,6487],{"_16":6404,"_22":6456,"_69":6},{"_16":6485,"_22":6486,"_69":11},"type","- Type of GS iteration (default: SYMMETRIC)",{"_16":6488,"_22":6489,"_69":11},"iterations","- Number of iterations (default: 1)","Promise",[],{"_16":6493,"_18":6494,"_20":6495,"_22":6495,"_24":6496,"_28":6500,"_30":6501},"mfem.linear.JacobiSmoother.create","mfem.linear.JacobiSmoother.create(matrixPtr, essentialDofs?)","Creates a new Jacobi smoother.",[6497,6498],{"_16":6404,"_22":6456,"_69":6},{"_16":4559,"_22":6499,"_69":11},"- Optional array of essential DOF indices to exclude","Promise",[],{"_16":6503,"_18":6504,"_20":6505,"_22":6505,"_24":6506,"_28":6507,"_30":6508},"mfem.linear.KLUSolver.isAvailable","mfem.linear.KLUSolver.isAvailable()","Checks if KLU (SuiteSparse) is available.",[],"Promise",[],{"_16":6510,"_18":6511,"_20":6512,"_22":6512,"_24":6513,"_28":6514,"_30":6515},"mfem.linear.KLUSolver.create","mfem.linear.KLUSolver.create()","Creates a new KLU solver.",[],"Promise",[],{"_16":6517,"_18":6518,"_20":6519,"_22":6519,"_24":6520,"_28":6521,"_30":6522},"mfem.linear.MINRESSolver.create","mfem.linear.MINRESSolver.create()","Creates a new MINRES solver.",[],"Promise",[],{"_16":6524,"_18":6525,"_20":6526,"_22":6526,"_24":6527,"_28":6528,"_30":6529},"mfem.linear.OrthoSolver.create","mfem.linear.OrthoSolver.create()","Creates a new orthogonalizing solver wrapper.",[],"Promise",[],{"_16":6531,"_18":6532,"_20":6533,"_22":6533,"_24":6534,"_28":6543,"_30":6544},"mfem.linear.ProductSolver.create","mfem.linear.ProductSolver.create(s0Ptr, s1Ptr, options?)","Creates a new product solver: S = S1 * S0.",[6535,6538,6541],{"_16":6536,"_22":6537,"_69":6},"s0Ptr","- Pointer to first solver (applied first)",{"_16":6539,"_22":6540,"_69":6},"s1Ptr","- Pointer to second solver (applied second)",{"_16":4789,"_22":6542,"_69":11},"- Ownership options","Promise",[],{"_16":6531,"_18":6546,"_20":6533,"_22":6533,"_24":6547,"_28":6543,"_30":6554},"mfem.linear.ProductSolver.create(s0, s1, options?)",[6548,6551,6553],{"_16":6549,"_22":6550,"_69":6},"s0","- First solver (applied first)",{"_16":1169,"_22":6552,"_69":6},"- Second solver (applied second)",{"_16":4789,"_22":6542,"_69":11},[],{"_16":6556,"_18":6557,"_20":6558,"_22":6558,"_24":6559,"_28":6560,"_30":6561},"mfem.linear.SLISolver.create","mfem.linear.SLISolver.create()","Creates a new SLI solver.",[],"Promise",[],{"_16":6563,"_18":6564,"_20":6565,"_22":6565,"_24":6566,"_28":6507,"_30":6567},"mfem.linear.UMFPackSolver.isAvailable","mfem.linear.UMFPackSolver.isAvailable()","Checks if UMFPack (SuiteSparse) is available.",[],[],{"_16":6569,"_18":6570,"_20":6571,"_22":6571,"_24":6572,"_28":6573,"_30":6574},"mfem.linear.UMFPackSolver.create","mfem.linear.UMFPackSolver.create()","Creates a new UMFPack solver.",[],"Promise",[],{"_16":6576,"_18":6577,"_20":6578,"_22":6579,"_24":6580,"_28":1426,"_30":6586},"mfem.linearForms.addBoundaryFluxIntegrator","mfem.linearForms.addBoundaryFluxIntegrator(lf, coeff, bdrAttrs?)","Add a VectorFE boundary flux integrator for H(div) spaces.\r","Add a VectorFE boundary flux integrator for H(div) spaces.\r\n\r\nComputes: ∫_∂Ω f * (v · n) ds",[6581,6582,6584],{"_16":4704,"_22":4724,"_69":6},{"_16":4385,"_22":6583,"_69":6},"- Scalar flux coefficient",{"_16":4711,"_22":6585,"_69":11},"- Optional boundary attributes to restrict to",[],{"_16":6588,"_18":6589,"_20":6590,"_22":6591,"_24":6592,"_28":1426,"_30":6597},"mfem.linearForms.addBoundaryIntegrator","mfem.linearForms.addBoundaryIntegrator(lf, coeff, bdrAttrs?)","Add a boundary integrator (g, v) to the linear form.\r","Add a boundary integrator (g, v) to the linear form.\r\n\r\nComputes: ∫_∂Ω g * v ds",[6593,6594,6596],{"_16":4704,"_22":4724,"_69":6},{"_16":4385,"_22":6595,"_69":6},"- Boundary source coefficient",{"_16":4711,"_22":6585,"_69":11},[],{"_16":6599,"_18":6600,"_20":6601,"_22":6602,"_24":6603,"_28":1426,"_30":6607},"mfem.linearForms.addBoundaryNormalIntegrator","mfem.linearForms.addBoundaryNormalIntegrator(lf, coeff, bdrAttrs?)","Add a boundary normal integrator (F · n, v) to the linear form.\r","Add a boundary normal integrator (F · n, v) to the linear form.\r\n\r\nComputes: ∫_∂Ω (F · n) * v ds",[6604,6605,6606],{"_16":4704,"_22":4724,"_69":6},{"_16":4385,"_22":5095,"_69":6},{"_16":4711,"_22":6585,"_69":11},[],{"_16":6609,"_18":6610,"_20":6611,"_22":6612,"_24":6613,"_28":1426,"_30":6617},"mfem.linearForms.addBoundaryTangentialIntegrator","mfem.linearForms.addBoundaryTangentialIntegrator(lf, coeff, bdrAttrs?)","Add a boundary tangential integrator (F × n, v) to the linear form.\r","Add a boundary tangential integrator (F × n, v) to the linear form.\r\nFor 2D: takes the tangential component of the vector field.\r\n\r\nComputes: ∫_∂Ω (F · t) * v ds",[6614,6615,6616],{"_16":4704,"_22":4724,"_69":6},{"_16":4385,"_22":5095,"_69":6},{"_16":4711,"_22":6585,"_69":11},[],{"_16":6619,"_18":6620,"_20":6621,"_22":6622,"_24":6623,"_28":1426,"_30":6631},"mfem.linearForms.addDGDirichletIntegrator","mfem.linearForms.addDGDirichletIntegrator(lf, coeff, sigma, kappa)","Add a DG Dirichlet boundary integrator for discontinuous Galerkin methods.\r","Add a DG Dirichlet boundary integrator for discontinuous Galerkin methods.\r\n\r\nNote: This integrator is not yet implemented in the WASM bindings.\r\nIt requires additional C++ support for DG-specific integrators.",[6624,6625,6627,6629],{"_16":4704,"_22":4724,"_69":6},{"_16":4385,"_22":6626,"_69":6},"- Dirichlet value coefficient",{"_16":4421,"_22":6628,"_69":6},"- Symmetry parameter (-1 for SIPG, 0 for IIPG, 1 for NIPG)",{"_16":4424,"_22":6630,"_69":6},"- Penalty parameter",[],{"_16":6633,"_18":6634,"_20":6635,"_22":6636,"_24":6637,"_28":1426,"_30":6640},"mfem.linearForms.addDomainGradientIntegrator","mfem.linearForms.addDomainGradientIntegrator(lf, coeff)","Add a domain gradient integrator (F, ∇v) to the linear form.\r","Add a domain gradient integrator (F, ∇v) to the linear form.\r\n\r\nComputes: ∫ F · ∇v dx",[6638,6639],{"_16":4704,"_22":4724,"_69":6},{"_16":4385,"_22":5095,"_69":6},[],{"_16":6642,"_18":6643,"_20":6644,"_22":6645,"_24":6646,"_28":1426,"_30":6650},"mfem.linearForms.addDomainIntegrator","mfem.linearForms.addDomainIntegrator(lf, coeff)","Add a domain integrator (f, v) to the linear form.\r","Add a domain integrator (f, v) to the linear form.\r\n\r\nComputes: ∫ f * v dx",[6647,6648],{"_16":4704,"_22":4724,"_69":6},{"_16":4385,"_22":6649,"_69":6},"- Source coefficient",[],{"_16":6652,"_18":6653,"_20":6654,"_22":6655,"_24":6656,"_28":1426,"_30":6659},"mfem.linearForms.addVectorDomainIntegrator","mfem.linearForms.addVectorDomainIntegrator(lf, coeff)","Add a vector domain integrator (F, v) to the linear form.\r","Add a vector domain integrator (F, v) to the linear form.\r\nFor vector-valued test functions.\r\n\r\nComputes: ∫ F · v dx",[6657,6658],{"_16":4704,"_22":4724,"_69":6},{"_16":4385,"_22":5095,"_69":6},[],{"_16":6661,"_18":6662,"_20":6663,"_22":6663,"_24":6664,"_28":1426,"_30":6666},"mfem.linearForms.assemble","mfem.linearForms.assemble(lf)","Assemble the linear form into a vector.",[6665],{"_16":4704,"_22":4724,"_69":6},[],{"_16":6668,"_18":6669,"_20":6670,"_22":6670,"_24":6671,"_28":5450,"_30":6673},"mfem.linearForms.getVector","mfem.linearForms.getVector(lf)","Get the assembled vector data from the linear form.",[6672],{"_16":4704,"_22":4724,"_69":6},[],{"_16":6675,"_18":6676,"_20":6677,"_22":6677,"_24":6678,"_28":6680,"_30":6681},"mfem.linearForms.create","mfem.linearForms.create(fespace)","Create a linear form on a finite element space.",[6679],{"_16":4547,"_22":4548,"_69":6},"Promise",[],{"_16":6683,"_18":6684,"_20":6685,"_22":6685,"_24":6686,"_28":6680,"_30":6688},"mfem.linearForms.LinearForm.create","mfem.linearForms.LinearForm.create(fespace)","Creates a new linear form on the specified finite element space.",[6687],{"_16":4547,"_22":4605,"_69":6},[],{"_16":6690,"_18":6691,"_20":6692,"_22":5456,"_24":6693,"_28":1426,"_30":6699},"mfem.matrix.add","mfem.matrix.add(dm, alpha, other)","add",[6694,6696,6697],{"_16":6695,"_22":5460,"_69":6},"dm",{"_16":4399,"_22":5703,"_69":6},{"_16":6698,"_22":5460,"_69":6},"other",[],{"_16":6701,"_18":6702,"_20":2475,"_22":5456,"_24":6703,"_28":5703,"_30":6705},"mfem.matrix.cols","mfem.matrix.cols(dm)",[6704],{"_16":6695,"_22":5460,"_69":6},[],{"_16":6707,"_18":6708,"_20":6709,"_22":5456,"_24":6710,"_28":5508,"_30":6713},"mfem.matrix.create","mfem.matrix.create(rows, cols)","create_2",[6711,6712],{"_16":2472,"_22":5703,"_69":6},{"_16":2475,"_22":5703,"_69":6},[],{"_16":6715,"_18":6716,"_20":6717,"_22":5456,"_24":6718,"_28":5703,"_30":6720},"mfem.matrix.determinant","mfem.matrix.determinant(dm)","determinant",[6719],{"_16":6695,"_22":5460,"_69":6},[],{"_16":6722,"_18":6723,"_20":6724,"_22":5456,"_24":6725,"_28":6727,"_30":6728},"mfem.matrix.eigenvalues","mfem.matrix.eigenvalues(dm)","eigenvalues",[6726],{"_16":6695,"_22":5460,"_69":6},"Promise",[],{"_16":6730,"_18":6731,"_20":6732,"_22":5456,"_24":6733,"_28":5508,"_30":6735},"mfem.matrix.fromArray","mfem.matrix.fromArray(data)","fromArray",[6734],{"_16":84,"_22":4840,"_69":6},[],{"_16":6737,"_18":6738,"_20":6739,"_22":5456,"_24":6740,"_28":5703,"_30":6746},"mfem.matrix.get","mfem.matrix.get(dm, i, j)","get_2",[6741,6742,6744],{"_16":6695,"_22":5460,"_69":6},{"_16":6743,"_22":5703,"_69":6},"i",{"_16":6745,"_22":5703,"_69":6},"j",[],{"_16":6748,"_18":6749,"_20":6750,"_22":5456,"_24":6751,"_28":5450,"_30":6753},"mfem.matrix.getData","mfem.matrix.getData(dm)","getData",[6752],{"_16":6695,"_22":5460,"_69":6},[],{"_16":6755,"_18":6756,"_20":6757,"_22":5456,"_24":6758,"_28":5508,"_30":6760},"mfem.matrix.identity","mfem.matrix.identity(n)","identity_2",[6759],{"_16":362,"_22":5703,"_69":6},[],{"_16":6762,"_18":6763,"_20":6764,"_22":5456,"_24":6765,"_28":1426,"_30":6767},"mfem.matrix.invert","mfem.matrix.invert(dm)","invert",[6766],{"_16":6695,"_22":5460,"_69":6},[],{"_16":6769,"_18":6770,"_20":6771,"_22":5456,"_24":6772,"_28":1426,"_30":6777},"mfem.matrix.mult","mfem.matrix.mult(dm, x, y)","mult",[6773,6774,6776],{"_16":6695,"_22":5460,"_69":6},{"_16":498,"_22":6775,"_69":6},"Vector",{"_16":501,"_22":6775,"_69":6},[],{"_16":6779,"_18":6780,"_20":6781,"_22":5456,"_24":6782,"_28":1426,"_30":6786},"mfem.matrix.multTranspose","mfem.matrix.multTranspose(dm, x, y)","multTranspose",[6783,6784,6785],{"_16":6695,"_22":5460,"_69":6},{"_16":498,"_22":6775,"_69":6},{"_16":501,"_22":6775,"_69":6},[],{"_16":6788,"_18":6789,"_20":2472,"_22":5456,"_24":6790,"_28":5703,"_30":6792},"mfem.matrix.rows","mfem.matrix.rows(dm)",[6791],{"_16":6695,"_22":5460,"_69":6},[],{"_16":6794,"_18":6795,"_20":6796,"_22":5456,"_24":6797,"_28":1426,"_30":6802},"mfem.matrix.set","mfem.matrix.set(dm, i, j, value)","set_2",[6798,6799,6800,6801],{"_16":6695,"_22":5460,"_69":6},{"_16":6743,"_22":5703,"_69":6},{"_16":6745,"_22":5703,"_69":6},{"_16":235,"_22":5703,"_69":6},[],{"_16":6804,"_18":6805,"_20":3815,"_22":5456,"_24":6806,"_28":6312,"_30":6809},"mfem.matrix.solve","mfem.matrix.solve(dm, b)",[6807,6808],{"_16":6695,"_22":5460,"_69":6},{"_16":436,"_22":6775,"_69":6},[],{"_16":6811,"_18":6812,"_20":1484,"_22":5456,"_24":6813,"_28":6727,"_30":6815},"mfem.matrix.svd","mfem.matrix.svd(dm)",[6814],{"_16":6695,"_22":5460,"_69":6},[],{"_16":6817,"_18":6818,"_20":1587,"_22":5456,"_24":6819,"_28":5703,"_30":6821},"mfem.matrix.trace","mfem.matrix.trace(dm)",[6820],{"_16":6695,"_22":5460,"_69":6},[],{"_16":6823,"_18":6824,"_20":6825,"_22":5456,"_24":6826,"_28":5508,"_30":6828},"mfem.matrix.transpose","mfem.matrix.transpose(dm)","transpose_2",[6827],{"_16":6695,"_22":5460,"_69":6},[],{"_16":6830,"_18":6831,"_20":353,"_22":5456,"_24":6832,"_28":5508,"_30":6835},"mfem.matrix.zeros","mfem.matrix.zeros(rows, cols)",[6833,6834],{"_16":2472,"_22":5703,"_69":6},{"_16":2475,"_22":5703,"_69":6},[],{"_16":6837,"_18":6838,"_20":5502,"_22":5503,"_24":6839,"_28":5508,"_30":6842},"mfem.matrix.DenseMatrix.create","mfem.matrix.DenseMatrix.create(height, width)",[6840,6841],{"_16":174,"_22":4979,"_69":6},{"_16":4981,"_22":5507,"_69":6},[],{"_16":6844,"_18":6845,"_20":5513,"_22":5513,"_24":6846,"_28":5508,"_30":6849},"mfem.matrix.DenseMatrix.zeros","mfem.matrix.DenseMatrix.zeros(height, width)",[6847,6848],{"_16":174,"_22":4979,"_69":6},{"_16":4981,"_22":5507,"_69":6},[],{"_16":6851,"_18":6852,"_20":5521,"_22":5521,"_24":6853,"_28":5508,"_30":6855},"mfem.matrix.DenseMatrix.identity","mfem.matrix.DenseMatrix.identity(n)",[6854],{"_16":362,"_22":5524,"_69":6},[],{"_16":6857,"_18":6858,"_20":5529,"_22":5529,"_24":6859,"_28":5508,"_30":6861},"mfem.matrix.DenseMatrix.fromArray","mfem.matrix.DenseMatrix.fromArray(data)",[6860],{"_16":84,"_22":5532,"_69":6},[],{"_16":6863,"_18":6864,"_20":5537,"_22":5538,"_24":6865,"_28":5508,"_30":6868},"mfem.matrix.DenseMatrix.fromPointer","mfem.matrix.DenseMatrix.fromPointer(ptr, ownsMemory?)",[6866,6867],{"_16":4648,"_22":5541,"_69":6},{"_16":5543,"_22":5544,"_69":11},[],{"_16":6870,"_18":6871,"_20":6872,"_22":6873,"_24":6874,"_28":1426,"_30":6880},"mfem.mesh.derefine","mfem.mesh.derefine(mesh, derefinements)","Derefines (coarsens) specified elements in a non-conforming mesh.\r","Derefines (coarsens) specified elements in a non-conforming mesh.\r\n\r\nDerefinement is the reverse of refinement - it merges previously refined\r\nelements back into their parent elements. This is useful for adaptive\r\nmesh refinement (AMR) where elements may need to be coarsened after\r\nsolution features have moved or diminished.\r\n\r\n**Requirements:**\r\n- The mesh must have NCMesh (non-conforming mesh) support enabled\r\n- The elements must have been previously refined\r\n- The derefinement indices refer to rows in the NCMesh derefinement table\r\n\r\nTo enable NCMesh support before refinement, use .",[6875,6877],{"_16":290,"_22":6876,"_69":6},"- Mesh instance with NCMesh support",{"_16":6878,"_22":6879,"_69":6},"derefinements","- Array of derefinement table row indices",[],{"_16":6882,"_18":6883,"_20":6884,"_22":6885,"_24":6886,"_28":1426,"_30":6888},"mfem.mesh.enableNCMesh","mfem.mesh.enableNCMesh(mesh)","Enables non-conforming mesh (NCMesh) support.\r","Enables non-conforming mesh (NCMesh) support.\r\n\r\nNCMesh support is required for local refinement with hanging nodes\r\nand for derefinement (coarsening). This function must be called\r\nbefore any local refinement operations if derefinement is desired later.",[6887],{"_16":290,"_22":4754,"_69":6},[],{"_16":6890,"_18":6891,"_20":6892,"_22":6893,"_24":6894,"_28":5703,"_30":6896},"mfem.mesh.getDerefTableSize","mfem.mesh.getDerefTableSize(mesh)","Gets the size of the derefinement table.\r","Gets the size of the derefinement table.\r\n\r\nThe derefinement table contains information about which element groups\r\ncan be coarsened. Each row in the table represents one possible\r\nderefinement operation.",[6895],{"_16":290,"_22":6876,"_69":6},[],{"_16":6898,"_18":6899,"_20":6900,"_22":6900,"_24":6901,"_28":6903,"_30":6904},"mfem.mesh.isNCMesh","mfem.mesh.isNCMesh(mesh)","Checks if a mesh has NCMesh (non-conforming mesh) support.",[6902],{"_16":290,"_22":4754,"_69":6},"boolean",[],{"_16":6906,"_18":6907,"_20":6908,"_22":6909,"_24":6910,"_28":1426,"_30":6916},"mfem.mesh.elevateNURBSDegree","mfem.mesh.elevateNURBSDegree(mesh, relDegree)","Elevates the polynomial degree of a NURBS mesh.\r","Elevates the polynomial degree of a NURBS mesh.\r\n\r\nThis modifies the mesh in place by increasing the polynomial order of\r\nall NURBS patches. The geometry is preserved exactly while adding\r\nadditional control points.",[6911,6913],{"_16":290,"_22":6912,"_69":6},"- NURBS mesh to elevate",{"_16":6914,"_22":6915,"_69":6},"relDegree","- Relative degree increase (e.g., 1 to go from order 2 to 3)",[],{"_16":6918,"_18":6919,"_20":6920,"_22":6921,"_24":6922,"_28":1426,"_30":6927},"mfem.mesh.setNURBSOrder","mfem.mesh.setNURBSOrder(mesh, order)","Sets the NURBS order uniformly.\r","Sets the NURBS order uniformly.\r\n\r\nThis sets the curvature order of the mesh, which affects the underlying\r\nNURBS representation. Note that this may perform degree elevation or\r\nreduction depending on the current order.",[6923,6925],{"_16":290,"_22":6924,"_69":6},"- NURBS mesh",{"_16":5562,"_22":6926,"_69":6},"- New polynomial order",[],{"_16":6929,"_18":6930,"_20":6931,"_22":6932,"_24":6933,"_28":4806,"_30":6936},"mfem.mesh.fromBinary","mfem.mesh.fromBinary(data)","Loads a mesh from a base64-encoded binary string.\r","Loads a mesh from a base64-encoded binary string.\r\n\r\nThis is the inverse of . The base64 string is decoded\r\nand parsed as an MFEM format mesh.",[6934],{"_16":84,"_22":6935,"_69":6},"- Base64-encoded string containing mesh data",[],{"_16":6938,"_18":6939,"_20":6940,"_22":6941,"_24":6942,"_28":4806,"_30":6945},"mfem.mesh.fromGmsh","mfem.mesh.fromGmsh(data)","Loads a mesh from a Gmsh format string.\r","Loads a mesh from a Gmsh format string.\r\n\r\nParses mesh data in Gmsh MSH format (versions 2.x and 4.x are supported).\r\nThis is useful for importing meshes created with the Gmsh mesh generator\r\nor exported from other tools in Gmsh format.",[6943],{"_16":84,"_22":6944,"_69":6},"- Gmsh mesh format string (MSH file contents)",[],{"_16":6947,"_18":6948,"_20":6949,"_22":6950,"_24":6951,"_28":4806,"_30":6954},"mfem.mesh.fromMFEM","mfem.mesh.fromMFEM(data)","Loads a mesh from an MFEM native format string.\r","Loads a mesh from an MFEM native format string.\r\n\r\nThis is an alias for provided for API consistency.\r\nMFEM's native mesh format is automatically detected by the parser.",[6952],{"_16":84,"_22":6953,"_69":6},"- MFEM native format mesh string (.mesh file contents)",[],{"_16":6956,"_18":6957,"_20":6958,"_22":6959,"_24":6960,"_28":4806,"_30":6963},"mfem.mesh.fromNetgen","mfem.mesh.fromNetgen(data)","Loads a mesh from a Netgen format string.\r","Loads a mesh from a Netgen format string.\r\n\r\nParses mesh data in Netgen neutral format. MFEM automatically detects\r\nthe format based on file headers:\r\n- 2D meshes typically start with \"areasmesh2\" or \"curved_areamesh2\"\r\n- 3D meshes typically start with \"NETGEN\" or \"NETGEN_Neutral_Format\"",[6961],{"_16":84,"_22":6962,"_69":6},"- Netgen format mesh string",[],{"_16":6965,"_18":6966,"_20":6967,"_22":6968,"_24":6969,"_28":4806,"_30":6972},"mfem.mesh.fromTrueGrid","mfem.mesh.fromTrueGrid(data)","Loads a mesh from a TrueGrid format string.\r","Loads a mesh from a TrueGrid format string.\r\n\r\nParses mesh data in TrueGrid format. MFEM automatically detects\r\nthe format based on file headers. TrueGrid files typically start\r\nwith \"TrueGrid\".",[6970],{"_16":84,"_22":6971,"_69":6},"- TrueGrid format mesh string",[],{"_16":6974,"_18":6975,"_20":6976,"_22":6977,"_24":6978,"_28":4806,"_30":6981},"mfem.mesh.fromVTK","mfem.mesh.fromVTK(data)","Loads a mesh from a VTK format string.\r","Loads a mesh from a VTK format string.\r\n\r\nParses mesh data in VTK legacy format (.vtk). This is useful for importing\r\nmeshes from visualization tools like ParaView or VTK-based applications.",[6979],{"_16":84,"_22":6980,"_69":6},"- VTK legacy format string (.vtk file contents)",[],{"_16":6983,"_18":6984,"_20":6985,"_22":6986,"_24":6987,"_28":4840,"_30":6990},"mfem.mesh.getElementCentroids","mfem.mesh.getElementCentroids(mesh)","Computes the centroid (geometric center) of each element in the mesh.\r","Computes the centroid (geometric center) of each element in the mesh.\r\n\r\nThe centroid is the average of the element's vertex coordinates and\r\nrepresents the center of mass assuming uniform density.",[6988],{"_16":290,"_22":6989,"_69":6},"- The mesh to compute element centroids for",[],{"_16":6992,"_18":6993,"_20":6994,"_22":6995,"_24":6996,"_28":5450,"_30":6999},"mfem.mesh.getElementVolumes","mfem.mesh.getElementVolumes(mesh)","Computes the volume (or area/length) of each element in the mesh.\r","Computes the volume (or area/length) of each element in the mesh.\r\n\r\nReturns the measure of each element according to the mesh dimension:\r\n- 1D: element lengths\r\n- 2D: element areas\r\n- 3D: element volumes\r\n\r\nThis is useful for computing integrals, checking mesh quality,\r\nor applying element-based operations.",[6997],{"_16":290,"_22":6998,"_69":6},"- The mesh to compute element volumes for",[],{"_16":7001,"_18":7002,"_20":7003,"_22":7003,"_24":7004,"_28":5450,"_30":7012},"mfem.mesh.getNURBSKnotVector","mfem.mesh.getNURBSKnotVector(mesh, patchIdx, dir)","Gets the knot vector for a NURBS patch in a specific direction.",[7005,7006,7009],{"_16":290,"_22":6924,"_69":6},{"_16":7007,"_22":7008,"_69":6},"patchIdx","- Patch index",{"_16":7010,"_22":7011,"_69":6},"dir","- Direction (0, 1, or 2 for x, y, z)",[],{"_16":7014,"_18":7015,"_20":7016,"_22":7016,"_24":7017,"_28":7020,"_30":7021},"mfem.mesh.getNURBSPatch","mfem.mesh.getNURBSPatch(mesh, patchIdx)","Gets full NURBS patch data including knot vectors.",[7018,7019],{"_16":290,"_22":6924,"_69":6},{"_16":7007,"_22":7008,"_69":6},"NURBSPatch",[],{"_16":7023,"_18":7024,"_20":7025,"_22":7025,"_24":7026,"_28":7029,"_30":7030},"mfem.mesh.getNURBSPatchInfo","mfem.mesh.getNURBSPatchInfo(mesh, patchIdx)","Gets information about a NURBS patch.",[7027,7028],{"_16":290,"_22":6924,"_69":6},{"_16":7007,"_22":7008,"_69":6},"NURBSPatchInfo",[],{"_16":7032,"_18":7033,"_20":7034,"_22":7034,"_24":7035,"_28":5703,"_30":7037},"mfem.mesh.getNumNURBSPatches","mfem.mesh.getNumNURBSPatches(mesh)","Gets the number of NURBS patches in the mesh.",[7036],{"_16":290,"_22":6924,"_69":6},[],{"_16":7039,"_18":7040,"_20":7041,"_22":7041,"_24":7042,"_28":1426,"_30":7049},"mfem.mesh.insertNURBSKnot","mfem.mesh.insertNURBSKnot(mesh, direction, knot)","Inserts a single knot into a NURBS mesh.",[7043,7044,7046],{"_16":290,"_22":6924,"_69":6},{"_16":954,"_22":7045,"_69":6},"- Parametric direction (0=x, 1=y, 2=z)",{"_16":7047,"_22":7048,"_69":6},"knot","- Knot value to insert (must be within the parametric domain)",[],{"_16":7051,"_18":7052,"_20":7053,"_22":7053,"_24":7054,"_28":1426,"_30":7060},"mfem.mesh.insertNURBSKnots","mfem.mesh.insertNURBSKnots(mesh, direction, knots)","Inserts multiple knots into a NURBS mesh in a specific direction.",[7055,7056,7057],{"_16":290,"_22":6924,"_69":6},{"_16":954,"_22":7045,"_69":6},{"_16":7058,"_22":7059,"_69":6},"knots","- Array of knot values to insert",[],{"_16":7062,"_18":7063,"_20":7064,"_22":7065,"_24":7066,"_28":1426,"_30":7072},"mfem.mesh.uniformNURBSRefinement","mfem.mesh.uniformNURBSRefinement(mesh, refFactor?)","Performs uniform refinement on a NURBS mesh.\r","Performs uniform refinement on a NURBS mesh.\r\n\r\nThis inserts new knots uniformly within each existing span, refining\r\nthe NURBS mesh while preserving the geometry exactly.",[7067,7069],{"_16":290,"_22":7068,"_69":6},"- NURBS mesh to refine",{"_16":7070,"_22":7071,"_69":11},"refFactor","- Refinement factor (1 = 1 new knot per span, etc.)",[],{"_16":7074,"_18":7075,"_20":7076,"_22":7077,"_24":7078,"_28":4806,"_30":7084},"mfem.mesh.makeCartesian1D","mfem.mesh.makeCartesian1D(n, sx?)","Creates a 1D Cartesian (line segment) mesh.\r","Creates a 1D Cartesian (line segment) mesh.\r\n\r\nGenerates a uniform mesh on the interval [0, sx] with `n` line segment elements.\r\nThis is useful for 1D finite element problems like ODEs, 1D heat transfer,\r\nor testing numerical methods.",[7079,7081],{"_16":362,"_22":7080,"_69":6},"- Number of elements (must be ≥ 1)",{"_16":7082,"_22":7083,"_69":11},"sx","- Domain size / length of the interval (default 1.0)",[],{"_16":7086,"_18":7087,"_20":7088,"_22":7089,"_24":7090,"_28":4806,"_30":7104},"mfem.mesh.makeCartesian2D","mfem.mesh.makeCartesian2D(nx, ny, type?, sx?, sy?)","Creates a 2D Cartesian (rectangular) mesh.\r","Creates a 2D Cartesian (rectangular) mesh.\r\n\r\nGenerates a structured mesh on the rectangular domain [0, sx] × [0, sy]\r\nwith the specified number of elements in each direction.",[7091,7094,7097,7099,7101],{"_16":7092,"_22":7093,"_69":6},"nx","- Number of elements in the x-direction (must be ≥ 1)",{"_16":7095,"_22":7096,"_69":6},"ny","- Number of elements in the y-direction (must be ≥ 1)",{"_16":6485,"_22":7098,"_69":11},"- Element type: `'quad'` for quadrilaterals (default), `'tri'` for triangles",{"_16":7082,"_22":7100,"_69":11},"- Domain size in x-direction (default 1.0)",{"_16":7102,"_22":7103,"_69":11},"sy","- Domain size in y-direction (default 1.0)",[],{"_16":7106,"_18":7107,"_20":7108,"_22":7109,"_24":7110,"_28":4806,"_30":7122},"mfem.mesh.makeCartesian3D","mfem.mesh.makeCartesian3D(nx, ny, nz, type?, sx?, sy?, sz?)","Creates a 3D Cartesian (box) mesh.\r","Creates a 3D Cartesian (box) mesh.\r\n\r\nGenerates a structured mesh on the box domain [0, sx] × [0, sy] × [0, sz]\r\nwith the specified number of elements in each direction.",[7111,7112,7113,7115,7117,7118,7119],{"_16":7092,"_22":7093,"_69":6},{"_16":7095,"_22":7096,"_69":6},{"_16":4101,"_22":7114,"_69":6},"- Number of elements in the z-direction (must be ≥ 1)",{"_16":6485,"_22":7116,"_69":11},"- Element type: `'hex'` for hexahedra (default), `'tet'` for tetrahedra, `'wedge'` for wedges",{"_16":7082,"_22":7100,"_69":11},{"_16":7102,"_22":7103,"_69":11},{"_16":7120,"_22":7121,"_69":11},"sz","- Domain size in z-direction (default 1.0)",[],{"_16":7124,"_18":7125,"_20":7126,"_22":7127,"_24":7128,"_28":4806,"_30":7134},"mfem.mesh.makeCircle","mfem.mesh.makeCircle(npts, radius?)","Creates a 2D circular disk mesh.\r","Creates a 2D circular disk mesh.\r\n\r\nGenerates a triangulated mesh approximating a circular disk by creating a\r\nsquare mesh and applying an elliptic conformal mapping. This mapping\r\npreserves mesh quality while smoothly transforming the square to a circle.\r\n\r\nThe mesh is centered at the origin with the specified radius.",[7129,7132],{"_16":7130,"_22":7131,"_69":6},"npts","- Controls mesh density. Higher values create finer meshes (minimum 3)",{"_16":150,"_22":7133,"_69":11},"- Radius of the circular disk (default 1.0)",[],{"_16":7136,"_18":7137,"_20":7138,"_22":7139,"_24":7140,"_28":4806,"_30":7147},"mfem.mesh.makeCylinder","mfem.mesh.makeCylinder(npts, length?, radius?)","Creates a 3D solid cylinder mesh.\r","Creates a 3D solid cylinder mesh.\r\n\r\nGenerates a hexahedral mesh of a solid cylinder by creating a box mesh\r\nand applying an elliptic conformal mapping to the x-y cross-section while\r\npreserving the z-coordinate. The cylinder is centered on the z-axis with\r\nz ∈ [0, length].",[7141,7143,7145],{"_16":7130,"_22":7142,"_69":6},"- Controls mesh density via ∛npts elements per side (minimum 4)",{"_16":987,"_22":7144,"_69":11},"- Length of the cylinder in the z-direction (default 1.0)",{"_16":150,"_22":7146,"_69":11},"- Radius of the cylinder in the x-y plane (default 1.0)",[],{"_16":7149,"_18":7150,"_20":7151,"_22":7152,"_24":7153,"_28":4806,"_30":7158},"mfem.mesh.makeDisk","mfem.mesh.makeDisk(npts, radius?)","Creates a 2D disk mesh using elliptic mapping.\r","Creates a 2D disk mesh using elliptic mapping.\r\n\r\nGenerates a triangulated mesh of a circular disk by mapping a square mesh\r\nto a disk using the elliptic conformal mapping:\r\n```\r\nx = u × √(1 - v²/2) × radius\r\ny = v × √(1 - u²/2) × radius\r\n```\r\n\r\nThis mapping produces high-quality elements with smooth variation across\r\nthe domain, making it suitable for finite element analysis.",[7154,7156],{"_16":7130,"_22":7155,"_69":6},"- Controls mesh density via √npts elements per side (minimum 3)",{"_16":150,"_22":7157,"_69":11},"- Radius of the disk (default 1.0)",[],{"_16":7160,"_18":7161,"_20":7162,"_22":7163,"_24":7164,"_28":4806,"_30":7168},"mfem.mesh.makeSphere","mfem.mesh.makeSphere(npts, radius?)","Creates a 3D solid sphere (ball) mesh.\r","Creates a 3D solid sphere (ball) mesh.\r\n\r\nGenerates a tetrahedral mesh of a solid ball by creating a cube mesh\r\nand applying a radial projection transformation. Interior points are\r\nmapped proportionally while boundary points are projected to the sphere surface.\r\n\r\nThe mesh is centered at the origin with the specified radius.",[7165,7166],{"_16":7130,"_22":7142,"_69":6},{"_16":150,"_22":7167,"_69":11},"- Radius of the sphere (default 1.0)",[],{"_16":7170,"_18":7171,"_20":7172,"_22":7173,"_24":7174,"_28":1426,"_30":7179},"mfem.mesh.refineLocal","mfem.mesh.refineLocal(mesh, elements)","Locally refines specified elements in the mesh.\r","Locally refines specified elements in the mesh.\r\n\r\nPerforms adaptive refinement by subdividing only the specified elements,\r\nleaving other elements unchanged. This is useful for adaptive mesh refinement\r\n(AMR) strategies where refinement is focused on regions with high error.\r\n\r\nThe mesh maintains conformity by adding necessary transition elements between\r\nrefined and unrefined regions.",[7175,7177],{"_16":290,"_22":7176,"_69":6},"- The mesh to refine (modified in place)",{"_16":132,"_22":7178,"_69":6},"- Array of element indices to refine (0-based)",[],{"_16":7181,"_18":7182,"_20":7183,"_22":7184,"_24":7185,"_28":1426,"_30":7188},"mfem.mesh.refineNonconforming","mfem.mesh.refineNonconforming(mesh, elements)","Performs non-conforming refinement of specified elements.\r","Performs non-conforming refinement of specified elements.\r\n\r\nNon-conforming refinement allows hanging nodes (vertices that lie on\r\nedges/faces of neighboring elements) which enables more flexible local\r\nrefinement without requiring transition elements.\r\n\r\n**Note:** The current implementation uses the same mechanism as\r\n. True non-conforming refinement with hanging node\r\nsupport requires full NCMesh integration which is not yet available.",[7186,7187],{"_16":290,"_22":7176,"_69":6},{"_16":132,"_22":7178,"_69":6},[],{"_16":7190,"_18":7191,"_20":7192,"_22":7193,"_24":7194,"_28":1426,"_30":7199},"mfem.mesh.refineUniform","mfem.mesh.refineUniform(mesh, times?)","Uniformly refines a mesh one or more times.\r","Uniformly refines a mesh one or more times.\r\n\r\nEach refinement level subdivides every element into smaller elements:\r\n- 2D triangles → 4 triangles\r\n- 2D quadrilaterals → 4 quadrilaterals\r\n- 3D tetrahedra → 8 tetrahedra\r\n- 3D hexahedra → 8 hexahedra\r\n\r\nThe number of elements grows exponentially: after `times` refinements,\r\na 2D mesh will have 4^times × original elements.",[7195,7196],{"_16":290,"_22":7176,"_69":6},{"_16":7197,"_22":7198,"_69":11},"times","- Number of refinement levels to apply (default 1)",[],{"_16":7201,"_18":7202,"_20":7203,"_22":7204,"_24":7205,"_28":1426,"_30":7212},"mfem.mesh.rotate","mfem.mesh.rotate(mesh, angle, axis?)","Rotates a mesh around an axis.\r","Rotates a mesh around an axis.\r\n\r\nFor 2D meshes, rotates around the origin (z-axis).\r\nFor 3D meshes, rotates around the specified coordinate axis passing\r\nthrough the origin.\r\n\r\nRotation follows the right-hand rule: positive angles rotate\r\ncounterclockwise when looking along the axis toward the origin.",[7206,7208,7210],{"_16":290,"_22":7207,"_69":6},"- The mesh to rotate (modified in place)",{"_16":2344,"_22":7209,"_69":6},"- Rotation angle in radians (positive = counterclockwise)",{"_16":2299,"_22":7211,"_69":11},"- Rotation axis for 3D: 0=x, 1=y, 2=z (default). Ignored for 2D.",[],{"_16":7214,"_18":7215,"_20":7216,"_22":7217,"_24":7218,"_28":1426,"_30":7223},"mfem.mesh.scale","mfem.mesh.scale(mesh, factor)","Scales a mesh uniformly or along each axis.\r","Scales a mesh uniformly or along each axis.\r\n\r\nMultiplies all vertex coordinates by the scale factor(s), effectively\r\nresizing the mesh. Scaling is performed relative to the origin.",[7219,7221],{"_16":290,"_22":7220,"_69":6},"- The mesh to scale (modified in place)",{"_16":3890,"_22":7222,"_69":6},"- Either a single uniform scale factor, or an array of\r\n per-axis factors [sx, sy] (2D) or [sx, sy, sz] (3D)",[],{"_16":7225,"_18":7226,"_20":7227,"_22":7228,"_24":7229,"_28":1426,"_30":7234},"mfem.mesh.setCurvature","mfem.mesh.setCurvature(mesh, order)","Sets the curvature order for high-order geometry representation.\r","Sets the curvature order for high-order geometry representation.\r\n\r\nConverts the mesh to use high-order polynomial nodes for representing\r\ncurved element boundaries. This is essential for accurately representing\r\ncurved domains (circles, spheres, etc.) and achieving optimal convergence\r\nrates with high-order finite elements.\r\n\r\nHigher orders provide better approximation of curved boundaries but\r\nincrease the number of geometry nodes per element.",[7230,7232],{"_16":290,"_22":7231,"_69":6},"- The mesh to set curvature on (modified in place)",{"_16":5562,"_22":7233,"_69":6},"- Polynomial order for geometry representation (≥ 1)",[],{"_16":7236,"_18":7237,"_20":7238,"_22":7239,"_24":7240,"_28":7246,"_30":7247},"mfem.mesh.getBoundaryNormals","mfem.mesh.getBoundaryNormals(mesh, bdrAttribute?)","Computes unit normal vectors for all boundary elements (or a subset).\r","Computes unit normal vectors for all boundary elements (or a subset).\r\n\r\nThis is a convenience function that calls for each\r\nboundary element and collects the results. The normals are computed at the\r\ncentroid of each boundary element.",[7241,7243],{"_16":290,"_22":7242,"_69":6},"- The mesh to compute boundary normals for",{"_16":7244,"_22":7245,"_69":11},"bdrAttribute","- Optional: If provided, only compute normals for boundary\r\n elements with this attribute. If undefined, compute for all.","Map",[],{"_16":7249,"_18":7250,"_20":7251,"_22":7252,"_24":7253,"_28":5450,"_30":7255},"mfem.mesh.getBoundaryNormalsFlat","mfem.mesh.getBoundaryNormalsFlat(mesh)","Computes unit normal vectors for all boundary elements as a flat array.\r","Computes unit normal vectors for all boundary elements as a flat array.\r\n\r\nThis is more efficient than when you need normals\r\nfor all boundary elements in a contiguous array format.",[7254],{"_16":290,"_22":7242,"_69":6},[],{"_16":7257,"_18":7258,"_20":7259,"_22":7260,"_24":7261,"_28":4712,"_30":7270},"mfem.mesh.getSurfaceNormal","mfem.mesh.getSurfaceNormal(mesh, bdrIndex, refPoint?)","Computes the unit outward normal vector at a point on a boundary element.\r","Computes the unit outward normal vector at a point on a boundary element.\r\n\r\nFor a 2D mesh (spaceDim=2, dim=1 on boundary):\r\n- The tangent is the Jacobian column\r\n- The normal is perpendicular (rotated 90 degrees)\r\n\r\nFor a 3D surface (spaceDim=3, dim=2 on boundary):\r\n- The two tangent vectors are the Jacobian columns\r\n- The normal is their cross product\r\n\r\nNote: The \"outward\" direction depends on the mesh orientation. MFEM typically\r\norients boundary elements so that the computed normal points outward.",[7262,7264,7267],{"_16":290,"_22":7263,"_69":6},"- The mesh containing the boundary element",{"_16":7265,"_22":7266,"_69":6},"bdrIndex","- Zero-based boundary element index",{"_16":7268,"_22":7269,"_69":11},"refPoint","- Optional reference coordinates on the boundary element.\r\n If not provided, uses the element centroid.",[],{"_16":7272,"_18":7273,"_20":7274,"_22":7275,"_24":7276,"_28":4840,"_30":7283},"mfem.mesh.getSurfaceTangents","mfem.mesh.getSurfaceTangents(mesh, bdrIndex, refPoint?, normalize?)","Gets the tangent vectors at a point on a boundary element.\r","Gets the tangent vectors at a point on a boundary element.\r\n\r\nThe tangent vectors are extracted directly from the Jacobian matrix columns.\r\nFor a 1D boundary element (edge), returns 1 tangent vector.\r\nFor a 2D boundary element (face), returns 2 tangent vectors.\r\n\r\nThe tangent vectors are NOT normalized - they represent the actual\r\ndifferential change in physical coordinates per unit change in reference\r\ncoordinates. Use this for computing surface metrics, arc lengths, or areas.",[7277,7278,7279,7280],{"_16":290,"_22":7263,"_69":6},{"_16":7265,"_22":7266,"_69":6},{"_16":7268,"_22":7269,"_69":11},{"_16":7281,"_22":7282,"_69":11},"normalize","- If true, normalize the tangent vectors to unit length.\r\n Default is false.",[],{"_16":7285,"_18":7286,"_20":7287,"_22":7288,"_24":7289,"_28":6108,"_30":7292},"mfem.mesh.toBinary","mfem.mesh.toBinary(mesh)","Exports a mesh to a base64-encoded binary string.\r","Exports a mesh to a base64-encoded binary string.\r\n\r\nThis provides a compact representation of the mesh suitable for\r\nstorage in JSON, localStorage, or transmission. The mesh is first\r\nserialized to MFEM format and then base64-encoded.",[7290],{"_16":290,"_22":7291,"_69":6},"- The mesh to export",[],{"_16":7294,"_18":7295,"_20":7296,"_22":7297,"_24":7298,"_28":6108,"_30":7300},"mfem.mesh.toGmsh","mfem.mesh.toGmsh(mesh)","Exports a mesh to Gmsh MSH 2.2 format string.\r","Exports a mesh to Gmsh MSH 2.2 format string.\r\n\r\nGenerates a string representation of the mesh in Gmsh MSH format,\r\nwhich can be used with Gmsh or other tools that support this format.\r\n\r\n**Note:** This is a simplified implementation that exports node coordinates\r\nand basic element information. Full element connectivity is not yet supported.\r\nFor complete mesh export, prefer or .",[7299],{"_16":290,"_22":7291,"_69":6},[],{"_16":7302,"_18":7303,"_20":7304,"_22":7305,"_24":7306,"_28":6108,"_30":7308},"mfem.mesh.toMFEM","mfem.mesh.toMFEM(mesh)","Exports a mesh to MFEM native format string.\r","Exports a mesh to MFEM native format string.\r\n\r\nGenerates a string representation of the mesh in MFEM's native format,\r\nwhich can be saved to a file or used with other MFEM tools. This format\r\npreserves all mesh information including high-order geometry nodes.",[7307],{"_16":290,"_22":7291,"_69":6},[],{"_16":7310,"_18":7311,"_20":7312,"_22":7313,"_24":7314,"_28":6108,"_30":7316},"mfem.mesh.toNetgen","mfem.mesh.toNetgen(mesh)","Exports a mesh to Netgen/TrueGrid format string.\r","Exports a mesh to Netgen/TrueGrid format string.\r\n\r\nUses MFEM's PrintXG() method which outputs a Netgen-compatible format.\r\nThis format can be imported by Netgen and related tools.",[7315],{"_16":290,"_22":7291,"_69":6},[],{"_16":7318,"_18":7319,"_20":7320,"_22":7321,"_24":7322,"_28":6108,"_30":7325},"mfem.mesh.toParaView","mfem.mesh.toParaView(mesh, options?)","Exports a mesh to ParaView VTU (VTK XML Unstructured Grid) format string.\r","Exports a mesh to ParaView VTU (VTK XML Unstructured Grid) format string.\r\n\r\nVTU is an XML-based format that can be directly loaded by ParaView\r\nand other VTK-compatible visualization tools. It supports high-order\r\nelement visualization through refinement.",[7323,7324],{"_16":290,"_22":7291,"_69":6},{"_16":4789,"_22":6127,"_69":11},[],{"_16":7327,"_18":7328,"_20":7329,"_22":7330,"_24":7331,"_28":6108,"_30":7333},"mfem.mesh.toVTK","mfem.mesh.toVTK(mesh)","Exports a mesh to VTK legacy format string.\r","Exports a mesh to VTK legacy format string.\r\n\r\nGenerates a string representation of the mesh in VTK legacy format (.vtk),\r\nwhich can be visualized in ParaView, VisIt, or other VTK-compatible tools.",[7332],{"_16":290,"_22":7291,"_69":6},[],{"_16":7335,"_18":7336,"_20":7337,"_22":7338,"_24":7339,"_28":1426,"_30":7344},"mfem.mesh.transform","mfem.mesh.transform(mesh, fn)","Transforms all mesh vertex coordinates using a custom function.\r","Transforms all mesh vertex coordinates using a custom function.\r\n\r\nThis function applies an arbitrary coordinate transformation to every vertex\r\nin the mesh. It's useful for creating curved domains, deforming meshes, or\r\napplying custom mappings.\r\n\r\nThe transformation function receives the current coordinates as an array\r\nand must return an array of the same length with the new coordinates.",[7340,7342],{"_16":290,"_22":7341,"_69":6},"- The mesh to transform (modified in place)",{"_16":4908,"_22":7343,"_69":6},"- Transformation function that maps old coordinates to new coordinates",[],{"_16":7346,"_18":7347,"_20":7348,"_22":7349,"_24":7350,"_28":1426,"_30":7356},"mfem.mesh.translate","mfem.mesh.translate(mesh, offset)","Translates a mesh by an offset vector.\r","Translates a mesh by an offset vector.\r\n\r\nAdds the offset to all vertex coordinates, effectively moving the entire\r\nmesh in space without changing its shape or size.",[7351,7353],{"_16":290,"_22":7352,"_69":6},"- The mesh to translate (modified in place)",{"_16":7354,"_22":7355,"_69":6},"offset","- Translation vector [dx, dy] for 2D or [dx, dy, dz] for 3D",[],{"_16":7358,"_18":7359,"_20":7360,"_22":7361,"_24":7362,"_28":7363,"_30":7364},"mfem.mesh.IsoparametricTransformation.create","mfem.mesh.IsoparametricTransformation.create()","Creates a new IsoparametricTransformation.\r","Creates a new IsoparametricTransformation.\r\n\r\nThe transformation is initially unconfigured. You must call\r\n and before using it.",[],"Promise",[],{"_16":7366,"_18":7367,"_20":7368,"_22":7369,"_24":7370,"_28":4806,"_30":7371},"mfem.mesh.Mesh.create","mfem.mesh.Mesh.create()","Creates an empty mesh.\r","Creates an empty mesh.\r\n\r\nThe returned mesh has no elements, vertices, or boundaries. Use\r\n| loadFromString() to populate it with mesh data.",[],[],{"_16":7373,"_18":7374,"_20":7375,"_22":7376,"_24":7377,"_28":4806,"_30":7381},"mfem.mesh.Mesh.fromString","mfem.mesh.Mesh.fromString(meshData)","Loads a mesh from a string containing mesh data in MFEM format.\r","Loads a mesh from a string containing mesh data in MFEM format.\r\n\r\nSupports the MFEM mesh format (versions 1.0 and 1.1). The mesh format\r\nincludes sections for dimension, elements, boundary elements, and vertices.",[7378],{"_16":7379,"_22":7380,"_69":6},"meshData","- String containing the mesh data in MFEM format",[],{"_16":7383,"_18":7384,"_20":7385,"_22":7385,"_24":7386,"_28":1426,"_30":7392},"mfem.nonlinear.mult","mfem.nonlinear.mult(solver, b, x)","Solve nonlinear system F(x) = b.",[7387,7389,7390],{"_16":5445,"_22":7388,"_69":6},"- Nonlinear solver instance (NewtonSolver or LBFGSSolver)",{"_16":436,"_22":6345,"_69":6},{"_16":498,"_22":7391,"_69":6},"- Solution vector (modified in place, initial guess on input)",[],{"_16":7394,"_18":7395,"_20":7396,"_22":7397,"_24":7398,"_28":1426,"_30":7403},"mfem.nonlinear.setHistorySize","mfem.nonlinear.setHistorySize(solver, m)","Set history size for L-BFGS solver.\r","Set history size for L-BFGS solver.\r\n\r\nThe history size determines how many gradient vectors are stored for\r\napproximating the inverse Hessian.",[7399,7401],{"_16":5445,"_22":7400,"_69":6},"- LBFGSSolver instance",{"_16":359,"_22":7402,"_69":6},"- History size (number of vectors to store)",[],{"_16":7405,"_18":7406,"_20":7407,"_22":7408,"_24":7409,"_28":1426,"_30":7415},"mfem.nonlinear.setLinearSolver","mfem.nonlinear.setLinearSolver(solver, linearSolver)","Set linear solver for Newton iterations.\r","Set linear solver for Newton iterations.\r\n\r\nThe linear solver is used to solve the Jacobian system at each Newton step.",[7410,7412],{"_16":5445,"_22":7411,"_69":6},"- Newton solver instance",{"_16":7413,"_22":7414,"_69":6},"linearSolver","- Linear solver for Jacobian systems (e.g., CGSolver, GMRESSolver)",[],{"_16":7417,"_18":7418,"_20":7419,"_22":7419,"_24":7420,"_28":1426,"_30":7423},"mfem.nonlinear.setMaxIterations","mfem.nonlinear.setMaxIterations(solver, max)","Set maximum iterations for nonlinear solver.",[7421,7422],{"_16":5445,"_22":7388,"_69":6},{"_16":841,"_22":6356,"_69":6},[],{"_16":7425,"_18":7426,"_20":7427,"_22":7427,"_24":7428,"_28":1426,"_30":7433},"mfem.nonlinear.setOperator","mfem.nonlinear.setOperator(solver, oper)","Set nonlinear operator for the solver.",[7429,7430],{"_16":5445,"_22":7388,"_69":6},{"_16":7431,"_22":7432,"_69":6},"oper","- Nonlinear operator (e.g., NonlinearForm)",[],{"_16":7435,"_18":7436,"_20":7437,"_22":7437,"_24":7438,"_28":1426,"_30":7442},"mfem.nonlinear.setTolerance","mfem.nonlinear.setTolerance(solver, rtol, atol?)","Set convergence tolerances for nonlinear solver.",[7439,7440,7441],{"_16":5445,"_22":7388,"_69":6},{"_16":6385,"_22":6386,"_69":6},{"_16":6388,"_22":6389,"_69":11},[],{"_16":7444,"_18":7445,"_20":7446,"_22":7447,"_24":7448,"_28":7452,"_30":7453},"mfem.nonlinear.HyperelasticIntegrator.create","mfem.nonlinear.HyperelasticIntegrator.create(modelPtr)","Creates a new hyperelastic integrator.\r","Creates a new hyperelastic integrator.\r\nNote: The integrator does NOT take ownership of the model.",[7449],{"_16":7450,"_22":7451,"_69":6},"modelPtr","Pointer to HyperelasticModel (e.g., NeoHookeanModel)","Promise",[],{"_16":7455,"_18":7456,"_20":7457,"_22":7457,"_24":7458,"_28":7462,"_30":7463},"mfem.nonlinear.LBFGSSolver.create","mfem.nonlinear.LBFGSSolver.create(historySize?)","Creates a new L-BFGS solver.",[7459],{"_16":7460,"_22":7461,"_69":11},"historySize","Number of vectors to store for history (default 10)","Promise",[],{"_16":7465,"_18":7466,"_20":7467,"_22":7467,"_24":7468,"_28":7474,"_30":7475},"mfem.nonlinear.NeoHookeanModel.create","mfem.nonlinear.NeoHookeanModel.create(mu, K)","Creates a new NeoHookean material model.",[7469,7471],{"_16":4438,"_22":7470,"_69":6},"Shear modulus (Lamé's second parameter)",{"_16":7472,"_22":7473,"_69":6},"K","Bulk modulus","Promise",[],{"_16":7477,"_18":7478,"_20":7479,"_22":7479,"_24":7480,"_28":7481,"_30":7482},"mfem.nonlinear.NewtonSolver.create","mfem.nonlinear.NewtonSolver.create()","Creates a new Newton solver.",[],"Promise",[],{"_16":7484,"_18":7485,"_20":7486,"_22":7486,"_24":7487,"_28":7491,"_30":7492},"mfem.nonlinear.NonlinearForm.create","mfem.nonlinear.NonlinearForm.create(fespacePtr)","Creates a new NonlinearForm on the given finite element space.",[7488],{"_16":7489,"_22":7490,"_69":6},"fespacePtr","Pointer to FiniteElementSpace","Promise",[],{"_16":7494,"_18":7495,"_20":7496,"_22":7496,"_24":7497,"_28":7500,"_30":7501},"mfem.nonlinear.VectorConvectionIntegrator.create","mfem.nonlinear.VectorConvectionIntegrator.create(coeff?)","Creates a new vector convection integrator.",[7498],{"_16":4385,"_22":7499,"_69":11},"Optional scalar coefficient to scale the convection term","Promise",[],{"_16":7503,"_18":7504,"_20":7505,"_22":7505,"_24":7506,"_28":7507,"_30":7508},"mfem.ode.AB1Solver.create","mfem.ode.AB1Solver.create()","Creates a new AB1 solver.",[],"Promise",[],{"_16":7510,"_18":7511,"_20":7512,"_22":7512,"_24":7513,"_28":7514,"_30":7515},"mfem.ode.AB2Solver.create","mfem.ode.AB2Solver.create()","Creates a new AB2 solver.",[],"Promise",[],{"_16":7517,"_18":7518,"_20":7519,"_22":7519,"_24":7520,"_28":7521,"_30":7522},"mfem.ode.AB3Solver.create","mfem.ode.AB3Solver.create()","Creates a new AB3 solver.",[],"Promise",[],{"_16":7524,"_18":7525,"_20":7526,"_22":7526,"_24":7527,"_28":7528,"_30":7529},"mfem.ode.AB4Solver.create","mfem.ode.AB4Solver.create()","Creates a new AB4 solver.",[],"Promise",[],{"_16":7531,"_18":7532,"_20":7533,"_22":7533,"_24":7534,"_28":7535,"_30":7536},"mfem.ode.AB5Solver.create","mfem.ode.AB5Solver.create()","Creates a new AB5 solver.",[],"Promise",[],{"_16":7538,"_18":7539,"_20":7540,"_22":7540,"_24":7541,"_28":7542,"_30":7543},"mfem.ode.AM1Solver.create","mfem.ode.AM1Solver.create()","Creates a new AM1 solver.",[],"Promise",[],{"_16":7545,"_18":7546,"_20":7547,"_22":7547,"_24":7548,"_28":7549,"_30":7550},"mfem.ode.AM2Solver.create","mfem.ode.AM2Solver.create()","Creates a new AM2 solver.",[],"Promise",[],{"_16":7552,"_18":7553,"_20":7554,"_22":7554,"_24":7555,"_28":7556,"_30":7557},"mfem.ode.AM3Solver.create","mfem.ode.AM3Solver.create()","Creates a new AM3 solver.",[],"Promise",[],{"_16":7559,"_18":7560,"_20":7561,"_22":7561,"_24":7562,"_28":7563,"_30":7564},"mfem.ode.AM4Solver.create","mfem.ode.AM4Solver.create()","Creates a new AM4 solver.",[],"Promise",[],{"_16":7566,"_18":7567,"_20":7568,"_22":7568,"_24":7569,"_28":7570,"_30":7571},"mfem.ode.BackwardEulerSolver.create","mfem.ode.BackwardEulerSolver.create()","Creates a new Backward Euler solver.",[],"Promise",[],{"_16":7573,"_18":7574,"_20":7575,"_22":7575,"_24":7576,"_28":7577,"_30":7578},"mfem.ode.ESDIRK32Solver.create","mfem.ode.ESDIRK32Solver.create()","Creates a new ESDIRK32 solver.",[],"Promise",[],{"_16":7580,"_18":7581,"_20":7582,"_22":7582,"_24":7583,"_28":7584,"_30":7585},"mfem.ode.ESDIRK33Solver.create","mfem.ode.ESDIRK33Solver.create()","Creates a new ESDIRK33 solver.",[],"Promise",[],{"_16":7587,"_18":7588,"_20":7589,"_22":7589,"_24":7590,"_28":7591,"_30":7592},"mfem.ode.ForwardEulerSolver.create","mfem.ode.ForwardEulerSolver.create()","Creates a new Forward Euler solver.",[],"Promise",[],{"_16":7594,"_18":7595,"_20":7596,"_22":7596,"_24":7597,"_28":7601,"_30":7602},"mfem.ode.GeneralizedAlphaSolver.create","mfem.ode.GeneralizedAlphaSolver.create(rhoInf?)","Creates a new Generalized-α solver.",[7598],{"_16":7599,"_22":7600,"_69":11},"rhoInf","Spectral radius at infinity (0 to 1, default: 1.0)","Promise",[],{"_16":7604,"_18":7605,"_20":7606,"_22":7606,"_24":7607,"_28":7608,"_30":7609},"mfem.ode.IMEXEulerSolver.create","mfem.ode.IMEXEulerSolver.create()","Creates a new IMEX Euler solver.",[],"Promise",[],{"_16":7611,"_18":7612,"_20":7613,"_22":7613,"_24":7614,"_28":7615,"_30":7616},"mfem.ode.IMEXRK2Solver.create","mfem.ode.IMEXRK2Solver.create()","Creates a new IMEX RK2 solver.",[],"Promise",[],{"_16":7618,"_18":7619,"_20":7620,"_22":7620,"_24":7621,"_28":7622,"_30":7623},"mfem.ode.ImplicitMidpointSolver.create","mfem.ode.ImplicitMidpointSolver.create()","Creates a new Implicit Midpoint solver.",[],"Promise",[],{"_16":7625,"_18":7626,"_20":7627,"_22":7627,"_24":7628,"_28":7631,"_30":7632},"mfem.ode.RK2Solver.create","mfem.ode.RK2Solver.create(alpha?)","Creates a new RK2 solver.",[7629],{"_16":4399,"_22":7630,"_69":11},"Parameter controlling the method (0.5 = midpoint, 1.0 = Heun)","Promise",[],{"_16":7634,"_18":7635,"_20":7636,"_22":7636,"_24":7637,"_28":7638,"_30":7639},"mfem.ode.RK3SSPSolver.create","mfem.ode.RK3SSPSolver.create()","Creates a new RK3 SSP solver.",[],"Promise",[],{"_16":7641,"_18":7642,"_20":7643,"_22":7643,"_24":7644,"_28":7645,"_30":7646},"mfem.ode.RK4Solver.create","mfem.ode.RK4Solver.create()","Creates a new RK4 solver.",[],"Promise",[],{"_16":7648,"_18":7649,"_20":7650,"_22":7650,"_24":7651,"_28":7652,"_30":7653},"mfem.ode.RK6Solver.create","mfem.ode.RK6Solver.create()","Creates a new RK6 solver.",[],"Promise",[],{"_16":7655,"_18":7656,"_20":7657,"_22":7657,"_24":7658,"_28":7659,"_30":7660},"mfem.ode.RK8Solver.create","mfem.ode.RK8Solver.create()","Creates a new RK8 solver.",[],"Promise",[],{"_16":7662,"_18":7663,"_20":7664,"_22":7664,"_24":7665,"_28":7666,"_30":7667},"mfem.ode.SDIRK23Solver.create","mfem.ode.SDIRK23Solver.create()","Creates a new SDIRK23 solver.",[],"Promise",[],{"_16":7669,"_18":7670,"_20":7671,"_22":7671,"_24":7672,"_28":7673,"_30":7674},"mfem.ode.SDIRK33Solver.create","mfem.ode.SDIRK33Solver.create()","Creates a new SDIRK33 solver.",[],"Promise",[],{"_16":7676,"_18":7677,"_20":7678,"_22":7678,"_24":7679,"_28":7680,"_30":7681},"mfem.ode.SDIRK34Solver.create","mfem.ode.SDIRK34Solver.create()","Creates a new SDIRK34 solver.",[],"Promise",[],{"_16":7683,"_18":7684,"_20":7685,"_22":7685,"_24":7686,"_28":7687,"_30":7688},"mfem.ode.TrapezoidalRuleSolver.create","mfem.ode.TrapezoidalRuleSolver.create()","Creates a new Trapezoidal Rule solver.",[],"Promise",[],{"_16":7690,"_18":7691,"_20":7692,"_22":7692,"_24":7693,"_28":7694,"_30":7695},"mfem.ode.AverageAccelerationSolver.create","mfem.ode.AverageAccelerationSolver.create()","Creates a new Average Acceleration solver.",[],"Promise",[],{"_16":7697,"_18":7698,"_20":7699,"_22":7699,"_24":7700,"_28":7701,"_30":7702},"mfem.ode.CentralDifferenceSolver.create","mfem.ode.CentralDifferenceSolver.create()","Creates a new Central Difference solver.",[],"Promise",[],{"_16":7704,"_18":7705,"_20":7706,"_22":7706,"_24":7707,"_28":7708,"_30":7709},"mfem.ode.FoxGoodwinSolver.create","mfem.ode.FoxGoodwinSolver.create()","Creates a new Fox-Goodwin solver.",[],"Promise",[],{"_16":7711,"_18":7712,"_20":7713,"_22":7713,"_24":7714,"_28":7716,"_30":7717},"mfem.ode.GeneralizedAlpha2Solver.create","mfem.ode.GeneralizedAlpha2Solver.create(rhoInf?)","Creates a new Generalized-Alpha 2 solver.",[7715],{"_16":7599,"_22":7600,"_69":11},"Promise",[],{"_16":7719,"_18":7720,"_20":7721,"_22":7721,"_24":7722,"_28":7725,"_30":7726},"mfem.ode.HHTAlphaSolver.create","mfem.ode.HHTAlphaSolver.create(alpha?)","Creates a new HHT-alpha solver.",[7723],{"_16":4399,"_22":7724,"_69":11},"Alpha parameter (2/3 to 1, default: 1.0)","Promise",[],{"_16":7728,"_18":7729,"_20":7730,"_22":7730,"_24":7731,"_28":7732,"_30":7733},"mfem.ode.LinearAccelerationSolver.create","mfem.ode.LinearAccelerationSolver.create()","Creates a new Linear Acceleration solver.",[],"Promise",[],{"_16":7735,"_18":7736,"_20":7737,"_22":7737,"_24":7738,"_28":7744,"_30":7745},"mfem.ode.NewmarkSolver.create","mfem.ode.NewmarkSolver.create(beta?, gamma?)","Creates a new Newmark solver.",[7739,7741],{"_16":2011,"_22":7740,"_69":11},"Newmark beta parameter (default: 0.25 for average acceleration)",{"_16":7742,"_22":7743,"_69":11},"gamma","Newmark gamma parameter (default: 0.5)","Promise",[],{"_16":7747,"_18":7748,"_20":7749,"_22":7749,"_24":7750,"_28":7752,"_30":7753},"mfem.ode.WBZAlphaSolver.create","mfem.ode.WBZAlphaSolver.create(rhoInf?)","Creates a new WBZ-alpha solver.",[7751],{"_16":7599,"_22":7600,"_69":11},"Promise",[],{"_16":7755,"_18":7756,"_20":7757,"_22":5456,"_24":7758,"_28":1426,"_30":7764},"mfem.sparse.add","mfem.sparse.add(sm, i, j, value)","add_2",[7759,7761,7762,7763],{"_16":7760,"_22":4577,"_69":6},"sm",{"_16":6743,"_22":5703,"_69":6},{"_16":6745,"_22":5703,"_69":6},{"_16":235,"_22":5703,"_69":6},[],{"_16":7766,"_18":7767,"_20":7768,"_22":5456,"_24":7769,"_28":6292,"_30":7772},"mfem.sparse.create","mfem.sparse.create(rows, cols)","create_3",[7770,7771],{"_16":2472,"_22":5703,"_69":6},{"_16":2475,"_22":5703,"_69":6},[],{"_16":7774,"_18":7775,"_20":7776,"_22":5456,"_24":7777,"_28":6292,"_30":7782},"mfem.sparse.fromCOO","mfem.sparse.fromCOO(rows, cols, data)","fromCOO",[7778,7779,7780],{"_16":2472,"_22":5703,"_69":6},{"_16":2475,"_22":5703,"_69":6},{"_16":84,"_22":7781,"_69":6},"{\r\n row: number[];\r\n col: number[];\r\n val: number[];\r\n}",[],{"_16":7784,"_18":7785,"_20":7786,"_22":7787,"_24":7788,"_28":4577,"_30":7792},"mfem.sparse.fromPointer","mfem.sparse.fromPointer(ptr, ownsMemory?)","Creates a SparseMatrix wrapper from an existing WASM pointer.\r","Creates a SparseMatrix wrapper from an existing WASM pointer.\r\n\r\nThis is a synchronous operation that wraps an existing pointer.\r\nThe MFEM module must already be loaded (via any async MFEM operation).",[7789,7790],{"_16":4648,"_22":6301,"_69":6},{"_16":5543,"_22":7791,"_69":11},"- If true, destroy() will free the memory; if false, it won't (default: false)",[],{"_16":7794,"_18":7795,"_20":7796,"_22":5456,"_24":7797,"_28":4757,"_30":7799},"mfem.sparse.getColIndices","mfem.sparse.getColIndices(sm)","getColIndices",[7798],{"_16":7760,"_22":4577,"_69":6},[],{"_16":7801,"_18":7802,"_20":7803,"_22":5456,"_24":7804,"_28":5450,"_30":7806},"mfem.sparse.getData","mfem.sparse.getData(sm)","getData_2",[7805],{"_16":7760,"_22":4577,"_69":6},[],{"_16":7808,"_18":7809,"_20":7810,"_22":5456,"_24":7811,"_28":4757,"_30":7813},"mfem.sparse.getRowOffsets","mfem.sparse.getRowOffsets(sm)","getRowOffsets",[7812],{"_16":7760,"_22":4577,"_69":6},[],{"_16":7815,"_18":7816,"_20":7817,"_22":5456,"_24":7818,"_28":1426,"_30":7822},"mfem.sparse.mult","mfem.sparse.mult(sm, x, y)","mult_2",[7819,7820,7821],{"_16":7760,"_22":4577,"_69":6},{"_16":498,"_22":6775,"_69":6},{"_16":501,"_22":6775,"_69":6},[],{"_16":7824,"_18":7825,"_20":7826,"_22":5456,"_24":7827,"_28":5703,"_30":7829},"mfem.sparse.numNonZeros","mfem.sparse.numNonZeros(sm)","numNonZeros",[7828],{"_16":7760,"_22":4577,"_69":6},[],{"_16":7831,"_18":7832,"_20":7833,"_22":5456,"_24":7834,"_28":5461,"_30":7836},"mfem.sparse.toDense","mfem.sparse.toDense(sm)","toDense",[7835],{"_16":7760,"_22":4577,"_69":6},[],{"_16":7838,"_18":7839,"_20":7840,"_22":5456,"_24":7841,"_28":6292,"_30":7843},"mfem.sparse.transpose","mfem.sparse.transpose(sm)","transpose_3",[7842],{"_16":7760,"_22":4577,"_69":6},[],{"_16":7845,"_18":7846,"_20":6288,"_22":6288,"_24":7847,"_28":6292,"_30":7850},"mfem.sparse.SparseMatrix.create","mfem.sparse.SparseMatrix.create(height, width)",[7848,7849],{"_16":174,"_22":4979,"_69":6},{"_16":4981,"_22":5507,"_69":6},[],{"_16":7852,"_18":7853,"_20":6297,"_22":6298,"_24":7854,"_28":6292,"_30":7857},"mfem.sparse.SparseMatrix.fromPointer","mfem.sparse.SparseMatrix.fromPointer(ptr, ownsMemory?)",[7855,7856],{"_16":4648,"_22":6301,"_69":6},{"_16":5543,"_22":6303,"_69":11},[],{"_16":7859,"_18":7860,"_20":7861,"_22":5456,"_24":7862,"_28":1426,"_30":7866},"mfem.vector.add","mfem.vector.add(v, alpha, other)","add_3",[7863,7864,7865],{"_16":2897,"_22":6775,"_69":6},{"_16":4399,"_22":5703,"_69":6},{"_16":6698,"_22":6775,"_69":6},[],{"_16":7868,"_18":7869,"_20":7870,"_22":5456,"_24":7871,"_28":6312,"_30":7874},"mfem.vector.copy","mfem.vector.copy(vec)","copy",[7872],{"_16":7873,"_22":6775,"_69":6},"vec",[],{"_16":7876,"_18":7877,"_20":7878,"_22":5456,"_24":7879,"_28":6312,"_30":7881},"mfem.vector.create","mfem.vector.create(size)","create_4",[7880],{"_16":193,"_22":5703,"_69":6},[],{"_16":7883,"_18":7884,"_20":1727,"_22":5456,"_24":7885,"_28":5703,"_30":7888},"mfem.vector.dot","mfem.vector.dot(v1, v2)",[7886,7887],{"_16":4857,"_22":6775,"_69":6},{"_16":4860,"_22":6775,"_69":6},[],{"_16":7890,"_18":7891,"_20":7892,"_22":5456,"_24":7893,"_28":6312,"_30":7896},"mfem.vector.fromArray","mfem.vector.fromArray(data)","fromArray_2",[7894],{"_16":84,"_22":7895,"_69":6},"number[] | Float64Array",[],{"_16":7898,"_18":7899,"_20":7900,"_22":7901,"_24":7902,"_28":6775,"_30":7904},"mfem.vector.fromPointer","mfem.vector.fromPointer(ptr)","Creates a Vector wrapper from an existing WASM pointer.\r","Creates a Vector wrapper from an existing WASM pointer.\r\n\r\nThis is a synchronous operation that wraps an existing pointer.\r\nThe MFEM module must already be loaded (via any async MFEM operation).",[7903],{"_16":4648,"_22":6321,"_69":6},[],{"_16":7906,"_18":7907,"_20":7908,"_22":5456,"_24":7909,"_28":5703,"_30":7912},"mfem.vector.get","mfem.vector.get(vec, i)","get_3",[7910,7911],{"_16":7873,"_22":6775,"_69":6},{"_16":6743,"_22":5703,"_69":6},[],{"_16":7914,"_18":7915,"_20":7916,"_22":5456,"_24":7917,"_28":5450,"_30":7919},"mfem.vector.getData","mfem.vector.getData(vec)","getData_3",[7918],{"_16":7873,"_22":6775,"_69":6},[],{"_16":7921,"_18":7922,"_20":7923,"_22":5456,"_24":7924,"_28":1426,"_30":7926},"mfem.vector.neg","mfem.vector.neg(vec)","neg",[7925],{"_16":7873,"_22":6775,"_69":6},[],{"_16":7928,"_18":7929,"_20":1530,"_22":5456,"_24":7930,"_28":5703,"_30":7932},"mfem.vector.norm","mfem.vector.norm(vec)",[7931],{"_16":7873,"_22":6775,"_69":6},[],{"_16":7934,"_18":7935,"_20":7936,"_22":5456,"_24":7937,"_28":5703,"_30":7939},"mfem.vector.normInf","mfem.vector.normInf(vec)","normInf",[7938],{"_16":7873,"_22":6775,"_69":6},[],{"_16":7941,"_18":7942,"_20":374,"_22":5456,"_24":7943,"_28":6312,"_30":7945},"mfem.vector.ones","mfem.vector.ones(size)",[7944],{"_16":193,"_22":5703,"_69":6},[],{"_16":7947,"_18":7948,"_20":376,"_22":5456,"_24":7949,"_28":6312,"_30":7951},"mfem.vector.rand","mfem.vector.rand(size)",[7950],{"_16":193,"_22":5703,"_69":6},[],{"_16":7953,"_18":7954,"_20":2150,"_22":5456,"_24":7955,"_28":1426,"_30":7958},"mfem.vector.scale","mfem.vector.scale(vec, alpha)",[7956,7957],{"_16":7873,"_22":6775,"_69":6},{"_16":4399,"_22":5703,"_69":6},[],{"_16":7960,"_18":7961,"_20":7962,"_22":5456,"_24":7963,"_28":1426,"_30":7967},"mfem.vector.set","mfem.vector.set(vec, i, value)","set_3",[7964,7965,7966],{"_16":7873,"_22":6775,"_69":6},{"_16":6743,"_22":5703,"_69":6},{"_16":235,"_22":5703,"_69":6},[],{"_16":7969,"_18":7970,"_20":7971,"_22":5456,"_24":7972,"_28":1426,"_30":7975},"mfem.vector.setAll","mfem.vector.setAll(vec, value)","setAll",[7973,7974],{"_16":7873,"_22":6775,"_69":6},{"_16":235,"_22":5703,"_69":6},[],{"_16":7977,"_18":7978,"_20":7979,"_22":5456,"_24":7980,"_28":1426,"_30":7984},"mfem.vector.setData","mfem.vector.setData(vec, data)","setData",[7981,7982],{"_16":7873,"_22":6775,"_69":6},{"_16":84,"_22":7983,"_69":6},"Float64Array | number[]",[],{"_16":7986,"_18":7987,"_20":193,"_22":5456,"_24":7988,"_28":5703,"_30":7990},"mfem.vector.size","mfem.vector.size(vec)",[7989],{"_16":7873,"_22":6775,"_69":6},[],{"_16":7992,"_18":7993,"_20":7994,"_22":5456,"_24":7995,"_28":6312,"_30":7997},"mfem.vector.zeros","mfem.vector.zeros(size)","zeros_2",[7996],{"_16":193,"_22":5703,"_69":6},[],{"_16":7999,"_18":8000,"_20":6308,"_22":6308,"_24":8001,"_28":6312,"_30":8003},"mfem.vector.Vector.create","mfem.vector.Vector.create(size)",[8002],{"_16":193,"_22":6311,"_69":6},[],{"_16":8005,"_18":8006,"_20":6317,"_22":6318,"_24":8007,"_28":6312,"_30":8009},"mfem.vector.Vector.fromPointer","mfem.vector.Vector.fromPointer(ptr)",[8008],{"_16":4648,"_22":6321,"_69":6},[],{"_16":8011,"_18":8012,"_20":8013,"_22":8014,"_24":8015,"_28":8019,"_30":8020},"mfem.checkBoundaryDofs","mfem.checkBoundaryDofs(fespace, bdrAttrs)","Check boundary DOF extraction for specified boundary attributes.\r","Check boundary DOF extraction for specified boundary attributes.\r\n\r\nVerifies that DOFs can be correctly extracted for the given boundary attributes\r\nand validates the resulting DOF indices.",[8016,8017],{"_16":4547,"_22":4605,"_69":6},{"_16":4711,"_22":8018,"_69":6},"- Array of boundary attributes to check","Promise",[],{"_16":8022,"_18":8023,"_20":8024,"_22":8025,"_24":8026,"_28":8027,"_30":8028},"mfem.checkForLeaks","mfem.checkForLeaks()","Check for memory leaks.\r","Check for memory leaks.\r\n\r\nAnalyzes object tracking data to find undestroyed objects.",[],"LeakReport",[],{"_16":8030,"_18":8031,"_20":8032,"_22":8033,"_24":8034,"_28":8038,"_30":8039},"mfem.checkPositiveDefinite","mfem.checkPositiveDefinite(mat)","Check if a sparse matrix is positive definite.\r","Check if a sparse matrix is positive definite.\r\n\r\nPerforms diagonal check (necessary condition) and attempts to estimate\r\nthe smallest eigenvalue using power iteration.",[8035],{"_16":8036,"_22":8037,"_69":6},"mat","- The sparse matrix to check","Promise",[],{"_16":8041,"_18":8042,"_20":8043,"_22":8044,"_24":8045,"_28":8054,"_30":8055},"mfem.checkResidual","mfem.checkResidual(A, x, b, tol)","Check if a solution satisfies the residual tolerance.\r","Check if a solution satisfies the residual tolerance.\r\n\r\nComputes the relative residual ||b - Ax|| / ||b|| and checks if it's\r\nbelow the specified tolerance.",[8046,8048,8050,8052],{"_16":659,"_22":8047,"_69":6},"- The operator (SparseMatrix or BilinearForm)",{"_16":498,"_22":8049,"_69":6},"- The solution vector",{"_16":436,"_22":8051,"_69":6},"- The right-hand side vector",{"_16":3719,"_22":8053,"_69":6},"- Tolerance for the relative residual","Promise",[],{"_16":8057,"_18":8058,"_20":8059,"_22":8059,"_24":8060,"_28":8064,"_30":8065},"mfem.checkSymmetry","mfem.checkSymmetry(mat, tol?)","Check if a sparse matrix is symmetric within a given tolerance.",[8061,8062],{"_16":8036,"_22":8037,"_69":6},{"_16":3719,"_22":8063,"_69":11},"- Tolerance for symmetry check (default: 1e-12)","Promise",[],{"_16":8067,"_18":8068,"_20":8069,"_22":8070,"_24":8071,"_28":8077,"_30":8078},"mfem.computeConditionNumber","mfem.computeConditionNumber(mat, maxIter?)","Estimate the condition number of a sparse matrix.\r","Estimate the condition number of a sparse matrix.\r\n\r\nUses power iteration to estimate the largest and smallest eigenvalues,\r\nthen computes their ratio.",[8072,8074],{"_16":8036,"_22":8073,"_69":6},"- The sparse matrix",{"_16":8075,"_22":8076,"_69":11},"maxIter","- Maximum iterations for power iteration (default: 100)","Promise",[],{"_16":8080,"_18":8081,"_20":8082,"_22":8082,"_24":8083,"_28":4713,"_30":8089},"mfem.computeResidual","mfem.computeResidual(A, x, b, r)","Compute the residual vector r = b - A*x.",[8084,8085,8086,8087],{"_16":659,"_22":8047,"_69":6},{"_16":498,"_22":8049,"_69":6},{"_16":436,"_22":8051,"_69":6},{"_16":2815,"_22":8088,"_69":6},"- The output residual vector (must be pre-allocated with same size as b)",[],{"_16":8091,"_18":8092,"_20":8093,"_22":8094,"_24":8095,"_28":1426,"_30":8099},"mfem.configureMFEM","mfem.configureMFEM(config)","Configure the MFEM WASM loader before initialization.\r","Configure the MFEM WASM loader before initialization.\r\nMust be called before loadMFEMModule().",[8096],{"_16":8097,"_22":8098,"_69":6},"config","Configuration options",[],{"_16":8101,"_18":8102,"_20":8103,"_22":8103,"_24":8104,"_28":1426,"_30":8105},"mfem.disableTiming","mfem.disableTiming()","Disable timing collection.",[],[],{"_16":8107,"_18":8108,"_20":8109,"_22":8110,"_24":8111,"_28":1426,"_30":8112},"mfem.enableTiming","mfem.enableTiming()","Enable timing collection for MFEMWASM operations.\r","Enable timing collection for MFEMWASM operations.\r\n\r\nWhen enabled, operations can be timed using the `withTiming` helper\r\nor by manually calling `startTimer` and `stopTimer`.",[],[],{"_16":8114,"_18":8115,"_20":8116,"_22":8116,"_24":8117,"_28":8118,"_30":8119},"mfem.getMemoryUsage","mfem.getMemoryUsage()","Get current WASM memory usage.",[],"Promise",[],{"_16":8121,"_18":8122,"_20":8123,"_22":8123,"_24":8124,"_28":8125,"_30":8126},"mfem.getMFEMModule","mfem.getMFEMModule()","Get the loaded MFEM module synchronously.",[],"MFEMModule",[],{"_16":8128,"_18":8129,"_20":8130,"_22":8130,"_24":8131,"_28":8132,"_30":8133},"mfem.getObjectCount","mfem.getObjectCount()","Get the current object counts by type.",[],"ObjectCounts",[],{"_16":8135,"_18":8136,"_20":8137,"_22":8137,"_24":8138,"_28":8139,"_30":8140},"mfem.getTimingReport","mfem.getTimingReport()","Get the current timing report.",[],"TimingReport",[],{"_16":8142,"_18":8143,"_20":8144,"_22":8144,"_24":8145,"_28":6903,"_30":8146},"mfem.isMFEMLoaded","mfem.isMFEMLoaded()","Check if the MFEM module has been loaded.",[],[],{"_16":8148,"_18":8149,"_20":8150,"_22":8151,"_24":8152,"_28":8153,"_30":8154},"mfem.loadMFEMModule","mfem.loadMFEMModule()","Load and initialize the MFEM WASM module.\r","Load and initialize the MFEM WASM module.\r\n\r\nThis function is idempotent - calling it multiple times returns the same\r\nmodule instance. The module is loaded lazily on first call.",[],"Promise",[],{"_16":8156,"_18":8157,"_20":8158,"_22":8159,"_24":8160,"_28":8163,"_30":8164},"mfem.loadSolution","mfem.loadSolution(data)","Loads a mesh and grid function pair from a JSON bundle string.\r","Loads a mesh and grid function pair from a JSON bundle string.\r\n\r\nThe bundle should contain both mesh and grid function in MFEM format,\r\nas created by . The grid function's FE space is\r\nautomatically reconstructed from the saved header information.",[8161],{"_16":84,"_22":8162,"_69":6},"- JSON string containing the solution bundle","Promise",[],{"_16":8166,"_18":8167,"_20":8168,"_22":8168,"_24":8169,"_28":8172,"_30":8173},"mfem.printDofInfo","mfem.printDofInfo(fespace)","Get comprehensive DOF information for a finite element space.",[8170],{"_16":4547,"_22":8171,"_69":6},"- The finite element space to inspect","Promise",[],{"_16":8175,"_18":8176,"_20":8177,"_22":8178,"_24":8179,"_28":1426,"_30":8180},"mfem.resetMFEMModule","mfem.resetMFEMModule()","Reset the module state for testing purposes.\r","Reset the module state for testing purposes.\r\nAfter calling this, loadMFEMModule() will load a fresh instance.",[],[],{"_16":8182,"_18":8183,"_20":8184,"_22":8185,"_24":8186,"_28":1426,"_30":8187},"mfem.resetTimers","mfem.resetTimers()","Reset all timing data.\r","Reset all timing data.\r\n\r\nClears all accumulated timing information.",[],[],{"_16":8189,"_18":8190,"_20":8191,"_22":8192,"_24":8193,"_28":6108,"_30":8200},"mfem.saveSolution","mfem.saveSolution(mesh, gf, options?)","Saves a mesh and grid function pair to a JSON bundle string.\r","Saves a mesh and grid function pair to a JSON bundle string.\r\n\r\nThe bundle contains both the mesh and grid function in MFEM format,\r\nalong with optional metadata. The grid function's FE space information\r\n(collection type, vdim, ordering) is preserved in the MFEM format header.",[8194,8196,8198],{"_16":290,"_22":8195,"_69":6},"- The mesh to save",{"_16":318,"_22":8197,"_69":6},"- The grid function to save",{"_16":4789,"_22":8199,"_69":11},"- Optional save options",[],{"_16":8202,"_18":8203,"_20":8204,"_22":8205,"_24":8206,"_28":8209,"_30":8210},"mfem.verifyAssembly","mfem.verifyAssembly(bf)","Verify that a bilinear form has been correctly assembled.\r","Verify that a bilinear form has been correctly assembled.\r\n\r\nChecks assembly status, matrix properties, and scans for NaN/Inf values.",[8207],{"_16":4722,"_22":8208,"_69":6},"- The bilinear form to verify","Promise",[],{"_16":8212,"_18":8213,"_20":8214,"_22":8214,"_24":8215,"_28":8219,"_30":8220},"mfem.visualizeDofs","mfem.visualizeDofs(fespace, elemIdx)","Get DOF locations for visualization/debugging of a specific element.",[8216,8217],{"_16":4547,"_22":4605,"_69":6},{"_16":5870,"_22":8218,"_69":6},"- Element index","Promise",[],{"_43":8222,"_16":8223,"_22":8224,"_47":48,"_49":8225,"_51":8226,"_52":8227},"sp-generated","Scientific Computing (SciPy)","SciPy-inspired scientific computing library with optimization, integration, linear algebra, and statistics.","🔬","sp",[8228,8244,8256,8267,8278,8290,8303,8314,8327,8339,8352,8361,8369,8380,8391,8402,8412,8427,8439,8450,8467,8479,8489,8498,8509,8521,8535,8547,8556,8564,8575,8585,8594,8604,8614,8623,8629,8637,8645,8653,8659,8666,8676,8684,8694,8702,8710,8719,8728,8735,8743,8750,8759,8770,8779,8793,8801,8809,8817,8825,8837,8846,8857,8865,8873,8881,8892,8903,8921,8933,8945,8953,8959,8966],{"_16":8229,"_18":8230,"_20":8231,"_22":8232,"_24":8233,"_28":8242,"_30":8243},"sp.integrate.quad","sp.integrate.quad(func, a, b, options?)","Compute a definite integral using adaptive quadrature.\r","Compute a definite integral using adaptive quadrature.\r\n\r\nIntegrates `func` from `a` to `b` (possibly infinite interval) using\r\nthe QUADPACK library compiled to WebAssembly.",[8234,8236,8238,8240],{"_16":4204,"_22":8235,"_69":6},"- The integrand function f(x, ...args).",{"_16":433,"_22":8237,"_69":6},"- Lower limit of integration. Use -Infinity for -∞.",{"_16":436,"_22":8239,"_69":6},"- Upper limit of integration. Use Infinity for +∞.",{"_16":4789,"_22":8241,"_69":11},"- Integration options.","Promise",[],{"_16":8245,"_18":8246,"_20":8247,"_22":8248,"_24":8249,"_28":8254,"_30":8255},"sp.linalg.inv","sp.linalg.inv(A, options?)","Compute the inverse of a sparse matrix.\r","Compute the inverse of a sparse matrix.\r\n\r\nWarning: The inverse of a sparse matrix is typically dense!\r\nConsider using splu + solve for solving systems instead.",[8250,8252],{"_16":659,"_22":8251,"_69":6},"- Sparse square matrix (n x n)",{"_16":4789,"_22":8253,"_69":11},"- Options including output format","Promise",[],{"_16":8257,"_18":8258,"_20":8259,"_22":8260,"_24":8261,"_28":8265,"_30":8266},"sp.linalg.spilu","sp.linalg.spilu(A, options?)","Compute incomplete LU factorization for use as a preconditioner.\r","Compute incomplete LU factorization for use as a preconditioner.\r\n\r\nThe result implements LinearOperator and can be passed as the M\r\nparameter to iterative solvers (cg, gmres, bicgstab).",[8262,8263],{"_16":659,"_22":8251,"_69":6},{"_16":4789,"_22":8264,"_69":11},"- ILU options including drop tolerance","Promise",[],{"_16":8268,"_18":8269,"_20":8270,"_22":8271,"_24":8272,"_28":8276,"_30":8277},"sp.linalg.splu","sp.linalg.splu(A, options?)","Compute sparse LU decomposition of matrix A.\r","Compute sparse LU decomposition of matrix A.\r\n\r\nReturns a factorization object that can be reused for solving\r\nmultiple systems with the same matrix A.",[8273,8274],{"_16":659,"_22":8251,"_69":6},{"_16":4789,"_22":8275,"_69":11},"- Factorization options","Promise",[],{"_16":8279,"_18":8280,"_20":8281,"_22":8281,"_24":8282,"_28":8288,"_30":8289},"sp.linalg.spsolve","sp.linalg.spsolve(A, b, options?)","Solve the sparse linear system A @ x = b using SuperLU.",[8283,8284,8286],{"_16":659,"_22":8251,"_69":6},{"_16":436,"_22":8285,"_69":6},"- Right-hand side vector (length n) or matrix (n x nrhs)",{"_16":4789,"_22":8287,"_69":11},"- Solver options","Promise",[],{"_16":8291,"_18":8292,"_20":8293,"_22":8294,"_24":8295,"_28":8301,"_30":8302},"sp.linalg.eigs","sp.linalg.eigs(A, k?, options?)","Find k eigenvalues and eigenvectors of a square matrix A.\r","Find k eigenvalues and eigenvectors of a square matrix A.\r\n\r\nFor non-symmetric matrices, eigenvalues may be complex.\r\nUses ARPACK's Implicitly Restarted Arnoldi Method.",[8296,8298,8300],{"_16":659,"_22":8297,"_69":6},"- Sparse matrix or LinearOperator",{"_16":1114,"_22":8299,"_69":11},"- Number of eigenvalues to compute (default: 6)",{"_16":4789,"_22":8287,"_69":11},"Promise",[],{"_16":8304,"_18":8305,"_20":8306,"_22":8307,"_24":8308,"_28":8301,"_30":8313},"sp.linalg.eigsh","sp.linalg.eigsh(A, k?, options?)","Find k eigenvalues and eigenvectors of the real symmetric square matrix A.\r","Find k eigenvalues and eigenvectors of the real symmetric square matrix A.\r\n\r\nUses ARPACK's Implicitly Restarted Lanczos Method.",[8309,8311,8312],{"_16":659,"_22":8310,"_69":6},"- Sparse matrix or LinearOperator (must be symmetric)",{"_16":1114,"_22":8299,"_69":11},{"_16":4789,"_22":8287,"_69":11},[],{"_16":8315,"_18":8316,"_20":8317,"_22":8318,"_24":8319,"_28":8325,"_30":8326},"sp.linalg.svds","sp.linalg.svds(A, k?, options?)","Compute the truncated SVD of a sparse matrix.\r","Compute the truncated SVD of a sparse matrix.\r\n\r\nImplemented via eigenvalue decomposition of A'A or AA'.",[8320,8322,8324],{"_16":659,"_22":8321,"_69":6},"- Sparse matrix",{"_16":1114,"_22":8323,"_69":11},"- Number of singular values to compute (default: 6)",{"_16":4789,"_22":8287,"_69":11},"Promise",[],{"_16":8328,"_18":8329,"_20":8330,"_22":8331,"_24":8332,"_28":4840,"_30":8338},"sp.linalg.expm","sp.linalg.expm(A, _options?)","Compute the matrix exponential of a sparse matrix.\r","Compute the matrix exponential of a sparse matrix.\r\n\r\nUses the Pade approximation with scaling and squaring method.\r\nNote: The result is always a dense 2D array since exp(A) is generally dense.",[8333,8335],{"_16":659,"_22":8334,"_69":6},"- Sparse square matrix",{"_16":8336,"_22":8337,"_69":11},"_options","ExpmOptions",[],{"_16":8340,"_18":8341,"_20":8342,"_22":8343,"_24":8344,"_28":8350,"_30":8351},"sp.linalg.expm_multiply","sp.linalg.expm_multiply(A, v, options?)","Compute the action of the matrix exponential on a vector: exp(t*A) * v\r","Compute the action of the matrix exponential on a vector: exp(t*A) * v\r\n\r\nUses the Krylov subspace method, which is more efficient than computing\r\nthe full matrix exponential for large sparse matrices.",[8345,8346,8348],{"_16":659,"_22":8297,"_69":6},{"_16":2897,"_22":8347,"_69":6},"- Vector to multiply",{"_16":4789,"_22":8349,"_69":11},"- Computation options","ExpmMultiplyResult",[],{"_16":8353,"_18":8354,"_20":8355,"_22":8355,"_24":8356,"_28":8359,"_30":8360},"sp.linalg.aslinearoperator","sp.linalg.aslinearoperator(A)","Convert various types to a LinearOperator",[8357],{"_16":659,"_22":8358,"_69":6},"- Sparse matrix, dense array, or LinearOperator","LinearOperator_2",[],{"_16":8362,"_18":8363,"_20":8364,"_22":8364,"_24":8365,"_28":8367,"_30":8368},"sp.linalg.isLinearOperator","sp.linalg.isLinearOperator(x)","Check if a value is a LinearOperator",[8366],{"_16":498,"_22":4815,"_69":6},"x is LinearOperator",[],{"_16":8370,"_18":8371,"_20":8372,"_22":8373,"_24":8374,"_28":8378,"_30":8379},"sp.linalg.bicgstab","sp.linalg.bicgstab(A, b, options?)","BiConjugate Gradient Stabilized method for solving Ax = b\r","BiConjugate Gradient Stabilized method for solving Ax = b\r\n\r\nSolves the linear system Ax = b for x, where A is a general\r\n(possibly non-symmetric) matrix.",[8375,8376,8377],{"_16":659,"_22":8297,"_69":6},{"_16":436,"_22":6345,"_69":6},{"_16":4789,"_22":8287,"_69":11},"IterativeSolverResult",[],{"_16":8381,"_18":8382,"_20":8383,"_22":8384,"_24":8385,"_28":8378,"_30":8390},"sp.linalg.cg","sp.linalg.cg(A, b, options?)","Conjugate Gradient method for solving Ax = b\r","Conjugate Gradient method for solving Ax = b\r\n\r\nSolves the linear system Ax = b for x, where A is a symmetric\r\npositive-definite matrix.",[8386,8388,8389],{"_16":659,"_22":8387,"_69":6},"- Sparse matrix or LinearOperator (must be symmetric positive-definite)",{"_16":436,"_22":6345,"_69":6},{"_16":4789,"_22":8287,"_69":11},[],{"_16":8392,"_18":8393,"_20":8394,"_22":8395,"_24":8396,"_28":8378,"_30":8401},"sp.linalg.gmres","sp.linalg.gmres(A, b, options?)","GMRES (Generalized Minimal Residual) method for solving Ax = b\r","GMRES (Generalized Minimal Residual) method for solving Ax = b\r\n\r\nSolves the linear system Ax = b for x using the restarted GMRES algorithm.\r\nWorks for general (possibly non-symmetric) matrices.",[8397,8398,8399],{"_16":659,"_22":8297,"_69":6},{"_16":436,"_22":6345,"_69":6},{"_16":4789,"_22":8400,"_69":11},"- Solver options including restart parameter",[],{"_16":8403,"_18":8404,"_20":8405,"_22":8405,"_24":8406,"_28":5703,"_30":8411},"sp.linalg.norm","sp.linalg.norm(x, ord?)","Sparse matrix or vector norm",[8407,8408],{"_16":498,"_22":8321,"_69":6},{"_16":8409,"_22":8410,"_69":11},"ord","- Order of the norm:\r\n- 'fro' or undefined: Frobenius norm (default)\r\n- 1: max column sum\r\n- -1: min column sum\r\n- Infinity: max row sum\r\n- -Infinity: min row sum\r\n- 2: largest singular value (not yet implemented)\r\n- -2: smallest singular value (not yet implemented)",[],{"_16":8413,"_18":8414,"_20":8415,"_22":8415,"_24":8416,"_28":8425,"_30":8426},"sp.optimize.minimize","sp.optimize.minimize(fun, x0, options?)","Minimization of scalar function of one or more variables.",[8417,8420,8423],{"_16":8418,"_22":8419,"_69":6},"fun","- Objective function: (x: number[]) => number",{"_16":8421,"_22":8422,"_69":6},"x0","- Initial guess",{"_16":4789,"_22":8424,"_69":11},"- Method, bounds, tolerances, etc.","Promise",[],{"_16":8428,"_18":8429,"_20":8430,"_22":8430,"_24":8431,"_28":8437,"_30":8438},"sp.sparse.bsr_matrix","sp.sparse.bsr_matrix(arg, options?)","Factory function to create a BSR matrix",[8432,8435],{"_16":8433,"_22":8434,"_69":6},"arg","BSRConstructorArrays | number[][]",{"_16":4789,"_22":8436,"_69":11},"{\r\n shape?: [number, number];\r\n blocksize?: [number, number];\r\n}","BSRMatrix",[],{"_16":8440,"_18":8441,"_20":8442,"_22":8442,"_24":8443,"_28":4577,"_30":8449},"sp.sparse.block_diag","sp.sparse.block_diag(mats, format?)","Build a block diagonal sparse matrix from provided matrices.",[8444,8447],{"_16":8445,"_22":8446,"_69":6},"mats","- Array of sparse matrices or dense 2D arrays",{"_16":1294,"_22":8448,"_69":11},"- Output format: 'coo', 'csr', or 'csc' (default 'csr')",[],{"_16":8451,"_18":8452,"_20":8453,"_22":8453,"_24":8454,"_28":8465,"_30":8466},"sp.sparse.diags","sp.sparse.diags(diagonals, offsets?, shape?, format?)","Construct a sparse matrix from diagonals.",[8455,8458,8460,8463],{"_16":8456,"_22":8457,"_69":6},"diagonals","- Array of diagonal values. Each element can be:\r\n- A number (scalar broadcast to fill the diagonal)\r\n- A number[] or Float64Array (explicit diagonal values)",{"_16":4625,"_22":8459,"_69":11},"- Diagonal offsets (default [0]). Can be a single number or array.",{"_16":8461,"_22":8462,"_69":11},"shape","- Matrix shape [m, n]. If not given, the matrix is square with\r\nsize = len(diagonals[0]) + abs(offsets[0])",{"_16":1294,"_22":8464,"_69":11},"- Output format: 'csr' or 'csc' (default 'csr')","CompressedSparseMatrix",[],{"_16":8468,"_18":8469,"_20":8470,"_22":8470,"_24":8471,"_28":8465,"_30":8478},"sp.sparse.eye","sp.sparse.eye(m, n?, k?, format?)","Sparse identity matrix.",[8472,8473,8475,8477],{"_16":359,"_22":4979,"_69":6},{"_16":362,"_22":8474,"_69":11},"- Number of columns (defaults to m)",{"_16":1114,"_22":8476,"_69":11},"- Diagonal offset (default 0 = main diagonal, positive = above, negative = below)",{"_16":1294,"_22":8464,"_69":11},[],{"_16":8480,"_18":8481,"_20":8482,"_22":8482,"_24":8483,"_28":4577,"_30":8488},"sp.sparse.hstack","sp.sparse.hstack(blocks, format?)","Stack sparse matrices horizontally (column-wise).",[8484,8487],{"_16":8485,"_22":8486,"_69":6},"blocks","- Array of sparse matrices to stack",{"_16":1294,"_22":8448,"_69":11},[],{"_16":8490,"_18":8491,"_20":8492,"_22":8492,"_24":8493,"_28":8496,"_30":8497},"sp.sparse.issparse","sp.sparse.issparse(x)","Check if x is a sparse matrix.",[8494],{"_16":498,"_22":8495,"_69":6},"- Object to check","x is SparseMatrix",[],{"_16":8499,"_18":8500,"_20":8501,"_22":8501,"_24":8502,"_28":4577,"_30":8508},"sp.sparse.kron","sp.sparse.kron(A, B, format?)","Kronecker product of sparse matrices.",[8503,8505,8507],{"_16":659,"_22":8504,"_69":6},"- First sparse matrix or dense 2D array",{"_16":656,"_22":8506,"_69":6},"- Second sparse matrix or dense 2D array",{"_16":1294,"_22":8448,"_69":11},[],{"_16":8510,"_18":8511,"_20":8512,"_22":8513,"_24":8514,"_28":4577,"_30":8520},"sp.sparse.kronsum","sp.sparse.kronsum(A, B, format?)","Kronecker sum of sparse matrices.\r","Kronecker sum of sparse matrices.\r\n\r\nkronsum(A, B) = kron(A, I_b) + kron(I_a, B)\r\n\r\nwhere I_a and I_b are identity matrices of shape A and B respectively.\r\nBoth A and B must be square matrices.",[8515,8517,8519],{"_16":659,"_22":8516,"_69":6},"- First square sparse matrix or dense 2D array",{"_16":656,"_22":8518,"_69":6},"- Second square sparse matrix or dense 2D array",{"_16":1294,"_22":8448,"_69":11},[],{"_16":8522,"_18":8523,"_20":8524,"_22":8524,"_24":8525,"_28":4577,"_30":8534},"sp.sparse.random","sp.sparse.random(m, n, density?, format?, rng?)","Generate a sparse matrix with uniformly distributed random values.",[8526,8527,8528,8530,8531],{"_16":359,"_22":4979,"_69":6},{"_16":362,"_22":5507,"_69":6},{"_16":4041,"_22":8529,"_69":11},"- Density of non-zero values (0 to 1, default 0.01)",{"_16":1294,"_22":8448,"_69":11},{"_16":8532,"_22":8533,"_69":11},"rng","- Optional random number generator function (default Math.random)",[],{"_16":8536,"_18":8537,"_20":8538,"_22":8538,"_24":8539,"_28":4577,"_30":8546},"sp.sparse.tril","sp.sparse.tril(A, k?, format?)","Return the lower triangular portion of a sparse matrix.",[8540,8542,8544],{"_16":659,"_22":8541,"_69":6},"- Sparse matrix or dense 2D array",{"_16":1114,"_22":8543,"_69":11},"- Diagonal offset (default 0). k=0 is main diagonal, k>0 above, k<0 below.",{"_16":1294,"_22":8545,"_69":11},"- Output format: 'coo', 'csr', or 'csc' (default 'coo')",[],{"_16":8548,"_18":8549,"_20":8550,"_22":8550,"_24":8551,"_28":4577,"_30":8555},"sp.sparse.triu","sp.sparse.triu(A, k?, format?)","Return the upper triangular portion of a sparse matrix.",[8552,8553,8554],{"_16":659,"_22":8541,"_69":6},{"_16":1114,"_22":8543,"_69":11},{"_16":1294,"_22":8545,"_69":11},[],{"_16":8557,"_18":8558,"_20":8559,"_22":8559,"_24":8560,"_28":4577,"_30":8563},"sp.sparse.vstack","sp.sparse.vstack(blocks, format?)","Stack sparse matrices vertically (row-wise).",[8561,8562],{"_16":8485,"_22":8486,"_69":6},{"_16":1294,"_22":8448,"_69":11},[],{"_16":8565,"_18":8566,"_20":8567,"_22":8567,"_24":8568,"_28":8573,"_30":8574},"sp.sparse.coo_matrix","sp.sparse.coo_matrix(arg, options?)","Factory function to create a COO matrix",[8569,8571],{"_16":8433,"_22":8570,"_69":6},"COOConstructorArrays | number[][]",{"_16":4789,"_22":8572,"_69":11},"{\r\n shape?: [number, number];\r\n}","COOMatrix",[],{"_16":8576,"_18":8577,"_20":8578,"_22":5456,"_24":8579,"_28":8583,"_30":8584},"sp.sparse.csc_matrix","sp.sparse.csc_matrix(arg, options?)","csc_matrix",[8580,8582],{"_16":8433,"_22":8581,"_69":6},"SparseConstructorArrays | number[][]",{"_16":4789,"_22":8572,"_69":11},"CSCMatrix",[],{"_16":8586,"_18":8587,"_20":8588,"_22":5456,"_24":8589,"_28":8592,"_30":8593},"sp.sparse.csr_matrix","sp.sparse.csr_matrix(arg, options?)","csr_matrix",[8590,8591],{"_16":8433,"_22":8581,"_69":6},{"_16":4789,"_22":8572,"_69":11},"CSRMatrix",[],{"_16":8595,"_18":8596,"_20":8597,"_22":8597,"_24":8598,"_28":8602,"_30":8603},"sp.sparse.dia_matrix","sp.sparse.dia_matrix(arg, options?)","Factory function to create a DIA matrix",[8599,8601],{"_16":8433,"_22":8600,"_69":6},"DIAConstructorArrays | number[][]",{"_16":4789,"_22":8572,"_69":11},"DIAMatrix",[],{"_16":8605,"_18":8606,"_20":8607,"_22":8607,"_24":8608,"_28":8612,"_30":8613},"sp.sparse.dok_matrix","sp.sparse.dok_matrix(arg, options?)","Factory function to create a DOK matrix",[8609,8611],{"_16":8433,"_22":8610,"_69":6},"number[][] | [number, number]",{"_16":4789,"_22":8572,"_69":11},"DOKMatrix",[],{"_16":8615,"_18":8616,"_20":8617,"_22":8617,"_24":8618,"_28":8621,"_30":8622},"sp.sparse.lil_matrix","sp.sparse.lil_matrix(arg, options?)","Factory function to create a LIL matrix",[8619,8620],{"_16":8433,"_22":8610,"_69":6},{"_16":4789,"_22":8572,"_69":11},"LILMatrix",[],{"_16":8624,"_18":8625,"_20":8355,"_22":8355,"_24":8626,"_28":8359,"_30":8628},"sp.sparse.aslinearoperator","sp.sparse.aslinearoperator(A)",[8627],{"_16":659,"_22":8358,"_69":6},[],{"_16":8630,"_18":8631,"_20":8372,"_22":8373,"_24":8632,"_28":8378,"_30":8636},"sp.sparse.bicgstab","sp.sparse.bicgstab(A, b, options?)",[8633,8634,8635],{"_16":659,"_22":8297,"_69":6},{"_16":436,"_22":6345,"_69":6},{"_16":4789,"_22":8287,"_69":11},[],{"_16":8638,"_18":8639,"_20":8383,"_22":8384,"_24":8640,"_28":8378,"_30":8644},"sp.sparse.cg","sp.sparse.cg(A, b, options?)",[8641,8642,8643],{"_16":659,"_22":8387,"_69":6},{"_16":436,"_22":6345,"_69":6},{"_16":4789,"_22":8287,"_69":11},[],{"_16":8646,"_18":8647,"_20":8394,"_22":8395,"_24":8648,"_28":8378,"_30":8652},"sp.sparse.gmres","sp.sparse.gmres(A, b, options?)",[8649,8650,8651],{"_16":659,"_22":8297,"_69":6},{"_16":436,"_22":6345,"_69":6},{"_16":4789,"_22":8400,"_69":11},[],{"_16":8654,"_18":8655,"_20":8364,"_22":8364,"_24":8656,"_28":8367,"_30":8658},"sp.sparse.isLinearOperator","sp.sparse.isLinearOperator(x)",[8657],{"_16":498,"_22":4815,"_69":6},[],{"_16":8660,"_18":8661,"_20":8405,"_22":8405,"_24":8662,"_28":5703,"_30":8665},"sp.sparse.linalg_norm","sp.sparse.linalg_norm(x, ord?)",[8663,8664],{"_16":498,"_22":8321,"_69":6},{"_16":8409,"_22":8410,"_69":11},[],{"_16":8667,"_18":8668,"_20":8669,"_22":8670,"_24":8671,"_28":8674,"_30":8675},"sp.special.i0","sp.special.i0(x)","Modified Bessel function of the first kind, order 0: I₀(x)\r","Modified Bessel function of the first kind, order 0: I₀(x)\r\n\r\nI₀(x) is related to J₀(ix) and grows exponentially for large x.\r\n\r\nProperties:\r\n - I₀(0) = 1\r\n - I₀(x) = I₀(-x) (even function)\r\n - I₀(x) ∼ e^x / √(2πx) as x → ∞",[8672],{"_16":498,"_22":8673,"_69":6},"- Input value(s). Can be a number or array of numbers.","Promise",[],{"_16":8677,"_18":8678,"_20":8679,"_22":8680,"_24":8681,"_28":8674,"_30":8683},"sp.special.i1","sp.special.i1(x)","Modified Bessel function of the first kind, order 1: I₁(x)\r","Modified Bessel function of the first kind, order 1: I₁(x)\r\n\r\nProperties:\r\n - I₁(0) = 0\r\n - I₁(-x) = -I₁(x) (odd function)",[8682],{"_16":498,"_22":8673,"_69":6},[],{"_16":8685,"_18":8686,"_20":8687,"_22":8688,"_24":8689,"_28":8674,"_30":8693},"sp.special.iv","sp.special.iv(v, x)","Modified Bessel function of the first kind, order v: Iᵥ(x)\r","Modified Bessel function of the first kind, order v: Iᵥ(x)\r\n\r\nGeneral modified Bessel function of the first kind for arbitrary order v.",[8690,8692],{"_16":2897,"_22":8691,"_69":6},"- Order of the Bessel function.",{"_16":498,"_22":8673,"_69":6},[],{"_16":8695,"_18":8696,"_20":8697,"_22":8698,"_24":8699,"_28":8674,"_30":8701},"sp.special.j0","sp.special.j0(x)","Bessel functions via WebAssembly.\r","Bessel functions via WebAssembly.\r\nMirrors scipy.special Bessel function implementations.",[8700],{"_16":498,"_22":8673,"_69":6},[],{"_16":8703,"_18":8704,"_20":8705,"_22":8706,"_24":8707,"_28":8674,"_30":8709},"sp.special.j1","sp.special.j1(x)","Bessel function of the first kind, order 1: J₁(x)\r","Bessel function of the first kind, order 1: J₁(x)\r\n\r\nProperties:\r\n - J₁(0) = 0\r\n - J₁(x) oscillates with decreasing amplitude as x → ∞",[8708],{"_16":498,"_22":8673,"_69":6},[],{"_16":8711,"_18":8712,"_20":8713,"_22":8714,"_24":8715,"_28":8674,"_30":8718},"sp.special.jv","sp.special.jv(v, x)","Bessel function of the first kind, order v: Jᵥ(x)\r","Bessel function of the first kind, order v: Jᵥ(x)\r\n\r\nGeneral Bessel function of the first kind for arbitrary order v.",[8716,8717],{"_16":2897,"_22":8691,"_69":6},{"_16":498,"_22":8673,"_69":6},[],{"_16":8720,"_18":8721,"_20":8722,"_22":8723,"_24":8724,"_28":8674,"_30":8727},"sp.special.k0","sp.special.k0(x)","Modified Bessel function of the second kind, order 0: K₀(x)\r","Modified Bessel function of the second kind, order 0: K₀(x)\r\n\r\nK₀(x) decays exponentially for large x and is singular at x = 0.\r\n\r\nProperties:\r\n - K₀(x) → ∞ as x → 0\r\n - K₀(x) ∼ √(π/(2x)) * e^(-x) as x → ∞",[8725],{"_16":498,"_22":8726,"_69":6},"- Input value(s). Must be positive. Can be a number or array of numbers.",[],{"_16":8729,"_18":8730,"_20":8731,"_22":8731,"_24":8732,"_28":8674,"_30":8734},"sp.special.k1","sp.special.k1(x)","Modified Bessel function of the second kind, order 1: K₁(x)",[8733],{"_16":498,"_22":8726,"_69":6},[],{"_16":8736,"_18":8737,"_20":8738,"_22":8739,"_24":8740,"_28":8674,"_30":8742},"sp.special.y0","sp.special.y0(x)","Bessel function of the second kind, order 0: Y₀(x)\r","Bessel function of the second kind, order 0: Y₀(x)\r\n\r\nAlso known as the Neumann function or Weber function.\r\nY₀(x) is singular at x = 0 and is real for x > 0.",[8741],{"_16":498,"_22":8726,"_69":6},[],{"_16":8744,"_18":8745,"_20":8746,"_22":8746,"_24":8747,"_28":8674,"_30":8749},"sp.special.y1","sp.special.y1(x)","Bessel function of the second kind, order 1: Y₁(x)",[8748],{"_16":498,"_22":8726,"_69":6},[],{"_16":8751,"_18":8752,"_20":8753,"_22":8754,"_24":8755,"_28":8674,"_30":8758},"sp.special.yv","sp.special.yv(v, x)","Bessel function of the second kind, order v: Yᵥ(x)\r","Bessel function of the second kind, order v: Yᵥ(x)\r\n\r\nGeneral Bessel function of the second kind for arbitrary order v.",[8756,8757],{"_16":2897,"_22":8691,"_69":6},{"_16":498,"_22":8726,"_69":6},[],{"_16":8760,"_18":8761,"_20":8762,"_22":8763,"_24":8764,"_28":8674,"_30":8769},"sp.special.beta","sp.special.beta(a, b)","Beta function and related special functions via WebAssembly.\r","Beta function and related special functions via WebAssembly.\r\nMirrors scipy.special.beta, betaln functions.",[8765,8767],{"_16":433,"_22":8766,"_69":6},"- First parameter. Can be a number or array of numbers.",{"_16":436,"_22":8768,"_69":6},"- Second parameter. Can be a number or array of numbers.",[],{"_16":8771,"_18":8772,"_20":8773,"_22":8774,"_24":8775,"_28":8674,"_30":8778},"sp.special.betaln","sp.special.betaln(a, b)","Natural logarithm of the beta function: ln(B(a, b))\r","Natural logarithm of the beta function: ln(B(a, b))\r\n\r\nFor large arguments, betaln(a, b) is more accurate than log(beta(a, b))\r\nbecause it avoids overflow of the beta function.",[8776,8777],{"_16":433,"_22":8766,"_69":6},{"_16":436,"_22":8768,"_69":6},[],{"_16":8780,"_18":8781,"_20":8782,"_22":8782,"_24":8783,"_28":8791,"_30":8792},"sp.special.comb","sp.special.comb(N, k, options?)","Binomial coefficient (N choose k).",[8784,8787,8789],{"_16":8785,"_22":8786,"_69":6},"N","- Number of items (integer or array)",{"_16":1114,"_22":8788,"_69":6},"- Number of items to choose (integer or array)",{"_16":4789,"_22":8790,"_69":11},"- Configuration options","Promise",[],{"_16":8794,"_18":8795,"_20":8796,"_22":8797,"_24":8798,"_28":8674,"_30":8800},"sp.special.erf","sp.special.erf(x)","Error functions via WebAssembly.\r","Error functions via WebAssembly.\r\nMirrors scipy.special.erf, erfc, erfcx, erfi functions.",[8799],{"_16":498,"_22":8673,"_69":6},[],{"_16":8802,"_18":8803,"_20":8804,"_22":8805,"_24":8806,"_28":8674,"_30":8808},"sp.special.erfc","sp.special.erfc(x)","Complementary error function: erfc(x) = 1 - erf(x)\r","Complementary error function: erfc(x) = 1 - erf(x)\r\n\r\nFor large x, erfc(x) is more accurate than computing 1 - erf(x)\r\ndirectly because erf(x) → 1 causes precision loss.",[8807],{"_16":498,"_22":8673,"_69":6},[],{"_16":8810,"_18":8811,"_20":8812,"_22":8813,"_24":8814,"_28":8674,"_30":8816},"sp.special.erfcx","sp.special.erfcx(x)","Scaled complementary error function: erfcx(x) = e^(x²) * erfc(x)\r","Scaled complementary error function: erfcx(x) = e^(x²) * erfc(x)\r\n\r\nThis function avoids the underflow/overflow issues that occur\r\nwhen computing erfc(x) for large |x|.\r\n\r\nProperties:\r\n - erfcx(0) = 1\r\n - erfcx(x) → 1/(√π * x) as x → ∞",[8815],{"_16":498,"_22":8673,"_69":6},[],{"_16":8818,"_18":8819,"_20":8820,"_22":8821,"_24":8822,"_28":8674,"_30":8824},"sp.special.erfi","sp.special.erfi(x)","Imaginary error function: erfi(x) = -i * erf(ix)\r","Imaginary error function: erfi(x) = -i * erf(ix)\r\n\r\nThe imaginary error function is the error function evaluated\r\nat an imaginary argument, made real.",[8823],{"_16":498,"_22":8673,"_69":6},[],{"_16":8826,"_18":8827,"_20":8828,"_22":8829,"_24":8830,"_28":8835,"_30":8836},"sp.special.factorial","sp.special.factorial(n, options?)","The factorial of a number or array of numbers.\r","The factorial of a number or array of numbers.\r\n\r\nThe factorial of non-negative integer n is the product of all\r\npositive integers less than or equal to n:\r\n\r\n n! = n × (n-1) × (n-2) × ... × 2 × 1\r\n\r\nFor example: 5! = 5 × 4 × 3 × 2 × 1 = 120\r\n\r\nWith `exact=false` (default), the factorial is approximated using the\r\ngamma function:\r\n\r\n n! = Γ(n+1)",[8831,8833],{"_16":362,"_22":8832,"_69":6},"- Input value(s) for n!. Can be a number or array of numbers.",{"_16":4789,"_22":8834,"_69":11},"- Optional settings for exact calculation and extend mode.","Promise",[],{"_16":8838,"_18":8839,"_20":8840,"_22":8841,"_24":8842,"_28":8835,"_30":8845},"sp.special.factorial2","sp.special.factorial2(n, options?)","Double factorial.\r","Double factorial.\r\n\r\nThis is the factorial with every second value skipped. For example:\r\n\r\n 7!! = 7 × 5 × 3 × 1 = 105\r\n 8!! = 8 × 6 × 4 × 2 = 384\r\n\r\nIt can be approximated numerically as:\r\n\r\n n!! = 2^(n/2) × Γ(n/2 + 1) × sqrt(2/π) if n is odd\r\n n!! = 2^(n/2) × Γ(n/2 + 1) if n is even",[8843,8844],{"_16":362,"_22":8673,"_69":6},{"_16":4789,"_22":8834,"_69":11},[],{"_16":8847,"_18":8848,"_20":8849,"_22":8850,"_24":8851,"_28":8835,"_30":8856},"sp.special.factorialk","sp.special.factorialk(n, k, options?)","Multifactorial of n of order k, n(!!...!).\r","Multifactorial of n of order k, n(!!...!).\r\n\r\nThis is the multifactorial of n skipping k values. For example:\r\n\r\n factorialk(17, 4) = 17!!!! = 17 × 13 × 9 × 5 × 1 = 8721\r\n\r\nIn particular, for any integer n:\r\n\r\n factorialk(n, 1) = factorial(n)\r\n factorialk(n, 2) = factorial2(n)\r\n\r\nWith `exact=false` (default), it can be approximated as (where r = n % k):\r\n\r\n n!(k) = k^((n-r)/k) × Γ(n/k + 1) / Γ(r/k + 1) × max(r, 1)",[8852,8853,8855],{"_16":362,"_22":8673,"_69":6},{"_16":1114,"_22":8854,"_69":6},"- Order of multifactorial (how many values to skip).",{"_16":4789,"_22":8834,"_69":11},[],{"_16":8858,"_18":8859,"_20":8860,"_22":8861,"_24":8862,"_28":8674,"_30":8864},"sp.special.gamma","sp.special.gamma(x)","Gamma function and related special functions via WebAssembly.\r","Gamma function and related special functions via WebAssembly.\r\nMirrors scipy.special.gamma, gammaln functions.",[8863],{"_16":498,"_22":8673,"_69":6},[],{"_16":8866,"_18":8867,"_20":8868,"_22":8869,"_24":8870,"_28":8674,"_30":8872},"sp.special.gammaln","sp.special.gammaln(x)","Natural logarithm of the absolute value of the gamma function.\r","Natural logarithm of the absolute value of the gamma function.\r\n\r\nFor large arguments, gammaln(x) is more accurate than log(gamma(x))\r\nbecause it avoids overflow of the gamma function.\r\n\r\nReturns: ln(|Γ(x)|)",[8871],{"_16":498,"_22":8673,"_69":6},[],{"_16":8874,"_18":8875,"_20":8876,"_22":8877,"_24":8878,"_28":8674,"_30":8880},"sp.special.rgamma","sp.special.rgamma(x)","Reciprocal of the gamma function: 1/Γ(x)\r","Reciprocal of the gamma function: 1/Γ(x)\r\n\r\nThis function is more numerically stable than computing 1/gamma(x),\r\nespecially for large |x| where gamma(x) might overflow or underflow.",[8879],{"_16":498,"_22":8673,"_69":6},[],{"_16":8882,"_18":8883,"_20":8884,"_22":8885,"_24":8886,"_28":8791,"_30":8891},"sp.special.perm","sp.special.perm(N, k, options?)","Permutations (k-permutations of N).\r","Permutations (k-permutations of N).\r\n\r\nComputes P(N, k) = N! / (N-k)!, the number of ways to arrange k items\r\nfrom N items where order matters.",[8887,8888,8890],{"_16":8785,"_22":8786,"_69":6},{"_16":1114,"_22":8889,"_69":6},"- Number of items to arrange (integer or array)",{"_16":4789,"_22":8790,"_69":11},[],{"_16":8893,"_18":8894,"_20":8895,"_22":8896,"_24":8897,"_28":8901,"_30":8902},"sp.stats.describe","sp.stats.describe(a, options?)","Compute several descriptive statistics of the passed array.\r","Compute several descriptive statistics of the passed array.\r\n\r\nReturns a DescribeResult with: nobs, minmax, mean, variance,\r\nskewness, and kurtosis.",[8898,8900],{"_16":433,"_22":8899,"_69":6},"- Input data array",{"_16":4789,"_22":8790,"_69":11},"Promise",[],{"_16":8904,"_18":8905,"_20":8906,"_22":8907,"_24":8908,"_28":8919,"_30":8920},"sp.stats.kurtosis","sp.stats.kurtosis(a, axis?, fisher?, bias?)","Compute the kurtosis (Fisher or Pearson) of a dataset.\r","Compute the kurtosis (Fisher or Pearson) of a dataset.\r\n\r\nKurtosis is the fourth central moment divided by the square of the\r\nvariance (second central moment). Fisher's definition subtracts 3\r\nso that the normal distribution has kurtosis 0.",[8909,8911,8913,8916],{"_16":433,"_22":8910,"_69":6},"- Input array",{"_16":2299,"_22":8912,"_69":11},"- Axis along which kurtosis is calculated. Default: 0",{"_16":8914,"_22":8915,"_69":11},"fisher","- If true (default), Fisher's definition (normal ==> 0.0).\r\n If false, Pearson's definition (normal ==> 3.0).",{"_16":8917,"_22":8918,"_69":11},"bias","- If false, apply bias correction. Default: true","Promise",[],{"_16":8922,"_18":8923,"_20":8924,"_22":8925,"_24":8926,"_28":8919,"_30":8932},"sp.stats.moment","sp.stats.moment(a, order?, axis?)","Compute the nth central moment of the data along the given axis.\r","Compute the nth central moment of the data along the given axis.\r\n\r\nThe nth central moment is E[(x - mean(x))^n].",[8927,8928,8930],{"_16":433,"_22":8910,"_69":6},{"_16":5562,"_22":8929,"_69":11},"- Order of the central moment (must be >= 0)",{"_16":2299,"_22":8931,"_69":11},"- Axis along which to compute the moment. Default: 0",[],{"_16":8934,"_18":8935,"_20":8936,"_22":8937,"_24":8938,"_28":8919,"_30":8944},"sp.stats.skew","sp.stats.skew(a, axis?, bias?)","Compute the sample skewness of a data set.\r","Compute the sample skewness of a data set.\r\n\r\nFor normally distributed data, the skewness should be about zero.\r\nFor unimodal continuous distributions, a negative skew indicates\r\nthe tail on the left side is longer, while a positive skew\r\nindicates the right side.\r\n\r\nUses Fisher-Pearson coefficient of skewness: m3 / m2^(3/2).",[8939,8940,8942],{"_16":433,"_22":8910,"_69":6},{"_16":2299,"_22":8941,"_69":11},"- Axis along which skewness is calculated. Default: 0",{"_16":8917,"_22":8943,"_69":11},"- If false, apply bias correction for statistical bias. Default: true",[],{"_16":8946,"_18":8947,"_20":8948,"_22":5456,"_24":8949,"_28":1426,"_30":8952},"sp.configureWasm","sp.configureWasm(config)","configureWasm",[8950],{"_16":8097,"_22":8951,"_69":6},"WasmLoadConfig",[],{"_16":8954,"_18":8955,"_20":8956,"_22":5456,"_24":8957,"_28":6903,"_30":8958},"sp.isWasmLoaded","sp.isWasmLoaded()","isWasmLoaded",[],[],{"_16":8960,"_18":8961,"_20":8962,"_22":5456,"_24":8963,"_28":8964,"_30":8965},"sp.loadWasmModule","sp.loadWasmModule()","loadWasmModule",[],"Promise",[],{"_16":8967,"_18":8968,"_20":8969,"_22":5456,"_24":8970,"_28":1426,"_30":8971},"sp.resetWasmModule","sp.resetWasmModule()","resetWasmModule",[],[],{"_43":8973,"_16":8974,"_22":8975,"_47":48,"_49":8976,"_51":8977,"_52":8978},"np-generated","Numerical Arrays (NumPy)","NumPy-inspired numerical array library for WebAssembly.","🔢","np",[8979,8992,9017,9035,9051,9066,9083,9095,9105,9120,9134,9145,9158,9170,9181,9193,9202,9213,9221,9231,9244,9258,9270,9279,9291,9306,9319,9334,9341,9348,9355,9362,9369,9377,9384,9395,9405,9418,9431,9438,9450,9460,9471,9480,9495,9504,9512,9525,9535,9544,9552,9560,9568,9580,9591,9598,9605,9618,9627,9642,9654,9664,9673,9686,9694,9703,9711,9719,9727,9736,9746,9759,9768,9780,9792,9801,9816,9823,9830,9838,9846,9854,9863,9872,9893,9901,9915,9930,9938,9949,9956,9964,9974,9986,9996,10011,10022,10035,10050,10059,10069,10076,10086,10098,10107,10118,10130,10140,10148,10156,10169,10176,10184,10201,10215,10226,10233,10240,10247,10263,10285,10296,10306,10320,10331,10342,10355,10362,10374,10382,10390,10400,10411,10420,10432,10446,10458,10472,10480,10492,10501,10510,10518,10526,10534,10541,10549,10557,10565,10574,10582,10594,10601,10610,10621,10631,10641,10649,10661,10674,10682,10689,10696,10705,10716,10726,10733,10742,10754,10768,10781,10792,10804,10814,10828,10837,10844,10851,10860,10868,10876,10885,10892,10900,10908,10916,10924,10944,10958,10967,10975,10984,10996,11007,11018,11030,11040,11059,11074,11090,11101,11109,11120,11130,11147,11156,11166,11173,11180,11192,11200,11208,11216,11224,11235,11242,11249,11255,11262,11269,11276,11283,11289,11296,11303,11316,11322,11331,11338,11346,11352,11359,11367,11374,11385,11391,11400,11407,11415,11421,11428,11436,11443,11452,11465,11482,11501,11513,11529,11538,11546,11554,11563,11572,11583,11595,11605,11614,11625,11633,11646,11659,11666,11675,11688,11708,11721,11728,11735,11748,11758,11768,11775,11782,11789,11802,11810,11817,11824,11832,11839,11850,11857,11864,11871,11881,11888,11895,11903,11910,11917,11923,11931,11938,11945,11953,11960,11969,11976,11983,11991,12003,12011,12019,12025,12033,12042,12052,12061,12068,12075,12081,12088,12095,12106,12112,12121,12128,12136,12142,12149,12157,12164,12173,12184,12192,12199,12207,12214,12222,12230,12242,12249,12259,12267,12276,12283,12291,12299,12307,12315,12323,12333,12346,12352,12364,12374,12384,12392,12401,12408,12415,12422,12429,12437,12445,12453,12460,12468,12476,12491,12498,12508,12521,12536,12545,12559,12570,12582,12592,12602,12611,12622,12632,12640,12652,12662,12671,12681,12690,12698,12706,12719,12728,12736,12752,12763,12772,12783,12793,12804,12817,12827,12836,12853,12866,12879,12893,12906,12919,12928,12937,12945,12952,12962,12970,12979,12987,12996,13004,13011,13023,13031,13045,13060,13070,13082,13092,13102,13119,13128,13143,13153,13162,13169,13176,13183,13190,13200,13207,13215,13225,13237,13244,13254,13263,13274,13281,13289,13298,13307,13319,13327,13339,13346,13354,13365,13378,13389,13402,13416,13426,13436,13448,13455,13464,13478,13485,13492,13502,13508,13514,13521,13532,13540,13550,13561,13571,13585,13595,13608,13615,13623,13635,13641,13652,13663,13671,13683,13693,13702,13713,13727,13735,13745,13752,13761,13773,13784,13793,13805,13812,13821,13829,13835,13848,13860,13870,13879,13890,13898,13912,13922,13930,13940,13948,13958,13965,13972,13979,13987,13994,14007,14016,14026,14036,14044,14052,14063,14070,14077,14086,14096,14107,14121,14128,14136,14143,14152,14163,14173,14183,14192,14201,14211,14219,14228,14237,14248,14257,14265,14273,14286,14300,14308,14322,14329,14337,14348,14360,14367,14378,14385,14397,14407,14417,14424,14431,14444,14456,14469,14479,14489,14497,14513,14523,14533,14543,14554,14564,14574,14583,14593,14602,14611,14618,14626,14635,14644,14652,14660,14668,14676,14683,14698,14707,14718,14734,14741,14756,14769,14778,14789,14799,14811,14823,14831,14839,14852,14863,14871,14878],{"_16":8980,"_18":8981,"_20":8982,"_22":8983,"_24":8984,"_28":1426,"_30":8991},"np.testing.assert_","np.testing.assert_(val, msg?)","Assert a condition is true.\r","Assert a condition is true.\r\n\r\nUnlike the built-in assert, this works in optimized mode\r\nand provides a consistent interface.",[8985,8988],{"_16":8986,"_22":8987,"_69":6},"val","- Value to test for truthiness",{"_16":8989,"_22":8990,"_69":11},"msg","- Message to display on failure",[],{"_16":8993,"_18":8994,"_20":8995,"_22":8996,"_24":8997,"_28":1426,"_30":9016},"np.testing.assert_allclose","np.testing.assert_allclose(actual, desired, rtol?, atol?, equal_nan?, err_msg?, _verbose?)","Assert that two arrays are element-wise equal within tolerance.\r","Assert that two arrays are element-wise equal within tolerance.\r\n\r\nThe comparison is:\r\n |actual - desired| <= atol + rtol * |desired|\r\n\r\nThis is the recommended assertion for floating-point comparisons.",[8998,9001,9004,9006,9008,9011,9014],{"_16":8999,"_22":9000,"_69":6},"actual","- Actual array",{"_16":9002,"_22":9003,"_69":6},"desired","- Expected array",{"_16":6385,"_22":9005,"_69":11},"- Relative tolerance (default: 1e-7)",{"_16":6388,"_22":9007,"_69":11},"- Absolute tolerance (default: 0)",{"_16":9009,"_22":9010,"_69":11},"equal_nan","- If true, NaN == NaN (default: true)",{"_16":9012,"_22":9013,"_69":11},"err_msg","- Custom error message",{"_16":9015,"_22":6903,"_69":11},"_verbose",[],{"_16":9018,"_18":9019,"_20":9020,"_22":9021,"_24":9022,"_28":1426,"_30":9034},"np.testing.assert_almost_equal","np.testing.assert_almost_equal(actual, desired, decimal?, err_msg?, verbose?)","Assert that two values are equal up to specified decimal places.\r","Assert that two values are equal up to specified decimal places.\r\n\r\nComparison: |actual - desired| < 10^(-decimal)\r\n\r\nFor more control over tolerances, use assert_allclose instead.",[9023,9025,9027,9030,9031],{"_16":8999,"_22":9024,"_69":6},"- Actual value or array",{"_16":9002,"_22":9026,"_69":6},"- Expected value or array",{"_16":9028,"_22":9029,"_69":11},"decimal","- Number of decimal places (default: 7)",{"_16":9012,"_22":9013,"_69":11},{"_16":9032,"_22":9033,"_69":11},"verbose","- Show detailed output",[],{"_16":9036,"_18":9037,"_20":9038,"_22":9039,"_24":9040,"_28":1426,"_30":9050},"np.testing.assert_approx_equal","np.testing.assert_approx_equal(actual, desired, significant?, err_msg?, verbose?)","Assert values are equal to specified significant figures.\r","Assert values are equal to specified significant figures.\r\n\r\nThe comparison is relative to the scale of the expected value.",[9041,9043,9045,9048,9049],{"_16":8999,"_22":9042,"_69":6},"- Actual value",{"_16":9002,"_22":9044,"_69":6},"- Expected value",{"_16":9046,"_22":9047,"_69":11},"significant","- Number of significant figures (default: 7)",{"_16":9012,"_22":9013,"_69":11},{"_16":9032,"_22":9033,"_69":11},[],{"_16":9052,"_18":9053,"_20":9054,"_22":9055,"_24":9056,"_28":1426,"_30":9065},"np.testing.assert_array_almost_equal","np.testing.assert_array_almost_equal(x, y, decimal?, err_msg?, verbose?)","Assert arrays are element-wise equal up to decimal places.\r","Assert arrays are element-wise equal up to decimal places.\r\n\r\nCombination of assert_array_equal and assert_almost_equal.\r\nFirst checks shapes, then element values.",[9057,9059,9061,9063,9064],{"_16":498,"_22":9058,"_69":6},"- First array",{"_16":501,"_22":9060,"_69":6},"- Second array",{"_16":9028,"_22":9062,"_69":11},"- Number of decimal places (default: 6)",{"_16":9012,"_22":9013,"_69":11},{"_16":9032,"_22":9033,"_69":11},[],{"_16":9067,"_18":9068,"_20":9069,"_22":9070,"_24":9071,"_28":1426,"_30":9082},"np.testing.assert_array_compare","np.testing.assert_array_compare(comparison, x, y, header?, precision?)","Assert arrays satisfy a custom comparison.\r","Assert arrays satisfy a custom comparison.\r\n\r\nLow-level function for building custom assertions.",[9072,9075,9076,9077,9080],{"_16":9073,"_22":9074,"_69":6},"comparison","- Comparison function (a, b) => boolean",{"_16":498,"_22":9058,"_69":6},{"_16":501,"_22":9060,"_69":6},{"_16":9078,"_22":9079,"_69":11},"header","- Error message header",{"_16":1336,"_22":9081,"_69":11},"- Decimal places for display",[],{"_16":9084,"_18":9085,"_20":9086,"_22":9087,"_24":9088,"_28":1426,"_30":9094},"np.testing.assert_array_equal","np.testing.assert_array_equal(x, y, err_msg?, verbose?)","Assert that two arrays are element-wise equal.\r","Assert that two arrays are element-wise equal.\r\n\r\nCompares shape and all elements. For floating-point arrays,\r\nuse assert_allclose for tolerance-based comparison.",[9089,9090,9091,9092],{"_16":498,"_22":9058,"_69":6},{"_16":501,"_22":9060,"_69":6},{"_16":9012,"_22":9013,"_69":11},{"_16":9032,"_22":9093,"_69":11},"- Show detailed output on failure",[],{"_16":9096,"_18":9097,"_20":9098,"_22":9098,"_24":9099,"_28":1426,"_30":9104},"np.testing.assert_array_less","np.testing.assert_array_less(x, y, err_msg?, verbose?)","Assert that all elements of x are strictly less than those of y.",[9100,9101,9102,9103],{"_16":498,"_22":9058,"_69":6},{"_16":501,"_22":9060,"_69":6},{"_16":9012,"_22":9013,"_69":11},{"_16":9032,"_22":9033,"_69":11},[],{"_16":9106,"_18":9107,"_20":9108,"_22":9109,"_24":9110,"_28":5703,"_30":9119},"np.testing.assert_array_max_ulp","np.testing.assert_array_max_ulp(a, b, maxulp?, dtype?)","Assert arrays differ by at most `maxulp` ULPs.\r","Assert arrays differ by at most `maxulp` ULPs.\r\n\r\nULP = Unit in the Last Place (floating-point precision unit).\r\nThis is the most precise way to compare floating-point numbers.",[9111,9112,9113,9116],{"_16":433,"_22":9058,"_69":6},{"_16":436,"_22":9060,"_69":6},{"_16":9114,"_22":9115,"_69":11},"maxulp","- Maximum ULP difference allowed (default: 1)",{"_16":9117,"_22":9118,"_69":11},"dtype","- Data type for comparison",[],{"_16":9121,"_18":9122,"_20":9123,"_22":9124,"_24":9125,"_28":1426,"_30":9133},"np.testing.assert_equal","np.testing.assert_equal(actual, desired, err_msg?, verbose?)","Assert that two objects are equal.\r","Assert that two objects are equal.\r\n\r\nHandles comparison of:\r\n- Scalars (number, string, boolean)\r\n- Arrays (JavaScript arrays, nested arrays)\r\n- NDArrays (element-wise comparison)\r\n- Objects (deep equality)\r\n\r\nSpecial cases:\r\n- NaN == NaN is treated as True for testing purposes\r\n- Infinity values are compared correctly",[9126,9128,9129,9131],{"_16":8999,"_22":9127,"_69":6},"- Actual value obtained",{"_16":9002,"_22":9044,"_69":6},{"_16":9012,"_22":9130,"_69":11},"- Custom error message prefix",{"_16":9032,"_22":9132,"_69":11},"- If true, show detailed diff (default: true)",[],{"_16":9135,"_18":9136,"_20":9137,"_22":9137,"_24":9138,"_28":4815,"_30":9144},"np.testing.assert_no_warnings","np.testing.assert_no_warnings(func, args)","Assert that a function emits no warnings.",[9139,9141],{"_16":4204,"_22":9140,"_69":6},"- Function to call",{"_16":9142,"_22":9143,"_69":6},"args","- Arguments to pass to function",[],{"_16":9146,"_18":9147,"_20":9148,"_22":9148,"_24":9149,"_28":1426,"_30":9157},"np.testing.assert_raises","np.testing.assert_raises(exception_class, callable, args)","Assert that a callable raises the specified exception.",[9150,9153,9155],{"_16":9151,"_22":9152,"_69":6},"exception_class","- Expected exception type",{"_16":9154,"_22":9140,"_69":6},"callable",{"_16":9142,"_22":9156,"_69":6},"- Arguments to pass to callable",[],{"_16":9159,"_18":9160,"_20":9161,"_22":9161,"_24":9162,"_28":1426,"_30":9169},"np.testing.assert_raises_regex","np.testing.assert_raises_regex(exception_class, expected_regexp, callable, args)","Assert exception is raised with matching message.",[9163,9164,9167,9168],{"_16":9151,"_22":9152,"_69":6},{"_16":9165,"_22":9166,"_69":6},"expected_regexp","- Regex pattern for message",{"_16":9154,"_22":9140,"_69":6},{"_16":9142,"_22":9156,"_69":6},[],{"_16":9171,"_18":9172,"_20":9173,"_22":9174,"_24":9175,"_28":1426,"_30":9180},"np.testing.assert_string_equal","np.testing.assert_string_equal(actual, desired)","Assert that two strings are equal.\r","Assert that two strings are equal.\r\n\r\nProvides clear diff output for multi-line strings.",[9176,9178],{"_16":8999,"_22":9177,"_69":6},"- Actual string",{"_16":9002,"_22":9179,"_69":6},"- Expected string",[],{"_16":9182,"_18":9183,"_20":9184,"_22":9185,"_24":9186,"_28":4815,"_30":9192},"np.testing.assert_warns","np.testing.assert_warns(warning_class, callable, args)","Assert that a function emits a warning.\r","Assert that a function emits a warning.\r\n\r\nNote: JavaScript doesn't have built-in warnings.\r\nThis integrates with a custom warning system if available.",[9187,9190,9191],{"_16":9188,"_22":9189,"_69":6},"warning_class","- Expected warning type",{"_16":9154,"_22":9140,"_69":6},{"_16":9142,"_22":9156,"_69":6},[],{"_16":9194,"_18":9195,"_20":9196,"_22":9196,"_24":9197,"_28":5703,"_30":9201},"np.testing.measure","np.testing.measure(code, times?)","Measure execution time of a code block.",[9198,9200],{"_16":33,"_22":9199,"_69":6},"- Function to benchmark",{"_16":7197,"_22":6489,"_69":11},[],{"_16":9203,"_18":9204,"_20":9205,"_22":9205,"_24":9206,"_28":1426,"_30":9212},"np.testing.print_assert_equal","np.testing.print_assert_equal(test_string, actual, desired)","Print comparison result for debugging.",[9207,9210,9211],{"_16":9208,"_22":9209,"_69":6},"test_string","- Description of test",{"_16":8999,"_22":9042,"_69":6},{"_16":9002,"_22":9044,"_69":6},[],{"_16":9214,"_18":9215,"_20":9216,"_22":9216,"_24":9217,"_28":9219,"_30":9220},"np.absolute","np.absolute(x)","Calculate the absolute value element-wise.",[9218],{"_16":498,"_22":9219,"_69":6},"NDArray",[],{"_16":9222,"_18":9223,"_20":9224,"_22":9224,"_24":9225,"_28":9219,"_30":9230},"np.add","np.add(x1, x2)","Add arguments element-wise.",[9226,9228],{"_16":9227,"_22":9219,"_69":6},"x1",{"_16":9229,"_22":9219,"_69":6},"x2",[],{"_16":9232,"_18":9233,"_20":9234,"_22":9234,"_24":9235,"_28":9242,"_30":9243},"np.all","np.all(a, axis?, keepdims?)","Test whether all array elements along a given axis evaluate to True.",[9236,9237,9239],{"_16":433,"_22":8910,"_69":6},{"_16":2299,"_22":9238,"_69":11},"- Axis along which to test (undefined for entire array)",{"_16":9240,"_22":9241,"_69":11},"keepdims","- If true, keep reduced axis as size-1 dimension","Promise",[],{"_16":9245,"_18":9246,"_20":9247,"_22":9247,"_24":9248,"_28":6507,"_30":9257},"np.allclose","np.allclose(a, b, rtol?, atol?, equal_nan?)","Returns True if two arrays are element-wise equal within a tolerance.",[9249,9250,9251,9253,9255],{"_16":433,"_22":9058,"_69":6},{"_16":436,"_22":9060,"_69":6},{"_16":6385,"_22":9252,"_69":11},"- Relative tolerance (default 1e-5)",{"_16":6388,"_22":9254,"_69":11},"- Absolute tolerance (default 1e-8)",{"_16":9009,"_22":9256,"_69":11},"- Whether to compare NaN's as equal (default false)",[],{"_16":9259,"_18":9260,"_20":9261,"_22":9262,"_24":9263,"_28":9268,"_30":9269},"np.angle","np.angle(z, deg?)","Return the angle of the complex argument.\r","Return the angle of the complex argument.\r\n\r\nThe angle is computed as the counterclockwise angle from the positive\r\nreal axis, using `arctan2(imag, real)`.",[9264,9266],{"_16":2681,"_22":9265,"_69":6},"- A complex number or array of complex numbers",{"_16":2840,"_22":9267,"_69":11},"- Return angle in degrees if true, radians if false (default)","Promise",[],{"_16":9271,"_18":9272,"_20":9273,"_22":9273,"_24":9274,"_28":9242,"_30":9278},"np.any","np.any(a, axis?, keepdims?)","Test whether any array element along a given axis evaluates to True.",[9275,9276,9277],{"_16":433,"_22":8910,"_69":6},{"_16":2299,"_22":9238,"_69":11},{"_16":9240,"_22":9241,"_69":11},[],{"_16":9280,"_18":9281,"_20":9282,"_22":9282,"_24":9283,"_28":9219,"_30":9290},"np.append","np.append(arr, values, axis?)","Append values to the end of an array.",[9284,9286,9288],{"_16":9285,"_22":8910,"_69":6},"arr",{"_16":2320,"_22":9287,"_69":6},"- Values to append",{"_16":2299,"_22":9289,"_69":11},"- Axis along which to append (default: flatten both)",[],{"_16":9292,"_18":9293,"_20":9294,"_22":9295,"_24":9296,"_28":9268,"_30":9305},"np.applyAlongAxis","np.applyAlongAxis(func1d, axis, arr, args)","Apply a function to 1-D slices along the given axis.\r","Apply a function to 1-D slices along the given axis.\r\n\r\nExecute `func1d(a, ...args)` where `func1d` operates on 1-D arrays\r\nand `a` is a 1-D slice of `arr` along `axis`.",[9297,9300,9302,9303],{"_16":9298,"_22":9299,"_69":6},"func1d","- Function that accepts a 1-D array and returns a scalar or 1-D array",{"_16":2299,"_22":9301,"_69":6},"- Axis along which to apply `func1d`",{"_16":9285,"_22":8910,"_69":6},{"_16":9142,"_22":9304,"_69":6},"- Additional arguments to pass to `func1d`",[],{"_16":9307,"_18":9308,"_20":9309,"_22":9310,"_24":9311,"_28":9268,"_30":9318},"np.applyOverAxes","np.applyOverAxes(func, arr, axes)","Apply a function repeatedly over multiple axes.\r","Apply a function repeatedly over multiple axes.\r\n\r\n`func` is called as `func(a, axis)` where `a` is the current array\r\nand `axis` is the current axis being processed. The result should\r\nhave the same number of dimensions as the input, or one less if\r\nthe function reduces along the axis (in which case `expandDims` is\r\nautomatically called to maintain dimensionality).",[9312,9314,9315],{"_16":4204,"_22":9313,"_69":6},"- Function to apply, signature: (a, axis) => NDArray",{"_16":9285,"_22":8910,"_69":6},{"_16":9316,"_22":9317,"_69":6},"axes","- Axes over which to apply func",[],{"_16":9320,"_18":9321,"_20":9322,"_22":9322,"_24":9323,"_28":9268,"_30":9333},"np.arange","np.arange(start, end?, step?)","Create an NDArray with evenly spaced values within a given interval.",[9324,9327,9330],{"_16":9325,"_22":9326,"_69":6},"start","- Start value (or end if end is not provided)",{"_16":9328,"_22":9329,"_69":11},"end","- End value (exclusive)",{"_16":9331,"_22":9332,"_69":11},"step","- Step between values (default: 1)",[],{"_16":9335,"_18":9336,"_20":9337,"_22":9337,"_24":9338,"_28":9219,"_30":9340},"np.arccos","np.arccos(x)","Trigonometric inverse cosine, element-wise.",[9339],{"_16":498,"_22":9219,"_69":6},[],{"_16":9342,"_18":9343,"_20":9344,"_22":9344,"_24":9345,"_28":9219,"_30":9347},"np.arccosh","np.arccosh(x)","Inverse hyperbolic cosine, element-wise.",[9346],{"_16":498,"_22":9219,"_69":6},[],{"_16":9349,"_18":9350,"_20":9351,"_22":9351,"_24":9352,"_28":9219,"_30":9354},"np.arcsin","np.arcsin(x)","Inverse sine, element-wise.",[9353],{"_16":498,"_22":9219,"_69":6},[],{"_16":9356,"_18":9357,"_20":9358,"_22":9358,"_24":9359,"_28":9219,"_30":9361},"np.arcsinh","np.arcsinh(x)","Inverse hyperbolic sine element-wise.",[9360],{"_16":498,"_22":9219,"_69":6},[],{"_16":9363,"_18":9364,"_20":9365,"_22":9365,"_24":9366,"_28":9219,"_30":9368},"np.arctan","np.arctan(x)","Trigonometric inverse tangent, element-wise.",[9367],{"_16":498,"_22":9219,"_69":6},[],{"_16":9370,"_18":9371,"_20":9372,"_22":9372,"_24":9373,"_28":9219,"_30":9376},"np.arctan2","np.arctan2(x1, x2)","Element-wise arc tangent of x1/x2 choosing the quadrant correctly.",[9374,9375],{"_16":9227,"_22":9219,"_69":6},{"_16":9229,"_22":9219,"_69":6},[],{"_16":9378,"_18":9379,"_20":9380,"_22":9380,"_24":9381,"_28":9219,"_30":9383},"np.arctanh","np.arctanh(x)","Inverse hyperbolic tangent element-wise.",[9382],{"_16":498,"_22":9219,"_69":6},[],{"_16":9385,"_18":9386,"_20":9387,"_22":9387,"_24":9388,"_28":8919,"_30":9394},"np.argmax","np.argmax(a, axis?, keepdims?)","Returns the indices of the maximum values along an axis.",[9389,9390,9392],{"_16":433,"_22":8910,"_69":6},{"_16":2299,"_22":9391,"_69":11},"- Axis along which to find argmax. null finds argmax of flattened array.",{"_16":9240,"_22":9393,"_69":11},"- If true, reduced axes are left with size 1",[],{"_16":9396,"_18":9397,"_20":9398,"_22":9398,"_24":9399,"_28":8919,"_30":9404},"np.argmin","np.argmin(a, axis?, keepdims?)","Returns the indices of the minimum values along an axis.",[9400,9401,9403],{"_16":433,"_22":8910,"_69":6},{"_16":2299,"_22":9402,"_69":11},"- Axis along which to find argmin. null finds argmin of flattened array.",{"_16":9240,"_22":9393,"_69":11},[],{"_16":9406,"_18":9407,"_20":9408,"_22":9408,"_24":9409,"_28":9268,"_30":9417},"np.argpartition","np.argpartition(a, kth, axis?)","Returns the indices that would partition an array.",[9410,9412,9415],{"_16":433,"_22":9411,"_69":6},"- Array to partition",{"_16":9413,"_22":9414,"_69":6},"kth","- Index to partition around",{"_16":2299,"_22":9416,"_69":11},"- Axis along which to partition (default: -1)",[],{"_16":9419,"_18":9420,"_20":9421,"_22":9421,"_24":9422,"_28":9268,"_30":9430},"np.argsort","np.argsort(a, axis?, kind?)","Returns the indices that would sort an array.",[9423,9425,9427],{"_16":433,"_22":9424,"_69":6},"- Array to sort",{"_16":2299,"_22":9426,"_69":11},"- Axis along which to sort. null flattens the array.\r\n Default is -1 (last axis).",{"_16":9428,"_22":9429,"_69":11},"kind","- Sorting algorithm",[],{"_16":9432,"_18":9433,"_20":9434,"_22":9434,"_24":9435,"_28":9268,"_30":9437},"np.argwhere","np.argwhere(arr)","Find the indices of array elements that are non-zero, grouped by element.",[9436],{"_16":9285,"_22":8910,"_69":6},[],{"_16":9439,"_18":9440,"_20":9441,"_22":9441,"_24":9442,"_28":9268,"_30":9449},"np.array","np.array(data, shape?, options?)","Create an NDArray from a nested array or flat array with shape.",[9443,9445,9447],{"_16":84,"_22":9444,"_69":6},"- Nested array or flat array of numbers",{"_16":8461,"_22":9446,"_69":11},"- Optional shape (inferred from nested structure if not provided)",{"_16":4789,"_22":9448,"_69":11},"- Optional configuration (dtype)",[],{"_16":9451,"_18":9452,"_20":9453,"_22":9453,"_24":9454,"_28":6108,"_30":9459},"np.array2string","np.array2string(arr, options?)","Return a string representation of an array.",[9455,9457],{"_16":9285,"_22":9456,"_69":6},"- Array to convert",{"_16":4789,"_22":9458,"_69":11},"- Override print options",[],{"_16":9461,"_18":9462,"_20":9463,"_22":9463,"_24":9464,"_28":6507,"_30":9470},"np.array_equal","np.array_equal(a1, a2, equal_nan?)","True if two arrays have the same shape and elements, False otherwise.",[9465,9467,9469],{"_16":9466,"_22":9058,"_69":6},"a1",{"_16":9468,"_22":9060,"_69":6},"a2",{"_16":9009,"_22":9256,"_69":11},[],{"_16":9472,"_18":9473,"_20":9474,"_22":9475,"_24":9476,"_28":6507,"_30":9479},"np.array_equiv","np.array_equiv(a1, a2)","Returns True if input arrays are shape consistent and all elements equal.\r","Returns True if input arrays are shape consistent and all elements equal.\r\n\r\nShape consistent means they are either the same shape, or one input array\r\ncan be broadcast to create the same shape as the other one.",[9477,9478],{"_16":9466,"_22":9058,"_69":6},{"_16":9468,"_22":9060,"_69":6},[],{"_16":9481,"_18":9482,"_20":9483,"_22":9484,"_24":9485,"_28":9493,"_30":9494},"np.array_split","np.array_split(arr, indices_or_sections, axis?)","Split an array into multiple sub-arrays as views.\r","Split an array into multiple sub-arrays as views.\r\nAllows unequal division (unlike split).",[9486,9488,9491],{"_16":9285,"_22":9487,"_69":6},"- Array to split",{"_16":9489,"_22":9490,"_69":6},"indices_or_sections","- Number of sections or split indices",{"_16":2299,"_22":9492,"_69":11},"- Axis along which to split (default: 0)","NDArray[]",[],{"_16":9496,"_18":9497,"_20":9498,"_22":9498,"_24":9499,"_28":6108,"_30":9503},"np.arrayRepr","np.arrayRepr(arr, options?)","Return the string representation of an array (with dtype info).",[9500,9502],{"_16":9285,"_22":9501,"_69":6},"- Array to represent",{"_16":4789,"_22":9458,"_69":11},[],{"_16":9505,"_18":9506,"_20":9507,"_22":9507,"_24":9508,"_28":6108,"_30":9511},"np.arrayStr","np.arrayStr(arr, options?)","Return a string representation of an array (no dtype).",[9509,9510],{"_16":9285,"_22":9501,"_69":6},{"_16":4789,"_22":9458,"_69":11},[],{"_16":9513,"_18":9514,"_20":9515,"_22":9516,"_24":9517,"_28":4840,"_30":9524},"np.as_series","np.as_series(alist, trim?)","Convert input to a list of 1D coefficient arrays.\r","Convert input to a list of 1D coefficient arrays.\r\n\r\nThis is used to normalize multiple coefficient array inputs for\r\noperations that work with several polynomials.",[9518,9521],{"_16":9519,"_22":9520,"_69":6},"alist","- List of array-like coefficient sequences",{"_16":9522,"_22":9523,"_69":11},"trim","- If true, remove trailing zeros (default: true)",[],{"_16":9526,"_18":9527,"_20":9528,"_22":9529,"_24":9530,"_28":9268,"_30":9534},"np.asanyarray","np.asanyarray(a, options?)","Convert the input to an array, passing through ndarrays unchanged.\r","Convert the input to an array, passing through ndarrays unchanged.\r\n\r\nIn NumPy, this preserves subclasses of ndarray. In numwasm, there are\r\nno subclasses, so this behaves identically to asarray.",[9531,9533],{"_16":433,"_22":9532,"_69":6},"- Input data",{"_16":4789,"_22":9448,"_69":11},[],{"_16":9536,"_18":9537,"_20":9538,"_22":9538,"_24":9539,"_28":9268,"_30":9543},"np.asarray","np.asarray(a, dtype?)","Convert the input to an array.",[9540,9541],{"_16":433,"_22":9532,"_69":6},{"_16":9117,"_22":9542,"_69":11},"- Optional data type",[],{"_16":9545,"_18":9546,"_20":9547,"_22":9547,"_24":9548,"_28":9268,"_30":9551},"np.asarray_chkfinite","np.asarray_chkfinite(a, options?)","Convert the input to an array, checking for NaNs or Infs.",[9549,9550],{"_16":433,"_22":9532,"_69":6},{"_16":4789,"_22":9448,"_69":11},[],{"_16":9553,"_18":9554,"_20":9555,"_22":9555,"_24":9556,"_28":9268,"_30":9559},"np.ascontiguousarray","np.ascontiguousarray(a, options?)","Return a contiguous array (ndim >= 1) in memory (C order).",[9557,9558],{"_16":433,"_22":9532,"_69":6},{"_16":4789,"_22":9448,"_69":11},[],{"_16":9561,"_18":9562,"_20":9563,"_22":9563,"_24":9564,"_28":9268,"_30":9567},"np.asfortranarray","np.asfortranarray(a, options?)","Return a contiguous array (ndim >= 1) in memory (Fortran order).",[9565,9566],{"_16":433,"_22":9532,"_69":6},{"_16":4789,"_22":9448,"_69":11},[],{"_16":9569,"_18":9570,"_20":9571,"_22":9572,"_24":9573,"_28":9219,"_30":9579},"np.astype","np.astype(a, dtype, copy?)","Cast an array to a specified type.\r","Cast an array to a specified type.\r\n\r\nThis is the top-level function version of NDArray.astype().",[9574,9575,9577],{"_16":433,"_22":8910,"_69":6},{"_16":9117,"_22":9576,"_69":6},"- Target data type",{"_16":7870,"_22":9578,"_69":11},"- If true, always return a copy. Default false.",[],{"_16":9581,"_18":9582,"_20":9583,"_22":9584,"_24":9585,"_28":9589,"_30":9590},"np.atleast_1d","np.atleast_1d(arrs)","Convert inputs to arrays with at least one dimension.\r","Convert inputs to arrays with at least one dimension.\r\nScalar inputs are converted to 1D arrays. Higher-dimensional inputs are unchanged.",[9586],{"_16":9587,"_22":9588,"_69":6},"arrs","- Input arrays","NDArray | NDArray[]",[],{"_16":9592,"_18":9593,"_20":9594,"_22":9594,"_24":9595,"_28":9589,"_30":9597},"np.atleast_2d","np.atleast_2d(arrs)","View inputs as arrays with at least two dimensions.",[9596],{"_16":9587,"_22":9588,"_69":6},[],{"_16":9599,"_18":9600,"_20":9601,"_22":9601,"_24":9602,"_28":9589,"_30":9604},"np.atleast_3d","np.atleast_3d(arrs)","View inputs as arrays with at least three dimensions.",[9603],{"_16":9587,"_22":9588,"_69":6},[],{"_16":9606,"_18":9607,"_20":9608,"_22":9608,"_24":9609,"_28":8919,"_30":9617},"np.average","np.average(a, axis?, weights?, keepdims?)","Compute the weighted average along the specified axis.",[9610,9611,9613,9616],{"_16":433,"_22":8910,"_69":6},{"_16":2299,"_22":9612,"_69":11},"- Axis along which to compute average. null computes average of all elements.",{"_16":9614,"_22":9615,"_69":11},"weights","- Array of weights for each value. If null, all weights are equal to 1.",{"_16":9240,"_22":9393,"_69":11},[],{"_16":9619,"_18":9620,"_20":9621,"_22":9622,"_24":9623,"_28":9268,"_30":9626},"np.bartlett","np.bartlett(M)","Return the Bartlett window.\r","Return the Bartlett window.\r\n\r\nThe Bartlett window is very similar to a triangular window, except\r\nthat the end points are at zero. Also known as the triangular or\r\nFejér window.\r\n\r\nFormula:\r\n w(n) = 1 + n/(M-1) for n <= 0\r\n w(n) = 1 - n/(M-1) for n > 0",[9624],{"_16":1960,"_22":9625,"_69":6},"- Number of points in the output window. If zero or less,\r\n an empty array is returned.",[],{"_16":9628,"_18":9629,"_20":9630,"_22":9630,"_24":9631,"_28":6108,"_30":9641},"np.baseRepr","np.baseRepr(num, base?, padding?)","Return a string representation of a number in the given base.",[9632,9635,9638],{"_16":9633,"_22":9634,"_69":6},"num","- Integer to convert",{"_16":9636,"_22":9637,"_69":11},"base","- Number base (2-36)",{"_16":9639,"_22":9640,"_69":11},"padding","- Minimum number of digits",[],{"_16":9643,"_18":9644,"_20":9645,"_22":9645,"_24":9646,"_28":9652,"_30":9653},"np.baseReprArray","np.baseReprArray(arr, base?, padding?)","Convert an array of numbers to base-N representations.",[9647,9649,9650],{"_16":9285,"_22":9648,"_69":6},"- Array of integers",{"_16":9636,"_22":9637,"_69":11},{"_16":9639,"_22":9651,"_69":11},"- Minimum digits per number","string[]",[],{"_16":9655,"_18":9656,"_20":9657,"_22":9658,"_24":9659,"_28":6108,"_30":9663},"np.binaryRepr","np.binaryRepr(num, width?)","Base Conversion Functions\r","Base Conversion Functions\r\n\r\nFunctions for converting numbers to binary and arbitrary base representations.\r\n\r\nReference: numpy/_core/numeric.py (binary_repr, base_repr)",[9660,9661],{"_16":9633,"_22":9634,"_69":6},{"_16":4981,"_22":9662,"_69":11},"- Fixed width for two's complement representation",[],{"_16":9665,"_18":9666,"_20":9667,"_22":9667,"_24":9668,"_28":9652,"_30":9672},"np.binaryReprArray","np.binaryReprArray(arr, width?)","Convert an array of numbers to binary representations.",[9669,9670],{"_16":9285,"_22":9648,"_69":6},{"_16":4981,"_22":9671,"_69":11},"- Fixed width for all representations",[],{"_16":9674,"_18":9675,"_20":9676,"_22":9676,"_24":9677,"_28":9268,"_30":9685},"np.bincount","np.bincount(x, weights?, minlength?)","Count number of occurrences of each value in array of non-negative ints.",[9678,9680,9682],{"_16":498,"_22":9679,"_69":6},"- Input array of non-negative integers",{"_16":9614,"_22":9681,"_69":11},"- Weights, array of the same shape as x (optional)",{"_16":9683,"_22":9684,"_69":11},"minlength","- Minimum number of bins for the output array (default: 0)",[],{"_16":9687,"_18":9688,"_20":9689,"_22":9689,"_24":9690,"_28":9219,"_30":9693},"np.bitwise_and","np.bitwise_and(x1, x2)","Compute the bit-wise AND of two arrays element-wise.",[9691,9692],{"_16":9227,"_22":9219,"_69":6},{"_16":9229,"_22":9219,"_69":6},[],{"_16":9695,"_18":9696,"_20":9697,"_22":9698,"_24":9699,"_28":9219,"_30":9702},"np.bitwise_count","np.bitwise_count(x)","Computes the number of 1-bits in the absolute value of x.\r","Computes the number of 1-bits in the absolute value of x.\r\nAlso known as popcount or population count.\r\nInput array must be integers.",[9700],{"_16":498,"_22":9701,"_69":6},"- Input array of integers",[],{"_16":9704,"_18":9705,"_20":9706,"_22":9706,"_24":9707,"_28":9219,"_30":9710},"np.bitwise_or","np.bitwise_or(x1, x2)","Compute the bit-wise OR of two arrays element-wise.",[9708,9709],{"_16":9227,"_22":9219,"_69":6},{"_16":9229,"_22":9219,"_69":6},[],{"_16":9712,"_18":9713,"_20":9714,"_22":9714,"_24":9715,"_28":9219,"_30":9718},"np.bitwise_xor","np.bitwise_xor(x1, x2)","Compute the bit-wise XOR of two arrays element-wise.",[9716,9717],{"_16":9227,"_22":9219,"_69":6},{"_16":9229,"_22":9219,"_69":6},[],{"_16":9720,"_18":9721,"_20":9722,"_22":9723,"_24":9724,"_28":9268,"_30":9726},"np.blackman","np.blackman(M)","Return the Blackman window.\r","Return the Blackman window.\r\n\r\nThe Blackman window is a taper formed by using the first three\r\nterms of a summation of cosines. It was designed to have close to\r\nthe minimal leakage possible.\r\n\r\nFormula: w(n) = 0.42 + 0.5*cos(π*n/(M-1)) + 0.08*cos(2π*n/(M-1))",[9725],{"_16":1960,"_22":9625,"_69":6},[],{"_16":9728,"_18":9729,"_20":9730,"_22":9730,"_24":9731,"_28":9219,"_30":9735},"np.block","np.block(arrays)","Assemble an nd-array from nested lists of blocks.",[9732],{"_16":9733,"_22":9734,"_69":6},"arrays","- Nested list of arrays (1D list for hstack, 2D for block assembly)",[],{"_16":9737,"_18":9738,"_20":9739,"_22":9740,"_24":9741,"_28":9744,"_30":9745},"np.broadcastArrays","np.broadcastArrays(arrays)","Broadcast any number of arrays against each other.\r","Broadcast any number of arrays against each other.\r\n\r\nReturns views of the arrays with the same shape. All returned arrays\r\nshare data with their originals.",[9742],{"_16":9733,"_22":9743,"_69":6},"- Arrays to broadcast together","Promise",[],{"_16":9747,"_18":9748,"_20":9749,"_22":9749,"_24":9750,"_28":9757,"_30":9758},"np.broadcastShapes","np.broadcastShapes(shape1, shape2)","Compute the broadcast shape for two shapes.",[9751,9754],{"_16":9752,"_22":9753,"_69":6},"shape1","- First shape",{"_16":9755,"_22":9756,"_69":6},"shape2","- Second shape","Promise",[],{"_16":9760,"_18":9761,"_20":9762,"_22":9762,"_24":9763,"_28":9757,"_30":9767},"np.broadcastShapesMulti","np.broadcastShapesMulti(shapes)","Compute the broadcast shape for multiple shapes.",[9764],{"_16":9765,"_22":9766,"_69":6},"shapes","- Array of shapes",[],{"_16":9769,"_18":9770,"_20":9771,"_22":9772,"_24":9773,"_28":9268,"_30":9779},"np.broadcastTo","np.broadcastTo(arr, targetShape)","Broadcast an array to a target shape.\r","Broadcast an array to a target shape.\r\n\r\nReturns a view of the array with the target shape. The view shares\r\ndata with the original array but has zero strides for broadcast dimensions.",[9774,9776],{"_16":9285,"_22":9775,"_69":6},"- Array to broadcast",{"_16":9777,"_22":9778,"_69":6},"targetShape","- Target shape",[],{"_16":9781,"_18":9782,"_20":9783,"_22":9783,"_24":9784,"_28":9790,"_30":9791},"np.buildIndexSpecs","np.buildIndexSpecs(indices, shape)","Build IndexSpec array from parsed indices for C interop.",[9785,9788],{"_16":9786,"_22":9787,"_69":6},"indices","- Expanded index elements (no ellipsis)",{"_16":8461,"_22":9789,"_69":6},"- Shape of the array being indexed","IndexSpec[]",[],{"_16":9793,"_18":9794,"_20":9795,"_22":9795,"_24":9796,"_28":9799,"_30":9800},"np.bytes","np.bytes(length)","Return random bytes.",[9797],{"_16":987,"_22":9798,"_69":6},"- Number of random bytes to generate","Uint8Array",[],{"_16":9802,"_18":9803,"_20":9804,"_22":9804,"_24":9805,"_28":6903,"_30":9815},"np.can_cast","np.can_cast(from, to, casting?)","Returns true if cast between data types can occur according to the casting rule.",[9806,9809,9812],{"_16":9807,"_22":9808,"_69":6},"from","- Data type to cast from",{"_16":9810,"_22":9811,"_69":6},"to","- Data type to cast to",{"_16":9813,"_22":9814,"_69":11},"casting","- Controls what kind of data casting may occur:\r\n- 'no': No casting allowed\r\n- 'equiv': Only byte-order changes allowed\r\n- 'safe': Only casts that can preserve values allowed\r\n- 'same_kind': Only safe casts or casts within a kind allowed\r\n- 'unsafe': Any data conversions allowed",[],{"_16":9817,"_18":9818,"_20":9819,"_22":9819,"_24":9820,"_28":9219,"_30":9822},"np.cbrt","np.cbrt(x)","Return the cube-root of an array, element-wise.",[9821],{"_16":498,"_22":9219,"_69":6},[],{"_16":9824,"_18":9825,"_20":9826,"_22":9826,"_24":9827,"_28":9219,"_30":9829},"np.ceil","np.ceil(x)","Return the ceiling of the input, element-wise.",[9828],{"_16":498,"_22":9219,"_69":6},[],{"_16":9831,"_18":9832,"_20":9833,"_22":9833,"_24":9834,"_28":4712,"_30":9837},"np.cheb2poly","np.cheb2poly(c)","Convert Chebyshev coefficients to power series.",[9835],{"_16":2644,"_22":9836,"_69":6},"- Chebyshev coefficients",[],{"_16":9839,"_18":9840,"_20":9841,"_22":9841,"_24":9842,"_28":4712,"_30":9845},"np.chebadd","np.chebadd(c1, c2)","Add two Chebyshev polynomials.",[9843,9844],{"_16":2726,"_22":4712,"_69":6},{"_16":2729,"_22":4712,"_69":6},[],{"_16":9847,"_18":9848,"_20":9849,"_22":9849,"_24":9850,"_28":4840,"_30":9853},"np.chebcompanion","np.chebcompanion(c)","Generate Chebyshev companion matrix.",[9851],{"_16":2644,"_22":9852,"_69":6},"- Coefficient array",[],{"_16":9855,"_18":9856,"_20":9857,"_22":9857,"_24":9858,"_28":4712,"_30":9862},"np.chebder","np.chebder(c, m?)","Chebyshev derivative.",[9859,9860],{"_16":2644,"_22":9852,"_69":6},{"_16":359,"_22":9861,"_69":11},"- Number of derivatives (default: 1)",[],{"_16":9864,"_18":9865,"_20":9866,"_22":9866,"_24":9867,"_28":9870,"_30":9871},"np.chebdiv","np.chebdiv(c1, c2)","Divide two Chebyshev polynomials.",[9868,9869],{"_16":2726,"_22":4712,"_69":6},{"_16":2729,"_22":4712,"_69":6},"[number[], number[]]",[],{"_16":9873,"_18":9874,"_20":9875,"_22":9875,"_24":9876,"_28":9891,"_30":9892},"np.chebfit","np.chebfit(x, y, deg, rcond?, full?, w?)","Chebyshev least squares fit.",[9877,9879,9881,9883,9886,9888],{"_16":498,"_22":9878,"_69":6},"- x values",{"_16":501,"_22":9880,"_69":6},"- y values",{"_16":2840,"_22":9882,"_69":6},"- Degree of fitting polynomial",{"_16":9884,"_22":9885,"_69":11},"rcond","- Cutoff for small singular values",{"_16":4019,"_22":9887,"_69":11},"- If true, return extra info",{"_16":9889,"_22":9890,"_69":11},"w","- Weights","Promise",[],{"_16":9894,"_18":9895,"_20":9896,"_22":9896,"_24":9897,"_28":4712,"_30":9900},"np.chebfromroots","np.chebfromroots(roots)","Construct Chebyshev polynomial from roots.",[9898],{"_16":2863,"_22":9899,"_69":6},"- Array of roots",[],{"_16":9902,"_18":9903,"_20":9904,"_22":9904,"_24":9905,"_28":4712,"_30":9914},"np.chebint","np.chebint(c, m?, k?, lbnd?)","Chebyshev integral.",[9906,9907,9909,9911],{"_16":2644,"_22":9852,"_69":6},{"_16":359,"_22":9908,"_69":11},"- Number of integrals (default: 1)",{"_16":1114,"_22":9910,"_69":11},"- Integration constants (default: all zero)",{"_16":9912,"_22":9913,"_69":11},"lbnd","- Lower bound (default: 0)",[],{"_16":9916,"_18":9917,"_20":9918,"_22":9919,"_24":9920,"_28":9928,"_30":9929},"np.chebinterpolate","np.chebinterpolate(func, deg, domain?)","Interpolate a function using Chebyshev polynomials.\r","Interpolate a function using Chebyshev polynomials.\r\n\r\nUses Chebyshev nodes for optimal interpolation on [-1, 1].",[9921,9923,9925],{"_16":4204,"_22":9922,"_69":6},"- Function to interpolate",{"_16":2840,"_22":9924,"_69":6},"- Degree of interpolating polynomial",{"_16":9926,"_22":9927,"_69":11},"domain","- Domain for interpolation (default: [-1, 1])","Promise",[],{"_16":9931,"_18":9932,"_20":9933,"_22":9933,"_24":9934,"_28":4712,"_30":9937},"np.chebmul","np.chebmul(c1, c2)","Multiply two Chebyshev polynomials.",[9935,9936],{"_16":2726,"_22":4712,"_69":6},{"_16":2729,"_22":4712,"_69":6},[],{"_16":9939,"_18":9940,"_20":9941,"_22":9941,"_24":9942,"_28":4712,"_30":9948},"np.chebpow","np.chebpow(c, pow, maxpower?)","Raise Chebyshev polynomial to a power.",[9943,9944,9946],{"_16":2644,"_22":4712,"_69":6},{"_16":9945,"_22":5703,"_69":6},"pow",{"_16":9947,"_22":5703,"_69":11},"maxpower",[],{"_16":9950,"_18":9951,"_20":9952,"_22":9952,"_24":9953,"_28":9928,"_30":9955},"np.chebroots","np.chebroots(c)","Find Chebyshev polynomial roots.",[9954],{"_16":2644,"_22":9852,"_69":6},[],{"_16":9957,"_18":9958,"_20":9959,"_22":9959,"_24":9960,"_28":4712,"_30":9963},"np.chebsub","np.chebsub(c1, c2)","Subtract two Chebyshev polynomials.",[9961,9962],{"_16":2726,"_22":4712,"_69":6},{"_16":2729,"_22":4712,"_69":6},[],{"_16":9965,"_18":9966,"_20":9967,"_22":9967,"_24":9968,"_28":5703,"_30":9973},"np.chebval","np.chebval(x, c)","Evaluate Chebyshev polynomial using Clenshaw's algorithm.",[9969,9971],{"_16":498,"_22":9970,"_69":6},"- Point at which to evaluate",{"_16":2644,"_22":9972,"_69":6},"- Coefficient array [c0, c1, c2, ...] for c0*T_0 + c1*T_1 + c2*T_2 + ...",[],{"_16":9975,"_18":9976,"_20":9977,"_22":9977,"_24":9978,"_28":4712,"_30":9985},"np.chebval2d","np.chebval2d(x, y, c)","Evaluate 2D Chebyshev polynomial.",[9979,9981,9983],{"_16":498,"_22":9980,"_69":6},"- x coordinates",{"_16":501,"_22":9982,"_69":6},"- y coordinates",{"_16":2644,"_22":9984,"_69":6},"- 2D coefficient array",[],{"_16":9987,"_18":9988,"_20":9989,"_22":9989,"_24":9990,"_28":4840,"_30":9995},"np.chebvander","np.chebvander(x, deg)","Chebyshev Vandermonde matrix.",[9991,9993],{"_16":498,"_22":9992,"_69":6},"- Sample points",{"_16":2840,"_22":9994,"_69":6},"- Degree of polynomial",[],{"_16":9997,"_18":9998,"_20":9999,"_22":9999,"_24":10000,"_28":8919,"_30":10010},"np.choice","np.choice(a, size?, replace?, p?)","Generates a random sample from a given array or range.",[10001,10003,10005,10008],{"_16":433,"_22":10002,"_69":6},"- If an array, a random sample is generated from its elements.\r\n If an int, the random sample is generated from arange(a).",{"_16":193,"_22":10004,"_69":11},"- Output shape. If null (default), a single value is returned.",{"_16":10006,"_22":10007,"_69":11},"replace","- Whether the sample is with or without replacement. Default is true.",{"_16":1645,"_22":10009,"_69":11},"- Probabilities associated with each entry in a. If not given, the sample\r\n assumes a uniform distribution over all entries.",[],{"_16":10012,"_18":10013,"_20":10014,"_22":10015,"_24":10016,"_28":9268,"_30":10021},"np.cholesky","np.cholesky(a, upper?)","Cholesky decomposition.\r","Cholesky decomposition.\r\n\r\nReturns the Cholesky factor of a Hermitian positive-definite matrix.",[10017,10019],{"_16":433,"_22":10018,"_69":6},"- Hermitian positive-definite matrix (N x N)",{"_16":1137,"_22":10020,"_69":11},"- If true, return upper triangular U (a = U^H @ U),\r\n otherwise return lower triangular L (a = L @ L^H)",[],{"_16":10023,"_18":10024,"_20":10025,"_22":10025,"_24":10026,"_28":9268,"_30":10034},"np.choose","np.choose(indices, choices, mode?)","Construct an array from an index array and a set of arrays to choose from.",[10027,10029,10032],{"_16":9786,"_22":10028,"_69":6},"- Array of indices into choices",{"_16":10030,"_22":10031,"_69":6},"choices","- Array of choice arrays",{"_16":2621,"_22":10033,"_69":11},"- How to handle out-of-bounds indices (default: 'raise')",[],{"_16":10036,"_18":10037,"_20":10038,"_22":10039,"_24":10040,"_28":9268,"_30":10049},"np.clip","np.clip(a, a_min, a_max)","Clip (limit) the values in an array.\r","Clip (limit) the values in an array.\r\n\r\nGiven an interval, values outside the interval are clipped to the interval edges.\r\nFor example, if an interval of [0, 1] is specified, values smaller than 0\r\nbecome 0, and values larger than 1 become 1.",[10041,10043,10046],{"_16":433,"_22":10042,"_69":6},"- Array containing elements to clip",{"_16":10044,"_22":10045,"_69":6},"a_min","- Minimum value. If null, clipping is not performed on the lower interval edge.",{"_16":10047,"_22":10048,"_69":6},"a_max","- Maximum value. If null, clipping is not performed on the upper interval edge.",[],{"_16":10051,"_18":10052,"_20":10053,"_22":10053,"_24":10054,"_28":9219,"_30":10058},"np.column_stack","np.column_stack(tup)","Stack 1-D arrays as columns into a 2-D array.",[10055],{"_16":10056,"_22":10057,"_69":6},"tup","- Sequence of 1-D or 2-D arrays",[],{"_16":10060,"_18":10061,"_20":10062,"_22":10062,"_24":10063,"_28":10067,"_30":10068},"np.common_type","np.common_type(dtypes)","Determine common type following standard coercion rules.",[10064],{"_16":10065,"_22":10066,"_69":6},"dtypes","DType[]","DType",[],{"_16":10070,"_18":10071,"_20":10072,"_22":10072,"_24":10073,"_28":10067,"_30":10075},"np.commonType","np.commonType(dtypes)","Get common type for multiple dtypes.",[10074],{"_16":10065,"_22":10066,"_69":6},[],{"_16":10077,"_18":10078,"_20":10079,"_22":10079,"_24":10080,"_28":9219,"_30":10085},"np.compare_chararrays","np.compare_chararrays(x1, x2)","Compare two string arrays element-wise.",[10081,10083],{"_16":9227,"_22":10082,"_69":6},"- First string array",{"_16":9229,"_22":10084,"_69":6},"- Second string array",[],{"_16":10087,"_18":10088,"_20":10089,"_22":10089,"_24":10090,"_28":9268,"_30":10097},"np.compress","np.compress(condition, arr, axis?)","Return selected slices of an array along given axis.",[10091,10094,10095],{"_16":10092,"_22":10093,"_69":6},"condition","- Boolean 1D array selecting which slices to keep",{"_16":9285,"_22":8910,"_69":6},{"_16":2299,"_22":10096,"_69":11},"- Axis along which to select (default: 0)",[],{"_16":10099,"_18":10100,"_20":10101,"_22":10102,"_24":10103,"_28":9757,"_30":10106},"np.computeBroadcastStrides","np.computeBroadcastStrides(arr, targetShape)","Compute the strides needed to broadcast an array to a target shape.\r","Compute the strides needed to broadcast an array to a target shape.\r\nThis is mainly for internal use.",[10104,10105],{"_16":9285,"_22":9775,"_69":6},{"_16":9777,"_22":9778,"_69":6},[],{"_16":10108,"_18":10109,"_20":10110,"_22":10110,"_24":10111,"_28":4712,"_30":10117},"np.computeResultShape","np.computeResultShape(specs, shape)","Compute the result shape from index specifications.",[10112,10115],{"_16":10113,"_22":10114,"_69":6},"specs","- Array of IndexSpec",{"_16":8461,"_22":10116,"_69":6},"- Original array shape",[],{"_16":10119,"_18":10120,"_20":10121,"_22":10121,"_24":10122,"_28":9219,"_30":10129},"np.concatenate","np.concatenate(arrays, axis?, dtype?)","Join a sequence of arrays along an existing axis.",[10123,10125,10127],{"_16":9733,"_22":10124,"_69":6},"- Sequence of arrays to concatenate",{"_16":2299,"_22":10126,"_69":11},"- The axis along which to concatenate (default: 0)",{"_16":9117,"_22":10128,"_69":11},"- Optional dtype for the output array",[],{"_16":10131,"_18":10132,"_20":10133,"_22":10133,"_24":10134,"_28":8077,"_30":10139},"np.cond","np.cond(x, p?)","Compute the condition number of a matrix.",[10135,10137],{"_16":498,"_22":10136,"_69":6},"- Matrix",{"_16":1645,"_22":10138,"_69":11},"- Norm order (default: 2, using SVD)",[],{"_16":10141,"_18":10142,"_20":10143,"_22":10144,"_24":10145,"_28":1426,"_30":10147},"np.configureWasm","np.configureWasm(config)","Configure WASM loading before initialization.\r","Configure WASM loading before initialization.\r\nMust be called before loadWasmModule() for custom URLs.",[10146],{"_16":8097,"_22":8951,"_69":6},[],{"_16":10149,"_18":10150,"_20":10151,"_22":10152,"_24":10153,"_28":9219,"_30":10155},"np.conjugate","np.conjugate(x)","Return the complex conjugate, element-wise.\r","Return the complex conjugate, element-wise.\r\n\r\nThe complex conjugate of a complex number is obtained by changing\r\nthe sign of its imaginary part.\r\n\r\nFor non-complex arrays, returns a copy of the input.",[10154],{"_16":498,"_22":8910,"_69":6},[],{"_16":10157,"_18":10158,"_20":10159,"_22":10160,"_24":10161,"_28":9268,"_30":10168},"np.convolve","np.convolve(a, v, mode?)","Returns the discrete, linear convolution of two one-dimensional sequences.\r","Returns the discrete, linear convolution of two one-dimensional sequences.\r\n\r\nThe convolution product is only given for points where the signals overlap completely.\r\nValues outside the signal boundary have no effect.",[10162,10164,10166],{"_16":433,"_22":10163,"_69":6},"- First one-dimensional input array",{"_16":2897,"_22":10165,"_69":6},"- Second one-dimensional input array",{"_16":2621,"_22":10167,"_69":11},"- 'full', 'same', or 'valid':\r\n- 'full': Output is the full discrete linear convolution (default)\r\n- 'same': Output is the same size as a, centered with respect to the 'full' output\r\n- 'valid': Output consists only of those elements that do not rely on zero-padding",[],{"_16":10170,"_18":10171,"_20":10172,"_22":10172,"_24":10173,"_28":9268,"_30":10175},"np.copy","np.copy(a)","Return a copy of an array.",[10174],{"_16":433,"_22":8910,"_69":6},[],{"_16":10177,"_18":10178,"_20":10179,"_22":10179,"_24":10180,"_28":9219,"_30":10183},"np.copysign","np.copysign(x1, x2)","Change the sign of x1 to that of x2, element-wise.",[10181,10182],{"_16":9227,"_22":9219,"_69":6},{"_16":9229,"_22":9219,"_69":6},[],{"_16":10185,"_18":10186,"_20":10187,"_22":10187,"_24":10188,"_28":1426,"_30":10200},"np.copyto","np.copyto(dst, src, _casting?, where?)","Copy values from one array to another, broadcasting as necessary.",[10189,10192,10195,10197],{"_16":10190,"_22":10191,"_69":6},"dst","- Destination array",{"_16":10193,"_22":10194,"_69":6},"src","- Source array",{"_16":10196,"_22":6108,"_69":11},"_casting",{"_16":10198,"_22":10199,"_69":11},"where","- Optional boolean mask array",[],{"_16":10202,"_18":10203,"_20":10204,"_22":10205,"_24":10206,"_28":9268,"_30":10214},"np.corrcoef","np.corrcoef(x, y?, rowvar?)","Return Pearson product-moment correlation coefficients.\r","Return Pearson product-moment correlation coefficients.\r\n\r\nThe correlation coefficient matrix of the variables.",[10207,10209,10211],{"_16":498,"_22":10208,"_69":6},"- A 1-D or 2-D array containing multiple variables and observations",{"_16":501,"_22":10210,"_69":11},"- An additional set of variables and observations. Has the same shape as x.",{"_16":10212,"_22":10213,"_69":11},"rowvar","- If true, each row represents a variable, with observations in columns.\r\n If false, the relationship is transposed.",[],{"_16":10216,"_18":10217,"_20":10218,"_22":10219,"_24":10220,"_28":9268,"_30":10225},"np.correlate","np.correlate(a, v, mode?)","Cross-correlation of two 1-dimensional sequences.\r","Cross-correlation of two 1-dimensional sequences.\r\n\r\nThis function computes the correlation as generally understood in signal processing texts:\r\nc_k = sum_n a_{n+k} * conj(v_n)",[10221,10222,10223],{"_16":433,"_22":10163,"_69":6},{"_16":2897,"_22":10165,"_69":6},{"_16":2621,"_22":10224,"_69":11},"- 'full', 'same', or 'valid':\r\n- 'full': Output is the full discrete linear correlation (default)\r\n- 'same': Output is the same size as a, centered with respect to the 'full' output\r\n- 'valid': Output consists only of those elements that do not rely on zero-padding",[],{"_16":10227,"_18":10228,"_20":10229,"_22":10229,"_24":10230,"_28":9219,"_30":10232},"np.cos","np.cos(x)","Cosine element-wise.",[10231],{"_16":498,"_22":9219,"_69":6},[],{"_16":10234,"_18":10235,"_20":10236,"_22":10236,"_24":10237,"_28":9219,"_30":10239},"np.cosh","np.cosh(x)","Hyperbolic cosine, element-wise.",[10238],{"_16":498,"_22":9219,"_69":6},[],{"_16":10241,"_18":10242,"_20":10243,"_22":10243,"_24":10244,"_28":8077,"_30":10246},"np.countNonzero","np.countNonzero(arr)","Count the number of nonzero elements in an array.",[10245],{"_16":9285,"_22":8910,"_69":6},[],{"_16":10248,"_18":10249,"_20":10250,"_22":10251,"_24":10252,"_28":9268,"_30":10262},"np.cov","np.cov(m, y?, rowvar?, bias?, ddof?)","Estimate a covariance matrix.\r","Estimate a covariance matrix.\r\n\r\nCovariance indicates the level to which two variables vary together.",[10253,10254,10256,10257,10259],{"_16":359,"_22":10208,"_69":6},{"_16":501,"_22":10255,"_69":11},"- An additional set of variables and observations. Has the same shape as m.",{"_16":10212,"_22":10213,"_69":11},{"_16":8917,"_22":10258,"_69":11},"- If false (default), normalization is by (N-1). If true, normalization is by N.",{"_16":10260,"_22":10261,"_69":11},"ddof","- If not null, this overrides the bias setting. ddof=1 gives unbiased estimate,\r\n ddof=0 gives biased estimate.",[],{"_16":10264,"_18":10265,"_20":10266,"_22":10267,"_24":10268,"_28":9268,"_30":10284},"np.cross","np.cross(a, b, axisa?, axisb?, axisc?, axis?)","Return the cross product of two (arrays of) vectors.\r","Return the cross product of two (arrays of) vectors.\r\n\r\nThe cross product of a and b in R^3 is a vector perpendicular to both\r\na and b. The vectors are defined by the last axis by default.",[10269,10271,10273,10276,10279,10282],{"_16":433,"_22":10270,"_69":6},"- First vector(s)",{"_16":436,"_22":10272,"_69":6},"- Second vector(s)",{"_16":10274,"_22":10275,"_69":11},"axisa","- Axis of a that defines the vector(s) (default: -1)",{"_16":10277,"_22":10278,"_69":11},"axisb","- Axis of b that defines the vector(s) (default: -1)",{"_16":10280,"_22":10281,"_69":11},"axisc","- Axis of c that contains the cross product vectors (default: -1)",{"_16":2299,"_22":10283,"_69":11},"- If specified, overrides axisa, axisb, and axisc",[],{"_16":10286,"_18":10287,"_20":10288,"_22":10288,"_24":10289,"_28":9268,"_30":10295},"np.cumprod","np.cumprod(a, axis?, dtype?)","Return the cumulative product of elements along a given axis.",[10290,10291,10293],{"_16":433,"_22":8910,"_69":6},{"_16":2299,"_22":10292,"_69":11},"- Axis along which to compute cumprod. null = flatten first",{"_16":9117,"_22":10294,"_69":11},"- Type of output array (default: promotes integers to float64)",[],{"_16":10297,"_18":10298,"_20":10299,"_22":10299,"_24":10300,"_28":9268,"_30":10305},"np.cumsum","np.cumsum(a, axis?, dtype?)","Return the cumulative sum of the elements along a given axis.",[10301,10302,10304],{"_16":433,"_22":8910,"_69":6},{"_16":2299,"_22":10303,"_69":11},"- Axis along which to compute cumsum. null = flatten first",{"_16":9117,"_22":10294,"_69":11},[],{"_16":10307,"_18":10308,"_20":10309,"_22":10310,"_24":10311,"_28":9268,"_30":10319},"np.cumulative_prod","np.cumulative_prod(x, axis?, dtype?, _include_initial?)","Return the cumulative product of array elements.\r","Return the cumulative product of array elements.\r\n\r\nNumPy 2.0 alias for cumprod with include_initial support.",[10312,10313,10315,10317],{"_16":498,"_22":8910,"_69":6},{"_16":2299,"_22":10314,"_69":11},"- Axis along which to compute. Default: 0",{"_16":9117,"_22":10316,"_69":11},"- Type of output array",{"_16":10318,"_22":6903,"_69":11},"_include_initial",[],{"_16":10321,"_18":10322,"_20":10323,"_22":10324,"_24":10325,"_28":9268,"_30":10330},"np.cumulative_sum","np.cumulative_sum(x, axis?, dtype?, _include_initial?)","Return the cumulative sum of array elements.\r","Return the cumulative sum of array elements.\r\n\r\nNumPy 2.0 alias for cumsum with include_initial support.",[10326,10327,10328,10329],{"_16":498,"_22":8910,"_69":6},{"_16":2299,"_22":10314,"_69":11},{"_16":9117,"_22":10316,"_69":11},{"_16":10318,"_22":6903,"_69":11},[],{"_16":10332,"_18":10333,"_20":10334,"_22":10334,"_24":10335,"_28":9219,"_30":10341},"np.decode","np.decode(a, encoding?)","Decode bytes to strings using specified encoding.",[10336,10338],{"_16":433,"_22":10337,"_69":6},"- Array of byte arrays (Uint8Arrays)",{"_16":10339,"_22":10340,"_69":11},"encoding","- Character encoding (default 'utf-8')",[],{"_16":10343,"_18":10344,"_20":10345,"_22":10346,"_24":10347,"_28":10353,"_30":10354},"np.default_rng","np.default_rng(seed?, options?)","Construct a new Generator with the given BitGenerator.\r","Construct a new Generator with the given BitGenerator.\r\n\r\nIf seed is:\r\n- null/undefined: Use OS entropy\r\n- number/bigint: Create SeedSequence from the integer\r\n- array: Create SeedSequence from the array\r\n- SeedSequence: Use directly\r\n- BitGenerator: Use directly",[10348,10351],{"_16":10349,"_22":10350,"_69":11},"seed","- Seed value or BitGenerator",{"_16":4789,"_22":10352,"_69":11},"- Options object with optional bitGenerator name","Generator_2",[],{"_16":10356,"_18":10357,"_20":10358,"_22":10358,"_24":10359,"_28":9219,"_30":10361},"np.degrees","np.degrees(x)","Convert angles from radians to degrees.",[10360],{"_16":498,"_22":9219,"_69":6},[],{"_16":10363,"_18":10364,"_20":10365,"_22":10365,"_24":10366,"_28":9268,"_30":10373},"np.deleteArr","np.deleteArr(arr, obj, axis?)","Return a new array with sub-arrays along an axis deleted.",[10367,10368,10371],{"_16":9285,"_22":8910,"_69":6},{"_16":10369,"_22":10370,"_69":6},"obj","- Index or indices to delete",{"_16":2299,"_22":10372,"_69":11},"- Axis along which to delete (default: flatten first)",[],{"_16":10375,"_18":10376,"_20":10377,"_22":10377,"_24":10378,"_28":10067,"_30":10381},"np.descrToDtype","np.descrToDtype(descr)","Parse NPY descriptor string to DType.",[10379],{"_16":10380,"_22":6108,"_69":6},"descr",[],{"_16":10383,"_18":10384,"_20":10385,"_22":10385,"_24":10386,"_28":8077,"_30":10389},"np.det","np.det(a)","Compute the determinant of an array.",[10387],{"_16":433,"_22":10388,"_69":6},"- Square matrix (N x N)",[],{"_16":10391,"_18":10392,"_20":10393,"_22":10393,"_24":10394,"_28":9268,"_30":10399},"np.diag","np.diag(v, k?)","Extract a diagonal or construct a diagonal array.",[10395,10397],{"_16":2897,"_22":10396,"_69":6},"- Input array (1D to create diagonal matrix, 2D to extract diagonal)",{"_16":1114,"_22":10398,"_69":11},"- Diagonal offset (default: 0)",[],{"_16":10401,"_18":10402,"_20":10403,"_22":10403,"_24":10404,"_28":9744,"_30":10410},"np.diag_indices","np.diag_indices(n, ndim?)","Return the indices to access the main diagonal of an array.",[10405,10407],{"_16":362,"_22":10406,"_69":6},"- Size of the array (along each dimension)",{"_16":10408,"_22":10409,"_69":11},"ndim","- Number of dimensions (default: 2)",[],{"_16":10412,"_18":10413,"_20":10414,"_22":10415,"_24":10416,"_28":9744,"_30":10419},"np.diag_indices_from","np.diag_indices_from(arr)","Return the indices to access the main diagonal of an array.\r","Return the indices to access the main diagonal of an array.\r\n\r\nThis returns a tuple of arrays, one for each dimension of a,\r\nsuitable for accessing the diagonal of an array.",[10417],{"_16":9285,"_22":10418,"_69":6},"- Array of which to get diagonal indices",[],{"_16":10421,"_18":10422,"_20":10423,"_22":10423,"_24":10424,"_28":9268,"_30":10431},"np.diagflat","np.diagflat(v, k?, options?)","Create a 2D array with the flattened input as a diagonal.",[10425,10427,10429],{"_16":2897,"_22":10426,"_69":6},"- Input array, which will be flattened",{"_16":1114,"_22":10428,"_69":11},"- Diagonal to set (default: 0, main diagonal)",{"_16":4789,"_22":10430,"_69":11},"NDArrayOptions",[],{"_16":10433,"_18":10434,"_20":10435,"_22":10435,"_24":10436,"_28":9268,"_30":10445},"np.diagonal","np.diagonal(arr, offset?, axis1?, axis2?)","Return specified diagonals from a 2D array.",[10437,10439,10441,10443],{"_16":9285,"_22":10438,"_69":6},"- Input array (must be 2D)",{"_16":7354,"_22":10440,"_69":11},"- Offset from main diagonal (default: 0)",{"_16":10442,"_22":5703,"_69":11},"axis1",{"_16":10444,"_22":5703,"_69":11},"axis2",[],{"_16":10447,"_18":10448,"_20":10449,"_22":10450,"_24":10451,"_28":9268,"_30":10457},"np.diff","np.diff(a, n?, axis?)","Calculate the n-th discrete difference along the given axis.\r","Calculate the n-th discrete difference along the given axis.\r\n\r\nThe first difference is given by out[i] = a[i+1] - a[i] along the given axis,\r\nhigher differences are calculated by using diff recursively.",[10452,10453,10455],{"_16":433,"_22":8910,"_69":6},{"_16":362,"_22":10454,"_69":11},"- The number of times values are differenced. If zero, the input is returned as-is.",{"_16":2299,"_22":10456,"_69":11},"- The axis along which the difference is taken, default is the last axis.",[],{"_16":10459,"_18":10460,"_20":10461,"_22":10461,"_24":10462,"_28":9268,"_30":10471},"np.digitize","np.digitize(x, bins, right?)","Return the indices of the bins to which each value in input array belongs.",[10463,10465,10468],{"_16":498,"_22":10464,"_69":6},"- Input array to be binned",{"_16":10466,"_22":10467,"_69":6},"bins","- Array of bins. Must be 1-dimensional and monotonic.",{"_16":10469,"_22":10470,"_69":11},"right","- If true, bins[i-1] < x <= bins[i]. If false (default), bins[i-1] <= x < bins[i].",[],{"_16":10473,"_18":10474,"_20":10475,"_22":10475,"_24":10476,"_28":9219,"_30":10479},"np.divide","np.divide(x1, x2)","Divide arguments element-wise (true division).",[10477,10478],{"_16":9227,"_22":9219,"_69":6},{"_16":9229,"_22":9219,"_69":6},[],{"_16":10481,"_18":10482,"_20":10483,"_22":10484,"_24":10485,"_28":10490,"_30":10491},"np.divmod","np.divmod(x1, x2)","Return element-wise quotient and remainder simultaneously.\r","Return element-wise quotient and remainder simultaneously.\r\nEquivalent to (floor_divide(x1, x2), remainder(x1, x2)), but\r\nreturns both in one call.",[10486,10488],{"_16":9227,"_22":10487,"_69":6},"- Dividend array",{"_16":9229,"_22":10489,"_69":6},"- Divisor array","[NDArray, NDArray]",[],{"_16":10493,"_18":10494,"_20":10495,"_22":10496,"_24":10497,"_28":9268,"_30":10500},"np.dot","np.dot(a, b)","Dot product of two arrays.\r","Dot product of two arrays.\r\n\r\nFor 1-D arrays: inner product of vectors.\r\nFor 2-D arrays: matrix multiplication.",[10498,10499],{"_16":433,"_22":9058,"_69":6},{"_16":436,"_22":9060,"_69":6},[],{"_16":10502,"_18":10503,"_20":10504,"_22":10504,"_24":10505,"_28":9493,"_30":10509},"np.dsplit","np.dsplit(arr, indices_or_sections)","Split array into multiple sub-arrays along the 3rd axis (depth).",[10506,10508],{"_16":9285,"_22":10507,"_69":6},"- Array with at least 3 dimensions",{"_16":9489,"_22":9490,"_69":6},[],{"_16":10511,"_18":10512,"_20":10513,"_22":10513,"_24":10514,"_28":9219,"_30":10517},"np.dstack","np.dstack(tup)","Stack arrays in sequence along the third axis (depth-wise).",[10515],{"_16":10056,"_22":10516,"_69":6},"- Sequence of arrays",[],{"_16":10519,"_18":10520,"_20":10521,"_22":10522,"_24":10523,"_28":5703,"_30":10525},"np.dtypeAlignment","np.dtypeAlignment(dtype)","Get natural alignment for a dtype (for C struct compatibility).\r","Get natural alignment for a dtype (for C struct compatibility).\r\nMost types align to their size, capped at 8 bytes.",[10524],{"_16":9117,"_22":10067,"_69":6},[],{"_16":10527,"_18":10528,"_20":10529,"_22":10529,"_24":10530,"_28":10067,"_30":10533},"np.dtypeFromString","np.dtypeFromString(name)","Convert string dtype name to DType enum.",[10531],{"_16":16,"_22":10532,"_69":6},"- String name (e.g., 'float64', 'int32')",[],{"_16":10535,"_18":10536,"_20":10537,"_22":10537,"_24":10538,"_28":5703,"_30":10540},"np.dtypeSize","np.dtypeSize(dtype)","Get the size of a dtype in bytes.",[10539],{"_16":9117,"_22":10067,"_69":6},[],{"_16":10542,"_18":10543,"_20":10544,"_22":10545,"_24":10546,"_28":6108,"_30":10548},"np.dtypeToDescr","np.dtypeToDescr(dtype)","Convert DType to NPY descriptor string.\r","Convert DType to NPY descriptor string.\r\n\r\nFormat: \r\n- Endian: '<' (little), '>' (big), '|' (not applicable)\r\n- Type: 'b' (bool), 'i' (int), 'u' (uint), 'f' (float), 'c' (complex)\r\n- Size: bytes (1, 2, 4, 8, 16)",[10547],{"_16":9117,"_22":10067,"_69":6},[],{"_16":10550,"_18":10551,"_20":10552,"_22":10552,"_24":10553,"_28":6108,"_30":10556},"np.dtypeToString","np.dtypeToString(dtype)","Get dtype string name.",[10554],{"_16":9117,"_22":10555,"_69":6},"- DType enum value",[],{"_16":10558,"_18":10559,"_20":10560,"_22":10560,"_24":10561,"_28":10563,"_30":10564},"np.dtypeToTypedArrayConstructor","np.dtypeToTypedArrayConstructor(dtype)","Get the TypedArray constructor for a given dtype.",[10562],{"_16":9117,"_22":10555,"_69":6},"Float32ArrayConstructor | Float64ArrayConstructor | Int32ArrayConstructor | Int16ArrayConstructor | Int8ArrayConstructor | Uint32ArrayConstructor | Uint16ArrayConstructor | Uint8ArrayConstructor | BigInt64ArrayConstructor | BigUint64ArrayConstructor",[],{"_16":10566,"_18":10567,"_20":10568,"_22":10569,"_24":10570,"_28":9268,"_30":10573},"np.ediff1d","np.ediff1d(arr, options?)","Compute the differences between consecutive elements of an array.\r","Compute the differences between consecutive elements of an array.\r\n\r\nThis is implemented in TypeScript as it's straightforward and doesn't\r\nrequire WASM for performance.",[10571,10572],{"_16":9285,"_22":8910,"_69":6},{"_16":4789,"_22":8790,"_69":11},[],{"_16":10575,"_18":10576,"_20":10577,"_22":10577,"_24":10578,"_28":10580,"_30":10581},"np.eig","np.eig(a)","Compute eigenvalues and right eigenvectors of a general matrix.",[10579],{"_16":433,"_22":10388,"_69":6},"Promise",[],{"_16":10583,"_18":10584,"_20":10585,"_22":10586,"_24":10587,"_28":10580,"_30":10593},"np.eigh","np.eigh(a, _UPLO?)","Compute eigenvalues and eigenvectors of a Hermitian/symmetric matrix.\r","Compute eigenvalues and eigenvectors of a Hermitian/symmetric matrix.\r\n\r\nEigenvalues are always real and returned in ascending order.",[10588,10590],{"_16":433,"_22":10589,"_69":6},"- Hermitian/symmetric matrix (N x N)",{"_16":10591,"_22":10592,"_69":11},"_UPLO","\"L\" | \"U\"",[],{"_16":10595,"_18":10596,"_20":10597,"_22":10597,"_24":10598,"_28":9268,"_30":10600},"np.eigvals","np.eigvals(a)","Compute eigenvalues only.",[10599],{"_16":433,"_22":9219,"_69":6},[],{"_16":10602,"_18":10603,"_20":10604,"_22":10604,"_24":10605,"_28":9268,"_30":10609},"np.eigvalsh","np.eigvalsh(a, UPLO?)","Compute eigenvalues of a Hermitian/symmetric matrix.",[10606,10607],{"_16":433,"_22":9219,"_69":6},{"_16":10608,"_22":10592,"_69":11},"UPLO",[],{"_16":10611,"_18":10612,"_20":10613,"_22":10614,"_24":10615,"_28":9268,"_30":10620},"np.einsum","np.einsum(subscripts, operands)","Evaluates the Einstein summation convention on the operands.\r","Evaluates the Einstein summation convention on the operands.\r\n\r\nUsing the Einstein summation convention, many common multi-dimensional,\r\nlinear algebraic array operations can be represented in a simple fashion.",[10616,10618],{"_16":1798,"_22":10617,"_69":6},"- Subscripts string in format \"ij,jk->ik\"",{"_16":10619,"_22":9588,"_69":6},"operands",[],{"_16":10622,"_18":10623,"_20":10624,"_22":10624,"_24":10625,"_28":10629,"_30":10630},"np.einsum_path","np.einsum_path(subscripts, operands)","Evaluates the lowest cost contraction order for an einsum expression.",[10626,10628],{"_16":1798,"_22":10627,"_69":6},"- Subscripts string",{"_16":10619,"_22":9588,"_69":6},"[number[][], string]",[],{"_16":10632,"_18":10633,"_20":10634,"_22":10635,"_24":10636,"_28":9268,"_30":10640},"np.empty","np.empty(shape, options?)","Create a new NDArray without initializing values.\r","Create a new NDArray without initializing values.\r\nFaster than zeros() but contains arbitrary values.",[10637,10639],{"_16":8461,"_22":10638,"_69":6},"- Array dimensions",{"_16":4789,"_22":9448,"_69":11},[],{"_16":10642,"_18":10643,"_20":10644,"_22":10644,"_24":10645,"_28":9268,"_30":10648},"np.empty_like","np.empty_like(a)","Create an uninitialized array with the same shape and type as a given array.",[10646],{"_16":433,"_22":10647,"_69":6},"- Reference array",[],{"_16":10650,"_18":10651,"_20":10652,"_22":10653,"_24":10654,"_28":10659,"_30":10660},"np.encode","np.encode(a, _encoding?)","Encode strings to bytes using specified encoding.\r","Encode strings to bytes using specified encoding.\r\nReturns an array of Uint8Arrays (one per string element).",[10655,10657],{"_16":433,"_22":10656,"_69":6},"- Input string array",{"_16":10658,"_22":6108,"_69":11},"_encoding","Uint8Array[]",[],{"_16":10662,"_18":10663,"_20":10664,"_22":10664,"_24":10665,"_28":9219,"_30":10673},"np.endswith","np.endswith(a, suffix, start?, end?)","Return true for each element if the string ends with suffix.",[10666,10667,10669,10671],{"_16":433,"_22":10656,"_69":6},{"_16":1267,"_22":10668,"_69":6},"- Suffix to check",{"_16":9325,"_22":10670,"_69":11},"- Start position (default 0)",{"_16":9328,"_22":10672,"_69":11},"- End position (default string length)",[],{"_16":10675,"_18":10676,"_20":10677,"_22":10677,"_24":10678,"_28":9219,"_30":10681},"np.equal","np.equal(x1, x2)","Return (x1 == x2) element-wise.",[10679,10680],{"_16":9227,"_22":9219,"_69":6},{"_16":9229,"_22":9219,"_69":6},[],{"_16":10683,"_18":10684,"_20":10685,"_22":10685,"_24":10686,"_28":9219,"_30":10688},"np.exp","np.exp(x)","Calculate the exponential of all elements in the input array.",[10687],{"_16":498,"_22":9219,"_69":6},[],{"_16":10690,"_18":10691,"_20":10692,"_22":10692,"_24":10693,"_28":9219,"_30":10695},"np.exp2","np.exp2(x)","Calculate 2**x for all elements in the array.",[10694],{"_16":498,"_22":9219,"_69":6},[],{"_16":10697,"_18":10698,"_20":10699,"_22":10699,"_24":10700,"_28":9219,"_30":10704},"np.expand_dims","np.expand_dims(a, axis)","Expand the shape of an array by inserting a new axis.",[10701,10702],{"_16":433,"_22":8910,"_69":6},{"_16":2299,"_22":10703,"_69":6},"- Position in the expanded axes where the new axis is placed",[],{"_16":10706,"_18":10707,"_20":10708,"_22":10708,"_24":10709,"_28":10714,"_30":10715},"np.expandEllipsis","np.expandEllipsis(indices, ndim)","Expand ellipsis and validate index dimensions.",[10710,10712],{"_16":9786,"_22":10711,"_69":6},"- Array of index elements (may contain ellipsis)",{"_16":10408,"_22":10713,"_69":6},"- Number of dimensions in the array being indexed","IndexElement[]",[],{"_16":10717,"_18":10718,"_20":10719,"_22":10719,"_24":10720,"_28":9219,"_30":10725},"np.expandtabs","np.expandtabs(a, tabsize?)","Return element-wise copy with tabs expanded to spaces.",[10721,10722],{"_16":433,"_22":10656,"_69":6},{"_16":10723,"_22":10724,"_69":11},"tabsize","- Tab stop spacing (default 8)",[],{"_16":10727,"_18":10728,"_20":10729,"_22":10729,"_24":10730,"_28":9219,"_30":10732},"np.expm1","np.expm1(x)","Calculate exp(x) - 1 for all elements in the array.",[10731],{"_16":498,"_22":9219,"_69":6},[],{"_16":10734,"_18":10735,"_20":10736,"_22":10736,"_24":10737,"_28":9268,"_30":10741},"np.extract","np.extract(condition, arr)","Return elements of an array that satisfy some condition.",[10738,10740],{"_16":10092,"_22":10739,"_69":6},"- Boolean array, same shape as arr",{"_16":9285,"_22":8910,"_69":6},[],{"_16":10743,"_18":10744,"_20":10745,"_22":10745,"_24":10746,"_28":9268,"_30":10753},"np.eye","np.eye(N, M?, k?, options?)","Create a 2D array with ones on the diagonal and zeros elsewhere.",[10747,10748,10750,10752],{"_16":8785,"_22":4979,"_69":6},{"_16":1960,"_22":10749,"_69":11},"- Number of columns (default: N)",{"_16":1114,"_22":10751,"_69":11},"- Diagonal offset (default: 0, main diagonal)",{"_16":4789,"_22":9448,"_69":11},[],{"_16":10755,"_18":10756,"_20":10757,"_22":10757,"_24":10758,"_28":9219,"_30":10767},"np.fft","np.fft(a, n?, axis?, norm?)","Compute the one-dimensional discrete Fourier Transform.",[10759,10761,10763,10765],{"_16":433,"_22":10760,"_69":6},"- Input array (can be complex or real)",{"_16":362,"_22":10762,"_69":11},"- Length of the transformed axis. If n < a.shape[axis], input is truncated.\r\n If n > a.shape[axis], input is zero-padded. Default: a.shape[axis]",{"_16":2299,"_22":10764,"_69":11},"- Axis over which to compute the FFT. Default: -1 (last axis)",{"_16":1530,"_22":10766,"_69":11},"- Normalization mode: \"backward\", \"ortho\", or \"forward\"",[],{"_16":10769,"_18":10770,"_20":10771,"_22":10771,"_24":10772,"_28":9219,"_30":10780},"np.fft2","np.fft2(a, s?, axes?, norm?)","Compute the 2-dimensional discrete Fourier Transform.",[10773,10774,10776,10778],{"_16":433,"_22":8910,"_69":6},{"_16":3799,"_22":10775,"_69":11},"- Shape (length of each axis) of the output. Default: shape of a",{"_16":9316,"_22":10777,"_69":11},"- Axes over which to compute the FFT. Default: (-2, -1)",{"_16":1530,"_22":10779,"_69":11},"- Normalization mode",[],{"_16":10782,"_18":10783,"_20":10784,"_22":10785,"_24":10786,"_28":9268,"_30":10791},"np.fftfreq","np.fftfreq(n, d?)","Return the Discrete Fourier Transform sample frequencies.\r","Return the Discrete Fourier Transform sample frequencies.\r\n\r\nReturns an array of length n with the sample frequencies:\r\nf = [0, 1, ..., n/2-1, -n/2, ..., -1] / (d*n) if n is even\r\nf = [0, 1, ..., (n-1)/2, -(n-1)/2, ..., -1] / (d*n) if n is odd",[10787,10789],{"_16":362,"_22":10788,"_69":6},"- Window length",{"_16":1946,"_22":10790,"_69":11},"- Sample spacing (default: 1.0)",[],{"_16":10793,"_18":10794,"_20":10795,"_22":10795,"_24":10796,"_28":9219,"_30":10803},"np.fftn","np.fftn(a, s?, axes?, norm?)","Compute the N-dimensional discrete Fourier Transform.",[10797,10798,10800,10802],{"_16":433,"_22":8910,"_69":6},{"_16":3799,"_22":10799,"_69":11},"- Shape of the output along transformed axes",{"_16":9316,"_22":10801,"_69":11},"- Axes over which to compute the FFT. Default: all axes",{"_16":1530,"_22":10779,"_69":11},[],{"_16":10805,"_18":10806,"_20":10807,"_22":10808,"_24":10809,"_28":9219,"_30":10813},"np.fftshift","np.fftshift(x, axes?)","Shift the zero-frequency component to the center of the spectrum.\r","Shift the zero-frequency component to the center of the spectrum.\r\n\r\nThis function swaps half-spaces for all axes listed (or all axes by default).",[10810,10811],{"_16":498,"_22":8910,"_69":6},{"_16":9316,"_22":10812,"_69":11},"- Axes over which to shift. Default: all axes",[],{"_16":10815,"_18":10816,"_20":10817,"_22":10818,"_24":10819,"_28":4713,"_30":10827},"np.fill_diagonal","np.fill_diagonal(a, val, wrap?)","Fill the main diagonal of the given array of any dimensionality.\r","Fill the main diagonal of the given array of any dimensionality.\r\n\r\nFor an array a with a.ndim >= 2, the diagonal is the list of\r\nlocations with indices a[i, i, ..., i] all identical. This function\r\nmodifies the input array in-place, it does not return a value.",[10820,10822,10824],{"_16":433,"_22":10821,"_69":6},"- Array to fill (modified in-place). Must be at least 2-D.",{"_16":8986,"_22":10823,"_69":6},"- Value to write on the diagonal",{"_16":10825,"_22":10826,"_69":11},"wrap","- For tall matrices, whether to \"wrap\" after filling the main diagonal",[],{"_16":10829,"_18":10830,"_20":10831,"_22":10831,"_24":10832,"_28":9652,"_30":10836},"np.find_duplicate","np.find_duplicate(list)","Find duplicate elements in a list.",[10833],{"_16":10834,"_22":10835,"_69":6},"list","- Array of strings to check",[],{"_16":10838,"_18":10839,"_20":10840,"_22":10840,"_24":10841,"_28":9268,"_30":10843},"np.flatnonzero","np.flatnonzero(arr)","Return flat indices of nonzero elements.",[10842],{"_16":9285,"_22":8910,"_69":6},[],{"_16":10845,"_18":10846,"_20":10847,"_22":10847,"_24":10848,"_28":9219,"_30":10850},"np.flatten","np.flatten(a)","Return a copy of the array collapsed into one dimension.",[10849],{"_16":433,"_22":8910,"_69":6},[],{"_16":10852,"_18":10853,"_20":10854,"_22":10854,"_24":10855,"_28":9219,"_30":10859},"np.flip","np.flip(arr, axis?)","Reverse the order of elements in an array along the given axis.",[10856,10857],{"_16":9285,"_22":8910,"_69":6},{"_16":2299,"_22":10858,"_69":11},"- Axis or axes along which to flip. Default is to flip all axes.",[],{"_16":10861,"_18":10862,"_20":10863,"_22":10863,"_24":10864,"_28":9219,"_30":10867},"np.fliplr","np.fliplr(arr)","Reverse the order of elements along axis 1 (left/right).",[10865],{"_16":9285,"_22":10866,"_69":6},"- Input array with at least 2 dimensions",[],{"_16":10869,"_18":10870,"_20":10871,"_22":10871,"_24":10872,"_28":9219,"_30":10875},"np.flipud","np.flipud(arr)","Reverse the order of elements along axis 0 (up/down).",[10873],{"_16":9285,"_22":10874,"_69":6},"- Input array with at least 1 dimension",[],{"_16":10877,"_18":10878,"_20":10879,"_22":10880,"_24":10881,"_28":9219,"_30":10884},"np.float_power","np.float_power(x1, x2)","First array elements raised to powers from second array, element-wise.\r","First array elements raised to powers from second array, element-wise.\r\nUnlike power, float_power always returns float64 output.\r\nIn numwasm, this is equivalent to power since we use float64 by default.",[10882,10883],{"_16":9227,"_22":9219,"_69":6},{"_16":9229,"_22":9219,"_69":6},[],{"_16":10886,"_18":10887,"_20":10888,"_22":10888,"_24":10889,"_28":9219,"_30":10891},"np.floor","np.floor(x)","Return the floor of the input, element-wise.",[10890],{"_16":498,"_22":9219,"_69":6},[],{"_16":10893,"_18":10894,"_20":10895,"_22":10895,"_24":10896,"_28":9219,"_30":10899},"np.floor_divide","np.floor_divide(x1, x2)","Return the largest integer smaller or equal to the division of the inputs.",[10897,10898],{"_16":9227,"_22":9219,"_69":6},{"_16":9229,"_22":9219,"_69":6},[],{"_16":10901,"_18":10902,"_20":10903,"_22":10903,"_24":10904,"_28":9219,"_30":10907},"np.fmax","np.fmax(x1, x2)","Element-wise maximum (ignores NaN).",[10905,10906],{"_16":9227,"_22":9219,"_69":6},{"_16":9229,"_22":9219,"_69":6},[],{"_16":10909,"_18":10910,"_20":10911,"_22":10911,"_24":10912,"_28":9219,"_30":10915},"np.fmin","np.fmin(x1, x2)","Element-wise minimum (ignores NaN).",[10913,10914],{"_16":9227,"_22":9219,"_69":6},{"_16":9229,"_22":9219,"_69":6},[],{"_16":10917,"_18":10918,"_20":10919,"_22":10919,"_24":10920,"_28":9219,"_30":10923},"np.fmod","np.fmod(x1, x2)","Returns element-wise remainder of floor_divide (C-style modulo).",[10921,10922],{"_16":9227,"_22":9219,"_69":6},{"_16":9229,"_22":9219,"_69":6},[],{"_16":10925,"_18":10926,"_20":10927,"_22":10927,"_24":10928,"_28":6108,"_30":10943},"np.formatFloatPositional","np.formatFloatPositional(value, precision?, _unique?, fractional?, trim?, sign?, padLeft?, padRight?)","Format a float in positional notation.",[10929,10930,10931,10933,10935,10937,10939,10941],{"_16":235,"_22":5703,"_69":6},{"_16":1336,"_22":5703,"_69":11},{"_16":10932,"_22":6903,"_69":11},"_unique",{"_16":10934,"_22":6903,"_69":11},"fractional",{"_16":9522,"_22":10936,"_69":11},"\"k\" | \".\" | \"0\" | \"-\"",{"_16":10938,"_22":6903,"_69":11},"sign",{"_16":10940,"_22":5703,"_69":11},"padLeft",{"_16":10942,"_22":5703,"_69":11},"padRight",[],{"_16":10945,"_18":10946,"_20":10947,"_22":10947,"_24":10948,"_28":6108,"_30":10957},"np.formatFloatScientific","np.formatFloatScientific(value, precision?, _unique?, trim?, sign?, padLeft?, expDigits?)","Format a float in scientific notation.",[10949,10950,10951,10952,10953,10954,10955],{"_16":235,"_22":5703,"_69":6},{"_16":1336,"_22":5703,"_69":11},{"_16":10932,"_22":6903,"_69":11},{"_16":9522,"_22":10936,"_69":11},{"_16":10938,"_22":6903,"_69":11},{"_16":10940,"_22":5703,"_69":11},{"_16":10956,"_22":5703,"_69":11},"expDigits",[],{"_16":10959,"_18":10960,"_20":10961,"_22":10961,"_24":10962,"_28":6108,"_30":10966},"np.formatValue","np.formatValue(value, fmt)","Format a number according to printf-style format string.",[10963,10964],{"_16":235,"_22":5703,"_69":6},{"_16":10965,"_22":6108,"_69":6},"fmt",[],{"_16":10968,"_18":10969,"_20":10970,"_22":10971,"_24":10972,"_28":10490,"_30":10974},"np.frexp","np.frexp(x)","Decompose the elements of x into mantissa and twos exponent.\r","Decompose the elements of x into mantissa and twos exponent.\r\nReturns (mantissa, exponent), where x = mantissa * 2^exponent.\r\nThe mantissa lies in the open-closed interval (-1, 1) for float64,\r\nand the twos exponent is a signed integer.",[10973],{"_16":498,"_22":8910,"_69":6},[],{"_16":10976,"_18":10977,"_20":10978,"_22":10978,"_24":10979,"_28":5703,"_30":10983},"np.fromBaseRepr","np.fromBaseRepr(str, base?)","Convert a base-N string to a number.",[10980,10982],{"_16":1129,"_22":10981,"_69":6},"- String representation",{"_16":9636,"_22":9637,"_69":11},[],{"_16":10985,"_18":10986,"_20":10987,"_22":10987,"_24":10988,"_28":5703,"_30":10995},"np.fromBinaryRepr","np.fromBinaryRepr(binary, twosComplement?, width?)","Convert a binary string to a number.",[10989,10992,10994],{"_16":10990,"_22":10991,"_69":6},"binary","- Binary string (optionally with '0b' prefix)",{"_16":10993,"_22":6903,"_69":11},"twosComplement",{"_16":4981,"_22":5703,"_69":11},[],{"_16":10997,"_18":10998,"_20":10999,"_22":10999,"_24":11000,"_28":9268,"_30":11006},"np.frombuffer","np.frombuffer(buffer, options?)","Interpret a buffer as a 1-dimensional array.",[11001,11004],{"_16":11002,"_22":11003,"_69":6},"buffer","- Buffer containing array data",{"_16":4789,"_22":11005,"_69":11},"- Interpretation options",[],{"_16":11008,"_18":11009,"_20":11010,"_22":11010,"_24":11011,"_28":9268,"_30":11017},"np.fromfile","np.fromfile(file, options?)","Construct an array from data in a binary file.",[11012,11015],{"_16":11013,"_22":11014,"_69":6},"file","- File source (path, File object, URL, or ArrayBuffer)",{"_16":4789,"_22":11016,"_69":11},"- Reading options",[],{"_16":11019,"_18":11020,"_20":11021,"_22":11022,"_24":11023,"_28":9268,"_30":11029},"np.fromfunction","np.fromfunction(func, shape, options?)","Construct an array by executing a function over each coordinate.\r","Construct an array by executing a function over each coordinate.\r\n\r\nThe resulting array has a value `fn(x, y, ...)` at coordinate `(x, y, ...)`.",[11024,11026,11028],{"_16":4204,"_22":11025,"_69":6},"- Function to execute on each coordinate (receives indices as arguments)",{"_16":8461,"_22":11027,"_69":6},"- Shape of the output array",{"_16":4789,"_22":9448,"_69":11},[],{"_16":11031,"_18":11032,"_20":11033,"_22":11033,"_24":11034,"_28":9268,"_30":11039},"np.fromiter","np.fromiter(iter, options?)","Create a 1D array from an iterable object.",[11035,11038],{"_16":11036,"_22":11037,"_69":6},"iter","- Iterable yielding numbers",{"_16":4789,"_22":9448,"_69":11},[],{"_16":11041,"_18":11042,"_20":11043,"_22":11044,"_24":11045,"_28":11057,"_30":11058},"np.frompyfunc","np.frompyfunc(func, nin, nout, identity?)","Create a ufunc-like wrapper from a JavaScript function.\r","Create a ufunc-like wrapper from a JavaScript function.\r\n\r\nTakes an arbitrary JavaScript function and returns a ufunc-like object\r\nthat can apply the function element-wise to arrays with broadcasting.",[11046,11048,11051,11054],{"_16":4204,"_22":11047,"_69":6},"- A JavaScript function that operates on scalars",{"_16":11049,"_22":11050,"_69":6},"nin","- The number of input arguments",{"_16":11052,"_22":11053,"_69":6},"nout","- The number of objects returned by func",{"_16":11055,"_22":11056,"_69":11},"identity","- Optional identity value for reduction operations","UfuncLike",[],{"_16":11060,"_18":11061,"_20":11062,"_22":11062,"_24":11063,"_28":9268,"_30":11073},"np.fromregex","np.fromregex(file, regexp, dtype?, options?)","Construct an array from a text file using regular expression parsing.",[11064,11066,11069,11071],{"_16":11013,"_22":11065,"_69":6},"- File source",{"_16":11067,"_22":11068,"_69":6},"regexp","- Regular expression with groups to extract",{"_16":9117,"_22":11070,"_69":11},"- Output data type",{"_16":4789,"_22":11072,"_69":11},"- Additional options",[],{"_16":11075,"_18":11076,"_20":11077,"_22":11078,"_24":11079,"_28":9268,"_30":11089},"np.fromstring","np.fromstring(string, sep?, count?, options?)","Create a 1D array from text data in a string.\r","Create a 1D array from text data in a string.\r\n\r\nA simple way to quickly create 1D arrays from raw text. The string\r\nis parsed using a separator character.",[11080,11082,11085,11088],{"_16":6108,"_22":11081,"_69":6},"- String containing the data",{"_16":11083,"_22":11084,"_69":11},"sep","- Separator between data items. If empty string, treats the\r\n string as binary data with each character representing a byte.",{"_16":11086,"_22":11087,"_69":11},"count","- Number of items to read. Default is -1 (read all).",{"_16":4789,"_22":9448,"_69":11},[],{"_16":11091,"_18":11092,"_20":11093,"_22":11093,"_24":11094,"_28":9268,"_30":11100},"np.full","np.full(shape, fillValue, options?)","Create a new NDArray filled with a constant value.",[11095,11096,11099],{"_16":8461,"_22":10638,"_69":6},{"_16":11097,"_22":11098,"_69":6},"fillValue","- Value to fill with",{"_16":4789,"_22":9448,"_69":11},[],{"_16":11102,"_18":11103,"_20":11104,"_22":11104,"_24":11105,"_28":9268,"_30":11108},"np.full_like","np.full_like(a, fillValue)","Create an array filled with a value, with the same shape and type as a given array.",[11106,11107],{"_16":433,"_22":10647,"_69":6},{"_16":11097,"_22":11098,"_69":6},[],{"_16":11110,"_18":11111,"_20":11112,"_22":11113,"_24":11114,"_28":9219,"_30":11119},"np.gcd","np.gcd(x1, x2)","Returns the greatest common divisor of |x1| and |x2|.\r","Returns the greatest common divisor of |x1| and |x2|.\r\nInput arrays must be integers.",[11115,11117],{"_16":9227,"_22":11116,"_69":6},"- First array of integers",{"_16":9229,"_22":11118,"_69":6},"- Second array of integers",[],{"_16":11121,"_18":11122,"_20":11123,"_22":11124,"_24":11125,"_28":9268,"_30":11129},"np.genfromtxt","np.genfromtxt(file, options?)","Load data from a text file with handling for missing values.\r","Load data from a text file with handling for missing values.\r\nMore sophisticated than loadtxt, supports missing value replacement.",[11126,11127],{"_16":11013,"_22":11065,"_69":6},{"_16":4789,"_22":11128,"_69":11},"- Parsing options",[],{"_16":11131,"_18":11132,"_20":11133,"_22":11133,"_24":11134,"_28":9268,"_30":11146},"np.geomspace","np.geomspace(start, stop, num?, endpoint?, options?)","Create an NDArray with numbers spaced evenly on a geometric scale.",[11135,11137,11140,11142,11145],{"_16":9325,"_22":11136,"_69":6},"- Start value (must be non-zero)",{"_16":11138,"_22":11139,"_69":6},"stop","- End value (must be non-zero)",{"_16":9633,"_22":11141,"_69":11},"- Number of samples (default: 50)",{"_16":11143,"_22":11144,"_69":11},"endpoint","- Include stop value (default: true)",{"_16":4789,"_22":9448,"_69":11},[],{"_16":11148,"_18":11149,"_20":11150,"_22":11150,"_24":11151,"_28":11154,"_30":11155},"np.getBitGenerator","np.getBitGenerator(name)","Get a BitGenerator class by name.",[11152],{"_16":16,"_22":11153,"_69":6},"- Name of the BitGenerator (case-insensitive)","new (seed?: number | bigint | number[] | SeedSequence | null) => BitGenerator",[],{"_16":11157,"_18":11158,"_20":11159,"_22":11160,"_24":11161,"_28":11164,"_30":11165},"np.getdomain","np.getdomain(x)","Get the domain appropriate for given data points.\r","Get the domain appropriate for given data points.\r\n\r\nReturns the minimum and maximum of the data as the domain.",[11162],{"_16":498,"_22":11163,"_69":6},"- Data points","[number, number]",[],{"_16":11167,"_18":11168,"_20":11169,"_22":11169,"_24":11170,"_28":11171,"_30":11172},"np.getPrintoptions","np.getPrintoptions()","Get current print options.",[],"Required",[],{"_16":11174,"_18":11175,"_20":11176,"_22":11176,"_24":11177,"_28":11178,"_30":11179},"np.getWasmModule","np.getWasmModule()","Get the loaded WASM module synchronously.",[],"WasmModule",[],{"_16":11181,"_18":11182,"_20":11183,"_22":11184,"_24":11185,"_28":11190,"_30":11191},"np.gradient","np.gradient(f, args)","Return the gradient of an N-dimensional array.\r","Return the gradient of an N-dimensional array.\r\n\r\nThe gradient is computed using second order accurate central differences\r\nin the interior points and first order accurate one-sides (forward or backwards)\r\ndifferences at the boundaries.",[11186,11188],{"_16":3860,"_22":11187,"_69":6},"- An N-dimensional array containing samples of a scalar function",{"_16":9142,"_22":11189,"_69":6},"(number | number[] | NDArray | {\r\n axis?: number | number[];\r\n edge_order?: number;\r\n})[]","Promise",[],{"_16":11193,"_18":11194,"_20":11195,"_22":11195,"_24":11196,"_28":9219,"_30":11199},"np.greater","np.greater(x1, x2)","Return (x1 > x2) element-wise.",[11197,11198],{"_16":9227,"_22":9219,"_69":6},{"_16":9229,"_22":9219,"_69":6},[],{"_16":11201,"_18":11202,"_20":11203,"_22":11203,"_24":11204,"_28":9219,"_30":11207},"np.greater_equal","np.greater_equal(x1, x2)","Return (x1 >= x2) element-wise.",[11205,11206],{"_16":9227,"_22":9219,"_69":6},{"_16":9229,"_22":9219,"_69":6},[],{"_16":11209,"_18":11210,"_20":11211,"_22":11212,"_24":11213,"_28":9268,"_30":11215},"np.hamming","np.hamming(M)","Return the Hamming window.\r","Return the Hamming window.\r\n\r\nThe Hamming window is a taper formed by using a weighted cosine,\r\nsimilar to Hanning but with raised endpoints to reduce the first\r\nside lobe.\r\n\r\nFormula: w(n) = 0.54 + 0.46*cos(π*n/(M-1))",[11214],{"_16":1960,"_22":9625,"_69":6},[],{"_16":11217,"_18":11218,"_20":11219,"_22":11220,"_24":11221,"_28":9268,"_30":11223},"np.hanning","np.hanning(M)","Return the Hanning window (also known as Hann window).\r","Return the Hanning window (also known as Hann window).\r\n\r\nThe Hanning window is a taper formed by using a weighted cosine.\r\nNamed for Julius von Hann.\r\n\r\nFormula: w(n) = 0.5 + 0.5*cos(π*n/(M-1))",[11222],{"_16":1960,"_22":9625,"_69":6},[],{"_16":11225,"_18":11226,"_20":11227,"_22":11228,"_24":11229,"_28":9219,"_30":11234},"np.heaviside","np.heaviside(x1, x2)","Compute the Heaviside step function.\r","Compute the Heaviside step function.\r\n\r\nH(x) = 0 if x < 0\r\nH(x) = h0 if x == 0\r\nH(x) = 1 if x > 0",[11230,11232],{"_16":9227,"_22":11231,"_69":6},"- Input values",{"_16":9229,"_22":11233,"_69":6},"- Value of the function at x1 == 0 (h0)",[],{"_16":11236,"_18":11237,"_20":11238,"_22":11238,"_24":11239,"_28":4712,"_30":11241},"np.herm2poly","np.herm2poly(c)","Convert Hermite coefficients to power series.",[11240],{"_16":2644,"_22":4712,"_69":6},[],{"_16":11243,"_18":11244,"_20":3288,"_22":5456,"_24":11245,"_28":4712,"_30":11248},"np.hermadd","np.hermadd(c1, c2)",[11246,11247],{"_16":2726,"_22":4712,"_69":6},{"_16":2729,"_22":4712,"_69":6},[],{"_16":11250,"_18":11251,"_20":3337,"_22":5456,"_24":11252,"_28":4840,"_30":11254},"np.hermcompanion","np.hermcompanion(c)",[11253],{"_16":2644,"_22":4712,"_69":6},[],{"_16":11256,"_18":11257,"_20":3256,"_22":5456,"_24":11258,"_28":4712,"_30":11261},"np.hermder","np.hermder(c, m?)",[11259,11260],{"_16":2644,"_22":4712,"_69":6},{"_16":359,"_22":5703,"_69":11},[],{"_16":11263,"_18":11264,"_20":3287,"_22":5456,"_24":11265,"_28":9870,"_30":11268},"np.hermdiv","np.hermdiv(c1, c2)",[11266,11267],{"_16":2726,"_22":4712,"_69":6},{"_16":2729,"_22":4712,"_69":6},[],{"_16":11270,"_18":11271,"_20":11272,"_22":11272,"_24":11273,"_28":4712,"_30":11275},"np.herme2poly","np.herme2poly(c)","Convert HermiteE coefficients to power series.",[11274],{"_16":2644,"_22":4712,"_69":6},[],{"_16":11277,"_18":11278,"_20":3429,"_22":5456,"_24":11279,"_28":4712,"_30":11282},"np.hermeadd","np.hermeadd(c1, c2)",[11280,11281],{"_16":2726,"_22":4712,"_69":6},{"_16":2729,"_22":4712,"_69":6},[],{"_16":11284,"_18":11285,"_20":3478,"_22":5456,"_24":11286,"_28":4840,"_30":11288},"np.hermecompanion","np.hermecompanion(c)",[11287],{"_16":2644,"_22":4712,"_69":6},[],{"_16":11290,"_18":11291,"_20":3397,"_22":5456,"_24":11292,"_28":4712,"_30":11295},"np.hermeder","np.hermeder(c, m?)",[11293,11294],{"_16":2644,"_22":4712,"_69":6},{"_16":359,"_22":5703,"_69":11},[],{"_16":11297,"_18":11298,"_20":3428,"_22":5456,"_24":11299,"_28":9870,"_30":11302},"np.hermediv","np.hermediv(c1, c2)",[11300,11301],{"_16":2726,"_22":4712,"_69":6},{"_16":2729,"_22":4712,"_69":6},[],{"_16":11304,"_18":11305,"_20":3396,"_22":5456,"_24":11306,"_28":9891,"_30":11315},"np.hermefit","np.hermefit(x, y, deg, rcond?, full?, w?)",[11307,11308,11309,11310,11312,11313],{"_16":498,"_22":4712,"_69":6},{"_16":501,"_22":4712,"_69":6},{"_16":2840,"_22":5703,"_69":6},{"_16":9884,"_22":11311,"_69":11},"number | null",{"_16":4019,"_22":6903,"_69":11},{"_16":9889,"_22":11314,"_69":11},"number[] | null",[],{"_16":11317,"_18":11318,"_20":3477,"_22":5456,"_24":11319,"_28":4712,"_30":11321},"np.hermefromroots","np.hermefromroots(roots)",[11320],{"_16":2863,"_22":4712,"_69":6},[],{"_16":11323,"_18":11324,"_20":3407,"_22":5456,"_24":11325,"_28":4712,"_30":11330},"np.hermeint","np.hermeint(c, m?, k?, lbnd?)",[11326,11327,11328,11329],{"_16":2644,"_22":4712,"_69":6},{"_16":359,"_22":5703,"_69":11},{"_16":1114,"_22":4712,"_69":11},{"_16":9912,"_22":5703,"_69":11},[],{"_16":11332,"_18":11333,"_20":3419,"_22":5456,"_24":11334,"_28":4712,"_30":11337},"np.hermemul","np.hermemul(c1, c2)",[11335,11336],{"_16":2726,"_22":4712,"_69":6},{"_16":2729,"_22":4712,"_69":6},[],{"_16":11339,"_18":11340,"_20":3459,"_22":5456,"_24":11341,"_28":4712,"_30":11345},"np.hermepow","np.hermepow(c, pow, maxpower?)",[11342,11343,11344],{"_16":2644,"_22":4712,"_69":6},{"_16":9945,"_22":5703,"_69":6},{"_16":9947,"_22":5703,"_69":11},[],{"_16":11347,"_18":11348,"_20":3469,"_22":5456,"_24":11349,"_28":9928,"_30":11351},"np.hermeroots","np.hermeroots(c)",[11350],{"_16":2644,"_22":4712,"_69":6},[],{"_16":11353,"_18":11354,"_20":3448,"_22":5456,"_24":11355,"_28":4712,"_30":11358},"np.hermesub","np.hermesub(c1, c2)",[11356,11357],{"_16":2726,"_22":4712,"_69":6},{"_16":2729,"_22":4712,"_69":6},[],{"_16":11360,"_18":11361,"_20":11362,"_22":11362,"_24":11363,"_28":5703,"_30":11366},"np.hermeval","np.hermeval(x, c)","Evaluate HermiteE polynomial.",[11364,11365],{"_16":498,"_22":5703,"_69":6},{"_16":2644,"_22":4712,"_69":6},[],{"_16":11368,"_18":11369,"_20":3496,"_22":5456,"_24":11370,"_28":4840,"_30":11373},"np.hermevander","np.hermevander(x, deg)",[11371,11372],{"_16":498,"_22":4712,"_69":6},{"_16":2840,"_22":5703,"_69":6},[],{"_16":11375,"_18":11376,"_20":3255,"_22":5456,"_24":11377,"_28":9891,"_30":11384},"np.hermfit","np.hermfit(x, y, deg, rcond?, full?, w?)",[11378,11379,11380,11381,11382,11383],{"_16":498,"_22":4712,"_69":6},{"_16":501,"_22":4712,"_69":6},{"_16":2840,"_22":5703,"_69":6},{"_16":9884,"_22":11311,"_69":11},{"_16":4019,"_22":6903,"_69":11},{"_16":9889,"_22":11314,"_69":11},[],{"_16":11386,"_18":11387,"_20":3336,"_22":5456,"_24":11388,"_28":4712,"_30":11390},"np.hermfromroots","np.hermfromroots(roots)",[11389],{"_16":2863,"_22":4712,"_69":6},[],{"_16":11392,"_18":11393,"_20":3266,"_22":5456,"_24":11394,"_28":4712,"_30":11399},"np.hermint","np.hermint(c, m?, k?, lbnd?)",[11395,11396,11397,11398],{"_16":2644,"_22":4712,"_69":6},{"_16":359,"_22":5703,"_69":11},{"_16":1114,"_22":4712,"_69":11},{"_16":9912,"_22":5703,"_69":11},[],{"_16":11401,"_18":11402,"_20":3278,"_22":5456,"_24":11403,"_28":4712,"_30":11406},"np.hermmul","np.hermmul(c1, c2)",[11404,11405],{"_16":2726,"_22":4712,"_69":6},{"_16":2729,"_22":4712,"_69":6},[],{"_16":11408,"_18":11409,"_20":3318,"_22":5456,"_24":11410,"_28":4712,"_30":11414},"np.hermpow","np.hermpow(c, pow, maxpower?)",[11411,11412,11413],{"_16":2644,"_22":4712,"_69":6},{"_16":9945,"_22":5703,"_69":6},{"_16":9947,"_22":5703,"_69":11},[],{"_16":11416,"_18":11417,"_20":3328,"_22":5456,"_24":11418,"_28":9928,"_30":11420},"np.hermroots","np.hermroots(c)",[11419],{"_16":2644,"_22":4712,"_69":6},[],{"_16":11422,"_18":11423,"_20":3307,"_22":5456,"_24":11424,"_28":4712,"_30":11427},"np.hermsub","np.hermsub(c1, c2)",[11425,11426],{"_16":2726,"_22":4712,"_69":6},{"_16":2729,"_22":4712,"_69":6},[],{"_16":11429,"_18":11430,"_20":11431,"_22":11431,"_24":11432,"_28":5703,"_30":11435},"np.hermval","np.hermval(x, c)","Evaluate Hermite polynomial.",[11433,11434],{"_16":498,"_22":5703,"_69":6},{"_16":2644,"_22":4712,"_69":6},[],{"_16":11437,"_18":11438,"_20":3355,"_22":5456,"_24":11439,"_28":4840,"_30":11442},"np.hermvander","np.hermvander(x, deg)",[11440,11441],{"_16":498,"_22":4712,"_69":6},{"_16":2840,"_22":5703,"_69":6},[],{"_16":11444,"_18":11445,"_20":11446,"_22":11446,"_24":11447,"_28":6108,"_30":11451},"np.hexRepr","np.hexRepr(num, width?)","Return the hexadecimal representation of a number.",[11448,11449],{"_16":9633,"_22":9634,"_69":6},{"_16":4981,"_22":11450,"_69":11},"- Minimum number of hex digits",[],{"_16":11453,"_18":11454,"_20":11455,"_22":11455,"_24":11456,"_28":9219,"_30":11464},"np.hfft","np.hfft(a, n?, axis?, norm?)","Compute the FFT of a signal that has Hermitian symmetry (real spectrum).",[11457,11459,11461,11463],{"_16":433,"_22":11458,"_69":6},"- Input array with Hermitian symmetry",{"_16":362,"_22":11460,"_69":11},"- Length of the transformed axis",{"_16":2299,"_22":11462,"_69":11},"- Axis over which to compute the FFT. Default: -1",{"_16":1530,"_22":10779,"_69":11},[],{"_16":11466,"_18":11467,"_20":11468,"_22":11468,"_24":11469,"_28":11480,"_30":11481},"np.histogram","np.histogram(a, bins?, range?, density?, weights?)","Compute the histogram of a dataset.",[11470,11471,11473,11476,11478],{"_16":433,"_22":9532,"_69":6},{"_16":10466,"_22":11472,"_69":11},"- Number of bins, method string, or explicit bin edges (default: 10)",{"_16":11474,"_22":11475,"_69":11},"range","- Lower and upper range of bins",{"_16":4041,"_22":11477,"_69":11},"- If true, return probability density instead of counts (default: false)",{"_16":9614,"_22":11479,"_69":11},"- Weights for each data point","Promise",[],{"_16":11483,"_18":11484,"_20":11485,"_22":11485,"_24":11486,"_28":11499,"_30":11500},"np.histogram2d","np.histogram2d(x, y, bins?, range?, density?, weights?)","Compute the bi-dimensional histogram of two data samples.",[11487,11489,11491,11493,11495,11497],{"_16":498,"_22":11488,"_69":6},"- Array of x coordinates",{"_16":501,"_22":11490,"_69":6},"- Array of y coordinates",{"_16":10466,"_22":11492,"_69":11},"- Number of bins or [nx, ny] or [xedges, yedges] (default: 10)",{"_16":11474,"_22":11494,"_69":11},"- [[xmin, xmax], [ymin, ymax]]",{"_16":4041,"_22":11496,"_69":11},"- If true, return probability density (default: false)",{"_16":9614,"_22":11498,"_69":11},"- Weights for each sample","Promise",[],{"_16":11502,"_18":11503,"_20":11504,"_22":11504,"_24":11505,"_28":9268,"_30":11512},"np.histogram_bin_edges","np.histogram_bin_edges(a, bins?, range?, weights?)","Compute histogram bin edges.",[11506,11507,11509,11510],{"_16":433,"_22":9532,"_69":6},{"_16":10466,"_22":11508,"_69":11},"- Number of bins, bin method string, or explicit bin edges (default: 'auto')",{"_16":11474,"_22":11475,"_69":11},{"_16":9614,"_22":11511,"_69":11},"- Weights (used for some bin estimation methods)",[],{"_16":11514,"_18":11515,"_20":11516,"_22":11516,"_24":11517,"_28":11527,"_30":11528},"np.histogramdd","np.histogramdd(sample, bins?, range?, density?, weights?)","Compute the multidimensional histogram of some data.",[11518,11521,11523,11525,11526],{"_16":11519,"_22":11520,"_69":6},"sample","- Data to histogram (shape: [N, D] for N samples in D dimensions,\r\n or 1D array for single dimension)",{"_16":10466,"_22":11522,"_69":11},"- Number of bins per dimension or list of bin edges (default: 10)",{"_16":11474,"_22":11524,"_69":11},"- Ranges for each dimension [[min, max], ...]",{"_16":4041,"_22":11496,"_69":11},{"_16":9614,"_22":11498,"_69":11},"Promise",[],{"_16":11530,"_18":11531,"_20":11532,"_22":11532,"_24":11533,"_28":9493,"_30":11537},"np.hsplit","np.hsplit(arr, indices_or_sections)","Split an array into multiple sub-arrays horizontally (column-wise).",[11534,11536],{"_16":9285,"_22":11535,"_69":6},"- Array",{"_16":9489,"_22":9490,"_69":6},[],{"_16":11539,"_18":11540,"_20":11541,"_22":11542,"_24":11543,"_28":9219,"_30":11545},"np.hstack","np.hstack(tup)","Stack arrays in sequence horizontally (column-wise).\r","Stack arrays in sequence horizontally (column-wise).\r\nFor 1-D arrays, concatenates along axis 0.\r\nFor 2-D+ arrays, concatenates along axis 1.",[11544],{"_16":10056,"_22":10516,"_69":6},[],{"_16":11547,"_18":11548,"_20":11549,"_22":11549,"_24":11550,"_28":9219,"_30":11553},"np.hypot","np.hypot(x1, x2)","Given the \"legs\" of a right triangle, return its hypotenuse.",[11551,11552],{"_16":9227,"_22":9219,"_69":6},{"_16":9229,"_22":9219,"_69":6},[],{"_16":11555,"_18":11556,"_20":11557,"_22":11558,"_24":11559,"_28":9268,"_30":11562},"np.i0","np.i0(x)","Modified Bessel function of the first kind, order 0.\r","Modified Bessel function of the first kind, order 0.\r\n\r\nUsually denoted I₀. This implementation uses Chebyshev polynomial\r\napproximations from the Cephes library, partitioning the domain\r\ninto [0, 8] and (8, ∞).",[11560],{"_16":498,"_22":11561,"_69":6},"- Input array, number, or array of numbers",[],{"_16":11564,"_18":11565,"_20":11566,"_22":11566,"_24":11567,"_28":9268,"_30":11571},"np.identity","np.identity(n, options?)","Create a square identity matrix.",[11568,11570],{"_16":362,"_22":11569,"_69":6},"- Size of the matrix",{"_16":4789,"_22":9448,"_69":11},[],{"_16":11573,"_18":11574,"_20":11575,"_22":11575,"_24":11576,"_28":9219,"_30":11582},"np.ifft","np.ifft(a, n?, axis?, norm?)","Compute the one-dimensional inverse discrete Fourier Transform.",[11577,11578,11579,11581],{"_16":433,"_22":8910,"_69":6},{"_16":362,"_22":11460,"_69":11},{"_16":2299,"_22":11580,"_69":11},"- Axis over which to compute the inverse FFT. Default: -1",{"_16":1530,"_22":10779,"_69":11},[],{"_16":11584,"_18":11585,"_20":11586,"_22":11586,"_24":11587,"_28":9219,"_30":11594},"np.ifft2","np.ifft2(a, s?, axes?, norm?)","Compute the 2-dimensional inverse discrete Fourier Transform.",[11588,11589,11591,11592],{"_16":433,"_22":9219,"_69":6},{"_16":3799,"_22":11590,"_69":11},"[number, number] | null",{"_16":9316,"_22":11164,"_69":11},{"_16":1530,"_22":11593,"_69":11},"FFTNorm",[],{"_16":11596,"_18":11597,"_20":11598,"_22":11598,"_24":11599,"_28":9219,"_30":11604},"np.ifftn","np.ifftn(a, s?, axes?, norm?)","Compute the N-dimensional inverse discrete Fourier Transform.",[11600,11601,11602,11603],{"_16":433,"_22":9219,"_69":6},{"_16":3799,"_22":11314,"_69":11},{"_16":9316,"_22":11314,"_69":11},{"_16":1530,"_22":11593,"_69":11},[],{"_16":11606,"_18":11607,"_20":11608,"_22":11609,"_24":11610,"_28":9219,"_30":11613},"np.ifftshift","np.ifftshift(x, axes?)","The inverse of fftshift.\r","The inverse of fftshift.\r\n\r\nUndoes the effect of fftshift.",[11611,11612],{"_16":498,"_22":8910,"_69":6},{"_16":9316,"_22":10812,"_69":11},[],{"_16":11615,"_18":11616,"_20":11617,"_22":11617,"_24":11618,"_28":9219,"_30":11624},"np.ihfft","np.ihfft(a, n?, axis?, norm?)","Compute the inverse FFT of a signal that has Hermitian symmetry.",[11619,11621,11622,11623],{"_16":433,"_22":11620,"_69":6},"- Input array (real-valued)",{"_16":362,"_22":11460,"_69":11},{"_16":2299,"_22":11580,"_69":11},{"_16":1530,"_22":10779,"_69":11},[],{"_16":11626,"_18":11627,"_20":11628,"_22":11629,"_24":11630,"_28":9219,"_30":11632},"np.imag","np.imag(val)","Return the imaginary part of the complex argument.\r","Return the imaginary part of the complex argument.\r\n\r\nFor non-complex arrays, returns an array of zeros with the same shape.",[11631],{"_16":8986,"_22":8910,"_69":6},[],{"_16":11634,"_18":11635,"_20":11636,"_22":11636,"_24":11637,"_28":9268,"_30":11645},"np.in1d","np.in1d(ar1, ar2, options?)","Test whether each element of ar1 is also present in ar2 (flat version).",[11638,11641,11644],{"_16":11639,"_22":11640,"_69":6},"ar1","- Input array (will be flattened)",{"_16":11642,"_22":11643,"_69":6},"ar2","- Values to test against",{"_16":4789,"_22":8790,"_69":11},[],{"_16":11647,"_18":11648,"_20":11649,"_22":11649,"_24":11650,"_28":11190,"_30":11658},"np.indices","np.indices(dimensions, dtype?, sparse?)","Return an array representing the indices of a grid.",[11651,11654,11656],{"_16":11652,"_22":11653,"_69":6},"dimensions","- The shape of the grid",{"_16":9117,"_22":11655,"_69":11},"- Data type of the result (default: Int32)",{"_16":3988,"_22":11657,"_69":11},"- Return sparse representation (default: false)",[],{"_16":11660,"_18":11661,"_20":11662,"_22":11663,"_24":11664,"_28":4713,"_30":11665},"np.initRandom","np.initRandom()","Initialize the random module.\r","Initialize the random module.\r\n\r\nThis must be called before using any random functions.\r\nIt loads the WASM module and sets up the default generator.",[],[],{"_16":11667,"_18":11668,"_20":11669,"_22":11670,"_24":11671,"_28":9268,"_30":11674},"np.inner","np.inner(a, b)","Inner product of two arrays.\r","Inner product of two arrays.\r\nFor 1-D arrays: dot product.\r\nFor N-D arrays: sum product over last axes.",[11672,11673],{"_16":433,"_22":9219,"_69":6},{"_16":436,"_22":9219,"_69":6},[],{"_16":11676,"_18":11677,"_20":11678,"_22":11678,"_24":11679,"_28":9219,"_30":11687},"np.insert","np.insert(arr, obj, values, axis?)","Insert values along the given axis before the given indices.",[11680,11681,11683,11685],{"_16":9285,"_22":8910,"_69":6},{"_16":10369,"_22":11682,"_69":6},"- Index or indices before which values are inserted",{"_16":2320,"_22":11684,"_69":6},"- Values to insert",{"_16":2299,"_22":11686,"_69":11},"- Axis along which to insert (default: flatten first)",[],{"_16":11689,"_18":11690,"_20":11691,"_22":11692,"_24":11693,"_28":8919,"_30":11707},"np.interp","np.interp(x, xp, fp, left?, right?)","One-dimensional linear interpolation for monotonically increasing sample points.\r","One-dimensional linear interpolation for monotonically increasing sample points.\r\n\r\nReturns the one-dimensional piecewise linear interpolant to a function with\r\ngiven discrete data points (xp, fp), evaluated at x.",[11694,11696,11699,11702,11705],{"_16":498,"_22":11695,"_69":6},"- The x-coordinates at which to evaluate the interpolated values",{"_16":11697,"_22":11698,"_69":6},"xp","- The x-coordinates of the data points, must be increasing",{"_16":11700,"_22":11701,"_69":6},"fp","- The y-coordinates of the data points, same length as xp",{"_16":11703,"_22":11704,"_69":11},"left","- Value to return for x < xp[0], default is fp[0]",{"_16":10469,"_22":11706,"_69":11},"- Value to return for x > xp[-1], default is fp[-1]",[],{"_16":11709,"_18":11710,"_20":11711,"_22":11712,"_24":11713,"_28":11719,"_30":11720},"np.intersect1d","np.intersect1d(ar1, ar2, options?)","Find the intersection of two arrays.\r","Find the intersection of two arrays.\r\n\r\nReturns the sorted unique values that are in both input arrays.",[11714,11716,11718],{"_16":11639,"_22":11715,"_69":6},"- First input array",{"_16":11642,"_22":11717,"_69":6},"- Second input array",{"_16":4789,"_22":8790,"_69":11},"Promise",[],{"_16":11722,"_18":11723,"_20":11724,"_22":11724,"_24":11725,"_28":9268,"_30":11727},"np.inv","np.inv(a)","Compute the (multiplicative) inverse of a matrix.",[11726],{"_16":433,"_22":10388,"_69":6},[],{"_16":11729,"_18":11730,"_20":11731,"_22":11731,"_24":11732,"_28":9219,"_30":11734},"np.invert","np.invert(x)","Compute bit-wise inversion, element-wise.",[11733],{"_16":498,"_22":9219,"_69":6},[],{"_16":11736,"_18":11737,"_20":11738,"_22":11739,"_24":11740,"_28":9219,"_30":11747},"np.irfft","np.irfft(a, n?, axis?, norm?)","Compute the inverse of the one-dimensional discrete Fourier Transform for real input.\r","Compute the inverse of the one-dimensional discrete Fourier Transform for real input.\r\n\r\nThis function computes the inverse of the one-dimensional n-point DFT of\r\nHermitian-symmetric input (from rfft). The input should have shape (..., n//2 + 1).",[11741,11743,11745,11746],{"_16":433,"_22":11742,"_69":6},"- Input array (complex, Hermitian-symmetric)",{"_16":362,"_22":11744,"_69":11},"- Length of the output. If n is not given, it is determined from the\r\n input shape: n = 2 * (a.shape[axis] - 1)",{"_16":2299,"_22":11580,"_69":11},{"_16":1530,"_22":10779,"_69":11},[],{"_16":11749,"_18":11750,"_20":11751,"_22":11751,"_24":11752,"_28":9219,"_30":11757},"np.irfft2","np.irfft2(a, s?, axes?, norm?)","Compute the inverse of the 2-dimensional FFT of real input.",[11753,11754,11755,11756],{"_16":433,"_22":9219,"_69":6},{"_16":3799,"_22":11590,"_69":11},{"_16":9316,"_22":11164,"_69":11},{"_16":1530,"_22":11593,"_69":11},[],{"_16":11759,"_18":11760,"_20":11761,"_22":11761,"_24":11762,"_28":9219,"_30":11767},"np.irfftn","np.irfftn(a, s?, axes?, norm?)","Compute the inverse of the N-dimensional FFT of real input.",[11763,11764,11765,11766],{"_16":433,"_22":9219,"_69":6},{"_16":3799,"_22":11314,"_69":11},{"_16":9316,"_22":11314,"_69":11},{"_16":1530,"_22":11593,"_69":11},[],{"_16":11769,"_18":11770,"_20":11771,"_22":11771,"_24":11772,"_28":9219,"_30":11774},"np.isalnum","np.isalnum(a)","Return true for each element if all characters are alphanumeric.",[11773],{"_16":433,"_22":10656,"_69":6},[],{"_16":11776,"_18":11777,"_20":11778,"_22":11778,"_24":11779,"_28":9219,"_30":11781},"np.isalpha","np.isalpha(a)","Return true for each element if all characters are alphabetic.",[11780],{"_16":433,"_22":10656,"_69":6},[],{"_16":11783,"_18":11784,"_20":11785,"_22":11785,"_24":11786,"_28":6903,"_30":11788},"np.isBoolDType","np.isBoolDType(dtype)","Check if dtype is boolean.",[11787],{"_16":9117,"_22":10067,"_69":6},[],{"_16":11790,"_18":11791,"_20":11792,"_22":11793,"_24":11794,"_28":9268,"_30":11801},"np.isclose","np.isclose(a, b, rtol?, atol?, equal_nan?)","Returns a boolean array where two arrays are element-wise equal within tolerance.\r","Returns a boolean array where two arrays are element-wise equal within tolerance.\r\n\r\nFormula: |a - b| <= (atol + rtol * |b|)",[11795,11796,11798,11799,11800],{"_16":433,"_22":9058,"_69":6},{"_16":436,"_22":11797,"_69":6},"- Second array (reference)",{"_16":6385,"_22":9252,"_69":11},{"_16":6388,"_22":9254,"_69":11},{"_16":9009,"_22":9256,"_69":11},[],{"_16":11803,"_18":11804,"_20":11805,"_22":11806,"_24":11807,"_28":9268,"_30":11809},"np.iscomplex","np.iscomplex(x)","Returns a bool array where True if input element is complex (imaginary part != 0).\r","Returns a bool array where True if input element is complex (imaginary part != 0).\r\nFor non-complex dtype arrays, returns all False.",[11808],{"_16":498,"_22":8910,"_69":6},[],{"_16":11811,"_18":11812,"_20":11813,"_22":11813,"_24":11814,"_28":6903,"_30":11816},"np.isComplexDType","np.isComplexDType(dtype)","Check if dtype is a complex type.",[11815],{"_16":9117,"_22":10067,"_69":6},[],{"_16":11818,"_18":11819,"_20":11820,"_22":11820,"_24":11821,"_28":6903,"_30":11823},"np.iscomplexobj","np.iscomplexobj(x)","Check if the array has a complex dtype.",[11822],{"_16":498,"_22":8910,"_69":6},[],{"_16":11825,"_18":11826,"_20":11827,"_22":11828,"_24":11829,"_28":9219,"_30":11831},"np.isdecimal","np.isdecimal(a)","Return true for each element if all characters are decimal.\r","Return true for each element if all characters are decimal.\r\nDecimal characters are those in Unicode category \"Nd\".",[11830],{"_16":433,"_22":10656,"_69":6},[],{"_16":11833,"_18":11834,"_20":11835,"_22":11835,"_24":11836,"_28":9219,"_30":11838},"np.isdigit","np.isdigit(a)","Return true for each element if all characters are digits (0-9).",[11837],{"_16":433,"_22":10656,"_69":6},[],{"_16":11840,"_18":11841,"_20":11842,"_22":11843,"_24":11844,"_28":6903,"_30":11849},"np.isdtype","np.isdtype(dtype, kind)","Returns a boolean indicating whether the provided dtype is of the specified kind.\r","Returns a boolean indicating whether the provided dtype is of the specified kind.\r\n\r\nThis is the NumPy 2.0 version of issubdtype, with a more explicit API.",[11845,11847],{"_16":9117,"_22":11846,"_69":6},"- The dtype to check",{"_16":9428,"_22":11848,"_69":6},"- The dtype kind to check against",[],{"_16":11851,"_18":11852,"_20":11853,"_22":11853,"_24":11854,"_28":9268,"_30":11856},"np.isfinite","np.isfinite(x)","Test element-wise for finiteness (not infinity and not NaN).",[11855],{"_16":498,"_22":8910,"_69":6},[],{"_16":11858,"_18":11859,"_20":11860,"_22":11860,"_24":11861,"_28":6903,"_30":11863},"np.isFloatDType","np.isFloatDType(dtype)","Check if dtype is a floating point type.",[11862],{"_16":9117,"_22":10067,"_69":6},[],{"_16":11865,"_18":11866,"_20":11867,"_22":11867,"_24":11868,"_28":6903,"_30":11870},"np.isfortran","np.isfortran(a)","Check if the array is Fortran contiguous but not C contiguous.",[11869],{"_16":433,"_22":8910,"_69":6},[],{"_16":11872,"_18":11873,"_20":11874,"_22":11875,"_24":11876,"_28":9268,"_30":11880},"np.isin","np.isin(ar1, ar2, options?)","Test whether each element of ar1 is also present in ar2.\r","Test whether each element of ar1 is also present in ar2.\r\n\r\nReturns a boolean array of the same shape as ar1.",[11877,11878,11879],{"_16":11639,"_22":8910,"_69":6},{"_16":11642,"_22":11643,"_69":6},{"_16":4789,"_22":8790,"_69":11},[],{"_16":11882,"_18":11883,"_20":11884,"_22":11884,"_24":11885,"_28":9268,"_30":11887},"np.isinf","np.isinf(x)","Test element-wise for positive or negative infinity.",[11886],{"_16":498,"_22":8910,"_69":6},[],{"_16":11889,"_18":11890,"_20":11891,"_22":11891,"_24":11892,"_28":6903,"_30":11894},"np.isIntegerDType","np.isIntegerDType(dtype)","Check if dtype is an integer type (signed or unsigned).",[11893],{"_16":9117,"_22":10067,"_69":6},[],{"_16":11896,"_18":11897,"_20":11898,"_22":11899,"_24":11900,"_28":9219,"_30":11902},"np.islower","np.islower(a)","Return true for each element if all cased characters are lowercase\r","Return true for each element if all cased characters are lowercase\r\nand there is at least one cased character.",[11901],{"_16":433,"_22":10656,"_69":6},[],{"_16":11904,"_18":11905,"_20":11906,"_22":11906,"_24":11907,"_28":9268,"_30":11909},"np.isnan","np.isnan(x)","Test element-wise for NaN.",[11908],{"_16":498,"_22":8910,"_69":6},[],{"_16":11911,"_18":11912,"_20":11913,"_22":11913,"_24":11914,"_28":9268,"_30":11916},"np.isneginf","np.isneginf(x)","Test element-wise for negative infinity.",[11915],{"_16":498,"_22":8910,"_69":6},[],{"_16":11918,"_18":11919,"_20":11920,"_22":11920,"_24":11921,"_28":6903,"_30":11922},"np.isNode","np.isNode()","Check if running in Node.js environment.",[],[],{"_16":11924,"_18":11925,"_20":11926,"_22":11927,"_24":11928,"_28":9219,"_30":11930},"np.isnumeric","np.isnumeric(a)","Return true for each element if all characters are numeric.\r","Return true for each element if all characters are numeric.\r\nNumeric characters include digit characters and characters\r\nthat have the Unicode numeric value property (subscripts, fractions, etc.).",[11929],{"_16":433,"_22":10656,"_69":6},[],{"_16":11932,"_18":11933,"_20":11934,"_22":11934,"_24":11935,"_28":6903,"_30":11937},"np.isNumericDType","np.isNumericDType(dtype)","Check if dtype is numeric (not bool).",[11936],{"_16":9117,"_22":10067,"_69":6},[],{"_16":11939,"_18":11940,"_20":11941,"_22":11941,"_24":11942,"_28":9268,"_30":11944},"np.isposinf","np.isposinf(x)","Test element-wise for positive infinity.",[11943],{"_16":498,"_22":8910,"_69":6},[],{"_16":11946,"_18":11947,"_20":11948,"_22":11949,"_24":11950,"_28":9268,"_30":11952},"np.isreal","np.isreal(x)","Returns a bool array where True if input element is real (imaginary part == 0).\r","Returns a bool array where True if input element is real (imaginary part == 0).\r\nFor non-complex dtype arrays, returns all True.",[11951],{"_16":498,"_22":8910,"_69":6},[],{"_16":11954,"_18":11955,"_20":11956,"_22":11956,"_24":11957,"_28":6903,"_30":11959},"np.isrealobj","np.isrealobj(x)","Check if the array has a non-complex dtype.",[11958],{"_16":498,"_22":8910,"_69":6},[],{"_16":11961,"_18":11962,"_20":11963,"_22":11963,"_24":11964,"_28":6903,"_30":11968},"np.isscalar","np.isscalar(element)","Check if an element is a scalar type.",[11965],{"_16":11966,"_22":11967,"_69":6},"element","- Value to check",[],{"_16":11970,"_18":11971,"_20":11972,"_22":11972,"_24":11973,"_28":6903,"_30":11975},"np.isSignedDType","np.isSignedDType(dtype)","Check if dtype is a signed type.",[11974],{"_16":9117,"_22":10067,"_69":6},[],{"_16":11977,"_18":11978,"_20":11979,"_22":11979,"_24":11980,"_28":9219,"_30":11982},"np.isspace","np.isspace(a)","Return true for each element if all characters are whitespace.",[11981],{"_16":433,"_22":10656,"_69":6},[],{"_16":11984,"_18":11985,"_20":11986,"_22":11986,"_24":11987,"_28":11989,"_30":11990},"np.isStructuredDType","np.isStructuredDType(dtype)","Type guard for structured dtypes.",[11988],{"_16":9117,"_22":4815,"_69":6},"dtype is StructuredDType",[],{"_16":11992,"_18":11993,"_20":11994,"_22":11994,"_24":11995,"_28":6903,"_30":12002},"np.issubdtype","np.issubdtype(arg1, arg2)","Return true if first argument is a typecode lower/equal in type hierarchy.",[11996,11999],{"_16":11997,"_22":11998,"_69":6},"arg1","- dtype to check",{"_16":12000,"_22":12001,"_69":6},"arg2","- dtype category or abstract type to compare against",[],{"_16":12004,"_18":12005,"_20":12006,"_22":12007,"_24":12008,"_28":9219,"_30":12010},"np.istitle","np.istitle(a)","Return true for each element if the string is titlecased.\r","Return true for each element if the string is titlecased.\r\nA string is titlecased if uppercase characters follow uncased\r\ncharacters and lowercase characters follow cased characters.",[12009],{"_16":433,"_22":10656,"_69":6},[],{"_16":12012,"_18":12013,"_20":12014,"_22":12015,"_24":12016,"_28":9219,"_30":12018},"np.isupper","np.isupper(a)","Return true for each element if all cased characters are uppercase\r","Return true for each element if all cased characters are uppercase\r\nand there is at least one cased character.",[12017],{"_16":433,"_22":10656,"_69":6},[],{"_16":12020,"_18":12021,"_20":12022,"_22":12022,"_24":12023,"_28":6903,"_30":12024},"np.isWasmLoaded","np.isWasmLoaded()","Check if the WASM module has been loaded.",[],[],{"_16":12026,"_18":12027,"_20":12028,"_22":12029,"_24":12030,"_28":6903,"_30":12032},"np.iterable","np.iterable(y)","Check whether the object is iterable.\r","Check whether the object is iterable.\r\n\r\nThis function returns True if the object is iterable, i.e., if it has\r\na Symbol.iterator method. Strings are considered iterable in JavaScript,\r\nbut this function returns false for strings to match NumPy behavior.",[12031],{"_16":501,"_22":8495,"_69":6},[],{"_16":12034,"_18":12035,"_20":12036,"_22":12037,"_24":12038,"_28":9744,"_30":12041},"np.ix_","np.ix_(args)","Construct an open mesh from multiple sequences.\r","Construct an open mesh from multiple sequences.\r\nThis function takes N 1-D sequences and returns N outputs with N dimensions each,\r\nsuch that the shape in the ith dimension is the length of the ith input.",[12039],{"_16":9142,"_22":12040,"_69":6},"- 1-D sequences (arrays or NDArrays)",[],{"_16":12043,"_18":12044,"_20":12045,"_22":12046,"_24":12047,"_28":9268,"_30":12051},"np.kaiser","np.kaiser(M, beta)","Return the Kaiser window.\r","Return the Kaiser window.\r\n\r\nThe Kaiser window is a taper formed by using a Bessel function.\r\nIt provides a good approximation to the Digital Prolate Spheroidal\r\nSequence (DPSS/Slepian window).\r\n\r\nFormula: w(n) = I₀(β * sqrt(1 - (2n/(M-1))²)) / I₀(β)\r\n\r\nThe beta parameter controls the window shape:\r\n- β = 0: Rectangular window\r\n- β ≈ 5: Similar to Hamming\r\n- β ≈ 6: Similar to Hanning\r\n- β ≈ 8.6: Similar to Blackman\r\n- β = 14: Good starting point for most applications",[12048,12049],{"_16":1960,"_22":9625,"_69":6},{"_16":2011,"_22":12050,"_69":6},"- Shape parameter for the window. Larger values produce\r\n narrower main lobe with lower side lobes.",[],{"_16":12053,"_18":12054,"_20":12055,"_22":12056,"_24":12057,"_28":9268,"_30":12060},"np.kron","np.kron(a, b)","Kronecker product of two arrays.\r","Kronecker product of two arrays.\r\n\r\nComputes the Kronecker product, a composite array made of blocks of the\r\nsecond array scaled by the first.",[12058,12059],{"_16":433,"_22":9058,"_69":6},{"_16":436,"_22":9060,"_69":6},[],{"_16":12062,"_18":12063,"_20":12064,"_22":12064,"_24":12065,"_28":4712,"_30":12067},"np.lag2poly","np.lag2poly(c)","Convert Laguerre coefficients to power series.",[12066],{"_16":2644,"_22":4712,"_69":6},[],{"_16":12069,"_18":12070,"_20":3572,"_22":5456,"_24":12071,"_28":4712,"_30":12074},"np.lagadd","np.lagadd(c1, c2)",[12072,12073],{"_16":2726,"_22":4712,"_69":6},{"_16":2729,"_22":4712,"_69":6},[],{"_16":12076,"_18":12077,"_20":3621,"_22":5456,"_24":12078,"_28":4840,"_30":12080},"np.lagcompanion","np.lagcompanion(c)",[12079],{"_16":2644,"_22":4712,"_69":6},[],{"_16":12082,"_18":12083,"_20":3540,"_22":5456,"_24":12084,"_28":4712,"_30":12087},"np.lagder","np.lagder(c, m?)",[12085,12086],{"_16":2644,"_22":4712,"_69":6},{"_16":359,"_22":5703,"_69":11},[],{"_16":12089,"_18":12090,"_20":3571,"_22":5456,"_24":12091,"_28":9870,"_30":12094},"np.lagdiv","np.lagdiv(c1, c2)",[12092,12093],{"_16":2726,"_22":4712,"_69":6},{"_16":2729,"_22":4712,"_69":6},[],{"_16":12096,"_18":12097,"_20":3539,"_22":5456,"_24":12098,"_28":9891,"_30":12105},"np.lagfit","np.lagfit(x, y, deg, rcond?, full?, w?)",[12099,12100,12101,12102,12103,12104],{"_16":498,"_22":4712,"_69":6},{"_16":501,"_22":4712,"_69":6},{"_16":2840,"_22":5703,"_69":6},{"_16":9884,"_22":11311,"_69":11},{"_16":4019,"_22":6903,"_69":11},{"_16":9889,"_22":11314,"_69":11},[],{"_16":12107,"_18":12108,"_20":3620,"_22":5456,"_24":12109,"_28":4712,"_30":12111},"np.lagfromroots","np.lagfromroots(roots)",[12110],{"_16":2863,"_22":4712,"_69":6},[],{"_16":12113,"_18":12114,"_20":3550,"_22":5456,"_24":12115,"_28":4712,"_30":12120},"np.lagint","np.lagint(c, m?, k?, lbnd?)",[12116,12117,12118,12119],{"_16":2644,"_22":4712,"_69":6},{"_16":359,"_22":5703,"_69":11},{"_16":1114,"_22":4712,"_69":11},{"_16":9912,"_22":5703,"_69":11},[],{"_16":12122,"_18":12123,"_20":3562,"_22":5456,"_24":12124,"_28":4712,"_30":12127},"np.lagmul","np.lagmul(c1, c2)",[12125,12126],{"_16":2726,"_22":4712,"_69":6},{"_16":2729,"_22":4712,"_69":6},[],{"_16":12129,"_18":12130,"_20":3602,"_22":5456,"_24":12131,"_28":4712,"_30":12135},"np.lagpow","np.lagpow(c, pow, maxpower?)",[12132,12133,12134],{"_16":2644,"_22":4712,"_69":6},{"_16":9945,"_22":5703,"_69":6},{"_16":9947,"_22":5703,"_69":11},[],{"_16":12137,"_18":12138,"_20":3612,"_22":5456,"_24":12139,"_28":9928,"_30":12141},"np.lagroots","np.lagroots(c)",[12140],{"_16":2644,"_22":4712,"_69":6},[],{"_16":12143,"_18":12144,"_20":3591,"_22":5456,"_24":12145,"_28":4712,"_30":12148},"np.lagsub","np.lagsub(c1, c2)",[12146,12147],{"_16":2726,"_22":4712,"_69":6},{"_16":2729,"_22":4712,"_69":6},[],{"_16":12150,"_18":12151,"_20":12152,"_22":12152,"_24":12153,"_28":5703,"_30":12156},"np.lagval","np.lagval(x, c)","Evaluate Laguerre polynomial.",[12154,12155],{"_16":498,"_22":5703,"_69":6},{"_16":2644,"_22":4712,"_69":6},[],{"_16":12158,"_18":12159,"_20":3639,"_22":5456,"_24":12160,"_28":4840,"_30":12163},"np.lagvander","np.lagvander(x, deg)",[12161,12162],{"_16":498,"_22":4712,"_69":6},{"_16":2840,"_22":5703,"_69":6},[],{"_16":12165,"_18":12166,"_20":12167,"_22":12168,"_24":12169,"_28":9219,"_30":12172},"np.lcm","np.lcm(x1, x2)","Returns the lowest common multiple of |x1| and |x2|.\r","Returns the lowest common multiple of |x1| and |x2|.\r\nInput arrays must be integers.",[12170,12171],{"_16":9227,"_22":11116,"_69":6},{"_16":9229,"_22":11118,"_69":6},[],{"_16":12174,"_18":12175,"_20":12176,"_22":12177,"_24":12178,"_28":9219,"_30":12183},"np.ldexp","np.ldexp(x1, x2)","Returns x1 * 2^x2, element-wise.\r","Returns x1 * 2^x2, element-wise.\r\n\r\nThe mantissas x1 and twos exponents x2 are used to construct\r\nfloating point numbers x = x1 * 2^x2.",[12179,12181],{"_16":9227,"_22":12180,"_69":6},"- Array of multipliers (mantissas)",{"_16":9229,"_22":12182,"_69":6},"- Array of twos exponents",[],{"_16":12185,"_18":12186,"_20":12187,"_22":12187,"_24":12188,"_28":9219,"_30":12191},"np.left_shift","np.left_shift(x1, x2)","Shift the bits of an integer to the left.",[12189,12190],{"_16":9227,"_22":9219,"_69":6},{"_16":9229,"_22":9219,"_69":6},[],{"_16":12193,"_18":12194,"_20":12195,"_22":12195,"_24":12196,"_28":4712,"_30":12198},"np.leg2poly","np.leg2poly(c)","Convert Legendre coefficients to power series.",[12197],{"_16":2644,"_22":4712,"_69":6},[],{"_16":12200,"_18":12201,"_20":12202,"_22":12202,"_24":12203,"_28":4712,"_30":12206},"np.legadd","np.legadd(c1, c2)","Add two Legendre polynomials.",[12204,12205],{"_16":2726,"_22":4712,"_69":6},{"_16":2729,"_22":4712,"_69":6},[],{"_16":12208,"_18":12209,"_20":12210,"_22":12210,"_24":12211,"_28":4840,"_30":12213},"np.legcompanion","np.legcompanion(c)","Generate Legendre companion matrix.",[12212],{"_16":2644,"_22":4712,"_69":6},[],{"_16":12215,"_18":12216,"_20":12217,"_22":12217,"_24":12218,"_28":4712,"_30":12221},"np.legder","np.legder(c, m?)","Legendre derivative.",[12219,12220],{"_16":2644,"_22":4712,"_69":6},{"_16":359,"_22":5703,"_69":11},[],{"_16":12223,"_18":12224,"_20":12225,"_22":12225,"_24":12226,"_28":9870,"_30":12229},"np.legdiv","np.legdiv(c1, c2)","Divide two Legendre polynomials.",[12227,12228],{"_16":2726,"_22":4712,"_69":6},{"_16":2729,"_22":4712,"_69":6},[],{"_16":12231,"_18":12232,"_20":12233,"_22":12233,"_24":12234,"_28":9891,"_30":12241},"np.legfit","np.legfit(x, y, deg, rcond?, full?, w?)","Legendre least squares fit.",[12235,12236,12237,12238,12239,12240],{"_16":498,"_22":4712,"_69":6},{"_16":501,"_22":4712,"_69":6},{"_16":2840,"_22":5703,"_69":6},{"_16":9884,"_22":11311,"_69":11},{"_16":4019,"_22":6903,"_69":11},{"_16":9889,"_22":11314,"_69":11},[],{"_16":12243,"_18":12244,"_20":12245,"_22":12245,"_24":12246,"_28":4712,"_30":12248},"np.legfromroots","np.legfromroots(roots)","Construct Legendre polynomial from roots.",[12247],{"_16":2863,"_22":4712,"_69":6},[],{"_16":12250,"_18":12251,"_20":12252,"_22":12252,"_24":12253,"_28":4712,"_30":12258},"np.legint","np.legint(c, m?, k?, lbnd?)","Legendre integral.",[12254,12255,12256,12257],{"_16":2644,"_22":4712,"_69":6},{"_16":359,"_22":5703,"_69":11},{"_16":1114,"_22":4712,"_69":11},{"_16":9912,"_22":5703,"_69":11},[],{"_16":12260,"_18":12261,"_20":12262,"_22":12262,"_24":12263,"_28":4712,"_30":12266},"np.legmul","np.legmul(c1, c2)","Multiply two Legendre polynomials.",[12264,12265],{"_16":2726,"_22":4712,"_69":6},{"_16":2729,"_22":4712,"_69":6},[],{"_16":12268,"_18":12269,"_20":12270,"_22":12270,"_24":12271,"_28":4712,"_30":12275},"np.legpow","np.legpow(c, pow, maxpower?)","Raise Legendre polynomial to a power.",[12272,12273,12274],{"_16":2644,"_22":4712,"_69":6},{"_16":9945,"_22":5703,"_69":6},{"_16":9947,"_22":5703,"_69":11},[],{"_16":12277,"_18":12278,"_20":12279,"_22":12279,"_24":12280,"_28":9928,"_30":12282},"np.legroots","np.legroots(c)","Find Legendre polynomial roots.",[12281],{"_16":2644,"_22":4712,"_69":6},[],{"_16":12284,"_18":12285,"_20":12286,"_22":12286,"_24":12287,"_28":4712,"_30":12290},"np.legsub","np.legsub(c1, c2)","Subtract two Legendre polynomials.",[12288,12289],{"_16":2726,"_22":4712,"_69":6},{"_16":2729,"_22":4712,"_69":6},[],{"_16":12292,"_18":12293,"_20":12294,"_22":12294,"_24":12295,"_28":5703,"_30":12298},"np.legval","np.legval(x, c)","Evaluate Legendre polynomial using Clenshaw-like algorithm.",[12296,12297],{"_16":498,"_22":9970,"_69":6},{"_16":2644,"_22":9852,"_69":6},[],{"_16":12300,"_18":12301,"_20":12302,"_22":12302,"_24":12303,"_28":4840,"_30":12306},"np.legvander","np.legvander(x, deg)","Legendre Vandermonde matrix.",[12304,12305],{"_16":498,"_22":4712,"_69":6},{"_16":2840,"_22":5703,"_69":6},[],{"_16":12308,"_18":12309,"_20":12310,"_22":12310,"_24":12311,"_28":9219,"_30":12314},"np.less","np.less(x1, x2)","Return (x1 < x2) element-wise.",[12312,12313],{"_16":9227,"_22":9219,"_69":6},{"_16":9229,"_22":9219,"_69":6},[],{"_16":12316,"_18":12317,"_20":12318,"_22":12318,"_24":12319,"_28":9219,"_30":12322},"np.less_equal","np.less_equal(x1, x2)","Return (x1 <= x2) element-wise.",[12320,12321],{"_16":9227,"_22":9219,"_69":6},{"_16":9229,"_22":9219,"_69":6},[],{"_16":12324,"_18":12325,"_20":12326,"_22":12327,"_24":12328,"_28":9268,"_30":12332},"np.lexsort","np.lexsort(keys)","Perform an indirect stable sort using a sequence of keys.\r","Perform an indirect stable sort using a sequence of keys.\r\n\r\nGiven multiple sorting keys, lexsort returns an array of integer indices\r\nthat describes the sort order by multiple columns. The last key in the\r\nsequence is used for the primary sort order, the second-to-last key for\r\nthe secondary sort order, and so on.",[12329],{"_16":12330,"_22":12331,"_69":6},"keys","- Array of keys to sort by. Each key should be 1-D with the same length.\r\n The last key is the primary sort key.",[],{"_16":12334,"_18":12335,"_20":12336,"_22":12336,"_24":12337,"_28":9268,"_30":12345},"np.linspace","np.linspace(start, stop, num?, endpoint?, options?)","Create an NDArray with evenly spaced numbers over a specified interval.",[12338,12340,12342,12343,12344],{"_16":9325,"_22":12339,"_69":6},"- Start value",{"_16":11138,"_22":12341,"_69":6},"- End value",{"_16":9633,"_22":11141,"_69":11},{"_16":11143,"_22":11144,"_69":11},{"_16":4789,"_22":9448,"_69":11},[],{"_16":12347,"_18":12348,"_20":12349,"_22":12349,"_24":12350,"_28":9652,"_30":12351},"np.listBitGenerators","np.listBitGenerators()","List available BitGenerator names.",[],[],{"_16":12353,"_18":12354,"_20":12355,"_22":12355,"_24":12356,"_28":9219,"_30":12363},"np.ljust","np.ljust(a, width, fillchar?)","Return element-wise left-justified string of given width.",[12357,12358,12360],{"_16":433,"_22":10656,"_69":6},{"_16":4981,"_22":12359,"_69":6},"- Total width of output string",{"_16":12361,"_22":12362,"_69":11},"fillchar","- Padding character (default space)",[],{"_16":12365,"_18":12366,"_20":12367,"_22":12367,"_24":12368,"_28":9268,"_30":12373},"np.load","np.load(file, _options?)","Load an array from a NPY file.",[12369,12371],{"_16":11013,"_22":12370,"_69":6},"- File path (Node.js), File object (browser), ArrayBuffer, or URL",{"_16":8336,"_22":12372,"_69":11},"LoadOptions",[],{"_16":12375,"_18":12376,"_20":12377,"_22":12378,"_24":12379,"_28":9268,"_30":12383},"np.loadtxt","np.loadtxt(file, options?)","Load data from a text file.\r","Load data from a text file.\r\n\r\nEach row in the text file must have the same number of values.",[12380,12382],{"_16":11013,"_22":12381,"_69":6},"- File source (path, File object, or URL)",{"_16":4789,"_22":11128,"_69":11},[],{"_16":12385,"_18":12386,"_20":12387,"_22":12388,"_24":12389,"_28":12390,"_30":12391},"np.loadWasmModule","np.loadWasmModule()","Load the WASM module asynchronously.\r","Load the WASM module asynchronously.\r\n\r\nThis function is idempotent - calling it multiple times will return\r\nthe same module instance. The module is loaded lazily on first call.",[],"Promise",[],{"_16":12393,"_18":12394,"_20":12395,"_22":12396,"_24":12397,"_28":12399,"_30":12400},"np.loadz","np.loadz(file)","Load arrays from a `.npz` file.\r","Load arrays from a `.npz` file.\r\n\r\nReturns an object with array names as keys and NDArrays as values.\r\nThe `files` property contains the list of array names.",[12398],{"_16":11013,"_22":12370,"_69":6},"Promise",[],{"_16":12402,"_18":12403,"_20":12404,"_22":12404,"_24":12405,"_28":9219,"_30":12407},"np.log","np.log(x)","Natural logarithm, element-wise.",[12406],{"_16":498,"_22":9219,"_69":6},[],{"_16":12409,"_18":12410,"_20":12411,"_22":12411,"_24":12412,"_28":9219,"_30":12414},"np.log10","np.log10(x)","Base-10 logarithm, element-wise.",[12413],{"_16":498,"_22":9219,"_69":6},[],{"_16":12416,"_18":12417,"_20":12418,"_22":12418,"_24":12419,"_28":9219,"_30":12421},"np.log1p","np.log1p(x)","Return the natural logarithm of one plus the input array, element-wise.",[12420],{"_16":498,"_22":9219,"_69":6},[],{"_16":12423,"_18":12424,"_20":12425,"_22":12425,"_24":12426,"_28":9219,"_30":12428},"np.log2","np.log2(x)","Base-2 logarithm of x.",[12427],{"_16":498,"_22":9219,"_69":6},[],{"_16":12430,"_18":12431,"_20":12432,"_22":12432,"_24":12433,"_28":9219,"_30":12436},"np.logaddexp","np.logaddexp(x1, x2)","Compute the logarithm of the sum of exponentials of the inputs.",[12434,12435],{"_16":9227,"_22":9219,"_69":6},{"_16":9229,"_22":9219,"_69":6},[],{"_16":12438,"_18":12439,"_20":12440,"_22":12440,"_24":12441,"_28":9219,"_30":12444},"np.logaddexp2","np.logaddexp2(x1, x2)","Compute log(2**x1 + 2**x2).",[12442,12443],{"_16":9227,"_22":9219,"_69":6},{"_16":9229,"_22":9219,"_69":6},[],{"_16":12446,"_18":12447,"_20":12448,"_22":12448,"_24":12449,"_28":9219,"_30":12452},"np.logical_and","np.logical_and(x1, x2)","Compute the truth value of x1 AND x2 element-wise.",[12450,12451],{"_16":9227,"_22":9219,"_69":6},{"_16":9229,"_22":9219,"_69":6},[],{"_16":12454,"_18":12455,"_20":12456,"_22":12456,"_24":12457,"_28":9219,"_30":12459},"np.logical_not","np.logical_not(x)","Compute the truth value of NOT x element-wise.",[12458],{"_16":498,"_22":9219,"_69":6},[],{"_16":12461,"_18":12462,"_20":12463,"_22":12463,"_24":12464,"_28":9219,"_30":12467},"np.logical_or","np.logical_or(x1, x2)","Compute the truth value of x1 OR x2 element-wise.",[12465,12466],{"_16":9227,"_22":9219,"_69":6},{"_16":9229,"_22":9219,"_69":6},[],{"_16":12469,"_18":12470,"_20":12471,"_22":12471,"_24":12472,"_28":9219,"_30":12475},"np.logical_xor","np.logical_xor(x1, x2)","Compute the truth value of x1 XOR x2, element-wise.",[12473,12474],{"_16":9227,"_22":9219,"_69":6},{"_16":9229,"_22":9219,"_69":6},[],{"_16":12477,"_18":12478,"_20":12479,"_22":12479,"_24":12480,"_28":9268,"_30":12490},"np.logspace","np.logspace(start, stop, num?, endpoint?, base?, options?)","Create an NDArray with numbers spaced evenly on a log scale.",[12481,12483,12485,12486,12487,12489],{"_16":9325,"_22":12482,"_69":6},"- Start value (power of base)",{"_16":11138,"_22":12484,"_69":6},"- End value (power of base)",{"_16":9633,"_22":11141,"_69":11},{"_16":11143,"_22":11144,"_69":11},{"_16":9636,"_22":12488,"_69":11},"- Base of the log scale (default: 10)",{"_16":4789,"_22":9448,"_69":11},[],{"_16":12492,"_18":12493,"_20":12494,"_22":12494,"_24":12495,"_28":9219,"_30":12497},"np.lower","np.lower(a)","Return element-wise copy with uppercase characters converted to lowercase.",[12496],{"_16":433,"_22":10656,"_69":6},[],{"_16":12499,"_18":12500,"_20":12501,"_22":12501,"_24":12502,"_28":9219,"_30":12507},"np.lstrip","np.lstrip(a, chars?)","Return element-wise copy with leading characters removed.",[12503,12504],{"_16":433,"_22":10656,"_69":6},{"_16":12505,"_22":12506,"_69":11},"chars","- Characters to remove (default: whitespace)",[],{"_16":12509,"_18":12510,"_20":12511,"_22":12512,"_24":12513,"_28":12519,"_30":12520},"np.lstsq","np.lstsq(a, b, rcond?)","Return the least-squares solution to a linear matrix equation.\r","Return the least-squares solution to a linear matrix equation.\r\n\r\nComputes the vector x that approximately solves the equation a @ x = b.",[12514,12516,12518],{"_16":433,"_22":12515,"_69":6},"- Coefficient matrix (M x N)",{"_16":436,"_22":12517,"_69":6},"- Ordinate values (M,) or (M x K)",{"_16":9884,"_22":9885,"_69":11},"Promise",[],{"_16":12522,"_18":12523,"_20":12524,"_22":12525,"_24":12526,"_28":12534,"_30":12535},"np.mapdomain","np.mapdomain(x, old, new_)","Map x from old domain to new domain.\r","Map x from old domain to new domain.\r\n\r\nThe mapping is: new = off + scl * old\r\nwhere off and scl are computed from the domains.",[12527,12529,12531],{"_16":498,"_22":12528,"_69":6},"- Values to map (number, array, or NDArray)",{"_16":1222,"_22":12530,"_69":6},"- Original domain [min, max]",{"_16":12532,"_22":12533,"_69":6},"new_","- Target domain [min, max]","number[] | number",[],{"_16":12537,"_18":12538,"_20":12539,"_22":12540,"_24":12541,"_28":11164,"_30":12544},"np.mapparms","np.mapparms(old, new_)","Get linear mapping parameters between domains.\r","Get linear mapping parameters between domains.\r\n\r\nReturns [offset, scale] such that new = offset + scale * old",[12542,12543],{"_16":1222,"_22":12530,"_69":6},{"_16":12532,"_22":12533,"_69":6},[],{"_16":12546,"_18":12547,"_20":12548,"_22":12549,"_24":12550,"_28":12557,"_30":12558},"np.mask_indices","np.mask_indices(n, func, k?)","Return indices that are non-zero in the mask.\r","Return indices that are non-zero in the mask.\r\n\r\nCalling this function with a mask function that returns a 2-D array\r\nwill return indices appropriate for accessing the elements that would\r\nbe selected by the mask.",[12551,12553,12555],{"_16":362,"_22":12552,"_69":6},"- Size of the array for which indices are needed",{"_16":4204,"_22":12554,"_69":6},"- A function whose call signature is similar to that of triu, tril.\r\n That is, func(n, k) returns a boolean array of shape (n, n).",{"_16":1114,"_22":12556,"_69":11},"- Diagonal offset","Promise<[NDArray, NDArray]>",[],{"_16":12560,"_18":12561,"_20":12562,"_22":12563,"_24":12564,"_28":9268,"_30":12569},"np.matmul","np.matmul(a, b)","Matrix multiplication of two arrays.\r","Matrix multiplication of two arrays.\r\n\r\nFor 2-D arrays: regular matrix multiplication.\r\nFor N-D arrays: broadcast over batch dimensions, matmul on last two.",[12565,12567],{"_16":433,"_22":12566,"_69":6},"- First array (..., M, K)",{"_16":436,"_22":12568,"_69":6},"- Second array (..., K, N)",[],{"_16":12571,"_18":12572,"_20":12573,"_22":12573,"_24":12574,"_28":8919,"_30":12581},"np.matrix_norm","np.matrix_norm(x, ord?, keepdims?)","Compute the matrix norm.",[12575,12577,12579],{"_16":498,"_22":12576,"_69":6},"- Input matrix (..., M, N)",{"_16":8409,"_22":12578,"_69":11},"- Order of the norm ('fro', 'nuc', 1, 2, -1, -2, Infinity, -Infinity)",{"_16":9240,"_22":12580,"_69":11},"- If true, axes are left with size one",[],{"_16":12583,"_18":12584,"_20":12585,"_22":12585,"_24":12586,"_28":9268,"_30":12591},"np.matrix_power","np.matrix_power(a, n)","Raise a square matrix to the (integer) power n.",[12587,12589],{"_16":433,"_22":12588,"_69":6},"- Square matrix",{"_16":362,"_22":12590,"_69":6},"- Exponent (can be negative for inverse)",[],{"_16":12593,"_18":12594,"_20":12595,"_22":12595,"_24":12596,"_28":8077,"_30":12601},"np.matrix_rank","np.matrix_rank(A, tol?)","Return matrix rank using SVD method.",[12597,12599],{"_16":659,"_22":12598,"_69":6},"- Matrix to determine rank of",{"_16":3719,"_22":12600,"_69":11},"- Threshold for considering singular values as zero",[],{"_16":12603,"_18":12604,"_20":12605,"_22":12606,"_24":12607,"_28":9219,"_30":12610},"np.matrix_transpose","np.matrix_transpose(x)","Transposes the last two dimensions of an array.\r","Transposes the last two dimensions of an array.\r\n\r\nNumPy 2.0 addition: Equivalent to swapaxes(a, -2, -1).",[12608],{"_16":498,"_22":12609,"_69":6},"- Input array, must have at least 2 dimensions",[],{"_16":12612,"_18":12613,"_20":12614,"_22":12615,"_24":12616,"_28":9268,"_30":12621},"np.matvec","np.matvec(x1, x2)","Matrix-vector product.\r","Matrix-vector product.\r\n\r\nNumPy 2.0 addition. Computes the matrix-vector product of x1 and x2.\r\nEquivalent to matmul with 2D @ 1D broadcasting.",[12617,12619],{"_16":9227,"_22":12618,"_69":6},"- Matrix (..., M, N)",{"_16":9229,"_22":12620,"_69":6},"- Vector (..., N)",[],{"_16":12623,"_18":12624,"_20":12625,"_22":12625,"_24":12626,"_28":8919,"_30":12631},"np.max","np.max(a, axis?, keepdims?)","Return the maximum of an array or maximum along an axis.",[12627,12628,12630],{"_16":433,"_22":8910,"_69":6},{"_16":2299,"_22":12629,"_69":11},"- Axis along which to find maximum. null finds maximum of all elements.",{"_16":9240,"_22":9393,"_69":11},[],{"_16":12633,"_18":12634,"_20":12635,"_22":12635,"_24":12636,"_28":9219,"_30":12639},"np.maximum","np.maximum(x1, x2)","Element-wise maximum of array elements (propagates NaN).",[12637,12638],{"_16":9227,"_22":9219,"_69":6},{"_16":9229,"_22":9219,"_69":6},[],{"_16":12641,"_18":12642,"_20":12643,"_22":12643,"_24":12644,"_28":8919,"_30":12651},"np.mean","np.mean(a, axis?, keepdims?, dtype?)","Compute the arithmetic mean along the specified axis.",[12645,12646,12648,12649],{"_16":433,"_22":8910,"_69":6},{"_16":2299,"_22":12647,"_69":11},"- Axis along which to compute mean. null computes mean of all elements.",{"_16":9240,"_22":9393,"_69":11},{"_16":9117,"_22":12650,"_69":11},"- Output dtype (default: float64 for integers, same as input otherwise)",[],{"_16":12653,"_18":12654,"_20":12655,"_22":12655,"_24":12656,"_28":8919,"_30":12661},"np.median","np.median(a, axis?, keepdims?)","Compute the median along the specified axis.",[12657,12658,12660],{"_16":433,"_22":8910,"_69":6},{"_16":2299,"_22":12659,"_69":11},"- Axis along which to compute median. null computes median of all elements.",{"_16":9240,"_22":9393,"_69":11},[],{"_16":12663,"_18":12664,"_20":12665,"_22":12665,"_24":12666,"_28":9744,"_30":12670},"np.meshgrid","np.meshgrid(xi)","Return coordinate matrices from coordinate vectors.",[12667],{"_16":12668,"_22":12669,"_69":6},"xi","- 1D coordinate arrays",[],{"_16":12672,"_18":12673,"_20":12674,"_22":12674,"_24":12675,"_28":8919,"_30":12680},"np.min","np.min(a, axis?, keepdims?)","Return the minimum of an array or minimum along an axis.",[12676,12677,12679],{"_16":433,"_22":8910,"_69":6},{"_16":2299,"_22":12678,"_69":11},"- Axis along which to find minimum. null finds minimum of all elements.",{"_16":9240,"_22":9393,"_69":11},[],{"_16":12682,"_18":12683,"_20":12684,"_22":12685,"_24":12686,"_28":10067,"_30":12689},"np.min_scalar_type","np.min_scalar_type(value)","Return the minimum scalar type needed to represent the value.\r","Return the minimum scalar type needed to represent the value.\r\n\r\nFor scalars, returns the smallest dtype that can hold the value.\r\nFor integers, finds the smallest integer type.\r\nFor floats, returns float64 (to preserve precision).",[12687],{"_16":235,"_22":12688,"_69":6},"- A scalar value",[],{"_16":12691,"_18":12692,"_20":12693,"_22":12693,"_24":12694,"_28":9219,"_30":12697},"np.minimum","np.minimum(x1, x2)","Element-wise minimum of array elements (propagates NaN).",[12695,12696],{"_16":9227,"_22":9219,"_69":6},{"_16":9229,"_22":9219,"_69":6},[],{"_16":12699,"_18":12700,"_20":12701,"_22":12702,"_24":12703,"_28":10490,"_30":12705},"np.modf","np.modf(x)","Return the fractional and integral parts of an array, element-wise.\r","Return the fractional and integral parts of an array, element-wise.\r\nThe fractional and integral parts are negative if the given number is negative.",[12704],{"_16":498,"_22":8910,"_69":6},[],{"_16":12707,"_18":12708,"_20":12709,"_22":12709,"_24":12710,"_28":9219,"_30":12718},"np.moveaxis","np.moveaxis(a, source, destination)","Move axes of an array to new positions.",[12711,12712,12715],{"_16":433,"_22":8910,"_69":6},{"_16":12713,"_22":12714,"_69":6},"source","- Original positions of the axes to move",{"_16":12716,"_22":12717,"_69":6},"destination","- Destination positions for each axis",[],{"_16":12720,"_18":12721,"_20":12722,"_22":12723,"_24":12724,"_28":9268,"_30":12727},"np.multi_dot","np.multi_dot(arrays)","Compute the dot product of two or more arrays in a single function call,\r","Compute the dot product of two or more arrays in a single function call,\r\nwhile automatically selecting the fastest evaluation order.\r\n\r\nUses dynamic programming to find the optimal parenthesization that\r\nminimizes the total number of scalar multiplications.",[12725],{"_16":9733,"_22":12726,"_69":6},"- List of arrays to multiply together",[],{"_16":12729,"_18":12730,"_20":12731,"_22":12731,"_24":12732,"_28":9219,"_30":12735},"np.multiply","np.multiply(x1, x2)","Multiply arguments element-wise.",[12733,12734],{"_16":9227,"_22":9219,"_69":6},{"_16":9229,"_22":9219,"_69":6},[],{"_16":12737,"_18":12738,"_20":12739,"_22":12739,"_24":12740,"_28":9268,"_30":12751},"np.nan_to_num","np.nan_to_num(x, nan?, posinf?, neginf?)","Replace NaN with zero and infinity with large finite numbers.",[12741,12742,12745,12748],{"_16":498,"_22":8910,"_69":6},{"_16":12743,"_22":12744,"_69":11},"nan","- Value to replace NaN with (default: 0.0)",{"_16":12746,"_22":12747,"_69":11},"posinf","- Value to replace positive infinity with (default: largest finite float)",{"_16":12749,"_22":12750,"_69":11},"neginf","- Value to replace negative infinity with (default: most negative finite float)",[],{"_16":12753,"_18":12754,"_20":12755,"_22":12755,"_24":12756,"_28":8919,"_30":12762},"np.nanargmax","np.nanargmax(a, axis?, keepdims?)","Return the indices of the maximum values along an axis, ignoring NaNs.",[12757,12758,12760],{"_16":433,"_22":8910,"_69":6},{"_16":2299,"_22":12759,"_69":11},"- Axis along which to operate (null = flattened array)",{"_16":9240,"_22":12761,"_69":11},"- If true, reduced axes are left with size one",[],{"_16":12764,"_18":12765,"_20":12766,"_22":12766,"_24":12767,"_28":8919,"_30":12771},"np.nanargmin","np.nanargmin(a, axis?, keepdims?)","Return the indices of the minimum values along an axis, ignoring NaNs.",[12768,12769,12770],{"_16":433,"_22":8910,"_69":6},{"_16":2299,"_22":12759,"_69":11},{"_16":9240,"_22":12761,"_69":11},[],{"_16":12773,"_18":12774,"_20":12775,"_22":12776,"_24":12777,"_28":9268,"_30":12782},"np.nancumprod","np.nancumprod(a, axis?, dtype?)","Return the cumulative product of array elements treating NaNs as one.\r","Return the cumulative product of array elements treating NaNs as one.\r\n\r\nThe cumulative product does not change when NaNs are encountered and\r\nleading NaNs are replaced by ones.",[12778,12779,12781],{"_16":433,"_22":8910,"_69":6},{"_16":2299,"_22":12780,"_69":11},"- Axis along which to compute. null = flatten first",{"_16":9117,"_22":10316,"_69":11},[],{"_16":12784,"_18":12785,"_20":12786,"_22":12787,"_24":12788,"_28":9268,"_30":12792},"np.nancumsum","np.nancumsum(a, axis?, dtype?)","Return the cumulative sum of array elements treating NaNs as zero.\r","Return the cumulative sum of array elements treating NaNs as zero.\r\n\r\nThe cumulative sum does not change when NaNs are encountered and\r\nleading NaNs are replaced by zeros.",[12789,12790,12791],{"_16":433,"_22":8910,"_69":6},{"_16":2299,"_22":12780,"_69":11},{"_16":9117,"_22":10316,"_69":11},[],{"_16":12794,"_18":12795,"_20":12796,"_22":12796,"_24":12797,"_28":8919,"_30":12803},"np.nanmax","np.nanmax(a, axis?, keepdims?)","Return maximum of an array or maximum along an axis, ignoring any NaNs.",[12798,12800,12802],{"_16":433,"_22":12799,"_69":6},"- Array containing numbers",{"_16":2299,"_22":12801,"_69":11},"- Axis or axes along which to operate (null = all elements)",{"_16":9240,"_22":12761,"_69":11},[],{"_16":12805,"_18":12806,"_20":12807,"_22":12807,"_24":12808,"_28":8919,"_30":12816},"np.nanmean","np.nanmean(a, axis?, keepdims?, dtype?)","Compute the arithmetic mean along the specified axis, ignoring NaNs.",[12809,12811,12813,12814],{"_16":433,"_22":12810,"_69":6},"- Array containing numbers whose mean is desired",{"_16":2299,"_22":12812,"_69":11},"- Axis or axes along which the means are computed (null = all elements)",{"_16":9240,"_22":12761,"_69":11},{"_16":9117,"_22":12815,"_69":11},"- Type to use in computing the mean",[],{"_16":12818,"_18":12819,"_20":12820,"_22":12820,"_24":12821,"_28":8919,"_30":12826},"np.nanmedian","np.nanmedian(a, axis?, keepdims?)","Compute the median along the specified axis, while ignoring NaNs.",[12822,12823,12825],{"_16":433,"_22":8910,"_69":6},{"_16":2299,"_22":12824,"_69":11},"- Axis or axes along which the medians are computed (null = all elements)",{"_16":9240,"_22":12761,"_69":11},[],{"_16":12828,"_18":12829,"_20":12830,"_22":12830,"_24":12831,"_28":8919,"_30":12835},"np.nanmin","np.nanmin(a, axis?, keepdims?)","Return minimum of an array or minimum along an axis, ignoring any NaNs.",[12832,12833,12834],{"_16":433,"_22":12799,"_69":6},{"_16":2299,"_22":12801,"_69":11},{"_16":9240,"_22":12761,"_69":11},[],{"_16":12837,"_18":12838,"_20":12839,"_22":12840,"_24":12841,"_28":8919,"_30":12852},"np.nanpercentile","np.nanpercentile(a, q, axis?, interpolation?, keepdims?)","Compute the q-th percentile of the data along the specified axis,\r","Compute the q-th percentile of the data along the specified axis,\r\nwhile ignoring NaN values.",[12842,12843,12846,12848,12851],{"_16":433,"_22":8910,"_69":6},{"_16":12844,"_22":12845,"_69":6},"q","- Percentile(s) to compute, in range [0, 100]",{"_16":2299,"_22":12847,"_69":11},"- Axis along which to compute (null = all elements)",{"_16":12849,"_22":12850,"_69":11},"interpolation","- Interpolation method ('linear', 'lower', 'higher', 'midpoint', 'nearest')",{"_16":9240,"_22":12761,"_69":11},[],{"_16":12854,"_18":12855,"_20":12856,"_22":12856,"_24":12857,"_28":8919,"_30":12865},"np.nanprod","np.nanprod(a, axis?, keepdims?, _dtype?)","Return the product of array elements over a given axis treating NaNs as one.",[12858,12860,12862,12863],{"_16":433,"_22":12859,"_69":6},"- Array containing numbers whose product is desired",{"_16":2299,"_22":12861,"_69":11},"- Axis or axes along which the product is computed (null = all elements)",{"_16":9240,"_22":12761,"_69":11},{"_16":12864,"_22":10067,"_69":11},"_dtype",[],{"_16":12867,"_18":12868,"_20":12869,"_22":12870,"_24":12871,"_28":8919,"_30":12878},"np.nanquantile","np.nanquantile(a, q, axis?, interpolation?, keepdims?)","Compute the q-th quantile of the data along the specified axis,\r","Compute the q-th quantile of the data along the specified axis,\r\nwhile ignoring NaN values.",[12872,12873,12875,12876,12877],{"_16":433,"_22":8910,"_69":6},{"_16":12844,"_22":12874,"_69":6},"- Quantile(s) to compute, in range [0, 1]",{"_16":2299,"_22":12847,"_69":11},{"_16":12849,"_22":12850,"_69":11},{"_16":9240,"_22":12761,"_69":11},[],{"_16":12880,"_18":12881,"_20":12882,"_22":12882,"_24":12883,"_28":8919,"_30":12892},"np.nanstd","np.nanstd(a, axis?, ddof?, keepdims?, dtype?)","Compute the standard deviation along the specified axis, ignoring NaNs.",[12884,12885,12887,12889,12890],{"_16":433,"_22":12799,"_69":6},{"_16":2299,"_22":12886,"_69":11},"- Axis or axes along which the standard deviation is computed (null = all elements)",{"_16":10260,"_22":12888,"_69":11},"- Delta Degrees of Freedom (divisor is N - ddof)",{"_16":9240,"_22":12761,"_69":11},{"_16":9117,"_22":12891,"_69":11},"- Type to use in computing the standard deviation",[],{"_16":12894,"_18":12895,"_20":12896,"_22":12896,"_24":12897,"_28":8919,"_30":12905},"np.nansum","np.nansum(a, axis?, keepdims?, dtype?)","Return the sum of array elements over a given axis treating NaNs as zero.",[12898,12900,12902,12903],{"_16":433,"_22":12899,"_69":6},"- Array containing numbers whose sum is desired",{"_16":2299,"_22":12901,"_69":11},"- Axis or axes along which the sum is computed (null = all elements)",{"_16":9240,"_22":12761,"_69":11},{"_16":9117,"_22":12904,"_69":11},"- The type of the returned array",[],{"_16":12907,"_18":12908,"_20":12909,"_22":12909,"_24":12910,"_28":8919,"_30":12918},"np.nanvar","np.nanvar(a, axis?, ddof?, keepdims?, dtype?)","Compute the variance along the specified axis, while ignoring NaNs.",[12911,12912,12914,12915,12916],{"_16":433,"_22":12799,"_69":6},{"_16":2299,"_22":12913,"_69":11},"- Axis or axes along which the variance is computed (null = all elements)",{"_16":10260,"_22":12888,"_69":11},{"_16":9240,"_22":12761,"_69":11},{"_16":9117,"_22":12917,"_69":11},"- Type to use in computing the variance",[],{"_16":12920,"_18":12921,"_20":12922,"_22":12922,"_24":12923,"_28":12926,"_30":12927},"np.ndenumerate","np.ndenumerate(arr)","Iterate over array with indices and values.",[12924],{"_16":9285,"_22":12925,"_69":6},"- Array to iterate","Generator<[number[], number]>",[],{"_16":12929,"_18":12930,"_20":12931,"_22":12931,"_24":12932,"_28":12935,"_30":12936},"np.ndindex","np.ndindex(shape)","Generate all index combinations for a shape.",[12933],{"_16":8461,"_22":12934,"_69":6},"- Dimensions","Generator",[],{"_16":12938,"_18":12939,"_20":12940,"_22":12940,"_24":12941,"_28":12943,"_30":12944},"np.nditer","np.nditer(arr)","Iterate over array elements.",[12942],{"_16":9285,"_22":12925,"_69":6},"Generator",[],{"_16":12946,"_18":12947,"_20":12948,"_22":12948,"_24":12949,"_28":9219,"_30":12951},"np.negative","np.negative(x)","Numerical negative, element-wise.",[12950],{"_16":498,"_22":9219,"_69":6},[],{"_16":12953,"_18":12954,"_20":12955,"_22":12955,"_24":12956,"_28":9219,"_30":12961},"np.nextafter","np.nextafter(x1, x2)","Return the next floating-point value after x1 towards x2, element-wise.",[12957,12959],{"_16":9227,"_22":12958,"_69":6},"- Starting values",{"_16":9229,"_22":12960,"_69":6},"- Direction values",[],{"_16":12963,"_18":12964,"_20":12965,"_22":12966,"_24":12967,"_28":9268,"_30":12969},"np.nonzero","np.nonzero(arr)","Find indices of nonzero elements.\r","Find indices of nonzero elements.\r\n\r\nReturns a 2D array of shape (num_nonzero, ndim) where each row\r\ncontains the multi-dimensional index of a nonzero element.",[12968],{"_16":9285,"_22":8910,"_69":6},[],{"_16":12971,"_18":12972,"_20":12973,"_22":12973,"_24":12974,"_28":8077,"_30":12978},"np.norm","np.norm(x, ord?)","Matrix or vector norm.",[12975,12976],{"_16":498,"_22":8910,"_69":6},{"_16":8409,"_22":12977,"_69":11},"- Order of the norm (default: 2 for vectors, 'fro' for matrices)\r\n Vector norms: 1, 2, inf, -inf, or any positive number\r\n Matrix norms: 1, 2, inf, -inf, 'fro', 'nuc'",[],{"_16":12980,"_18":12981,"_20":12982,"_22":12982,"_24":12983,"_28":9219,"_30":12986},"np.not_equal","np.not_equal(x1, x2)","Return (x1 != x2) element-wise.",[12984,12985],{"_16":9227,"_22":9219,"_69":6},{"_16":9229,"_22":9219,"_69":6},[],{"_16":12988,"_18":12989,"_20":12990,"_22":12990,"_24":12991,"_28":6108,"_30":12995},"np.octalRepr","np.octalRepr(num, width?)","Return the octal representation of a number.",[12992,12993],{"_16":9633,"_22":9634,"_69":6},{"_16":4981,"_22":12994,"_69":11},"- Minimum number of octal digits",[],{"_16":12997,"_18":12998,"_20":12999,"_22":12999,"_24":13000,"_28":9268,"_30":13003},"np.ones","np.ones(shape, options?)","Create a new NDArray filled with ones.",[13001,13002],{"_16":8461,"_22":10638,"_69":6},{"_16":4789,"_22":9448,"_69":11},[],{"_16":13005,"_18":13006,"_20":13007,"_22":13007,"_24":13008,"_28":9268,"_30":13010},"np.ones_like","np.ones_like(a)","Create an array of ones with the same shape and type as a given array.",[13009],{"_16":433,"_22":10647,"_69":6},[],{"_16":13012,"_18":13013,"_20":13014,"_22":13015,"_24":13016,"_28":13021,"_30":13022},"np.openMemmap","np.openMemmap(file, options?)","Open a memory-mapped file.\r","Open a memory-mapped file.\r\n\r\nConvenience function wrapping Memmap.open().",[13017,13019],{"_16":11013,"_22":13018,"_69":6},"- File path or ArrayBuffer",{"_16":4789,"_22":13020,"_69":11},"- Memmap options","Promise",[],{"_16":13024,"_18":13025,"_20":13026,"_22":13026,"_24":13027,"_28":9268,"_30":13030},"np.outer","np.outer(a, b)","Compute the outer product of two vectors.",[13028,13029],{"_16":433,"_22":9219,"_69":6},{"_16":436,"_22":9219,"_69":6},[],{"_16":13032,"_18":13033,"_20":13034,"_22":13035,"_24":13036,"_28":9268,"_30":13044},"np.packbits","np.packbits(a, axis?, bitorder?)","Pack the elements of a binary array into bits in a uint8 array.\r","Pack the elements of a binary array into bits in a uint8 array.\r\n\r\nThe result is padded to full bytes with zeros.",[13037,13039,13041],{"_16":433,"_22":13038,"_69":6},"- Input array of uint8 values (each treated as a single bit: 0 or non-zero)",{"_16":2299,"_22":13040,"_69":11},"- The axis along which to pack. If null, the input is flattened",{"_16":13042,"_22":13043,"_69":11},"bitorder","- Order of bits in the packed representation. 'big' (default) means\r\n the first bit goes into the highest bit of the byte; 'little' means\r\n the first bit goes into the lowest bit of the byte",[],{"_16":13046,"_18":13047,"_20":13048,"_22":13048,"_24":13049,"_28":9268,"_30":13059},"np.pad","np.pad(arr, pad_width, mode?, constant_values?)","Pad an array.",[13050,13051,13054,13056],{"_16":9285,"_22":8910,"_69":6},{"_16":13052,"_22":13053,"_69":6},"pad_width","- Number of values padded to edges of each axis",{"_16":2621,"_22":13055,"_69":11},"- Padding mode (default: 'constant')",{"_16":13057,"_22":13058,"_69":11},"constant_values","- Value to use for constant padding (default: 0)",[],{"_16":13061,"_18":13062,"_20":13063,"_22":13064,"_24":13065,"_28":9268,"_30":13069},"np.partition","np.partition(a, kth, axis?)","Return a partitioned copy of an array.\r","Return a partitioned copy of an array.\r\n\r\nCreates a copy of the array with its elements rearranged so that\r\nelements smaller than the kth element are moved before it and\r\nelements greater are moved after it.",[13066,13067,13068],{"_16":433,"_22":9411,"_69":6},{"_16":9413,"_22":9414,"_69":6},{"_16":2299,"_22":9416,"_69":11},[],{"_16":13071,"_18":13072,"_20":13073,"_22":13073,"_24":13074,"_28":8919,"_30":13081},"np.percentile","np.percentile(a, q, axis?, keepdims?)","Compute the q-th percentile of the data along the specified axis.",[13075,13076,13078,13080],{"_16":433,"_22":8910,"_69":6},{"_16":12844,"_22":13077,"_69":6},"- Percentile to compute, in range [0, 100]",{"_16":2299,"_22":13079,"_69":11},"- Axis along which to compute percentile. null computes percentile of flattened array.",{"_16":9240,"_22":9393,"_69":11},[],{"_16":13083,"_18":13084,"_20":13085,"_22":13085,"_24":13086,"_28":9268,"_30":13091},"np.permutation","np.permutation(x, axis?)","Randomly permute a sequence, or return a permuted range.",[13087,13089],{"_16":498,"_22":13088,"_69":6},"- If an integer, randomly permute arange(x).\r\n If an array, make a copy and shuffle the elements randomly.",{"_16":2299,"_22":13090,"_69":11},"- Axis along which to permute (default 0)",[],{"_16":13093,"_18":13094,"_20":13095,"_22":13096,"_24":13097,"_28":9219,"_30":13101},"np.permute_dims","np.permute_dims(a, axes?)","Permute the dimensions of an array.\r","Permute the dimensions of an array.\r\nThis is an alias for transpose, added in NumPy 2.0.",[13098,13099],{"_16":433,"_22":8910,"_69":6},{"_16":9316,"_22":13100,"_69":11},"- Permutation of axes (optional, reverses all axes if not provided)",[],{"_16":13103,"_18":13104,"_20":13105,"_22":13106,"_24":13107,"_28":9268,"_30":13118},"np.piecewise","np.piecewise(x, condlist, funclist, args)","Evaluate a piecewise-defined function.\r","Evaluate a piecewise-defined function.\r\n\r\nGiven a set of conditions and corresponding functions, evaluate each\r\nfunction on the input only where its condition is true.",[13108,13110,13113,13116],{"_16":498,"_22":13109,"_69":6},"- Input array (domain of the piecewise function)",{"_16":13111,"_22":13112,"_69":6},"condlist","- List of boolean arrays defining conditions",{"_16":13114,"_22":13115,"_69":6},"funclist","- List of functions or constants for each condition.\r\n If funclist has one more element than condlist, the last\r\n element is used as the default (\"otherwise\") case.",{"_16":9142,"_22":13117,"_69":6},"- Additional arguments passed to all functions",[],{"_16":13120,"_18":13121,"_20":13122,"_22":13122,"_24":13123,"_28":9268,"_30":13127},"np.pinv","np.pinv(a, rcond?)","Compute the (Moore-Penrose) pseudo-inverse of a matrix.",[13124,13126],{"_16":433,"_22":13125,"_69":6},"- Matrix to pseudo-invert",{"_16":9884,"_22":9885,"_69":11},[],{"_16":13129,"_18":13130,"_20":13131,"_22":13132,"_24":13133,"_28":4713,"_30":13142},"np.place","np.place(arr, mask, vals)","Change elements of an array based on conditional and input values.\r","Change elements of an array based on conditional and input values.\r\nSimilar to putmask, but places values sequentially.",[13134,13136,13139],{"_16":9285,"_22":13135,"_69":6},"- Array to modify (in place)",{"_16":13137,"_22":13138,"_69":6},"mask","- Boolean mask array",{"_16":13140,"_22":13141,"_69":6},"vals","- Values to place (used sequentially, cycled if needed)",[],{"_16":13144,"_18":13145,"_20":13146,"_22":13147,"_24":13148,"_28":4712,"_30":13152},"np.poly","np.poly(seq_of_zeros)","Find the coefficients of a polynomial with the given sequence of roots.\r","Find the coefficients of a polynomial with the given sequence of roots.\r\n\r\nThis is a NumPy legacy function. Returns coefficients in descending\r\npowers order (highest power first), which is the opposite of the numpy.polynomial\r\nmodule convention.\r\n\r\nNOTE: This is the legacy numpy.poly function. For the modern API, use\r\npolyfromroots() from the polynomial module which uses ascending powers order.",[13149],{"_16":13150,"_22":13151,"_69":6},"seq_of_zeros","- A sequence of polynomial roots",[],{"_16":13154,"_18":13155,"_20":13156,"_22":13156,"_24":13157,"_28":4712,"_30":13161},"np.poly2cheb","np.poly2cheb(pol)","Convert power series coefficients to Chebyshev coefficients.",[13158],{"_16":13159,"_22":13160,"_69":6},"pol","- Power series coefficients",[],{"_16":13163,"_18":13164,"_20":13165,"_22":13165,"_24":13166,"_28":4712,"_30":13168},"np.poly2herm","np.poly2herm(pol)","Convert power series to Hermite coefficients.",[13167],{"_16":13159,"_22":4712,"_69":6},[],{"_16":13170,"_18":13171,"_20":13172,"_22":13172,"_24":13173,"_28":4712,"_30":13175},"np.poly2herme","np.poly2herme(pol)","Convert power series to HermiteE coefficients.",[13174],{"_16":13159,"_22":4712,"_69":6},[],{"_16":13177,"_18":13178,"_20":13179,"_22":13179,"_24":13180,"_28":4712,"_30":13182},"np.poly2lag","np.poly2lag(pol)","Convert power series to Laguerre coefficients.",[13181],{"_16":13159,"_22":4712,"_69":6},[],{"_16":13184,"_18":13185,"_20":13186,"_22":13186,"_24":13187,"_28":4712,"_30":13189},"np.poly2leg","np.poly2leg(pol)","Convert power series to Legendre coefficients.",[13188],{"_16":13159,"_22":4712,"_69":6},[],{"_16":13191,"_18":13192,"_20":13193,"_22":13193,"_24":13194,"_28":4712,"_30":13199},"np.polyadd","np.polyadd(c1, c2)","Add two coefficient arrays (power series).",[13195,13197],{"_16":2726,"_22":13196,"_69":6},"- First coefficient array",{"_16":2729,"_22":13198,"_69":6},"- Second coefficient array",[],{"_16":13201,"_18":13202,"_20":13203,"_22":13203,"_24":13204,"_28":4840,"_30":13206},"np.polycompanion","np.polycompanion(c)","Generate companion matrix.",[13205],{"_16":2644,"_22":9852,"_69":6},[],{"_16":13208,"_18":13209,"_20":13210,"_22":13210,"_24":13211,"_28":4712,"_30":13214},"np.polyder","np.polyder(c, m?)","Polynomial derivative.",[13212,13213],{"_16":2644,"_22":9852,"_69":6},{"_16":359,"_22":9861,"_69":11},[],{"_16":13216,"_18":13217,"_20":13218,"_22":13218,"_24":13219,"_28":9870,"_30":13224},"np.polydiv","np.polydiv(c1, c2)","Divide two coefficient arrays (power series).",[13220,13222],{"_16":2726,"_22":13221,"_69":6},"- Dividend coefficient array",{"_16":2729,"_22":13223,"_69":6},"- Divisor coefficient array",[],{"_16":13226,"_18":13227,"_20":13228,"_22":13228,"_24":13229,"_28":9891,"_30":13236},"np.polyfit","np.polyfit(x, y, deg, rcond?, full?, w?)","Least squares polynomial fit.",[13230,13231,13232,13233,13234,13235],{"_16":498,"_22":9878,"_69":6},{"_16":501,"_22":9880,"_69":6},{"_16":2840,"_22":9882,"_69":6},{"_16":9884,"_22":9885,"_69":11},{"_16":4019,"_22":9887,"_69":11},{"_16":9889,"_22":9890,"_69":11},[],{"_16":13238,"_18":13239,"_20":13240,"_22":13240,"_24":13241,"_28":4712,"_30":13243},"np.polyfromroots","np.polyfromroots(roots)","Construct polynomial from roots.",[13242],{"_16":2863,"_22":9899,"_69":6},[],{"_16":13245,"_18":13246,"_20":13247,"_22":13247,"_24":13248,"_28":4712,"_30":13253},"np.polyint","np.polyint(c, m?, k?, lbnd?)","Polynomial integral.",[13249,13250,13251,13252],{"_16":2644,"_22":9852,"_69":6},{"_16":359,"_22":9908,"_69":11},{"_16":1114,"_22":9910,"_69":11},{"_16":9912,"_22":9913,"_69":11},[],{"_16":13255,"_18":13256,"_20":13257,"_22":13258,"_24":13259,"_28":4712,"_30":13262},"np.polymul","np.polymul(c1, c2)","Multiply two coefficient arrays (power series).\r","Multiply two coefficient arrays (power series).\r\nUses convolution.",[13260,13261],{"_16":2726,"_22":13196,"_69":6},{"_16":2729,"_22":13198,"_69":6},[],{"_16":13264,"_18":13265,"_20":13266,"_22":13266,"_24":13267,"_28":4712,"_30":13273},"np.polypow","np.polypow(c, pow, maxpower?)","Raise polynomial to a non-negative integer power.",[13268,13269,13271],{"_16":2644,"_22":9852,"_69":6},{"_16":9945,"_22":13270,"_69":6},"- Non-negative integer power",{"_16":9947,"_22":13272,"_69":11},"- Maximum allowed power (default: 100)",[],{"_16":13275,"_18":13276,"_20":13277,"_22":13277,"_24":13278,"_28":9928,"_30":13280},"np.polyroots","np.polyroots(c)","Find polynomial roots.",[13279],{"_16":2644,"_22":9852,"_69":6},[],{"_16":13282,"_18":13283,"_20":13284,"_22":13284,"_24":13285,"_28":4712,"_30":13288},"np.polysub","np.polysub(c1, c2)","Subtract two coefficient arrays (power series).",[13286,13287],{"_16":2726,"_22":13196,"_69":6},{"_16":2729,"_22":13198,"_69":6},[],{"_16":13290,"_18":13291,"_20":13292,"_22":13292,"_24":13293,"_28":5703,"_30":13297},"np.polyval","np.polyval(x, c)","Evaluate polynomial at x using Horner's method.",[13294,13295],{"_16":498,"_22":9970,"_69":6},{"_16":2644,"_22":13296,"_69":6},"- Coefficient array [c0, c1, c2, ...] for c0 + c1*x + c2*x^2 + ...",[],{"_16":13299,"_18":13300,"_20":13301,"_22":13301,"_24":13302,"_28":4712,"_30":13306},"np.polyval2d","np.polyval2d(x, y, c)","Evaluate 2D polynomial on x-y pairs.",[13303,13304,13305],{"_16":498,"_22":9980,"_69":6},{"_16":501,"_22":9982,"_69":6},{"_16":2644,"_22":9984,"_69":6},[],{"_16":13308,"_18":13309,"_20":13310,"_22":13310,"_24":13311,"_28":4712,"_30":13318},"np.polyval3d","np.polyval3d(x, y, z, c)","Evaluate 3D polynomial on x-y-z triples.",[13312,13313,13314,13316],{"_16":498,"_22":9980,"_69":6},{"_16":501,"_22":9982,"_69":6},{"_16":2681,"_22":13315,"_69":6},"- z coordinates",{"_16":2644,"_22":13317,"_69":6},"- 3D coefficient array",[],{"_16":13320,"_18":13321,"_20":13322,"_22":13322,"_24":13323,"_28":4840,"_30":13326},"np.polyvander","np.polyvander(x, deg)","Generate Vandermonde matrix.",[13324,13325],{"_16":498,"_22":9992,"_69":6},{"_16":2840,"_22":9994,"_69":6},[],{"_16":13328,"_18":13329,"_20":13330,"_22":13330,"_24":13331,"_28":4840,"_30":13338},"np.polyvander2d","np.polyvander2d(x, y, deg)","Generate 2D Vandermonde matrix.",[13332,13334,13336],{"_16":498,"_22":13333,"_69":6},"- x sample points",{"_16":501,"_22":13335,"_69":6},"- y sample points",{"_16":2840,"_22":13337,"_69":6},"- [degree in x, degree in y]",[],{"_16":13340,"_18":13341,"_20":13342,"_22":13342,"_24":13343,"_28":9219,"_30":13345},"np.positive","np.positive(x)","Numerical positive (returns a copy).",[13344],{"_16":498,"_22":9219,"_69":6},[],{"_16":13347,"_18":13348,"_20":13349,"_22":13349,"_24":13350,"_28":9219,"_30":13353},"np.power","np.power(x1, x2)","First array elements raised to powers from second array, element-wise.",[13351,13352],{"_16":9227,"_22":9219,"_69":6},{"_16":9229,"_22":9219,"_69":6},[],{"_16":13355,"_18":13356,"_20":13357,"_22":13357,"_24":13358,"_28":8919,"_30":13364},"np.prod","np.prod(a, axis?, keepdims?, dtype?)","Return the product of array elements over a given axis.",[13359,13360,13362,13363],{"_16":433,"_22":8910,"_69":6},{"_16":2299,"_22":13361,"_69":11},"- Axis along which to compute product. null computes product of all elements.",{"_16":9240,"_22":9393,"_69":11},{"_16":9117,"_22":12650,"_69":11},[],{"_16":13366,"_18":13367,"_20":13368,"_22":13369,"_24":13370,"_28":10067,"_30":13377},"np.promoteTypes","np.promoteTypes(dtype1, dtype2)","Get result type when combining two dtypes.\r","Get result type when combining two dtypes.\r\nFollows NumPy promotion rules.",[13371,13374],{"_16":13372,"_22":13373,"_69":6},"dtype1","- First dtype",{"_16":13375,"_22":13376,"_69":6},"dtype2","- Second dtype",[],{"_16":13379,"_18":13380,"_20":13381,"_22":13382,"_24":13383,"_28":8919,"_30":13388},"np.ptp","np.ptp(a, axis?, keepdims?)","Range of values (maximum - minimum) along an axis.\r","Range of values (maximum - minimum) along an axis.\r\n\r\nThe name of the function comes from the acronym for 'peak to peak'.",[13384,13385,13387],{"_16":433,"_22":8910,"_69":6},{"_16":2299,"_22":13386,"_69":11},"- Axis along which to find the peak-to-peak value. null computes ptp of flattened array.",{"_16":9240,"_22":9393,"_69":11},[],{"_16":13390,"_18":13391,"_20":13392,"_22":13392,"_24":13393,"_28":4713,"_30":13401},"np.put","np.put(arr, indices, values, mode?)","Put values into an array at specified flat indices.",[13394,13396,13398,13400],{"_16":9285,"_22":13395,"_69":6},"- Target array (modified in place)",{"_16":9786,"_22":13397,"_69":6},"- Array of flat indices",{"_16":2320,"_22":13399,"_69":6},"- Values to put (broadcast if smaller)",{"_16":2621,"_22":10033,"_69":11},[],{"_16":13403,"_18":13404,"_20":13405,"_22":13405,"_24":13406,"_28":4713,"_30":13415},"np.put_along_axis","np.put_along_axis(arr, indicesArr, values, axis)","Put values into the destination array by matching 1d index and data slices.",[13407,13409,13411,13413],{"_16":9285,"_22":13408,"_69":6},"- Destination array (modified in place)",{"_16":13410,"_22":9219,"_69":6},"indicesArr",{"_16":2320,"_22":13412,"_69":6},"- Values to put",{"_16":2299,"_22":13414,"_69":6},"- The axis to put along",[],{"_16":13417,"_18":13418,"_20":13131,"_22":13419,"_24":13420,"_28":4713,"_30":13425},"np.putmask","np.putmask(arr, mask, values)","Change elements of an array based on conditional and input values.\r\nSets a.flat[n] = values[n % len(values)] for each n where mask.flat[n]==True.",[13421,13422,13423],{"_16":9285,"_22":13135,"_69":6},{"_16":13137,"_22":13138,"_69":6},{"_16":2320,"_22":13424,"_69":6},"- Values to put (cycled if smaller than number of True in mask)",[],{"_16":13427,"_18":13428,"_20":13429,"_22":13430,"_24":13431,"_28":13434,"_30":13435},"np.qr","np.qr(a)","QR decomposition.\r","QR decomposition.\r\n\r\nFactor the matrix a as qr, where q is orthonormal and r is upper-triangular.",[13432],{"_16":433,"_22":13433,"_69":6},"- Matrix to factor (M x N)","Promise",[],{"_16":13437,"_18":13438,"_20":13439,"_22":13439,"_24":13440,"_28":8919,"_30":13447},"np.quantile","np.quantile(a, q, axis?, keepdims?)","Compute the q-th quantile of the data along the specified axis.",[13441,13442,13444,13446],{"_16":433,"_22":8910,"_69":6},{"_16":12844,"_22":13443,"_69":6},"- Quantile to compute, in range [0, 1]",{"_16":2299,"_22":13445,"_69":11},"- Axis along which to compute quantile. null computes quantile of flattened array.",{"_16":9240,"_22":9393,"_69":11},[],{"_16":13449,"_18":13450,"_20":13451,"_22":13451,"_24":13452,"_28":9219,"_30":13454},"np.radians","np.radians(x)","Convert angles from degrees to radians.",[13453],{"_16":498,"_22":9219,"_69":6},[],{"_16":13456,"_18":13457,"_20":13458,"_22":13459,"_24":13460,"_28":13462,"_30":13463},"np.rand","np.rand(shape)","Random values in a given shape.\r","Random values in a given shape.\r\n\r\nCreate an array of the given shape and populate it with random samples\r\nfrom a uniform distribution over [0, 1).",[13461],{"_16":8461,"_22":4712,"_69":6},"NDArray | number",[],{"_16":13465,"_18":13466,"_20":13467,"_22":13467,"_24":13468,"_28":13462,"_30":13477},"np.randint","np.randint(low, high?, size?)","Return random integers from low (inclusive) to high (exclusive).",[13469,13472,13475],{"_16":13470,"_22":13471,"_69":6},"low","- Lower bound",{"_16":13473,"_22":13474,"_69":11},"high","- Upper bound (optional)",{"_16":193,"_22":13476,"_69":11},"- Output shape",[],{"_16":13479,"_18":13480,"_20":13481,"_22":13481,"_24":13482,"_28":13462,"_30":13484},"np.randn","np.randn(args)","Draw samples from a standard normal distribution.",[13483],{"_16":9142,"_22":4712,"_69":6},[],{"_16":13486,"_18":13487,"_20":13488,"_22":13488,"_24":13489,"_28":13462,"_30":13491},"np.random","np.random(size?)","Return random floats in the half-open interval [0.0, 1.0).",[13490],{"_16":193,"_22":13476,"_69":11},[],{"_16":13493,"_18":13494,"_20":13467,"_22":13467,"_24":13495,"_28":13462,"_30":13501},"np.random_integers","np.random_integers(low, high?, size?)",[13496,13498,13500],{"_16":13470,"_22":13497,"_69":6},"- Lowest integer (unless high is None, then range is [0, low))",{"_16":13473,"_22":13499,"_69":11},"- Upper bound (exclusive). If None, range is [0, low)",{"_16":193,"_22":13476,"_69":11},[],{"_16":13503,"_18":13504,"_20":13488,"_22":13488,"_24":13505,"_28":13462,"_30":13507},"np.random_sample","np.random_sample(size?)",[13506],{"_16":193,"_22":13476,"_69":11},[],{"_16":13509,"_18":13510,"_20":13488,"_22":13488,"_24":13511,"_28":13462,"_30":13513},"np.ranf","np.ranf(size?)",[13512],{"_16":193,"_22":13476,"_69":11},[],{"_16":13515,"_18":13516,"_20":13517,"_22":13517,"_24":13518,"_28":9219,"_30":13520},"np.ravel","np.ravel(a)","Return a contiguous flattened array.",[13519],{"_16":433,"_22":8910,"_69":6},[],{"_16":13522,"_18":13523,"_20":13524,"_22":13524,"_24":13525,"_28":9928,"_30":13531},"np.ravelMultiIndex","np.ravelMultiIndex(coords, shape)","Convert a tuple of coordinate arrays into flat indices.",[13526,13529],{"_16":13527,"_22":13528,"_69":6},"coords","- Array of coordinate arrays, one per dimension",{"_16":8461,"_22":13530,"_69":6},"- Shape of the array",[],{"_16":13533,"_18":13534,"_20":13535,"_22":13536,"_24":13537,"_28":9219,"_30":13539},"np.real","np.real(val)","Return the real part of the complex argument.\r","Return the real part of the complex argument.\r\n\r\nFor non-complex arrays, returns a copy of the input.",[13538],{"_16":8986,"_22":8910,"_69":6},[],{"_16":13541,"_18":13542,"_20":13543,"_22":13544,"_24":13545,"_28":9268,"_30":13549},"np.real_if_close","np.real_if_close(a, tol?)","If input is complex with all imaginary parts close to zero, return real parts.\r","If input is complex with all imaginary parts close to zero, return real parts.\r\n\r\n\"Close to zero\" is defined as `tol` times the machine epsilon of the type.",[13546,13547],{"_16":433,"_22":8910,"_69":6},{"_16":3719,"_22":13548,"_69":11},"- Tolerance in machine epsilons for complex128, or absolute\r\n tolerance if tol < 1. Default is 100.",[],{"_16":13551,"_18":13552,"_20":13553,"_22":13553,"_24":13554,"_28":13559,"_30":13560},"np.recArray","np.recArray(data?, options?)","Create a record array.",[13555,13557],{"_16":84,"_22":13556,"_69":11},"- Input data (list of tuples, existing array, or null for empty)",{"_16":4789,"_22":13558,"_69":11},"- Creation options","Promise",[],{"_16":13562,"_18":13563,"_20":13564,"_22":13564,"_24":13565,"_28":13559,"_30":13570},"np.recFromarrays","np.recFromarrays(arrayList, options?)","Create a record array from a list of arrays (columns).",[13566,13569],{"_16":13567,"_22":13568,"_69":6},"arrayList","- List of arrays, one per field",{"_16":4789,"_22":13558,"_69":11},[],{"_16":13572,"_18":13573,"_20":13574,"_22":13574,"_24":13575,"_28":13559,"_30":13584},"np.recFromfile","np.recFromfile(file, dtype, shape?, offset?)","Create a record array from a file.",[13576,13578,13580,13582],{"_16":11013,"_22":13577,"_69":6},"- File path (Node.js) or File object (browser)",{"_16":9117,"_22":13579,"_69":6},"- Structured dtype",{"_16":8461,"_22":13581,"_69":11},"- Shape of output array",{"_16":7354,"_22":13583,"_69":11},"- Byte offset into file",[],{"_16":13586,"_18":13587,"_20":13588,"_22":13588,"_24":13589,"_28":13559,"_30":13594},"np.recFromrecords","np.recFromrecords(recList, options?)","Create a record array from a list of records (rows).",[13590,13593],{"_16":13591,"_22":13592,"_69":6},"recList","- List of records (tuples or arrays)",{"_16":4789,"_22":13558,"_69":11},[],{"_16":13596,"_18":13597,"_20":13598,"_22":13598,"_24":13599,"_28":13559,"_30":13607},"np.recFromstring","np.recFromstring(datastring, dtype, shape?, offset?)","Create a record array from a binary string/buffer.",[13600,13603,13604,13605],{"_16":13601,"_22":13602,"_69":6},"datastring","- Binary data (ArrayBuffer or typed array)",{"_16":9117,"_22":13579,"_69":6},{"_16":8461,"_22":13581,"_69":11},{"_16":7354,"_22":13606,"_69":11},"- Byte offset into data",[],{"_16":13609,"_18":13610,"_20":13611,"_22":13611,"_24":13612,"_28":9219,"_30":13614},"np.reciprocal","np.reciprocal(x)","Return the reciprocal of the argument, element-wise.",[13613],{"_16":498,"_22":9219,"_69":6},[],{"_16":13616,"_18":13617,"_20":13618,"_22":13618,"_24":13619,"_28":9219,"_30":13622},"np.remainder","np.remainder(x1, x2)","Return element-wise remainder of division (Python-style modulo).",[13620,13621],{"_16":9227,"_22":9219,"_69":6},{"_16":9229,"_22":9219,"_69":6},[],{"_16":13624,"_18":13625,"_20":13626,"_22":13626,"_24":13627,"_28":9268,"_30":13634},"np.repeat","np.repeat(arr, repeats, axis?)","Repeat elements of an array.",[13628,13629,13632],{"_16":9285,"_22":8910,"_69":6},{"_16":13630,"_22":13631,"_69":6},"repeats","- Number of repetitions for each element",{"_16":2299,"_22":13633,"_69":11},"- Axis along which to repeat (default: flatten first)",[],{"_16":13636,"_18":13637,"_20":13638,"_22":13638,"_24":13639,"_28":1426,"_30":13640},"np.resetPrintoptions","np.resetPrintoptions()","Reset print options to defaults.",[],[],{"_16":13642,"_18":13643,"_20":13644,"_22":13644,"_24":13645,"_28":9219,"_30":13651},"np.reshape","np.reshape(a, newshape)","Gives a new shape to an array without changing its data.",[13646,13648],{"_16":433,"_22":13647,"_69":6},"- Array to be reshaped",{"_16":13649,"_22":13650,"_69":6},"newshape","- New shape (can include one -1 for auto-calculation)",[],{"_16":13653,"_18":13654,"_20":13655,"_22":13656,"_24":13657,"_28":9268,"_30":13662},"np.resize","np.resize(arr, new_shape)","Return a new array with the specified shape.\r","Return a new array with the specified shape.\r\nIf the new array is larger than the original, it is filled with repeated copies.",[13658,13659],{"_16":9285,"_22":8910,"_69":6},{"_16":13660,"_22":13661,"_69":6},"new_shape","- Shape of the resized array",[],{"_16":13664,"_18":13665,"_20":13666,"_22":13666,"_24":13667,"_28":10067,"_30":13670},"np.result_type","np.result_type(dtypes)","Return the type that results from applying the type promotion rules to the arguments.",[13668],{"_16":10065,"_22":13669,"_69":6},"- Input dtypes",[],{"_16":13672,"_18":13673,"_20":13674,"_22":13675,"_24":13676,"_28":9219,"_30":13682},"np.rfft","np.rfft(a, n?, axis?, norm?)","Compute the one-dimensional discrete Fourier Transform for real input.\r","Compute the one-dimensional discrete Fourier Transform for real input.\r\n\r\nThis function computes the one-dimensional n-point DFT of a real-valued\r\narray. The output is Hermitian-symmetric, so only the positive frequencies\r\nare returned: output has shape (..., n//2 + 1).",[13677,13678,13680,13681],{"_16":433,"_22":11620,"_69":6},{"_16":362,"_22":13679,"_69":11},"- Number of points in the FFT. If n < a.shape[axis], input is truncated.\r\n If n > a.shape[axis], input is zero-padded.",{"_16":2299,"_22":11462,"_69":11},{"_16":1530,"_22":10779,"_69":11},[],{"_16":13684,"_18":13685,"_20":13686,"_22":13686,"_24":13687,"_28":9219,"_30":13692},"np.rfft2","np.rfft2(a, s?, axes?, norm?)","Compute the 2-dimensional FFT of a real array.",[13688,13689,13690,13691],{"_16":433,"_22":9219,"_69":6},{"_16":3799,"_22":11590,"_69":11},{"_16":9316,"_22":11164,"_69":11},{"_16":1530,"_22":11593,"_69":11},[],{"_16":13694,"_18":13695,"_20":13696,"_22":13697,"_24":13698,"_28":9268,"_30":13701},"np.rfftfreq","np.rfftfreq(n, d?)","Return the Discrete Fourier Transform sample frequencies for rfft.\r","Return the Discrete Fourier Transform sample frequencies for rfft.\r\n\r\nReturns an array of length n//2 + 1 with the positive sample frequencies:\r\nf = [0, 1, ..., n//2] / (d*n)",[13699,13700],{"_16":362,"_22":10788,"_69":6},{"_16":1946,"_22":10790,"_69":11},[],{"_16":13703,"_18":13704,"_20":13705,"_22":13706,"_24":13707,"_28":9219,"_30":13712},"np.rfftn","np.rfftn(a, s?, axes?, norm?)","Compute the N-dimensional discrete Fourier Transform for real input.\r","Compute the N-dimensional discrete Fourier Transform for real input.\r\n\r\nThe output has Hermitian symmetry along the last transformed axis.\r\nOutput shape along the last axis: s[-1]//2 + 1",[13708,13709,13710,13711],{"_16":433,"_22":9219,"_69":6},{"_16":3799,"_22":11314,"_69":11},{"_16":9316,"_22":11314,"_69":11},{"_16":1530,"_22":11593,"_69":11},[],{"_16":13714,"_18":13715,"_20":13716,"_22":13716,"_24":13717,"_28":9219,"_30":13726},"np.rfind","np.rfind(a, sub, start?, end?)","For each element, return the highest index where substring is found.",[13718,13719,13722,13724],{"_16":433,"_22":10656,"_69":6},{"_16":13720,"_22":13721,"_69":6},"sub","- Substring to search for",{"_16":9325,"_22":13723,"_69":11},"- Start position for search (default 0)",{"_16":9328,"_22":13725,"_69":11},"- End position for search (default string length)",[],{"_16":13728,"_18":13729,"_20":13730,"_22":13730,"_24":13731,"_28":9219,"_30":13734},"np.right_shift","np.right_shift(x1, x2)","Shift the bits of an integer to the right.",[13732,13733],{"_16":9227,"_22":9219,"_69":6},{"_16":9229,"_22":9219,"_69":6},[],{"_16":13736,"_18":13737,"_20":13738,"_22":13738,"_24":13739,"_28":9219,"_30":13744},"np.rindex","np.rindex(a, sub, start?, end?)","Like rfind, but raises ValueError if substring is not found.",[13740,13741,13742,13743],{"_16":433,"_22":10656,"_69":6},{"_16":13720,"_22":13721,"_69":6},{"_16":9325,"_22":13723,"_69":11},{"_16":9328,"_22":13725,"_69":11},[],{"_16":13746,"_18":13747,"_20":13748,"_22":13748,"_24":13749,"_28":9219,"_30":13751},"np.rint","np.rint(x)","Round elements of the array to the nearest integer.",[13750],{"_16":498,"_22":9219,"_69":6},[],{"_16":13753,"_18":13754,"_20":13755,"_22":13755,"_24":13756,"_28":9219,"_30":13760},"np.rjust","np.rjust(a, width, fillchar?)","Return element-wise right-justified string of given width.",[13757,13758,13759],{"_16":433,"_22":10656,"_69":6},{"_16":4981,"_22":12359,"_69":6},{"_16":12361,"_22":12362,"_69":11},[],{"_16":13762,"_18":13763,"_20":13764,"_22":13764,"_24":13765,"_28":9219,"_30":13772},"np.roll","np.roll(arr, shift, axis?)","Roll array elements along a given axis.",[13766,13767,13770],{"_16":9285,"_22":8910,"_69":6},{"_16":13768,"_22":13769,"_69":6},"shift","- Number of places to shift elements",{"_16":2299,"_22":13771,"_69":11},"- Axis along which to roll (default: flatten, roll, reshape)",[],{"_16":13774,"_18":13775,"_20":13776,"_22":13776,"_24":13777,"_28":9219,"_30":13783},"np.rollaxis","np.rollaxis(a, axis, start?)","Roll the specified axis backwards, until it lies in a given position.",[13778,13779,13781],{"_16":433,"_22":8910,"_69":6},{"_16":2299,"_22":13780,"_69":6},"- The axis to be rolled",{"_16":9325,"_22":13782,"_69":11},"- Start position (default: 0)",[],{"_16":13785,"_18":13786,"_20":13787,"_22":13788,"_24":13789,"_28":9928,"_30":13792},"np.roots","np.roots(p)","Find the roots of a polynomial with coefficients given in c.\r","Find the roots of a polynomial with coefficients given in c.\r\n\r\nThis is a NumPy legacy function. The coefficients are given in descending\r\npowers order (highest power first), which is the opposite of the numpy.polynomial\r\nmodule convention.\r\n\r\nNOTE: This is the legacy numpy.roots function. For the modern API, use\r\npolyroots() from the polynomial module which uses ascending powers order.",[13790],{"_16":1645,"_22":13791,"_69":6},"- Coefficient array in descending powers order [c_n, c_{n-1}, ..., c_1, c_0]",[],{"_16":13794,"_18":13795,"_20":13796,"_22":13796,"_24":13797,"_28":9219,"_30":13804},"np.rot90","np.rot90(arr, k?, axes?)","Rotate an array by 90 degrees in the plane specified by axes.",[13798,13800,13802],{"_16":9285,"_22":13799,"_69":6},"- Array with at least 2 dimensions",{"_16":1114,"_22":13801,"_69":11},"- Number of times to rotate by 90 degrees (default: 1)",{"_16":9316,"_22":13803,"_69":11},"- The two axes that define the plane of rotation (default: [0, 1])",[],{"_16":13806,"_18":13807,"_20":13808,"_22":13808,"_24":13809,"_28":9219,"_30":13811},"np.round","np.round(x)","Round to nearest even value (banker's rounding).",[13810],{"_16":498,"_22":9219,"_69":6},[],{"_16":13813,"_18":13814,"_20":13815,"_22":13815,"_24":13816,"_28":9219,"_30":13820},"np.rpartition","np.rpartition(a, sep)","Partition each element around the last occurrence of sep.",[13817,13818],{"_16":433,"_22":10656,"_69":6},{"_16":11083,"_22":13819,"_69":6},"- Separator string",[],{"_16":13822,"_18":13823,"_20":13824,"_22":13824,"_24":13825,"_28":9219,"_30":13828},"np.rstrip","np.rstrip(a, chars?)","Return element-wise copy with trailing characters removed.",[13826,13827],{"_16":433,"_22":10656,"_69":6},{"_16":12505,"_22":12506,"_69":11},[],{"_16":13830,"_18":13831,"_20":13488,"_22":13488,"_24":13832,"_28":13462,"_30":13834},"np.sample","np.sample(size?)",[13833],{"_16":193,"_22":13476,"_69":11},[],{"_16":13836,"_18":13837,"_20":13838,"_22":13838,"_24":13839,"_28":13846,"_30":13847},"np.save","np.save(file, arr, _options?)","Save an array to a binary file in NPY format.",[13840,13842,13844],{"_16":11013,"_22":13841,"_69":6},"- File path (Node.js), FileSystemFileHandle (browser), or null to return ArrayBuffer",{"_16":9285,"_22":13843,"_69":6},"- Array to save",{"_16":8336,"_22":13845,"_69":11},"SaveOptions","Promise",[],{"_16":13849,"_18":13850,"_20":13851,"_22":13851,"_24":13852,"_28":4713,"_30":13859},"np.savetxt","np.savetxt(file, arr, options?)","Save an array to a text file.",[13853,13855,13857],{"_16":11013,"_22":13854,"_69":6},"- Output file (path or FileSystemFileHandle)",{"_16":9285,"_22":13856,"_69":6},"- 1D or 2D array to save",{"_16":4789,"_22":13858,"_69":11},"- Formatting options",[],{"_16":13861,"_18":13862,"_20":13863,"_22":13864,"_24":13865,"_28":13846,"_30":13869},"np.savez","np.savez(file, args)","Save multiple arrays to a single file in uncompressed `.npz` format.\r","Save multiple arrays to a single file in uncompressed `.npz` format.\r\n\r\nThe `.npz` file format is a ZIP archive containing multiple `.npy` files,\r\none for each array. Arrays are named 'arr_0', 'arr_1', etc. for positional\r\narguments, or by their keyword argument names.",[13866,13867],{"_16":11013,"_22":13841,"_69":6},{"_16":9142,"_22":13868,"_69":6},"- Arrays to save (positional) or object mapping names to arrays",[],{"_16":13871,"_18":13872,"_20":13873,"_22":13874,"_24":13875,"_28":13846,"_30":13878},"np.savez_compressed","np.savez_compressed(file, args)","Save multiple arrays to a single file in compressed `.npz` format.\r","Save multiple arrays to a single file in compressed `.npz` format.\r\n\r\nSimilar to `savez`, but each array is individually compressed using DEFLATE.\r\nThis can significantly reduce file size for sparse or repetitive data.",[13876,13877],{"_16":11013,"_22":13841,"_69":6},{"_16":9142,"_22":13868,"_69":6},[],{"_16":13880,"_18":13881,"_20":13882,"_22":13882,"_24":13883,"_28":8919,"_30":13889},"np.searchsorted","np.searchsorted(a, v, side?)","Find indices where elements should be inserted to maintain order.",[13884,13886,13887],{"_16":433,"_22":13885,"_69":6},"- Sorted 1D input array",{"_16":2897,"_22":11684,"_69":6},{"_16":2459,"_22":13888,"_69":11},"- 'left' or 'right' side to insert",[],{"_16":13891,"_18":13892,"_20":13893,"_22":13893,"_24":13894,"_28":1426,"_30":13897},"np.seed","np.seed(seed)","Seed the default random generator.",[13895],{"_16":10349,"_22":13896,"_69":6},"- Seed value",[],{"_16":13899,"_18":13900,"_20":13901,"_22":13901,"_24":13902,"_28":9268,"_30":13911},"np.select","np.select(condlist, choicelist, defaultValue?)","Return an array drawn from elements in choicelist, depending on conditions.",[13903,13905,13908],{"_16":13111,"_22":13904,"_69":6},"- List of boolean arrays (conditions)",{"_16":13906,"_22":13907,"_69":6},"choicelist","- List of arrays from which output elements are taken",{"_16":13909,"_22":13910,"_69":11},"defaultValue","- Value used when all conditions are False (default: 0)",[],{"_16":13913,"_18":13914,"_20":13915,"_22":13916,"_24":13917,"_28":9268,"_30":13921},"np.setdiff1d","np.setdiff1d(ar1, ar2, options?)","Find the set difference of two arrays.\r","Find the set difference of two arrays.\r\n\r\nReturns the sorted unique values in ar1 that are not in ar2.",[13918,13919,13920],{"_16":11639,"_22":11715,"_69":6},{"_16":11642,"_22":11717,"_69":6},{"_16":4789,"_22":8790,"_69":11},[],{"_16":13923,"_18":13924,"_20":13925,"_22":13925,"_24":13926,"_28":1426,"_30":13929},"np.setPrintoptions","np.setPrintoptions(options)","Set printing options globally.",[13927],{"_16":4789,"_22":13928,"_69":6},"- New print options (partial, merged with current)",[],{"_16":13931,"_18":13932,"_20":13933,"_22":13934,"_24":13935,"_28":9268,"_30":13939},"np.setxor1d","np.setxor1d(ar1, ar2, options?)","Find the set exclusive-or of two arrays.\r","Find the set exclusive-or of two arrays.\r\n\r\nReturns the sorted unique values in exactly one (not both) of the input arrays.",[13936,13937,13938],{"_16":11639,"_22":11715,"_69":6},{"_16":11642,"_22":11717,"_69":6},{"_16":4789,"_22":8790,"_69":11},[],{"_16":13941,"_18":13942,"_20":13943,"_22":13943,"_24":13944,"_28":6507,"_30":13947},"np.shapesAreBroadcastable","np.shapesAreBroadcastable(shape1, shape2)","Check if two shapes are broadcast-compatible.",[13945,13946],{"_16":9752,"_22":9753,"_69":6},{"_16":9755,"_22":9756,"_69":6},[],{"_16":13949,"_18":13950,"_20":13951,"_22":13951,"_24":13952,"_28":4713,"_30":13957},"np.shuffle","np.shuffle(x, axis?)","Randomly shuffle elements of an array in-place along an axis.",[13953,13955],{"_16":498,"_22":13954,"_69":6},"- Array to shuffle (modified in-place)",{"_16":2299,"_22":13956,"_69":11},"- Axis along which to shuffle (default 0)",[],{"_16":13959,"_18":13960,"_20":13961,"_22":13961,"_24":13962,"_28":9219,"_30":13964},"np.sign","np.sign(x)","Returns element-wise sign: -1, 0, or +1.",[13963],{"_16":498,"_22":9219,"_69":6},[],{"_16":13966,"_18":13967,"_20":13968,"_22":13968,"_24":13969,"_28":9219,"_30":13971},"np.signbit","np.signbit(x)","Return element-wise True where signbit is set (less than zero).",[13970],{"_16":498,"_22":9219,"_69":6},[],{"_16":13973,"_18":13974,"_20":13975,"_22":13975,"_24":13976,"_28":9219,"_30":13978},"np.sin","np.sin(x)","Trigonometric sine, element-wise.",[13977],{"_16":498,"_22":9219,"_69":6},[],{"_16":13980,"_18":13981,"_20":13982,"_22":13983,"_24":13984,"_28":9219,"_30":13986},"np.sinc","np.sinc(x)","Return the normalized sinc function: sin(pi*x) / (pi*x).\r","Return the normalized sinc function: sin(pi*x) / (pi*x).\r\nThe sinc function is used in various signal processing applications.",[13985],{"_16":498,"_22":8910,"_69":6},[],{"_16":13988,"_18":13989,"_20":13990,"_22":13990,"_24":13991,"_28":9219,"_30":13993},"np.sinh","np.sinh(x)","Hyperbolic sine, element-wise.",[13992],{"_16":498,"_22":9219,"_69":6},[],{"_16":13995,"_18":13996,"_20":13997,"_22":13997,"_24":13998,"_28":14005,"_30":14006},"np.slice","np.slice(start?, stop?, step?)","Factory function for creating slices with cleaner syntax.",[13999,14001,14003],{"_16":9325,"_22":14000,"_69":11},"- Start index (null for default)",{"_16":11138,"_22":14002,"_69":11},"- Stop index (null for default)",{"_16":9331,"_22":14004,"_69":11},"- Step size (null for 1)","Slice",[],{"_16":14008,"_18":14009,"_20":14010,"_22":14011,"_24":14012,"_28":14014,"_30":14015},"np.slogdet","np.slogdet(a)","Compute sign and (natural) logarithm of the determinant.\r","Compute sign and (natural) logarithm of the determinant.\r\nMore numerically stable than computing det directly for large matrices.",[14013],{"_16":433,"_22":9219,"_69":6},"Promise",[],{"_16":14017,"_18":14018,"_20":14019,"_22":14019,"_24":14020,"_28":9268,"_30":14025},"np.solve","np.solve(a, b)","Solve a linear matrix equation: a @ x = b",[14021,14023],{"_16":433,"_22":14022,"_69":6},"- Coefficient matrix (N x N)",{"_16":436,"_22":14024,"_69":6},"- Ordinate values (N,) or (N x NRHS)",[],{"_16":14027,"_18":14028,"_20":14029,"_22":14029,"_24":14030,"_28":9268,"_30":14035},"np.sort","np.sort(a, axis?, kind?)","Return a sorted copy of an array.",[14031,14032,14033],{"_16":433,"_22":9424,"_69":6},{"_16":2299,"_22":9426,"_69":11},{"_16":9428,"_22":14034,"_69":11},"- Sorting algorithm: 'quicksort', 'mergesort', 'heapsort', or 'stable'",[],{"_16":14037,"_18":14038,"_20":14039,"_22":14040,"_24":14041,"_28":9219,"_30":14043},"np.sort_complex","np.sort_complex(a)","Sort a complex array using the real part first, then the imaginary part.\r","Sort a complex array using the real part first, then the imaginary part.\r\n\r\nThe input array is flattened before sorting. Non-complex arrays are\r\nconverted to complex in the output.",[14042],{"_16":433,"_22":11640,"_69":6},[],{"_16":14045,"_18":14046,"_20":14047,"_22":14048,"_24":14049,"_28":9219,"_30":14051},"np.spacing","np.spacing(x)","Return the distance between x and the nearest adjacent number.\r","Return the distance between x and the nearest adjacent number.\r\nThis is effectively the ulp (unit in the last place) of x.",[14050],{"_16":498,"_22":11231,"_69":6},[],{"_16":14053,"_18":14054,"_20":14055,"_22":14056,"_24":14057,"_28":9493,"_30":14062},"np.split","np.split(arr, indices_or_sections, axis?)","Split an array into multiple sub-arrays of equal size.\r","Split an array into multiple sub-arrays of equal size.\r\nRaises error if array cannot be split into equal sections.",[14058,14059,14061],{"_16":9285,"_22":9487,"_69":6},{"_16":9489,"_22":14060,"_69":6},"- Number of equal sections or split indices",{"_16":2299,"_22":9492,"_69":11},[],{"_16":14064,"_18":14065,"_20":14066,"_22":14066,"_24":14067,"_28":9219,"_30":14069},"np.sqrt","np.sqrt(x)","Return the non-negative square-root of an array, element-wise.",[14068],{"_16":498,"_22":9219,"_69":6},[],{"_16":14071,"_18":14072,"_20":14073,"_22":14073,"_24":14074,"_28":9219,"_30":14076},"np.square","np.square(x)","Return the element-wise square of the input.",[14075],{"_16":498,"_22":9219,"_69":6},[],{"_16":14078,"_18":14079,"_20":14080,"_22":14080,"_24":14081,"_28":9219,"_30":14085},"np.squeeze","np.squeeze(a, axis?)","Remove axes of length one from array.",[14082,14083],{"_16":433,"_22":8910,"_69":6},{"_16":2299,"_22":14084,"_69":11},"- Specific axis to squeeze (optional, -1 for all size-1 axes)",[],{"_16":14087,"_18":14088,"_20":14089,"_22":14089,"_24":14090,"_28":9219,"_30":14095},"np.stack","np.stack(arrays, axis?)","Join a sequence of arrays along a new axis.",[14091,14093],{"_16":9733,"_22":14092,"_69":6},"- Sequence of arrays with the same shape",{"_16":2299,"_22":14094,"_69":11},"- The axis in the result along which to stack (default: 0)",[],{"_16":14097,"_18":14098,"_20":14099,"_22":14099,"_24":14100,"_28":9219,"_30":14106},"np.startswith","np.startswith(a, prefix, start?, end?)","Return true for each element if the string starts with prefix.",[14101,14102,14104,14105],{"_16":433,"_22":10656,"_69":6},{"_16":1253,"_22":14103,"_69":6},"- Prefix to check",{"_16":9325,"_22":10670,"_69":11},{"_16":9328,"_22":10672,"_69":11},[],{"_16":14108,"_18":14109,"_20":14110,"_22":14110,"_24":14111,"_28":8919,"_30":14120},"np.std","np.std(a, axis?, ddof?, keepdims?, dtype?)","Compute the standard deviation along the specified axis.",[14112,14113,14115,14117,14118],{"_16":433,"_22":8910,"_69":6},{"_16":2299,"_22":14114,"_69":11},"- Axis along which to compute std. null computes std of all elements.",{"_16":10260,"_22":14116,"_69":11},"- Delta Degrees of Freedom. Divisor is N - ddof. Default: 0",{"_16":9240,"_22":9393,"_69":11},{"_16":9117,"_22":14119,"_69":11},"- Output dtype",[],{"_16":14122,"_18":14123,"_20":14124,"_22":14124,"_24":14125,"_28":9219,"_30":14127},"np.str_len","np.str_len(a)","Return the length of each element.",[14126],{"_16":433,"_22":10656,"_69":6},[],{"_16":14129,"_18":14130,"_20":14131,"_22":14131,"_24":14132,"_28":9219,"_30":14135},"np.strAdd","np.strAdd(x1, x2)","Return element-wise string concatenation.",[14133,14134],{"_16":9227,"_22":10082,"_69":6},{"_16":9229,"_22":10084,"_69":6},[],{"_16":14137,"_18":14138,"_20":14139,"_22":14139,"_24":14140,"_28":9219,"_30":14142},"np.strCapitalize","np.strCapitalize(a)","Return element-wise copy with first character capitalized and rest lowercase.",[14141],{"_16":433,"_22":10656,"_69":6},[],{"_16":14144,"_18":14145,"_20":14146,"_22":14146,"_24":14147,"_28":9219,"_30":14151},"np.strCenter","np.strCenter(a, width, fillchar?)","Return element-wise centered string of given width.",[14148,14149,14150],{"_16":433,"_22":10656,"_69":6},{"_16":4981,"_22":12359,"_69":6},{"_16":12361,"_22":12362,"_69":11},[],{"_16":14153,"_18":14154,"_20":14155,"_22":14155,"_24":14156,"_28":9219,"_30":14162},"np.strCount","np.strCount(a, sub, start?, end?)","Return the number of non-overlapping occurrences of substring.",[14157,14158,14160,14161],{"_16":433,"_22":10656,"_69":6},{"_16":13720,"_22":14159,"_69":6},"- Substring to count",{"_16":9325,"_22":13723,"_69":11},{"_16":9328,"_22":13725,"_69":11},[],{"_16":14164,"_18":14165,"_20":14166,"_22":14166,"_24":14167,"_28":9219,"_30":14172},"np.strEqual","np.strEqual(x1, x2)","Return (x1 == x2) element-wise for string arrays.",[14168,14170],{"_16":9227,"_22":14169,"_69":6},"- First string array or JS string array",{"_16":9229,"_22":14171,"_69":6},"- Second string array or JS string array",[],{"_16":14174,"_18":14175,"_20":14176,"_22":14176,"_24":14177,"_28":9219,"_30":14182},"np.strFind","np.strFind(a, sub, start?, end?)","For each element, return the lowest index where substring is found.",[14178,14179,14180,14181],{"_16":433,"_22":10656,"_69":6},{"_16":13720,"_22":13721,"_69":6},{"_16":9325,"_22":13723,"_69":11},{"_16":9328,"_22":13725,"_69":11},[],{"_16":14184,"_18":14185,"_20":14186,"_22":14187,"_24":14188,"_28":9219,"_30":14191},"np.strGreater","np.strGreater(x1, x2)","Return (x1 > x2) element-wise for string arrays.\r","Return (x1 > x2) element-wise for string arrays.\r\nComparison is lexicographic.",[14189,14190],{"_16":9227,"_22":10082,"_69":6},{"_16":9229,"_22":10084,"_69":6},[],{"_16":14193,"_18":14194,"_20":14195,"_22":14196,"_24":14197,"_28":9219,"_30":14200},"np.strGreaterEqual","np.strGreaterEqual(x1, x2)","Return (x1 >= x2) element-wise for string arrays.\r","Return (x1 >= x2) element-wise for string arrays.\r\nComparison is lexicographic.",[14198,14199],{"_16":9227,"_22":10082,"_69":6},{"_16":9229,"_22":10084,"_69":6},[],{"_16":14202,"_18":14203,"_20":14204,"_22":14204,"_24":14205,"_28":9219,"_30":14210},"np.strIndex","np.strIndex(a, sub, start?, end?)","Like find, but raises ValueError if substring is not found.",[14206,14207,14208,14209],{"_16":433,"_22":10656,"_69":6},{"_16":13720,"_22":13721,"_69":6},{"_16":9325,"_22":13723,"_69":11},{"_16":9328,"_22":13725,"_69":11},[],{"_16":14212,"_18":14213,"_20":14214,"_22":14214,"_24":14215,"_28":9219,"_30":14218},"np.strip","np.strip(a, chars?)","Return element-wise copy with leading and trailing characters removed.",[14216,14217],{"_16":433,"_22":10656,"_69":6},{"_16":12505,"_22":12506,"_69":11},[],{"_16":14220,"_18":14221,"_20":14222,"_22":14223,"_24":14224,"_28":9219,"_30":14227},"np.strLess","np.strLess(x1, x2)","Return (x1 < x2) element-wise for string arrays.\r","Return (x1 < x2) element-wise for string arrays.\r\nComparison is lexicographic (dictionary order).",[14225,14226],{"_16":9227,"_22":10082,"_69":6},{"_16":9229,"_22":10084,"_69":6},[],{"_16":14229,"_18":14230,"_20":14231,"_22":14232,"_24":14233,"_28":9219,"_30":14236},"np.strLessEqual","np.strLessEqual(x1, x2)","Return (x1 <= x2) element-wise for string arrays.\r","Return (x1 <= x2) element-wise for string arrays.\r\nComparison is lexicographic.",[14234,14235],{"_16":9227,"_22":10082,"_69":6},{"_16":9229,"_22":10084,"_69":6},[],{"_16":14238,"_18":14239,"_20":14240,"_22":14241,"_24":14242,"_28":9219,"_30":14247},"np.strMod","np.strMod(a, values)","Return element-wise (a % i), i.e. string formatting.\r","Return element-wise (a % i), i.e. string formatting.\r\n\r\nThis is the printf-style string formatting operation.\r\nEach string in `a` is interpreted as a format string,\r\nand the corresponding values in `values` are substituted.",[14243,14245],{"_16":433,"_22":14244,"_69":6},"- Input format string array",{"_16":2320,"_22":14246,"_69":6},"- Values to substitute (array or single value)",[],{"_16":14249,"_18":14250,"_20":14251,"_22":14251,"_24":14252,"_28":9219,"_30":14256},"np.strMultiply","np.strMultiply(a, i)","Return element-wise (a * i), string repeated i times.",[14253,14254],{"_16":433,"_22":10656,"_69":6},{"_16":6743,"_22":14255,"_69":6},"- Number of repetitions (or array of repetition counts)",[],{"_16":14258,"_18":14259,"_20":14260,"_22":14260,"_24":14261,"_28":9219,"_30":14264},"np.strNotEqual","np.strNotEqual(x1, x2)","Return (x1 != x2) element-wise for string arrays.",[14262,14263],{"_16":9227,"_22":10082,"_69":6},{"_16":9229,"_22":10084,"_69":6},[],{"_16":14266,"_18":14267,"_20":14268,"_22":14268,"_24":14269,"_28":9219,"_30":14272},"np.strPartition","np.strPartition(a, sep)","Partition each element around the first occurrence of sep.",[14270,14271],{"_16":433,"_22":10656,"_69":6},{"_16":11083,"_22":13819,"_69":6},[],{"_16":14274,"_18":14275,"_20":14276,"_22":14276,"_24":14277,"_28":9219,"_30":14285},"np.strReplace","np.strReplace(a, old, new_, count?)","Return element-wise copy with occurrences of old replaced by new.",[14278,14279,14281,14283],{"_16":433,"_22":10656,"_69":6},{"_16":1222,"_22":14280,"_69":6},"- Substring to replace",{"_16":12532,"_22":14282,"_69":6},"- Replacement string",{"_16":11086,"_22":14284,"_69":11},"- Maximum replacements per element (-1 for all)",[],{"_16":14287,"_18":14288,"_20":14289,"_22":14290,"_24":14291,"_28":9219,"_30":14299},"np.strSlice","np.strSlice(a, start?, stop?, step?)","Return element-wise sliced strings.\r","Return element-wise sliced strings.\r\n\r\nThis is the NumPy 2.0 string slicing function, providing\r\nPython-style string slicing for each element.",[14292,14293,14295,14297],{"_16":433,"_22":10656,"_69":6},{"_16":9325,"_22":14294,"_69":11},"- Start index (default 0)",{"_16":11138,"_22":14296,"_69":11},"- Stop index (default: end of string)",{"_16":9331,"_22":14298,"_69":11},"- Step size (default 1)",[],{"_16":14301,"_18":14302,"_20":14303,"_22":14304,"_24":14305,"_28":9219,"_30":14307},"np.strTitle","np.strTitle(a)","Return element-wise titlecased version.\r","Return element-wise titlecased version.\r\nWords start with uppercase, remaining characters are lowercase.",[14306],{"_16":433,"_22":10656,"_69":6},[],{"_16":14309,"_18":14310,"_20":14311,"_22":14312,"_24":14313,"_28":9219,"_30":14321},"np.strTranslate","np.strTranslate(a, table, deletechars?)","Return element-wise translation of string using a translation table.\r","Return element-wise translation of string using a translation table.\r\n\r\nEach character in the string is mapped through the translation table.\r\nCharacters not in the table are left unchanged.",[14314,14315,14318],{"_16":433,"_22":10656,"_69":6},{"_16":14316,"_22":14317,"_69":6},"table","- Translation table as a Map, object, or string pairs",{"_16":14319,"_22":14320,"_69":11},"deletechars","- Characters to delete (optional)",[],{"_16":14323,"_18":14324,"_20":14325,"_22":14325,"_24":14326,"_28":5703,"_30":14328},"np.structDtypeSize","np.structDtypeSize(dtype)","Get byte size for a given dtype.",[14327],{"_16":9117,"_22":10067,"_69":6},[],{"_16":14330,"_18":14331,"_20":14332,"_22":14332,"_24":14333,"_28":9219,"_30":14336},"np.subtract","np.subtract(x1, x2)","Subtract arguments, element-wise.",[14334,14335],{"_16":9227,"_22":9219,"_69":6},{"_16":9229,"_22":9219,"_69":6},[],{"_16":14338,"_18":14339,"_20":14340,"_22":14340,"_24":14341,"_28":8919,"_30":14347},"np.sum","np.sum(a, axis?, keepdims?, dtype?)","Sum of array elements over a given axis.",[14342,14343,14345,14346],{"_16":433,"_22":8910,"_69":6},{"_16":2299,"_22":14344,"_69":11},"- Axis along which to sum. null sums all elements.",{"_16":9240,"_22":9393,"_69":11},{"_16":9117,"_22":12650,"_69":11},[],{"_16":14349,"_18":14350,"_20":14351,"_22":14351,"_24":14352,"_28":14358,"_30":14359},"np.svd","np.svd(a, fullMatrices?)","Singular Value Decomposition.",[14353,14355],{"_16":433,"_22":14354,"_69":6},"- Matrix to decompose (M x N)",{"_16":14356,"_22":14357,"_69":11},"fullMatrices","- If true, U and Vh have full shapes (M x M) and (N x N)\r\n If false, shapes are reduced (M x K) and (K x N)","Promise",[],{"_16":14361,"_18":14362,"_20":14363,"_22":14363,"_24":14364,"_28":9268,"_30":14366},"np.svdvals","np.svdvals(a)","Return singular values only.",[14365],{"_16":433,"_22":9219,"_69":6},[],{"_16":14368,"_18":14369,"_20":14370,"_22":14370,"_24":14371,"_28":9219,"_30":14377},"np.swapaxes","np.swapaxes(a, axis1, axis2)","Interchange two axes of an array.",[14372,14373,14375],{"_16":433,"_22":8910,"_69":6},{"_16":10442,"_22":14374,"_69":6},"- First axis",{"_16":10444,"_22":14376,"_69":6},"- Second axis",[],{"_16":14379,"_18":14380,"_20":14381,"_22":14381,"_24":14382,"_28":9219,"_30":14384},"np.swapcase","np.swapcase(a)","Return element-wise copy with uppercase and lowercase swapped.",[14383],{"_16":433,"_22":10656,"_69":6},[],{"_16":14386,"_18":14387,"_20":14388,"_22":14388,"_24":14389,"_28":9268,"_30":14396},"np.take","np.take(arr, indices, axis?, mode?)","Take elements from an array along an axis.",[14390,14391,14393,14395],{"_16":9285,"_22":10194,"_69":6},{"_16":9786,"_22":14392,"_69":6},"- Array of indices to take",{"_16":2299,"_22":14394,"_69":11},"- Axis along which to take (default: 0)",{"_16":2621,"_22":10033,"_69":11},[],{"_16":14398,"_18":14399,"_20":14400,"_22":14400,"_24":14401,"_28":9268,"_30":14406},"np.take_along_axis","np.take_along_axis(arr, indicesArr, axis)","Take values from the input array by matching 1d index and data slices.",[14402,14403,14404],{"_16":9285,"_22":10194,"_69":6},{"_16":13410,"_22":9219,"_69":6},{"_16":2299,"_22":14405,"_69":6},"- The axis to take along",[],{"_16":14408,"_18":14409,"_20":14410,"_22":14410,"_24":14411,"_28":9268,"_30":14416},"np.takeFlat","np.takeFlat(arr, indices, mode?)","Take elements from a flattened array.",[14412,14414,14415],{"_16":9285,"_22":14413,"_69":6},"- Source array (will be flattened conceptually)",{"_16":9786,"_22":13397,"_69":6},{"_16":2621,"_22":10033,"_69":11},[],{"_16":14418,"_18":14419,"_20":14420,"_22":14420,"_24":14421,"_28":9219,"_30":14423},"np.tan","np.tan(x)","Compute tangent element-wise.",[14422],{"_16":498,"_22":9219,"_69":6},[],{"_16":14425,"_18":14426,"_20":14427,"_22":14427,"_24":14428,"_28":9219,"_30":14430},"np.tanh","np.tanh(x)","Compute hyperbolic tangent element-wise.",[14429],{"_16":498,"_22":9219,"_69":6},[],{"_16":14432,"_18":14433,"_20":14434,"_22":14435,"_24":14436,"_28":9268,"_30":14443},"np.tensordot","np.tensordot(a, b, axes?)","Compute tensor dot product along specified axes.\r","Compute tensor dot product along specified axes.\r\n\r\nFor tensors a and b, tensordot(a, b, axes) computes the sum of products\r\nover the specified axes.",[14437,14439,14441],{"_16":433,"_22":14438,"_69":6},"- First tensor",{"_16":436,"_22":14440,"_69":6},"- Second tensor",{"_16":9316,"_22":14442,"_69":11},"- Axes to sum over:\r\n- number N: last N axes of a with first N axes of b\r\n- [axesA, axesB]: specific axes for each tensor",[],{"_16":14445,"_18":14446,"_20":14447,"_22":14448,"_24":14449,"_28":9268,"_30":14455},"np.tensorinv","np.tensorinv(a, ind?)","Compute the 'inverse' of an N-dimensional array.\r","Compute the 'inverse' of an N-dimensional array.\r\n\r\nThe result is an inverse for a with respect to the tensordot operation\r\ntensordot(a, b, ind).",[14450,14452],{"_16":433,"_22":14451,"_69":6},"- Tensor to pseudo-invert",{"_16":14453,"_22":14454,"_69":11},"ind","- Number of first indices that are involved in the inverse sum",[],{"_16":14457,"_18":14458,"_20":14459,"_22":14460,"_24":14461,"_28":9268,"_30":14468},"np.tensorsolve","np.tensorsolve(a, b, axes?)","Solve the tensor equation a x = b for x.\r","Solve the tensor equation a x = b for x.\r\n\r\nIt is assumed that all indices of x are summed over in the product,\r\ntogether with the rightmost indices of a.",[14462,14464,14466],{"_16":433,"_22":14463,"_69":6},"- Coefficient tensor",{"_16":436,"_22":14465,"_69":6},"- Right-hand side tensor",{"_16":9316,"_22":14467,"_69":11},"- Axes in a to reorder to the right, for the solve",[],{"_16":14470,"_18":14471,"_20":14472,"_22":14472,"_24":14473,"_28":9268,"_30":14478},"np.tile","np.tile(arr, reps)","Construct an array by repeating arr the number of times given by reps.",[14474,14475],{"_16":9285,"_22":8910,"_69":6},{"_16":14476,"_22":14477,"_69":6},"reps","- Number of repetitions along each axis",[],{"_16":14480,"_18":14481,"_20":14482,"_22":14482,"_24":14483,"_28":8077,"_30":14488},"np.trace","np.trace(a, offset?, axis1?, axis2?)","Return the sum along diagonals of the array.",[14484,14485,14486,14487],{"_16":433,"_22":9219,"_69":6},{"_16":7354,"_22":5703,"_69":11},{"_16":10442,"_22":5703,"_69":11},{"_16":10444,"_22":5703,"_69":11},[],{"_16":14490,"_18":14491,"_20":14492,"_22":14492,"_24":14493,"_28":9219,"_30":14496},"np.transpose","np.transpose(a, axes?)","Reverse or permute the axes of an array.",[14494,14495],{"_16":433,"_22":8910,"_69":6},{"_16":9316,"_22":13100,"_69":11},[],{"_16":14498,"_18":14499,"_20":14500,"_22":14501,"_24":14502,"_28":8919,"_30":14512},"np.trapezoid","np.trapezoid(y, x?, dx?, axis?)","Integrate along the given axis using the composite trapezoidal rule.\r","Integrate along the given axis using the composite trapezoidal rule.\r\n\r\nIf x is provided, the integration happens in sequence along its elements.\r\nOtherwise, the default sample distance of 1 is used.",[14503,14505,14507,14510],{"_16":501,"_22":14504,"_69":6},"- Array to be integrated",{"_16":498,"_22":14506,"_69":11},"- The sample points corresponding to y values. If null, dx is used.",{"_16":14508,"_22":14509,"_69":11},"dx","- Spacing between sample points when x is null. Default is 1.",{"_16":2299,"_22":14511,"_69":11},"- Axis along which to integrate",[],{"_16":14514,"_18":14515,"_20":14516,"_22":14516,"_24":14517,"_28":9268,"_30":14522},"np.tri","np.tri(N, M?, k?, options?)","Create a 2D array with ones at and below the given diagonal.",[14518,14519,14520,14521],{"_16":8785,"_22":4979,"_69":6},{"_16":1960,"_22":10749,"_69":11},{"_16":1114,"_22":10398,"_69":11},{"_16":4789,"_22":9448,"_69":11},[],{"_16":14524,"_18":14525,"_20":14526,"_22":14527,"_24":14528,"_28":9268,"_30":14532},"np.tril","np.tril(arr, k?)","Lower triangle of an array.\r","Lower triangle of an array.\r\n\r\nReturn a copy of an array with elements above the k-th diagonal zeroed.",[14529,14530],{"_16":9285,"_22":8910,"_69":6},{"_16":1114,"_22":14531,"_69":11},"- Diagonal above which to zero elements (default: 0)",[],{"_16":14534,"_18":14535,"_20":14536,"_22":14536,"_24":14537,"_28":12557,"_30":14542},"np.tril_indices","np.tril_indices(n, k?, m?)","Return the indices for the lower-triangle of an (n, m) array.",[14538,14539,14540],{"_16":362,"_22":4979,"_69":6},{"_16":1114,"_22":10751,"_69":11},{"_16":359,"_22":14541,"_69":11},"- Number of columns (default: n)",[],{"_16":14544,"_18":14545,"_20":14546,"_22":14547,"_24":14548,"_28":12557,"_30":14553},"np.tril_indices_from","np.tril_indices_from(arr, k?)","Return the indices for the lower-triangle of an (n, m) array.\r","Return the indices for the lower-triangle of an (n, m) array.\r\n\r\nThis is a specialized version that gets the shape from an input array.",[14549,14551],{"_16":9285,"_22":14550,"_69":6},"- Input array from which to get shape",{"_16":1114,"_22":14552,"_69":11},"- Diagonal offset (k=0 is main diagonal, k<0 is below, k>0 is above)",[],{"_16":14555,"_18":14556,"_20":14557,"_22":14557,"_24":14558,"_28":9219,"_30":14563},"np.trim_zeros","np.trim_zeros(arr, trim?)","Trim the leading and/or trailing zeros from a 1-D array.",[14559,14561],{"_16":9285,"_22":14560,"_69":6},"- Input 1-D array",{"_16":9522,"_22":14562,"_69":11},"- 'f' for front, 'b' for back, 'fb' for both (default: 'fb')",[],{"_16":14565,"_18":14566,"_20":14567,"_22":14568,"_24":14569,"_28":4712,"_30":14573},"np.trimcoef","np.trimcoef(c, tol?)","Remove small trailing coefficients.\r","Remove small trailing coefficients.\r\n\r\nTrailing elements with absolute value less than or equal to `tol` are removed.",[14570,14571],{"_16":2644,"_22":9852,"_69":6},{"_16":3719,"_22":14572,"_69":11},"- Tolerance for considering coefficients as zero (default: 0)",[],{"_16":14575,"_18":14576,"_20":14577,"_22":14577,"_24":14578,"_28":4712,"_30":14582},"np.trimseq","np.trimseq(seq)","Remove trailing zeros from a sequence.",[14579],{"_16":14580,"_22":14581,"_69":6},"seq","- Input sequence",[],{"_16":14584,"_18":14585,"_20":14586,"_22":14587,"_24":14588,"_28":9268,"_30":14592},"np.triu","np.triu(arr, k?)","Upper triangle of an array.\r","Upper triangle of an array.\r\n\r\nReturn a copy of an array with elements below the k-th diagonal zeroed.",[14589,14590],{"_16":9285,"_22":8910,"_69":6},{"_16":1114,"_22":14591,"_69":11},"- Diagonal below which to zero elements (default: 0)",[],{"_16":14594,"_18":14595,"_20":14596,"_22":14596,"_24":14597,"_28":12557,"_30":14601},"np.triu_indices","np.triu_indices(n, k?, m?)","Return the indices for the upper-triangle of an (n, m) array.",[14598,14599,14600],{"_16":362,"_22":4979,"_69":6},{"_16":1114,"_22":10751,"_69":11},{"_16":359,"_22":14541,"_69":11},[],{"_16":14603,"_18":14604,"_20":14605,"_22":14606,"_24":14607,"_28":12557,"_30":14610},"np.triu_indices_from","np.triu_indices_from(arr, k?)","Return the indices for the upper-triangle of an (n, m) array.\r","Return the indices for the upper-triangle of an (n, m) array.\r\n\r\nThis is a specialized version that gets the shape from an input array.",[14608,14609],{"_16":9285,"_22":14550,"_69":6},{"_16":1114,"_22":14552,"_69":11},[],{"_16":14612,"_18":14613,"_20":14614,"_22":14614,"_24":14615,"_28":9219,"_30":14617},"np.trunc","np.trunc(x)","Return the truncated value of the input, element-wise.",[14616],{"_16":498,"_22":9219,"_69":6},[],{"_16":14619,"_18":14620,"_20":14621,"_22":14621,"_24":14622,"_28":10067,"_30":14625},"np.typedArrayToDType","np.typedArrayToDType(arr)","Infer DType from a TypedArray.",[14623],{"_16":9285,"_22":14624,"_69":6},"- TypedArray instance",[],{"_16":14627,"_18":14628,"_20":14629,"_22":14630,"_24":14631,"_28":9268,"_30":14634},"np.union1d","np.union1d(ar1, ar2)","Find the union of two arrays.\r","Find the union of two arrays.\r\n\r\nReturns the sorted unique values that are in either of the input arrays.",[14632,14633],{"_16":11639,"_22":11715,"_69":6},{"_16":11642,"_22":11717,"_69":6},[],{"_16":14636,"_18":14637,"_20":14638,"_22":14638,"_24":14639,"_28":14642,"_30":14643},"np.unique","np.unique(arr, options?)","Find the unique elements of an array.",[14640,14641],{"_16":9285,"_22":11640,"_69":6},{"_16":4789,"_22":8790,"_69":11},"Promise",[],{"_16":14645,"_18":14646,"_20":14647,"_22":14647,"_24":14648,"_28":14650,"_30":14651},"np.uniqueAll","np.uniqueAll(arr)","Return unique values, indices, inverse, and counts.",[14649],{"_16":9285,"_22":8910,"_69":6},"Promise",[],{"_16":14653,"_18":14654,"_20":14655,"_22":14655,"_24":14656,"_28":14658,"_30":14659},"np.uniqueCounts","np.uniqueCounts(arr)","Return unique values and their counts.",[14657],{"_16":9285,"_22":8910,"_69":6},"Promise<{\r\n values: NDArray;\r\n counts: NDArray;\r\n}>",[],{"_16":14661,"_18":14662,"_20":14663,"_22":14663,"_24":14664,"_28":14666,"_30":14667},"np.uniqueIndex","np.uniqueIndex(arr)","Return unique values and indices of first occurrence.",[14665],{"_16":9285,"_22":8910,"_69":6},"Promise<{\r\n values: NDArray;\r\n indices: NDArray;\r\n}>",[],{"_16":14669,"_18":14670,"_20":14671,"_22":14671,"_24":14672,"_28":14674,"_30":14675},"np.uniqueInverse","np.uniqueInverse(arr)","Return unique values and indices to reconstruct original.",[14673],{"_16":9285,"_22":8910,"_69":6},"Promise<{\r\n values: NDArray;\r\n inverse: NDArray;\r\n}>",[],{"_16":14677,"_18":14678,"_20":14679,"_22":14679,"_24":14680,"_28":9268,"_30":14682},"np.uniqueValues","np.uniqueValues(arr)","Return only the unique values (simplified interface).",[14681],{"_16":9285,"_22":8910,"_69":6},[],{"_16":14684,"_18":14685,"_20":14686,"_22":14687,"_24":14688,"_28":9268,"_30":14697},"np.unpackbits","np.unpackbits(a, axis?, count?, bitorder?)","Unpack elements of a uint8 array into a binary array.\r","Unpack elements of a uint8 array into a binary array.\r\n\r\nEach element is unpacked into 8 bits (or fewer for the last element\r\nif count is specified).",[14689,14691,14693,14695],{"_16":433,"_22":14690,"_69":6},"- Input array of uint8 values",{"_16":2299,"_22":14692,"_69":11},"- The axis along which to unpack. If null, the input is flattened",{"_16":11086,"_22":14694,"_69":11},"- Number of bits to unpack from the last dimension. If null,\r\n all bits are unpacked. Negative count removes bits from the end.",{"_16":13042,"_22":14696,"_69":11},"- Order of bits in the packed representation. 'big' (default) means\r\n the highest bit is unpacked first; 'little' means the lowest\r\n bit is unpacked first",[],{"_16":14699,"_18":14700,"_20":14701,"_22":14701,"_24":14702,"_28":14705,"_30":14706},"np.unravelIndex","np.unravelIndex(indices, shape)","Convert a flat index into a tuple of coordinate arrays.",[14703,14704],{"_16":9786,"_22":13397,"_69":6},{"_16":8461,"_22":13530,"_69":6},"Promise",[],{"_16":14708,"_18":14709,"_20":14710,"_22":14711,"_24":14712,"_28":9493,"_30":14717},"np.unstack","np.unstack(arr, axis?)","Unpack the array along a given axis.\r","Unpack the array along a given axis.\r\nThe inverse of stack.",[14713,14715],{"_16":9285,"_22":14714,"_69":6},"- Array to unpack",{"_16":2299,"_22":14716,"_69":11},"- Axis along which to unpack (default: 0)",[],{"_16":14719,"_18":14720,"_20":14721,"_22":14722,"_24":14723,"_28":9268,"_30":14733},"np.unwrap","np.unwrap(p, discont?, axis?, period?)","Unwrap by taking the complement of large deltas with respect to the period.\r","Unwrap by taking the complement of large deltas with respect to the period.\r\n\r\nThis unwraps a signal by changing absolute jumps greater than discont to\r\ntheir 2*pi complement.",[14724,14725,14728,14730],{"_16":1645,"_22":8910,"_69":6},{"_16":14726,"_22":14727,"_69":11},"discont","- Maximum discontinuity between values, default is pi",{"_16":2299,"_22":14729,"_69":11},"- Axis along which to unwrap",{"_16":14731,"_22":14732,"_69":11},"period","- Size of the range over which the input wraps, default is 2*pi",[],{"_16":14735,"_18":14736,"_20":14737,"_22":14737,"_24":14738,"_28":9219,"_30":14740},"np.upper","np.upper(a)","Return element-wise copy with lowercase characters converted to uppercase.",[14739],{"_16":433,"_22":10656,"_69":6},[],{"_16":14742,"_18":14743,"_20":14744,"_22":14745,"_24":14746,"_28":9268,"_30":14755},"np.vander","np.vander(x, N?, increasing?, options?)","Generate a Vandermonde matrix.\r","Generate a Vandermonde matrix.\r\n\r\nThe columns of the output matrix are powers of the input vector.\r\nThe order of the powers is determined by the `increasing` parameter.",[14747,14749,14751,14754],{"_16":498,"_22":14748,"_69":6},"- 1D input array",{"_16":8785,"_22":14750,"_69":11},"- Number of columns (default: length of x)",{"_16":14752,"_22":14753,"_69":11},"increasing","- Order of powers (default: false, decreasing)",{"_16":4789,"_22":9448,"_69":11},[],{"_16":14757,"_18":14758,"_20":14759,"_22":14759,"_24":14760,"_28":8919,"_30":14768},"np.variance","np.variance(a, axis?, ddof?, keepdims?, dtype?)","Compute the variance along the specified axis.",[14761,14762,14764,14766,14767],{"_16":433,"_22":8910,"_69":6},{"_16":2299,"_22":14763,"_69":11},"- Axis along which to compute variance. null computes variance of all elements.",{"_16":10260,"_22":14765,"_69":11},"- Delta Degrees of Freedom. Divisor is N - ddof. Default: 0 (population variance)",{"_16":9240,"_22":9393,"_69":11},{"_16":9117,"_22":14119,"_69":11},[],{"_16":14770,"_18":14771,"_20":14772,"_22":14773,"_24":14774,"_28":8077,"_30":14777},"np.vdot","np.vdot(a, b)","Compute the dot product of two vectors (flattened inputs).\r","Compute the dot product of two vectors (flattened inputs).\r\nFor complex arrays, the first argument is conjugated.",[14775,14776],{"_16":433,"_22":9219,"_69":6},{"_16":436,"_22":9219,"_69":6},[],{"_16":14779,"_18":14780,"_20":14781,"_22":14782,"_24":14783,"_28":8919,"_30":14788},"np.vecdot","np.vecdot(x1, x2, axis?)","Compute the vector dot product of two arrays along the last axis.\r","Compute the vector dot product of two arrays along the last axis.\r\n\r\nNumPy 2.0 addition. For 1-D arrays, this is the same as dot.\r\nFor N-D arrays, sums the product of elements along the last axis.",[14784,14785,14786],{"_16":9227,"_22":11715,"_69":6},{"_16":9229,"_22":11717,"_69":6},{"_16":2299,"_22":14787,"_69":11},"- Axis along which to compute the dot product (default: -1)",[],{"_16":14790,"_18":14791,"_20":14792,"_22":14793,"_24":14794,"_28":9268,"_30":14798},"np.vecmat","np.vecmat(x1, x2)","Vector-matrix product.\r","Vector-matrix product.\r\n\r\nNumPy 2.0 addition. Computes the vector-matrix product of x1 and x2.\r\nEquivalent to matmul with 1D @ 2D broadcasting.",[14795,14797],{"_16":9227,"_22":14796,"_69":6},"- Vector (..., M)",{"_16":9229,"_22":12618,"_69":6},[],{"_16":14800,"_18":14801,"_20":14802,"_22":14802,"_24":14803,"_28":8919,"_30":14810},"np.vector_norm","np.vector_norm(x, ord?, axis?, keepdims?)","Compute the vector norm.",[14804,14805,14807,14809],{"_16":498,"_22":8910,"_69":6},{"_16":8409,"_22":14806,"_69":11},"- Order of the norm (default: 2, Euclidean)",{"_16":2299,"_22":14808,"_69":11},"- Axis along which to compute. null = flatten",{"_16":9240,"_22":12580,"_69":11},[],{"_16":14812,"_18":14813,"_20":14814,"_22":14814,"_24":14815,"_28":14821,"_30":14822},"np.vectorize","np.vectorize(pyfunc, options?)","Factory function for creating a Vectorize instance.",[14816,14819],{"_16":14817,"_22":14818,"_69":6},"pyfunc","- Function to vectorize",{"_16":4789,"_22":14820,"_69":11},"- Vectorization options","Vectorize",[],{"_16":14824,"_18":14825,"_20":14826,"_22":14826,"_24":14827,"_28":9493,"_30":14830},"np.vsplit","np.vsplit(arr, indices_or_sections)","Split an array into multiple sub-arrays vertically (row-wise).",[14828,14829],{"_16":9285,"_22":13799,"_69":6},{"_16":9489,"_22":9490,"_69":6},[],{"_16":14832,"_18":14833,"_20":14834,"_22":14835,"_24":14836,"_28":9219,"_30":14838},"np.vstack","np.vstack(tup)","Stack arrays in sequence vertically (row-wise).\r","Stack arrays in sequence vertically (row-wise).\r\nEquivalent to concatenation along the first axis after making 1-D arrays 2-D.",[14837],{"_16":10056,"_22":10516,"_69":6},[],{"_16":14840,"_18":14841,"_20":14842,"_22":14843,"_24":14844,"_28":9268,"_30":14851},"np.where","np.where(condition, x?, y?)","Return elements chosen from x or y depending on condition.\r","Return elements chosen from x or y depending on condition.\r\n\r\nIf x and y are provided, returns an array where elements are taken\r\nfrom x where condition is true, and from y where condition is false.\r\n\r\nIf only condition is provided, returns the indices where condition is true\r\n(equivalent to nonzero).",[14845,14847,14849],{"_16":10092,"_22":14846,"_69":6},"- Boolean condition array",{"_16":498,"_22":14848,"_69":11},"- Values where condition is true (optional)",{"_16":501,"_22":14850,"_69":11},"- Values where condition is false (optional)",[],{"_16":14853,"_18":14854,"_20":14855,"_22":14855,"_24":14856,"_28":14861,"_30":14862},"np.withPrintoptions","np.withPrintoptions(options, fn)","Execute a function with temporary print options.",[14857,14859],{"_16":4789,"_22":14858,"_69":6},"- Temporary print options",{"_16":4908,"_22":14860,"_69":6},"- Function to execute","T",[],{"_16":14864,"_18":14865,"_20":14866,"_22":14866,"_24":14867,"_28":9268,"_30":14870},"np.zeros","np.zeros(shape, options?)","Create a new NDArray filled with zeros.",[14868,14869],{"_16":8461,"_22":10638,"_69":6},{"_16":4789,"_22":9448,"_69":11},[],{"_16":14872,"_18":14873,"_20":14874,"_22":14874,"_24":14875,"_28":9268,"_30":14877},"np.zeros_like","np.zeros_like(a)","Create an array of zeros with the same shape and type as a given array.",[14876],{"_16":433,"_22":10647,"_69":6},[],{"_16":14879,"_18":14880,"_20":14881,"_22":14882,"_24":14883,"_28":9219,"_30":14886},"np.zfill","np.zfill(a, width)","Return element-wise numeric string left-padded with zeros.\r","Return element-wise numeric string left-padded with zeros.\r\nSign prefix is handled correctly.",[14884,14885],{"_16":433,"_22":10656,"_69":6},{"_16":4981,"_22":12359,"_69":6},[],{"_43":14888,"_16":14889,"_22":14890,"_47":48,"_49":14891,"_51":14892,"_52":14893},"ode-generated","ODE Solvers","ODE solvers from Hairer and Netlib, including dopri5, dop853, VODE, and more.","📈","ode",[14894,14902,14909,14915,14922,14928,14945,14956,14967,14978,14989,15000,15011,15022,15033,15044,15055,15066,15080,15091],{"_16":14895,"_18":14896,"_20":14897,"_22":5456,"_24":14898,"_28":1426,"_30":14901},"ode.core.configureODE","ode.core.configureODE(config)","configureODE",[14899],{"_16":8097,"_22":14900,"_69":6},"ODELoadConfig",[],{"_16":14903,"_18":14904,"_20":14905,"_22":5456,"_24":14906,"_28":14907,"_30":14908},"ode.core.getODEModule","ode.core.getODEModule()","getODEModule",[],"ODEModule",[],{"_16":14910,"_18":14911,"_20":14912,"_22":5456,"_24":14913,"_28":6903,"_30":14914},"ode.core.isODELoaded","ode.core.isODELoaded()","isODELoaded",[],[],{"_16":14916,"_18":14917,"_20":14918,"_22":5456,"_24":14919,"_28":14920,"_30":14921},"ode.core.loadODEModule","ode.core.loadODEModule()","loadODEModule",[],"Promise",[],{"_16":14923,"_18":14924,"_20":14925,"_22":5456,"_24":14926,"_28":1426,"_30":14927},"ode.core.resetODEModule","ode.core.resetODEModule()","resetODEModule",[],[],{"_16":14929,"_18":14930,"_20":14931,"_22":14932,"_24":14933,"_28":14943,"_30":14944},"ode.explicit.dop853","ode.explicit.dop853(fun, t_span, y0, options?)","Solve an ODE using the DOP853 method (Dormand-Prince 8(5,3)).\r","Solve an ODE using the DOP853 method (Dormand-Prince 8(5,3)).\r\n\r\nDOP853 is an explicit Runge-Kutta method of order 8 with embedded\r\nmethods of orders 5 and 3 for error estimation. More efficient than\r\nDOPRI5/RK45 when high accuracy is required.",[14934,14936,14939,14942],{"_16":8418,"_22":14935,"_69":6},"- ODE function: f(t, y) => dy/dt",{"_16":14937,"_22":14938,"_69":6},"t_span","- Time span [t0, tf]",{"_16":14940,"_22":14941,"_69":6},"y0","- Initial state vector",{"_16":4789,"_22":8287,"_69":11},"Promise",[],{"_16":14946,"_18":14947,"_20":14948,"_22":14949,"_24":14950,"_28":14943,"_30":14955},"ode.explicit.dopri5","ode.explicit.dopri5(fun, t_span, y0, options?)","Solve an ODE using the DOPRI5 method (Dormand-Prince 5(4)).\r","Solve an ODE using the DOPRI5 method (Dormand-Prince 5(4)).\r\n\r\nDOPRI5 is an explicit Runge-Kutta method of order 5 with an embedded\r\norder 4 method for error estimation. Equivalent to SciPy's RK45.",[14951,14952,14953,14954],{"_16":8418,"_22":14935,"_69":6},{"_16":14937,"_22":14938,"_69":6},{"_16":14940,"_22":14941,"_69":6},{"_16":4789,"_22":8287,"_69":11},[],{"_16":14957,"_18":14958,"_20":14959,"_22":14960,"_24":14961,"_28":14943,"_30":14966},"ode.explicit.dverk","ode.explicit.dverk(fun, t_span, y0, options?)","Solve an ODE using the DVERK method (Verner 6(5) RK).\r","Solve an ODE using the DVERK method (Verner 6(5) RK).\r\n\r\nDVERK is a higher-order explicit Runge-Kutta method with 6th order\r\naccuracy and 5th order error estimation. More efficient than RKF45\r\nfor problems requiring higher accuracy.",[14962,14963,14964,14965],{"_16":8418,"_22":14935,"_69":6},{"_16":14937,"_22":14938,"_69":6},{"_16":14940,"_22":14941,"_69":6},{"_16":4789,"_22":8287,"_69":11},[],{"_16":14968,"_18":14969,"_20":14970,"_22":14971,"_24":14972,"_28":14943,"_30":14977},"ode.explicit.ode_abm","ode.explicit.ode_abm(fun, t_span, y0, options?)","Solve an ODE using the Adams-Bashforth-Moulton method.\r","Solve an ODE using the Adams-Bashforth-Moulton method.\r\n\r\nThis is a multistep predictor-corrector method. More efficient than\r\nsingle-step methods for smooth problems because it reuses previous\r\nfunction evaluations.",[14973,14974,14975,14976],{"_16":8418,"_22":14935,"_69":6},{"_16":14937,"_22":14938,"_69":6},{"_16":14940,"_22":14941,"_69":6},{"_16":4789,"_22":8287,"_69":11},[],{"_16":14979,"_18":14980,"_20":14981,"_22":14982,"_24":14983,"_28":14943,"_30":14988},"ode.explicit.odex","ode.explicit.odex(fun, t_span, y0, options?)","Solve an ODE using the ODEX method (GBS Extrapolation).\r","Solve an ODE using the ODEX method (GBS Extrapolation).\r\n\r\nODEX is a GBS extrapolation method based on the explicit midpoint rule.\r\nIt features automatic order selection (up to very high orders) and is\r\nhighly efficient for smooth problems requiring high accuracy.",[14984,14985,14986,14987],{"_16":8418,"_22":14935,"_69":6},{"_16":14937,"_22":14938,"_69":6},{"_16":14940,"_22":14941,"_69":6},{"_16":4789,"_22":8287,"_69":11},[],{"_16":14990,"_18":14991,"_20":14992,"_22":14993,"_24":14994,"_28":14943,"_30":14999},"ode.explicit.rkf45","ode.explicit.rkf45(fun, t_span, y0, options?)","Solve an ODE using the RKF45 method (Runge-Kutta-Fehlberg 4(5)).\r","Solve an ODE using the RKF45 method (Runge-Kutta-Fehlberg 4(5)).\r\n\r\nRKF45 is a classic explicit Runge-Kutta method with embedded error\r\nestimation. Similar to DOPRI5 but with a different embedded pair.",[14995,14996,14997,14998],{"_16":8418,"_22":14935,"_69":6},{"_16":14937,"_22":14938,"_69":6},{"_16":14940,"_22":14941,"_69":6},{"_16":4789,"_22":8287,"_69":11},[],{"_16":15001,"_18":15002,"_20":15003,"_22":15004,"_24":15005,"_28":14943,"_30":15010},"ode.explicit.rksuite","ode.explicit.rksuite(fun, t_span, y0, options?)","Solve an ODE using RKSUITE.\r","Solve an ODE using RKSUITE.\r\n\r\nRKSUITE is a well-tested suite of Runge-Kutta methods with three\r\npairs available: (2,3), (4,5), and (7,8). It includes sophisticated\r\nerror control and optional global error assessment.",[15006,15007,15008,15009],{"_16":8418,"_22":14935,"_69":6},{"_16":14937,"_22":14938,"_69":6},{"_16":14940,"_22":14941,"_69":6},{"_16":4789,"_22":8287,"_69":11},[],{"_16":15012,"_18":15013,"_20":15014,"_22":15015,"_24":15016,"_28":14943,"_30":15021},"ode.implicit.radau","ode.implicit.radau(fun, t_span, y0, options?)","Solve an ODE using the RADAU method (Variable Order Radau IIA).\r","Solve an ODE using the RADAU method (Variable Order Radau IIA).\r\n\r\nRADAU is a variable order implicit Runge-Kutta method based on Radau IIA\r\nnodes. It can use orders 5, 9, or 13 (corresponding to 3, 5, or 7 stages)\r\nand automatically selects the optimal order during integration.",[15017,15018,15019,15020],{"_16":8418,"_22":14935,"_69":6},{"_16":14937,"_22":14938,"_69":6},{"_16":14940,"_22":14941,"_69":6},{"_16":4789,"_22":8287,"_69":11},[],{"_16":15023,"_18":15024,"_20":15025,"_22":15026,"_24":15027,"_28":14943,"_30":15032},"ode.implicit.radau5","ode.implicit.radau5(fun, t_span, y0, options?)","Solve an ODE using the RADAU5 method (Implicit Radau IIA order 5).\r","Solve an ODE using the RADAU5 method (Implicit Radau IIA order 5).\r\n\r\nRADAU5 is an implicit Runge-Kutta method suitable for stiff systems.\r\nUses Newton iteration with LU decomposition. Providing an analytical\r\nJacobian improves performance.",[15028,15029,15030,15031],{"_16":8418,"_22":14935,"_69":6},{"_16":14937,"_22":14938,"_69":6},{"_16":14940,"_22":14941,"_69":6},{"_16":4789,"_22":8287,"_69":11},[],{"_16":15034,"_18":15035,"_20":15036,"_22":15037,"_24":15038,"_28":14943,"_30":15043},"ode.implicit.rodas","ode.implicit.rodas(fun, t_span, y0, options?)","Solve an ODE using the RODAS method (Rosenbrock order 3(4)).\r","Solve an ODE using the RODAS method (Rosenbrock order 3(4)).\r\n\r\nRODAS is a Rosenbrock method suitable for stiff systems where Newton\r\niteration is not desired. It uses direct linear algebra (LU decomposition)\r\nrather than iterative solvers.",[15039,15040,15041,15042],{"_16":8418,"_22":14935,"_69":6},{"_16":14937,"_22":14938,"_69":6},{"_16":14940,"_22":14941,"_69":6},{"_16":4789,"_22":8287,"_69":11},[],{"_16":15045,"_18":15046,"_20":15047,"_22":15048,"_24":15049,"_28":14943,"_30":15054},"ode.implicit.vode","ode.implicit.vode(fun, t_span, y0, options?)","Solve an ODE using VODE (Variable-coefficient ODE solver).\r","Solve an ODE using VODE (Variable-coefficient ODE solver).\r\n\r\nVODE is the most versatile solver in the ODEPACK family. It automatically\r\nselects between Adams methods (for non-stiff problems) and BDF methods\r\n(for stiff problems) based on the mf parameter.",[15050,15051,15052,15053],{"_16":8418,"_22":14935,"_69":6},{"_16":14937,"_22":14938,"_69":6},{"_16":14940,"_22":14941,"_69":6},{"_16":4789,"_22":8287,"_69":11},[],{"_16":15056,"_18":15057,"_20":15058,"_22":15059,"_24":15060,"_28":14943,"_30":15065},"ode.implicit.vodpk","ode.implicit.vodpk(fun, t_span, y0, options?)","Solve an ODE using VODPK (VODE with Krylov methods).\r","Solve an ODE using VODPK (VODE with Krylov methods).\r\n\r\nVODPK is designed for large stiff systems where a full Jacobian would\r\nbe too expensive to compute and store. It uses GMRES with optional\r\npreconditioning.",[15061,15062,15063,15064],{"_16":8418,"_22":14935,"_69":6},{"_16":14937,"_22":14938,"_69":6},{"_16":14940,"_22":14941,"_69":6},{"_16":4789,"_22":8287,"_69":11},[],{"_16":15067,"_18":15068,"_20":15069,"_22":15070,"_24":15071,"_28":15078,"_30":15079},"ode.implicit.zvode","ode.implicit.zvode(fun, t_span, y0, options?)","Solve a complex-valued ODE using ZVODE.\r","Solve a complex-valued ODE using ZVODE.\r\n\r\nZVODE handles ODEs where both the state and derivatives are complex.\r\nThis is common in quantum mechanics and wave physics.",[15072,15074,15075,15077],{"_16":8418,"_22":15073,"_69":6},"- Complex ODE function: f(t, y) => dy/dt",{"_16":14937,"_22":14938,"_69":6},{"_16":14940,"_22":15076,"_69":6},"- Initial state vector (complex)",{"_16":4789,"_22":8287,"_69":11},"Promise",[],{"_16":15081,"_18":15082,"_20":15083,"_22":15084,"_24":15085,"_28":14943,"_30":15090},"ode.rkc","ode.rkc(fun, t_span, y0, options?)","Solve an ODE using RKC (Runge-Kutta-Chebyshev).\r","Solve an ODE using RKC (Runge-Kutta-Chebyshev).\r\n\r\nRKC is designed for mildly stiff problems arising from spatial\r\ndiscretization of parabolic PDEs (e.g., heat equation, diffusion).\r\nIt is explicit but uses a variable number of stages to achieve\r\nstability for larger step sizes.",[15086,15087,15088,15089],{"_16":8418,"_22":14935,"_69":6},{"_16":14937,"_22":14938,"_69":6},{"_16":14940,"_22":14941,"_69":6},{"_16":4789,"_22":8287,"_69":11},[],{"_16":15092,"_18":15093,"_20":15094,"_22":15095,"_24":15096,"_28":15101,"_30":15102},"ode.solve_ivp","ode.solve_ivp(fun, t_span, y0, options?)","Solve an initial value problem for a system of ODEs.\r","Solve an initial value problem for a system of ODEs.\r\n\r\nIntegrates a system of ordinary differential equations:\r\n dy/dt = f(t, y)\r\n y(t0) = y0",[15097,15098,15099,15100],{"_16":8418,"_22":14935,"_69":6},{"_16":14937,"_22":14938,"_69":6},{"_16":14940,"_22":14941,"_69":6},{"_16":4789,"_22":8287,"_69":11},"Promise",[],{"_43":15104,"_16":15105,"_22":15106,"_47":48,"_49":3790,"_51":3793,"_52":15107},"sym-generated","Symbolic Math (SymEngine)","Symbolic mathematics library based on SymEngine.",[15108,15121,15137,15148,15163,15169,15175,15184,15193,15202,15211,15220,15229,15238,15248,15257,15267,15275,15284,15292,15301,15310,15321,15330,15341,15351,15359,15368,15377,15385,15398,15409,15415,15424,15434,15443,15452,15460,15469,15477,15485,15496,15505,15516,15524,15532,15542,15552,15558,15566,15574,15583,15591,15600,15608,15617,15628,15636,15645,15655,15663,15672,15680,15691,15701,15713,15723,15732,15740,15746,15754,15764,15780,15788,15795,15803,15811,15818,15825,15832,15839,15849,15859,15866,15873,15881,15888,15896,15904,15911,15918,15930,15941,15955,15967,15975,15984,15998,16005,16014,16022,16033,16041,16049,16058,16067,16077,16086,16098,16106,16116,16124,16132,16140,16148,16156,16165,16173,16184,16195,16205,16214,16222,16230,16239,16247,16255,16261,16270,16276,16285,16293,16301,16309,16317,16326,16336,16344,16352,16363,16374,16384,16394,16402,16410,16418,16431,16439,16447,16456,16464,16472,16480,16488,16496,16504,16510,16520,16528],{"_16":15109,"_18":15110,"_20":15111,"_22":15112,"_24":15113,"_28":15119,"_30":15120},"sym.assumptions.refine","sym.assumptions.refine(expr, assumptions)","Simplifies an expression using the given assumptions.\r","Simplifies an expression using the given assumptions.\r\n\r\nThe `refine` function applies simplification rules that are valid\r\nunder the given assumptions. For example:\r\n\r\n- `abs(x)` → `x` when x is positive\r\n- `sqrt(x^2)` → `x` when x is positive\r\n- `floor(n)` → `n` when n is an integer\r\n- `sign(x)` → `1` when x is positive",[15114,15117],{"_16":15115,"_22":15116,"_69":6},"expr","- The expression to refine.",{"_16":3973,"_22":15118,"_69":6},"- The assumptions to apply.","Expr",[],{"_16":15122,"_18":15123,"_20":15124,"_22":15125,"_24":15126,"_28":15135,"_30":15136},"sym.assumptions.ask","sym.assumptions.ask(query, symbol, assumptions?)","Asks a query about a symbol under the given assumptions.\r","Asks a query about a symbol under the given assumptions.\r\n\r\nThis is a convenience function that dispatches to the appropriate\r\nquery method based on the query name or function.\r\n\r\nFor numbers (Integer, Rational, RealDouble), intrinsic properties\r\ncan be queried without assumptions.",[15127,15130,15133],{"_16":15128,"_22":15129,"_69":6},"query","- The query function (e.g., Q.positive) or name (e.g., 'positive').",{"_16":15131,"_22":15132,"_69":6},"symbol","- The symbol or expression to query.",{"_16":3973,"_22":15134,"_69":11},"- Optional assumptions to use. If not provided, uses empty assumptions.","Tribool",[],{"_16":15138,"_18":15139,"_20":15140,"_22":15141,"_24":15142,"_28":15119,"_30":15147},"sym.calculus.diff","sym.calculus.diff(expr, args)","Computes the derivative of a symbolic expression.\r","Computes the derivative of a symbolic expression.\r\n\r\nPerforms symbolic differentiation with support for multiple variables\r\nand higher-order derivatives. The function handles various calling\r\nconventions to express different types of derivatives.",[15143,15145],{"_16":15115,"_22":15144,"_69":6},"- The expression to differentiate.",{"_16":9142,"_22":15146,"_69":6},"- Symbols and optional derivative orders in alternating pattern.",[],{"_16":15149,"_18":15150,"_20":15151,"_22":15152,"_24":15153,"_28":15119,"_30":15162},"sym.calculus.series","sym.calculus.series(expr, x, x0?, n?)","Computes the Taylor series expansion of an expression around a point.\r","Computes the Taylor series expansion of an expression around a point.\r\n\r\nExpands a symbolic expression as a polynomial approximation using its\r\nTaylor series. Currently supports expansion around x = 0 (Maclaurin series).",[15154,15156,15158,15160],{"_16":15115,"_22":15155,"_69":6},"- The expression to expand.",{"_16":498,"_22":15157,"_69":6},"- The expansion variable (symbol).",{"_16":8421,"_22":15159,"_69":11},"- The expansion point (currently only 0 is supported).",{"_16":362,"_22":15161,"_69":11},"- Number of terms in the series (precision parameter, default 6).",[],{"_16":15164,"_18":15165,"_20":15166,"_22":15166,"_24":15167,"_28":15119,"_30":15168},"sym.logic.BoolTrue","sym.logic.BoolTrue()","Creates the boolean constant True.",[],[],{"_16":15170,"_18":15171,"_20":15172,"_22":15172,"_24":15173,"_28":15119,"_30":15174},"sym.logic.BoolFalse","sym.logic.BoolFalse()","Creates the boolean constant False.",[],[],{"_16":15176,"_18":15177,"_20":15178,"_22":15179,"_24":15180,"_28":15119,"_30":15183},"sym.abs","sym.abs(x)","symngwasm - SymEngine-based symbolic mathematics in TypeScript with WebAssembly.\r","symngwasm - SymEngine-based symbolic mathematics in TypeScript with WebAssembly.\r\n\r\nA comprehensive symbolic computation library built on SymEngine (C++ library)\r\ncompiled to WebAssembly. Provides capabilities for symbolic algebra, calculus,\r\nequation solving, matrix operations, and expression manipulation.",[15181],{"_16":498,"_22":15182,"_69":6},"- The expression to take the absolute value of.",[],{"_16":15185,"_18":15186,"_20":15187,"_22":15188,"_24":15189,"_28":15119,"_30":15192},"sym.acos","sym.acos(x)","Computes the arccosine (inverse cosine) of a symbolic expression.\r","Computes the arccosine (inverse cosine) of a symbolic expression.\r\n\r\nReturns the angle whose cosine is x. The principal value is in [0, π].",[15190],{"_16":498,"_22":15191,"_69":6},"- The value (in the range [-1, 1] for real results).",[],{"_16":15194,"_18":15195,"_20":15196,"_22":15197,"_24":15198,"_28":15119,"_30":15201},"sym.acosh","sym.acosh(x)","Computes the inverse hyperbolic cosine of a symbolic expression.\r","Computes the inverse hyperbolic cosine of a symbolic expression.\r\n\r\nReturns the non-negative value y such that cosh(y) = x.\r\nAlso known as the area hyperbolic cosine: acosh(x) = ln(x + √(x² - 1)).",[15199],{"_16":498,"_22":15200,"_69":6},"- The argument (x ≥ 1 for real results).",[],{"_16":15203,"_18":15204,"_20":15205,"_22":15206,"_24":15207,"_28":15119,"_30":15210},"sym.acot","sym.acot(x)","Computes the arc-cotangent (inverse cotangent) of a symbolic expression.\r","Computes the arc-cotangent (inverse cotangent) of a symbolic expression.\r\n\r\nReturns the angle whose cotangent is x. The principal value is in (0, π).",[15208],{"_16":498,"_22":15209,"_69":6},"- The value (can be any real number except 0).",[],{"_16":15212,"_18":15213,"_20":15214,"_22":15215,"_24":15216,"_28":15119,"_30":15219},"sym.acoth","sym.acoth(x)","Computes the inverse hyperbolic cotangent of a symbolic expression.\r","Computes the inverse hyperbolic cotangent of a symbolic expression.\r\n\r\nReturns the value y such that coth(y) = x.\r\nAlso known as the area hyperbolic cotangent: acoth(x) = (1/2) * ln((x+1)/(x-1)).",[15217],{"_16":498,"_22":15218,"_69":6},"- The argument (|x| > 1 for real results).",[],{"_16":15221,"_18":15222,"_20":15223,"_22":15224,"_24":15225,"_28":15119,"_30":15228},"sym.acsc","sym.acsc(x)","Computes the arc-cosecant (inverse cosecant) of a symbolic expression.\r","Computes the arc-cosecant (inverse cosecant) of a symbolic expression.\r\n\r\nReturns the angle whose cosecant is x. The principal value is in [-π/2, π/2], excluding 0.",[15226],{"_16":498,"_22":15227,"_69":6},"- The value (|x| ≥ 1 for real results).",[],{"_16":15230,"_18":15231,"_20":15232,"_22":15233,"_24":15234,"_28":15119,"_30":15237},"sym.acsch","sym.acsch(x)","Computes the inverse hyperbolic cosecant of a symbolic expression.\r","Computes the inverse hyperbolic cosecant of a symbolic expression.\r\n\r\nReturns the value y such that csch(y) = x.\r\nAlso known as the area hyperbolic cosecant: acsch(x) = ln((1 + √(1+x²))/x) for x > 0.",[15235],{"_16":498,"_22":15236,"_69":6},"- The argument (x ≠ 0 for real results).",[],{"_16":15239,"_18":15240,"_20":15241,"_22":15241,"_24":15242,"_28":15119,"_30":15247},"sym.add","sym.add(a, b)","Add two expressions: a + b",[15243,15245],{"_16":433,"_22":15244,"_69":6},"First operand",{"_16":436,"_22":15246,"_69":6},"Second operand",[],{"_16":15249,"_18":15250,"_20":15251,"_22":15252,"_24":15253,"_28":15119,"_30":15256},"sym.arg","sym.arg(x)","Computes the argument (phase angle) of a complex expression.\r","Computes the argument (phase angle) of a complex expression.\r\n\r\nFor a complex number z = a + bi, arg(z) = atan2(b, a), which gives\r\nthe angle θ in the polar form z = r * e^(iθ). The result is in radians,\r\nranging from -π to π.",[15254],{"_16":498,"_22":15255,"_69":6},"- The complex expression to compute the argument of.",[],{"_16":15258,"_18":15259,"_20":15260,"_22":15261,"_24":15262,"_28":15265,"_30":15266},"sym.as_real_imag","sym.as_real_imag(expr)","Extracts the real and imaginary parts of a complex expression.\r","Extracts the real and imaginary parts of a complex expression.\r\n\r\nSeparates a complex expression into its real and imaginary components,\r\nreturning both as separate expressions.",[15263],{"_16":15115,"_22":15264,"_69":6},"- The complex expression to decompose.","{\r\n real: Expr;\r\n imag: Expr;\r\n}",[],{"_16":15268,"_18":15269,"_20":15270,"_22":15271,"_24":15272,"_28":15119,"_30":15274},"sym.asec","sym.asec(x)","Computes the arc-secant (inverse secant) of a symbolic expression.\r","Computes the arc-secant (inverse secant) of a symbolic expression.\r\n\r\nReturns the angle whose secant is x. The principal value is in [0, π], excluding π/2.",[15273],{"_16":498,"_22":15227,"_69":6},[],{"_16":15276,"_18":15277,"_20":15278,"_22":15279,"_24":15280,"_28":15119,"_30":15283},"sym.asech","sym.asech(x)","Computes the inverse hyperbolic secant of a symbolic expression.\r","Computes the inverse hyperbolic secant of a symbolic expression.\r\n\r\nReturns the non-negative value y such that sech(y) = x.\r\nAlso known as the area hyperbolic secant: asech(x) = ln((1 + √(1-x²))/x).",[15281],{"_16":498,"_22":15282,"_69":6},"- The argument (0 < x ≤ 1 for real results).",[],{"_16":15285,"_18":15286,"_20":15287,"_22":15288,"_24":15289,"_28":15119,"_30":15291},"sym.asin","sym.asin(x)","Computes the arcsine (inverse sine) of a symbolic expression.\r","Computes the arcsine (inverse sine) of a symbolic expression.\r\n\r\nReturns the angle whose sine is x. The principal value is in [-π/2, π/2].",[15290],{"_16":498,"_22":15191,"_69":6},[],{"_16":15293,"_18":15294,"_20":15295,"_22":15296,"_24":15297,"_28":15119,"_30":15300},"sym.asinh","sym.asinh(x)","Computes the inverse hyperbolic sine of a symbolic expression.\r","Computes the inverse hyperbolic sine of a symbolic expression.\r\n\r\nReturns the value y such that sinh(y) = x.\r\nAlso known as the area hyperbolic sine: asinh(x) = ln(x + √(x² + 1)).",[15298],{"_16":498,"_22":15299,"_69":6},"- The argument (can be any real number).",[],{"_16":15302,"_18":15303,"_20":15304,"_22":15305,"_24":15306,"_28":15119,"_30":15309},"sym.atan","sym.atan(x)","Computes the arctangent (inverse tangent) of a symbolic expression.\r","Computes the arctangent (inverse tangent) of a symbolic expression.\r\n\r\nReturns the angle whose tangent is x. The principal value is in (-π/2, π/2).",[15307],{"_16":498,"_22":15308,"_69":6},"- The value (can be any real number).",[],{"_16":15311,"_18":15312,"_20":15313,"_22":15314,"_24":15315,"_28":15119,"_30":15320},"sym.atan2","sym.atan2(y, x)","Computes the two-argument arctangent of symbolic expressions.\r","Computes the two-argument arctangent of symbolic expressions.\r\n\r\nReturns the angle θ in (-π, π] such that (cos(θ), sin(θ)) is proportional to (x, y).\r\nThis is the angle of the vector (x, y) from the positive x-axis, correctly handling\r\nall four quadrants.",[15316,15318],{"_16":501,"_22":15317,"_69":6},"- The y-coordinate (opposite side / numerator in y/x).",{"_16":498,"_22":15319,"_69":6},"- The x-coordinate (adjacent side / denominator in y/x).",[],{"_16":15322,"_18":15323,"_20":15324,"_22":15325,"_24":15326,"_28":15119,"_30":15329},"sym.atanh","sym.atanh(x)","Computes the inverse hyperbolic tangent of a symbolic expression.\r","Computes the inverse hyperbolic tangent of a symbolic expression.\r\n\r\nReturns the value y such that tanh(y) = x.\r\nAlso known as the area hyperbolic tangent: atanh(x) = (1/2) * ln((1+x)/(1-x)).",[15327],{"_16":498,"_22":15328,"_69":6},"- The argument (-1 < x < 1 for real results).",[],{"_16":15331,"_18":15332,"_20":15333,"_22":15334,"_24":15335,"_28":15119,"_30":15340},"sym.beta","sym.beta(a, b)","Computes the beta function of symbolic expressions.\r","Computes the beta function of symbolic expressions.\r\n\r\nThe beta function B(a, b) is defined as the integral of t^(a-1)(1-t)^(b-1) from 0 to 1,\r\nand can be expressed in terms of the gamma function as B(a, b) = Γ(a)Γ(b)/Γ(a+b).",[15336,15338],{"_16":433,"_22":15337,"_69":6},"- The first parameter (as a symbolic expression).",{"_16":436,"_22":15339,"_69":6},"- The second parameter (as a symbolic expression).",[],{"_16":15342,"_18":15343,"_20":15344,"_22":15344,"_24":15345,"_28":15119,"_30":15350},"sym.binomial","sym.binomial(n, k)","Computes the binomial coefficient C(n, k) = n! / (k! * (n-k)!).",[15346,15348],{"_16":362,"_22":15347,"_69":6},"- The total number of items.",{"_16":1114,"_22":15349,"_69":6},"- The number of items to choose.",[],{"_16":15352,"_18":15353,"_20":15354,"_22":15354,"_24":15355,"_28":15119,"_30":15358},"sym.boundary","sym.boundary(set)","Computes the boundary of a set.",[15356],{"_16":2592,"_22":15357,"_69":6},"- The set to find the boundary of.",[],{"_16":15360,"_18":15361,"_20":15362,"_22":15363,"_24":15364,"_28":15119,"_30":15367},"sym.cbrt","sym.cbrt(x)","Computes the cube root of a symbolic expression.\r","Computes the cube root of a symbolic expression.\r\n\r\nReturns the real cube root of x. Unlike square root, the cube root\r\nof a negative number is a negative real number. Equivalent to pow(x, 1/3).",[15365],{"_16":498,"_22":15366,"_69":6},"- The radicand (as a symbolic expression).",[],{"_16":15369,"_18":15370,"_20":15371,"_22":15372,"_24":15373,"_28":15119,"_30":15376},"sym.ceiling","sym.ceiling(x)","Computes the ceiling function of a symbolic expression.\r","Computes the ceiling function of a symbolic expression.\r\n\r\nReturns the smallest integer greater than or equal to x, denoted ⌈x⌉.\r\nAlso known as the least integer function.",[15374],{"_16":498,"_22":15375,"_69":6},"- The expression to compute the ceiling of.",[],{"_16":15378,"_18":15379,"_20":15380,"_22":15380,"_24":15381,"_28":15119,"_30":15384},"sym.closure","sym.closure(set)","Computes the closure of a set.",[15382],{"_16":2592,"_22":15383,"_69":6},"- The set to find the closure of.",[],{"_16":15386,"_18":15387,"_20":15388,"_22":15389,"_24":15390,"_28":15119,"_30":15397},"sym.coeff","sym.coeff(expr, x, n)","Extract the coefficient of x^n from an expression.\r","Extract the coefficient of x^n from an expression.\r\n\r\nFor a polynomial expression, returns the coefficient of the term x^n.\r\nIf n is 0, returns the constant term.",[15391,15393,15395],{"_16":15115,"_22":15392,"_69":6},"- The expression to extract the coefficient from.",{"_16":498,"_22":15394,"_69":6},"- The variable to extract the coefficient of.",{"_16":362,"_22":15396,"_69":6},"- The power of x (as an expression, typically an Integer).",[],{"_16":15399,"_18":15400,"_20":15401,"_22":15401,"_24":15402,"_28":15119,"_30":15408},"sym.complement","sym.complement(a, universe)","Computes the complement of a set relative to another set.",[15403,15405],{"_16":433,"_22":15404,"_69":6},"- The set to complement.",{"_16":15406,"_22":15407,"_69":6},"universe","- The universe set (defaults to Reals if not specified).",[],{"_16":15410,"_18":15411,"_20":15412,"_22":15412,"_24":15413,"_28":15119,"_30":15414},"sym.Complexes","sym.Complexes()","Creates the set of complex numbers ℂ.",[],[],{"_16":15416,"_18":15417,"_20":15418,"_22":15419,"_24":15420,"_28":15119,"_30":15423},"sym.conjugate","sym.conjugate(x)","Computes the complex conjugate of an expression.\r","Computes the complex conjugate of an expression.\r\n\r\nFor a complex number z = a + bi, the conjugate is z* = a - bi.\r\nThis function works symbolically, so it can handle expressions\r\ncontaining symbolic variables.",[15421],{"_16":498,"_22":15422,"_69":6},"- The expression to conjugate.",[],{"_16":15425,"_18":15426,"_20":15427,"_22":15427,"_24":15428,"_28":15119,"_30":15433},"sym.contains","sym.contains(set, element)","Checks if an element is contained in a set.",[15429,15431],{"_16":2592,"_22":15430,"_69":6},"- The set to check.",{"_16":11966,"_22":15432,"_69":6},"- The element to check for.",[],{"_16":15435,"_18":15436,"_20":15437,"_22":15438,"_24":15439,"_28":15119,"_30":15442},"sym.cos","sym.cos(x)","Computes the cosine of a symbolic expression.\r","Computes the cosine of a symbolic expression.\r\n\r\nThe cosine function returns the ratio of the adjacent side to the hypotenuse\r\nin a right triangle. For symbolic expressions, it creates a symbolic cos(x)\r\nthat can be manipulated algebraically.",[15440],{"_16":498,"_22":15441,"_69":6},"- The angle in radians (as a symbolic expression).",[],{"_16":15444,"_18":15445,"_20":15446,"_22":15447,"_24":15448,"_28":15119,"_30":15451},"sym.cosh","sym.cosh(x)","Computes the hyperbolic cosine of a symbolic expression.\r","Computes the hyperbolic cosine of a symbolic expression.\r\n\r\nThe hyperbolic cosine is defined as cosh(x) = (e^x + e^(-x)) / 2.\r\nIt represents the x-coordinate of a point on the unit hyperbola,\r\nand also describes the shape of a hanging chain (catenary).",[15449],{"_16":498,"_22":15450,"_69":6},"- The argument (as a symbolic expression).",[],{"_16":15453,"_18":15454,"_20":15455,"_22":15456,"_24":15457,"_28":15119,"_30":15459},"sym.cot","sym.cot(x)","Computes the cotangent of a symbolic expression.\r","Computes the cotangent of a symbolic expression.\r\n\r\nThe cotangent function is defined as cot(x) = cos(x)/sin(x) = 1/tan(x),\r\nrepresenting the ratio of the adjacent side to the opposite side.",[15458],{"_16":498,"_22":15441,"_69":6},[],{"_16":15461,"_18":15462,"_20":15463,"_22":15464,"_24":15465,"_28":15119,"_30":15468},"sym.coth","sym.coth(x)","Computes the hyperbolic cotangent of a symbolic expression.\r","Computes the hyperbolic cotangent of a symbolic expression.\r\n\r\nThe hyperbolic cotangent is defined as coth(x) = cosh(x)/sinh(x) = 1/tanh(x).",[15466],{"_16":498,"_22":15467,"_69":6},"- The argument (as a symbolic expression, x ≠ 0).",[],{"_16":15470,"_18":15471,"_20":15472,"_22":15473,"_24":15474,"_28":15119,"_30":15476},"sym.csc","sym.csc(x)","Computes the cosecant of a symbolic expression.\r","Computes the cosecant of a symbolic expression.\r\n\r\nThe cosecant function is defined as csc(x) = 1/sin(x), representing\r\nthe ratio of the hypotenuse to the opposite side.",[15475],{"_16":498,"_22":15441,"_69":6},[],{"_16":15478,"_18":15479,"_20":15480,"_22":15481,"_24":15482,"_28":15119,"_30":15484},"sym.csch","sym.csch(x)","Computes the hyperbolic cosecant of a symbolic expression.\r","Computes the hyperbolic cosecant of a symbolic expression.\r\n\r\nThe hyperbolic cosecant is defined as csch(x) = 1/sinh(x) = 2/(e^x - e^(-x)).",[15483],{"_16":498,"_22":15467,"_69":6},[],{"_16":15486,"_18":15487,"_20":15488,"_22":15489,"_24":15490,"_28":15494,"_30":15495},"sym.cse","sym.cse(exprs)","Performs common subexpression elimination on a list of expressions.\r","Performs common subexpression elimination on a list of expressions.\r\n\r\nIdentifies repeated subexpressions and replaces them with generated symbols\r\nto reduce redundant computation. This is useful for optimizing numerical\r\nevaluation of complex expressions.",[15491],{"_16":15492,"_22":15493,"_69":6},"exprs","- The expressions to analyze for common subexpressions.","CSEResult",[],{"_16":15497,"_18":15498,"_20":15499,"_22":15500,"_24":15501,"_28":15119,"_30":15504},"sym.denom","sym.denom(expr)","Extracts the denominator of a rational expression.\r","Extracts the denominator of a rational expression.\r\n\r\nFor an expression representing a fraction p/q, returns q.\r\nFor non-fractional expressions, returns 1 (since any expression\r\ncan be viewed as itself over 1).",[15502],{"_16":15115,"_22":15503,"_69":6},"- The expression to extract the denominator from.",[],{"_16":15506,"_18":15507,"_20":15508,"_22":15508,"_24":15509,"_28":15514,"_30":15515},"sym.diag","sym.diag(values, k?)","Create a diagonal matrix from values.",[15510,15512],{"_16":2320,"_22":15511,"_69":6},"Elements for the diagonal",{"_16":1114,"_22":15513,"_69":11},"Diagonal offset (default 0, positive for superdiagonals, negative for subdiagonals)","Matrix",[],{"_16":15517,"_18":15518,"_20":15519,"_22":15520,"_24":15521,"_28":15119,"_30":15523},"sym.digamma","sym.digamma(x)","Computes the digamma function of a symbolic expression.\r","Computes the digamma function of a symbolic expression.\r\n\r\nThe digamma function ψ(x) is the logarithmic derivative of the gamma function:\r\nψ(x) = d/dx ln(Γ(x)) = Γ'(x)/Γ(x). It is also known as the psi function.",[15522],{"_16":498,"_22":15450,"_69":6},[],{"_16":15525,"_18":15526,"_20":15527,"_22":15528,"_24":15529,"_28":15119,"_30":15531},"sym.dirichlet_eta","sym.dirichlet_eta(s)","Computes the Dirichlet eta function of a symbolic expression.\r","Computes the Dirichlet eta function of a symbolic expression.\r\n\r\nThe Dirichlet eta function η(s) is defined as Σ(n=1 to ∞) (-1)^(n-1)/n^s,\r\nwhich is the alternating version of the Riemann zeta function.\r\nIt is related to the zeta function by η(s) = (1 - 2^(1-s)) × ζ(s).",[15530],{"_16":3799,"_22":15450,"_69":6},[],{"_16":15533,"_18":15534,"_20":15535,"_22":15535,"_24":15536,"_28":15119,"_30":15541},"sym.div","sym.div(a, b)","Divide two expressions: a / b",[15537,15539],{"_16":433,"_22":15538,"_69":6},"Numerator",{"_16":436,"_22":15540,"_69":6},"Denominator",[],{"_16":15543,"_18":15544,"_20":15545,"_22":15546,"_24":15547,"_28":15550,"_30":15551},"sym.dummy","sym.dummy(name?)","Creates a new unique dummy symbol.\r","Creates a new unique dummy symbol.\r\n\r\nConvenience function equivalent to `new Dummy(name)`.",[15548],{"_16":16,"_22":15549,"_69":11},"Optional name for the dummy.","Dummy",[],{"_16":15553,"_18":15554,"_20":15555,"_22":15555,"_24":15556,"_28":15119,"_30":15557},"sym.EmptySet","sym.EmptySet()","Creates the empty set ∅.",[],[],{"_16":15559,"_18":15560,"_20":15561,"_22":15562,"_24":15563,"_28":15119,"_30":15565},"sym.erf","sym.erf(x)","Computes the error function of a symbolic expression.\r","Computes the error function of a symbolic expression.\r\n\r\nThe error function erf(x) is defined as (2/√π) × ∫₀ˣ e^(-t²) dt.\r\nIt is the integral of the Gaussian distribution and is widely used\r\nin probability, statistics, and partial differential equations.",[15564],{"_16":498,"_22":15450,"_69":6},[],{"_16":15567,"_18":15568,"_20":15569,"_22":15570,"_24":15571,"_28":15119,"_30":15573},"sym.erfc","sym.erfc(x)","Computes the complementary error function of a symbolic expression.\r","Computes the complementary error function of a symbolic expression.\r\n\r\nThe complementary error function erfc(x) is defined as 1 - erf(x),\r\nor equivalently (2/√π) × ∫ₓ^∞ e^(-t²) dt. It is more accurate than\r\ncomputing 1 - erf(x) directly for large x.",[15572],{"_16":498,"_22":15450,"_69":6},[],{"_16":15575,"_18":15576,"_20":15577,"_22":15578,"_24":15579,"_28":15119,"_30":15582},"sym.exp","sym.exp(x)","Computes the exponential function of a symbolic expression.\r","Computes the exponential function of a symbolic expression.\r\n\r\nReturns e raised to the power of x, where e is Euler's number\r\n(approximately 2.71828). For symbolic expressions, creates a\r\nsymbolic exp(x) that can be manipulated algebraically.",[15580],{"_16":498,"_22":15581,"_69":6},"- The exponent (as a symbolic expression).",[],{"_16":15584,"_18":15585,"_20":15586,"_22":15587,"_24":15588,"_28":15119,"_30":15590},"sym.expand","sym.expand(expr)","Expands an expression by distributing multiplication over addition.\r","Expands an expression by distributing multiplication over addition.\r\n\r\nPerforms algebraic expansion of products and powers, converting expressions\r\nlike (a + b)² into a² + 2ab + b².",[15589],{"_16":15115,"_22":15155,"_69":6},[],{"_16":15592,"_18":15593,"_20":15594,"_22":15595,"_24":15596,"_28":15265,"_30":15599},"sym.expand_complex","sym.expand_complex(expr)","Expands a complex expression into its real and imaginary parts.\r","Expands a complex expression into its real and imaginary parts.\r\n\r\nAlias for . Separates a complex expression into\r\nits real and imaginary components.",[15597],{"_16":15115,"_22":15598,"_69":6},"- The complex expression to expand.",[],{"_16":15601,"_18":15602,"_20":15603,"_22":15604,"_24":15605,"_28":15119,"_30":15607},"sym.expand_trig","sym.expand_trig(expr)","Expands trigonometric functions using exponential identities.\r","Expands trigonometric functions using exponential identities.\r\n\r\nConverts trigonometric functions to their exponential form and then\r\nexpands the result. Useful for simplifying products of trig functions.",[15606],{"_16":15115,"_22":15155,"_69":6},[],{"_16":15609,"_18":15610,"_20":15611,"_22":15612,"_24":15613,"_28":15119,"_30":15616},"sym.exprFromWasm","sym.exprFromWasm(obj)","Create an Expr subclass instance from a WASM object based on its type.\r","Create an Expr subclass instance from a WASM object based on its type.\r\nUsed internally and by the matrices module to convert WASM basic pointers to Expr.",[15614],{"_16":10369,"_22":15615,"_69":6},"SymEngineObject",[],{"_16":15618,"_18":15619,"_20":15620,"_22":15620,"_24":15621,"_28":15514,"_30":15627},"sym.eye","sym.eye(n, m?, k?)","Create an identity matrix.",[15622,15624,15626],{"_16":362,"_22":15623,"_69":6},"Number of rows (and columns if m not specified)",{"_16":359,"_22":15625,"_69":11},"Number of columns (optional, defaults to n)",{"_16":1114,"_22":15513,"_69":11},[],{"_16":15629,"_18":15630,"_20":15631,"_22":15631,"_24":15632,"_28":15119,"_30":15635},"sym.factorial","sym.factorial(n)","Computes the factorial n! = 1 * 2 * 3 * ... * n.",[15633],{"_16":362,"_22":15634,"_69":6},"- The number (must be non-negative).",[],{"_16":15637,"_18":15638,"_20":15639,"_22":15640,"_24":15641,"_28":15119,"_30":15644},"sym.fibonacci","sym.fibonacci(n)","Computes the nth Fibonacci number.\r","Computes the nth Fibonacci number.\r\n\r\nF(0) = 0, F(1) = 1, F(n) = F(n-1) + F(n-2)",[15642],{"_16":362,"_22":15643,"_69":6},"- The index (must be non-negative).",[],{"_16":15646,"_18":15647,"_20":15648,"_22":15649,"_24":15650,"_28":15653,"_30":15654},"sym.fibonacci2","sym.fibonacci2(n)","Computes F(n) and F(n-1) simultaneously.\r","Computes F(n) and F(n-1) simultaneously.\r\n\r\nMore efficient when you need both values.",[15651],{"_16":362,"_22":15652,"_69":6},"- The index (must be positive).","{\r\n fn: Expr;\r\n fn1: Expr;\r\n}",[],{"_16":15656,"_18":15657,"_20":15658,"_22":15658,"_24":15659,"_28":15119,"_30":15662},"sym.FiniteSet","sym.FiniteSet(args)","Creates a finite set from elements.",[15660],{"_16":9142,"_22":15661,"_69":6},"(number | Expr)[]",[],{"_16":15664,"_18":15665,"_20":15666,"_22":15667,"_24":15668,"_28":15119,"_30":15671},"sym.floor","sym.floor(x)","Computes the floor function of a symbolic expression.\r","Computes the floor function of a symbolic expression.\r\n\r\nReturns the greatest integer less than or equal to x, denoted ⌊x⌋.\r\nAlso known as the integer part or greatest integer function.",[15669],{"_16":498,"_22":15670,"_69":6},"- The expression to compute the floor of.",[],{"_16":15673,"_18":15674,"_20":15675,"_22":15676,"_24":15677,"_28":15119,"_30":15679},"sym.gamma","sym.gamma(x)","Computes the gamma function of a symbolic expression.\r","Computes the gamma function of a symbolic expression.\r\n\r\nThe gamma function Γ(x) extends the factorial to complex numbers.\r\nFor positive integers, Γ(n) = (n-1)!. It satisfies the recurrence\r\nrelation Γ(x+1) = x·Γ(x).",[15678],{"_16":498,"_22":15450,"_69":6},[],{"_16":15681,"_18":15682,"_20":15683,"_22":15684,"_24":15685,"_28":15119,"_30":15690},"sym.gcd","sym.gcd(a, b)","Compute the greatest common divisor of two expressions.\r","Compute the greatest common divisor of two expressions.\r\n\r\nFor integers, returns the largest positive integer that divides both.\r\nFor polynomials, returns the highest degree polynomial that divides both.",[15686,15688],{"_16":433,"_22":15687,"_69":6},"- First expression.",{"_16":436,"_22":15689,"_69":6},"- Second expression.",[],{"_16":15692,"_18":15693,"_20":15694,"_22":15695,"_24":15696,"_28":15699,"_30":15700},"sym.gcdex","sym.gcdex(a, b)","Compute the extended greatest common divisor.\r","Compute the extended greatest common divisor.\r\n\r\nReturns the GCD along with Bezout coefficients s and t such that:\r\ngcd(a, b) = s*a + t*b\r\n\r\nThis is useful for solving Diophantine equations and computing\r\nmodular inverses.",[15697,15698],{"_16":433,"_22":15687,"_69":6},{"_16":436,"_22":15689,"_69":6},"GCDExtResult",[],{"_16":15702,"_18":15703,"_20":15704,"_22":15705,"_24":15706,"_28":15711,"_30":15712},"sym.gcdext","sym.gcdext(a, b)","Computes the extended GCD of two numbers.\r","Computes the extended GCD of two numbers.\r\n\r\nReturns gcd(a, b) along with coefficients s and t such that\r\ngcd = s*a + t*b (Bézout's identity).",[15707,15709],{"_16":433,"_22":15708,"_69":6},"- First number.",{"_16":436,"_22":15710,"_69":6},"- Second number.","ExtendedGCDResult",[],{"_16":15714,"_18":15715,"_20":15716,"_22":15716,"_24":15717,"_28":6903,"_30":15722},"sym.hasSymbol","sym.hasSymbol(expr, symbol)","Checks if an expression contains a specific symbol.",[15718,15720],{"_16":15115,"_22":15719,"_69":6},"- The expression to search in.",{"_16":15131,"_22":15721,"_69":6},"- The symbol to search for.",[],{"_16":15724,"_18":15725,"_20":15726,"_22":15727,"_24":15728,"_28":15119,"_30":15731},"sym.im","sym.im(x)","Extracts the imaginary part of a complex expression.\r","Extracts the imaginary part of a complex expression.\r\n\r\nFor a complex number z = a + bi, im(z) returns b (not bi).\r\nThis function works symbolically on expressions containing\r\nsymbolic variables and the imaginary unit I.",[15729],{"_16":498,"_22":15730,"_69":6},"- The expression to extract the imaginary part from.",[],{"_16":15733,"_18":15734,"_20":15735,"_22":15735,"_24":15736,"_28":15119,"_30":15739},"sym.inf","sym.inf(set)","Computes the infimum (greatest lower bound) of a set.",[15737],{"_16":2592,"_22":15738,"_69":6},"- The set to find the infimum of.",[],{"_16":15741,"_18":15742,"_20":15743,"_22":15743,"_24":15744,"_28":15119,"_30":15745},"sym.Integers","sym.Integers()","Creates the set of integers ℤ.",[],[],{"_16":15747,"_18":15748,"_20":15749,"_22":15749,"_24":15750,"_28":15119,"_30":15753},"sym.interior","sym.interior(set)","Computes the interior of a set.",[15751],{"_16":2592,"_22":15752,"_69":6},"- The set to find the interior of.",[],{"_16":15755,"_18":15756,"_20":15757,"_22":15757,"_24":15758,"_28":15119,"_30":15763},"sym.intersection","sym.intersection(a, b)","Computes the intersection of two sets.",[15759,15761],{"_16":433,"_22":15760,"_69":6},"- First set.",{"_16":436,"_22":15762,"_69":6},"- Second set.",[],{"_16":15765,"_18":15766,"_20":15767,"_22":15767,"_24":15768,"_28":15119,"_30":15779},"sym.Interval","sym.Interval(start, end, leftOpen?, rightOpen?)","Creates an interval.",[15769,15771,15773,15776],{"_16":9325,"_22":15770,"_69":6},"- Start of the interval (can be number or Expr).",{"_16":9328,"_22":15772,"_69":6},"- End of the interval (can be number or Expr).",{"_16":15774,"_22":15775,"_69":11},"leftOpen","- If true, the interval is open on the left (excludes start).",{"_16":15777,"_22":15778,"_69":11},"rightOpen","- If true, the interval is open on the right (excludes end).",[],{"_16":15781,"_18":15782,"_20":15783,"_22":15783,"_24":15784,"_28":6903,"_30":15787},"sym.isComplex","sym.isComplex(expr)","Checks if the expression is a Complex number (exact complex).",[15785],{"_16":15115,"_22":15786,"_69":6},"- The expression to check.",[],{"_16":15789,"_18":15790,"_20":15791,"_22":15791,"_24":15792,"_28":6903,"_30":15794},"sym.isComplexDouble","sym.isComplexDouble(expr)","Checks if the expression is a ComplexDouble (floating-point complex).",[15793],{"_16":15115,"_22":15786,"_69":6},[],{"_16":15796,"_18":15797,"_20":15798,"_22":15799,"_24":15800,"_28":6903,"_30":15802},"sym.isComplexMPC","sym.isComplexMPC(expr)","Checks if the expression is a ComplexMPC (arbitrary-precision complex).\r","Checks if the expression is a ComplexMPC (arbitrary-precision complex).\r\n\r\nNote: This requires MPC support in the build.",[15801],{"_16":15115,"_22":15786,"_69":6},[],{"_16":15804,"_18":15805,"_20":15806,"_22":15806,"_24":15807,"_28":6903,"_30":15810},"sym.isComplexValued","sym.isComplexValued(expr)","Checks if the number is complex-valued (has non-zero imaginary part).",[15808],{"_16":15115,"_22":15809,"_69":6},"- The expression to check (should be a number).",[],{"_16":15812,"_18":15813,"_20":15814,"_22":15814,"_24":15815,"_28":6903,"_30":15817},"sym.isInteger","sym.isInteger(expr)","Checks if the expression is an Integer.",[15816],{"_16":15115,"_22":15786,"_69":6},[],{"_16":15819,"_18":15820,"_20":15821,"_22":15821,"_24":15822,"_28":6903,"_30":15824},"sym.isNegative","sym.isNegative(expr)","Checks if the number is negative.",[15823],{"_16":15115,"_22":15809,"_69":6},[],{"_16":15826,"_18":15827,"_20":15828,"_22":15828,"_24":15829,"_28":6903,"_30":15831},"sym.isNumber","sym.isNumber(expr)","Checks if the expression is a Number (Integer, Rational, Real, Complex).",[15830],{"_16":15115,"_22":15786,"_69":6},[],{"_16":15833,"_18":15834,"_20":15835,"_22":15835,"_24":15836,"_28":6903,"_30":15838},"sym.isPositive","sym.isPositive(expr)","Checks if the number is positive.",[15837],{"_16":15115,"_22":15809,"_69":6},[],{"_16":15840,"_18":15841,"_20":15842,"_22":15842,"_24":15843,"_28":6903,"_30":15848},"sym.isProperSubset","sym.isProperSubset(a, b)","Checks if set a is a proper subset of set b.",[15844,15846],{"_16":433,"_22":15845,"_69":6},"- Potential proper subset.",{"_16":436,"_22":15847,"_69":6},"- Potential superset.",[],{"_16":15850,"_18":15851,"_20":15852,"_22":15852,"_24":15853,"_28":6903,"_30":15858},"sym.isProperSuperset","sym.isProperSuperset(a, b)","Checks if set a is a proper superset of set b.",[15854,15856],{"_16":433,"_22":15855,"_69":6},"- Potential proper superset.",{"_16":436,"_22":15857,"_69":6},"- Potential subset.",[],{"_16":15860,"_18":15861,"_20":15862,"_22":15862,"_24":15863,"_28":6903,"_30":15865},"sym.isRational","sym.isRational(expr)","Checks if the expression is a Rational number.",[15864],{"_16":15115,"_22":15786,"_69":6},[],{"_16":15867,"_18":15868,"_20":15869,"_22":15869,"_24":15870,"_28":6903,"_30":15872},"sym.isRealDouble","sym.isRealDouble(expr)","Checks if the expression is a RealDouble (floating-point real).",[15871],{"_16":15115,"_22":15786,"_69":6},[],{"_16":15874,"_18":15875,"_20":15876,"_22":15877,"_24":15878,"_28":6903,"_30":15880},"sym.isRealMPFR","sym.isRealMPFR(expr)","Checks if the expression is a RealMPFR (arbitrary-precision real).\r","Checks if the expression is a RealMPFR (arbitrary-precision real).\r\n\r\nNote: This requires MPFR support in the build.",[15879],{"_16":15115,"_22":15786,"_69":6},[],{"_16":15882,"_18":15883,"_20":15884,"_22":15884,"_24":15885,"_28":6903,"_30":15887},"sym.isSet","sym.isSet(expr)","Checks if the expression is a Set.",[15886],{"_16":15115,"_22":15786,"_69":6},[],{"_16":15889,"_18":15890,"_20":15891,"_22":15891,"_24":15892,"_28":6903,"_30":15895},"sym.isSubset","sym.isSubset(a, b)","Checks if set a is a subset of set b.",[15893,15894],{"_16":433,"_22":15857,"_69":6},{"_16":436,"_22":15847,"_69":6},[],{"_16":15897,"_18":15898,"_20":15899,"_22":15899,"_24":15900,"_28":6903,"_30":15903},"sym.isSuperset","sym.isSuperset(a, b)","Checks if set a is a superset of set b.",[15901,15902],{"_16":433,"_22":15847,"_69":6},{"_16":436,"_22":15857,"_69":6},[],{"_16":15905,"_18":15906,"_20":15907,"_22":15907,"_24":15908,"_28":6903,"_30":15910},"sym.isSymbol","sym.isSymbol(expr)","Checks if the expression is a Symbol.",[15909],{"_16":15115,"_22":15786,"_69":6},[],{"_16":15912,"_18":15913,"_20":15914,"_22":15914,"_24":15915,"_28":6903,"_30":15917},"sym.isZero","sym.isZero(expr)","Checks if the number has value zero.",[15916],{"_16":15115,"_22":15809,"_69":6},[],{"_16":15919,"_18":15920,"_20":15921,"_22":15922,"_24":15923,"_28":15514,"_30":15929},"sym.jacobian","sym.jacobian(funcs, vars)","Compute the Jacobian matrix of a vector of functions with respect to variables.\r","Compute the Jacobian matrix of a vector of functions with respect to variables.\r\n\r\nThe Jacobian is a matrix of partial derivatives where element (i,j) is\r\nthe partial derivative of the i-th function with respect to the j-th variable.",[15924,15927],{"_16":15925,"_22":15926,"_69":6},"funcs","Column matrix of functions (expressions)",{"_16":3823,"_22":15928,"_69":6},"Column matrix of variables (symbols) to differentiate with respect to",[],{"_16":15931,"_18":15932,"_20":15933,"_22":15934,"_24":15935,"_28":15119,"_30":15940},"sym.kronecker_delta","sym.kronecker_delta(i, j)","Computes the Kronecker delta of two symbolic expressions.\r","Computes the Kronecker delta of two symbolic expressions.\r\n\r\nThe Kronecker delta δ(i, j) equals 1 if i = j and 0 otherwise.\r\nIt is the discrete analog of the Dirac delta function and is\r\nfundamental in linear algebra and tensor analysis.",[15936,15938],{"_16":6743,"_22":15937,"_69":6},"- The first index (as a symbolic expression).",{"_16":6745,"_22":15939,"_69":6},"- The second index (as a symbolic expression).",[],{"_16":15942,"_18":15943,"_20":15944,"_22":15945,"_24":15946,"_28":15953,"_30":15954},"sym.lambdify","sym.lambdify(expr, args, options?)","Converts a symbolic expression to a fast numerical function.\r","Converts a symbolic expression to a fast numerical function.\r\n\r\nCreates a compiled numerical evaluation function that can be called\r\nwith numerical values for the symbols. This is much faster than\r\nusing `evalf()` repeatedly for the same expression structure.",[15947,15949,15951],{"_16":15115,"_22":15948,"_69":6},"- The expression to evaluate.",{"_16":9142,"_22":15950,"_69":6},"- Symbol or array of symbols that will be the function arguments.",{"_16":4789,"_22":15952,"_69":11},"- Options for the lambdification.","LambdaFunction",[],{"_16":15956,"_18":15957,"_20":15958,"_22":15959,"_24":15960,"_28":15965,"_30":15966},"sym.lambdifyMulti","sym.lambdifyMulti(exprs, args, options?)","Converts multiple symbolic expressions to a fast numerical function.\r","Converts multiple symbolic expressions to a fast numerical function.\r\n\r\nSimilar to `lambdify`, but returns an array of results for multiple\r\nexpressions evaluated at the same point.",[15961,15963,15964],{"_16":15492,"_22":15962,"_69":6},"- Array of expressions to evaluate.",{"_16":9142,"_22":15950,"_69":6},{"_16":4789,"_22":15952,"_69":11},"LambdaFunctionMulti",[],{"_16":15968,"_18":15969,"_20":15970,"_22":15971,"_24":15972,"_28":15119,"_30":15974},"sym.lambertw","sym.lambertw(x)","Computes the Lambert W function of a symbolic expression.\r","Computes the Lambert W function of a symbolic expression.\r\n\r\nThe Lambert W function W(x) is defined as the inverse of f(w) = w*e^w.\r\nThat is, if y = W(x), then y*e^y = x. This function returns the\r\nprincipal branch W₀(x).",[15973],{"_16":498,"_22":15450,"_69":6},[],{"_16":15976,"_18":15977,"_20":15978,"_22":15979,"_24":15980,"_28":15119,"_30":15983},"sym.lcm","sym.lcm(a, b)","Compute the least common multiple of two expressions.\r","Compute the least common multiple of two expressions.\r\n\r\nFor integers, returns the smallest positive integer divisible by both.\r\nFor polynomials, returns the lowest degree polynomial divisible by both.",[15981,15982],{"_16":433,"_22":15687,"_69":6},{"_16":436,"_22":15689,"_69":6},[],{"_16":15985,"_18":15986,"_20":15987,"_22":15988,"_24":15989,"_28":15996,"_30":15997},"sym.linsolve","sym.linsolve(system, symbols)","Solves a system of linear equations.\r","Solves a system of linear equations.\r\n\r\nGiven a system of linear equations and the variables to solve for,\r\nreturns the solution values. Uses Gaussian elimination internally.",[15990,15993],{"_16":15991,"_22":15992,"_69":6},"system","- Array of linear equations (each treated as `expr = 0`).",{"_16":15994,"_22":15995,"_69":6},"symbols","- Array of symbols to solve for.","Expr[]",[],{"_16":15999,"_18":16000,"_20":16001,"_22":16001,"_24":16002,"_28":16003,"_30":16004},"sym.loadWasmModule","sym.loadWasmModule()","Load the WASM module (singleton pattern)",[],"Promise",[],{"_16":16006,"_18":16007,"_20":16008,"_22":16009,"_24":16010,"_28":15119,"_30":16013},"sym.log","sym.log(x)","Computes the natural logarithm of a symbolic expression.\r","Computes the natural logarithm of a symbolic expression.\r\n\r\nReturns the natural (base e) logarithm of x. For symbolic expressions,\r\ncreates a symbolic log(x) that can be manipulated algebraically.",[16011],{"_16":498,"_22":16012,"_69":6},"- The argument (positive real or complex expression).",[],{"_16":16015,"_18":16016,"_20":16017,"_22":16018,"_24":16019,"_28":15119,"_30":16021},"sym.loggamma","sym.loggamma(x)","Computes the log-gamma function of a symbolic expression.\r","Computes the log-gamma function of a symbolic expression.\r\n\r\nThe log-gamma function is defined as log(Γ(x)), which is useful for\r\nnumerical computation when Γ(x) would overflow, and for computing\r\nratios of gamma functions.",[16020],{"_16":498,"_22":15450,"_69":6},[],{"_16":16023,"_18":16024,"_20":16025,"_22":16026,"_24":16027,"_28":15119,"_30":16032},"sym.lowergamma","sym.lowergamma(s, x)","Computes the lower incomplete gamma function of symbolic expressions.\r","Computes the lower incomplete gamma function of symbolic expressions.\r\n\r\nThe lower incomplete gamma function γ(s, x) is defined as the integral\r\nof t^(s-1)e^(-t) from 0 to x. It represents the cumulative distribution\r\nfunction of the gamma distribution (up to normalization).",[16028,16030],{"_16":3799,"_22":16029,"_69":6},"- The shape parameter (as a symbolic expression).",{"_16":498,"_22":16031,"_69":6},"- The upper limit of integration (as a symbolic expression).",[],{"_16":16034,"_18":16035,"_20":16036,"_22":16037,"_24":16038,"_28":15119,"_30":16040},"sym.lucas","sym.lucas(n)","Computes the nth Lucas number.\r","Computes the nth Lucas number.\r\n\r\nL(0) = 2, L(1) = 1, L(n) = L(n-1) + L(n-2)",[16039],{"_16":362,"_22":15643,"_69":6},[],{"_16":16042,"_18":16043,"_20":16044,"_22":16044,"_24":16045,"_28":16047,"_30":16048},"sym.lucas2","sym.lucas2(n)","Computes L(n) and L(n-1) simultaneously.",[16046],{"_16":362,"_22":15652,"_69":6},"{\r\n ln: Expr;\r\n ln1: Expr;\r\n}",[],{"_16":16050,"_18":16051,"_20":16052,"_22":16053,"_24":16054,"_28":15119,"_30":16057},"sym.Max","sym.Max(args)","Computes the maximum of multiple symbolic expressions.\r","Computes the maximum of multiple symbolic expressions.\r\n\r\nReturns the largest value among the given arguments. For symbolic arguments\r\nthat cannot be compared numerically, returns a symbolic Max expression that\r\nmay simplify when more information is available.",[16055],{"_16":9142,"_22":16056,"_69":6},"- Two or more expressions to find the maximum of.",[],{"_16":16059,"_18":16060,"_20":16061,"_22":16062,"_24":16063,"_28":15119,"_30":16066},"sym.Min","sym.Min(args)","Computes the minimum of multiple symbolic expressions.\r","Computes the minimum of multiple symbolic expressions.\r\n\r\nReturns the smallest value among the given arguments. For symbolic arguments\r\nthat cannot be compared numerically, returns a symbolic Min expression that\r\nmay simplify when more information is available.",[16064],{"_16":9142,"_22":16065,"_69":6},"- Two or more expressions to find the minimum of.",[],{"_16":16068,"_18":16069,"_20":16070,"_22":16070,"_24":16071,"_28":15119,"_30":16076},"sym.mod","sym.mod(n, d)","Computes n mod d (modulo, rounding toward zero).",[16072,16074],{"_16":362,"_22":16073,"_69":6},"- The dividend.",{"_16":1946,"_22":16075,"_69":6},"- The divisor.",[],{"_16":16078,"_18":16079,"_20":16080,"_22":16081,"_24":16082,"_28":15119,"_30":16085},"sym.modF","sym.modF(n, d)","Computes n mod d (modulo, rounding toward -infinity).\r","Computes n mod d (modulo, rounding toward -infinity).\r\n\r\nThis is the floor division remainder, which always has the same sign as d.",[16083,16084],{"_16":362,"_22":16073,"_69":6},{"_16":1946,"_22":16075,"_69":6},[],{"_16":16087,"_18":16088,"_20":16089,"_22":16090,"_24":16091,"_28":16096,"_30":16097},"sym.modInverse","sym.modInverse(a, m)","Computes the modular inverse of a modulo m.\r","Computes the modular inverse of a modulo m.\r\n\r\nReturns b such that a*b ≡ 1 (mod m), if it exists.",[16092,16094],{"_16":433,"_22":16093,"_69":6},"- The number to invert.",{"_16":359,"_22":16095,"_69":6},"- The modulus.","Expr | null",[],{"_16":16099,"_18":16100,"_20":16101,"_22":16101,"_24":16102,"_28":15119,"_30":16105},"sym.mul","sym.mul(a, b)","Multiply two expressions: a * b",[16103,16104],{"_16":433,"_22":15244,"_69":6},{"_16":436,"_22":15246,"_69":6},[],{"_16":16107,"_18":16108,"_20":16109,"_22":16110,"_24":16111,"_28":15119,"_30":16115},"sym.N","sym.N(expr, precision?)","Evaluates an expression numerically to the specified precision.\r","Evaluates an expression numerically to the specified precision.\r\n\r\nThis is a convenience function equivalent to `expr.evalf(precision)`.\r\nIt mirrors SymPy's `N()` function.",[16112,16113],{"_16":15115,"_22":15948,"_69":6},{"_16":1336,"_22":16114,"_69":11},"- Number of bits of precision (default: 53, i.e., double precision).",[],{"_16":16117,"_18":16118,"_20":16119,"_22":16119,"_24":16120,"_28":15119,"_30":16123},"sym.neg","sym.neg(a)","Negate an expression: -a",[16121],{"_16":433,"_22":16122,"_69":6},"The operand",[],{"_16":16125,"_18":16126,"_20":16127,"_22":16127,"_24":16128,"_28":6903,"_30":16131},"sym.neq","sym.neq(a, b)","Checks if two expressions are not equal.",[16129,16130],{"_16":433,"_22":15687,"_69":6},{"_16":436,"_22":15689,"_69":6},[],{"_16":16133,"_18":16134,"_20":16135,"_22":16135,"_24":16136,"_28":15119,"_30":16139},"sym.nextprime","sym.nextprime(n)","Finds the next prime number after a given number.",[16137],{"_16":362,"_22":16138,"_69":6},"- The starting number.",[],{"_16":16141,"_18":16142,"_20":16143,"_22":16143,"_24":16144,"_28":15119,"_30":16147},"sym.ntheory_gcd","sym.ntheory_gcd(a, b)","Computes the greatest common divisor (GCD) of two numbers.",[16145,16146],{"_16":433,"_22":15708,"_69":6},{"_16":436,"_22":15710,"_69":6},[],{"_16":16149,"_18":16150,"_20":16151,"_22":16151,"_24":16152,"_28":15119,"_30":16155},"sym.ntheory_lcm","sym.ntheory_lcm(a, b)","Computes the least common multiple (LCM) of two numbers.",[16153,16154],{"_16":433,"_22":15708,"_69":6},{"_16":436,"_22":15710,"_69":6},[],{"_16":16157,"_18":16158,"_20":16159,"_22":16160,"_24":16161,"_28":15119,"_30":16164},"sym.numer","sym.numer(expr)","Extracts the numerator of a rational expression.\r","Extracts the numerator of a rational expression.\r\n\r\nFor an expression representing a fraction p/q, returns p.\r\nFor non-fractional expressions, returns the expression itself\r\n(since any expression can be viewed as itself over 1).",[16162],{"_16":15115,"_22":16163,"_69":6},"- The expression to extract the numerator from.",[],{"_16":16166,"_18":16167,"_20":16168,"_22":16168,"_24":16169,"_28":15514,"_30":16172},"sym.ones","sym.ones(rows, cols)","Create a matrix of ones.",[16170,16171],{"_16":2472,"_22":360,"_69":6},{"_16":2475,"_22":363,"_69":6},[],{"_16":16174,"_18":16175,"_20":16176,"_22":16177,"_24":16178,"_28":15119,"_30":16183},"sym.parse","sym.parse(str, options?)","Parses a mathematical expression from a string.\r","Parses a mathematical expression from a string.\r\n\r\nConverts a string representation of a mathematical expression into\r\na symbolic expression object. Supports standard mathematical notation\r\nincluding:\r\n- Arithmetic operators: `+`, `-`, `*`, `/`, `^` (power)\r\n- Parentheses for grouping\r\n- Function calls: `sin(x)`, `cos(x)`, `exp(x)`, etc.\r\n- Constants: `pi`, `E`, `I` (imaginary unit)\r\n- Scientific notation: `1e-5`, `3.14e2`",[16179,16181],{"_16":1129,"_22":16180,"_69":6},"- The string to parse.",{"_16":4789,"_22":16182,"_69":11},"- Parsing options.",[],{"_16":16185,"_18":16186,"_20":16187,"_22":16188,"_24":16189,"_28":15119,"_30":16194},"sym.polygamma","sym.polygamma(n, x)","Computes the polygamma function of symbolic expressions.\r","Computes the polygamma function of symbolic expressions.\r\n\r\nThe polygamma function ψ^(n)(x) is the (n+1)th derivative of the log-gamma function,\r\nor equivalently the nth derivative of the digamma function:\r\nψ^(n)(x) = d^n/dx^n ψ(x) = d^(n+1)/dx^(n+1) ln(Γ(x))",[16190,16192],{"_16":362,"_22":16191,"_69":6},"- The order of the derivative (n ≥ 0).",{"_16":498,"_22":16193,"_69":6},"- The argument at which to evaluate.",[],{"_16":16196,"_18":16197,"_20":16198,"_22":16198,"_24":16199,"_28":15119,"_30":16204},"sym.pow","sym.pow(base, exp)","Raise to a power: base ** exp",[16200,16202],{"_16":9636,"_22":16201,"_69":6},"The base (Expr or number)",{"_16":704,"_22":16203,"_69":6},"The exponent (Expr or number)",[],{"_16":16206,"_18":16207,"_20":16208,"_22":16209,"_24":16210,"_28":15119,"_30":16213},"sym.powsimp","sym.powsimp(expr)","Simplifies expressions with powers by combining bases and exponents.\r","Simplifies expressions with powers by combining bases and exponents.\r\n\r\nApplies power rules to simplify expressions involving exponents,\r\nsuch as combining x^a * x^b = x^(a+b).",[16211],{"_16":15115,"_22":16212,"_69":6},"- The expression to simplify.",[],{"_16":16215,"_18":16216,"_20":16217,"_22":16217,"_24":16218,"_28":15119,"_30":16221},"sym.quotient","sym.quotient(n, d)","Computes n / d (quotient, rounding toward zero).",[16219,16220],{"_16":362,"_22":16073,"_69":6},{"_16":1946,"_22":16075,"_69":6},[],{"_16":16223,"_18":16224,"_20":16225,"_22":16225,"_24":16226,"_28":15119,"_30":16229},"sym.quotientF","sym.quotientF(n, d)","Computes n / d (quotient, rounding toward -infinity).",[16227,16228],{"_16":362,"_22":16073,"_69":6},{"_16":1946,"_22":16075,"_69":6},[],{"_16":16231,"_18":16232,"_20":16233,"_22":16233,"_24":16234,"_28":16237,"_30":16238},"sym.quotientMod","sym.quotientMod(n, d)","Computes both quotient and remainder at once (rounding toward zero).",[16235,16236],{"_16":362,"_22":16073,"_69":6},{"_16":1946,"_22":16075,"_69":6},"QuotientModResult",[],{"_16":16240,"_18":16241,"_20":16242,"_22":16242,"_24":16243,"_28":16237,"_30":16246},"sym.quotientModF","sym.quotientModF(n, d)","Computes both quotient and remainder (rounding toward -infinity).",[16244,16245],{"_16":362,"_22":16073,"_69":6},{"_16":1946,"_22":16075,"_69":6},[],{"_16":16248,"_18":16249,"_20":16250,"_22":16251,"_24":16252,"_28":15119,"_30":16254},"sym.radsimp","sym.radsimp(expr)","Simplifies expressions involving radicals (roots).\r","Simplifies expressions involving radicals (roots).\r\n\r\nRationalizes denominators and simplifies expressions containing\r\nsquare roots, cube roots, and other radicals.",[16253],{"_16":15115,"_22":16212,"_69":6},[],{"_16":16256,"_18":16257,"_20":16258,"_22":16258,"_24":16259,"_28":15119,"_30":16260},"sym.Rationals","sym.Rationals()","Creates the set of rational numbers ℚ.",[],[],{"_16":16262,"_18":16263,"_20":16264,"_22":16265,"_24":16266,"_28":15119,"_30":16269},"sym.re","sym.re(x)","Extracts the real part of a complex expression.\r","Extracts the real part of a complex expression.\r\n\r\nFor a complex number z = a + bi, re(z) returns a.\r\nThis function works symbolically on expressions containing\r\nsymbolic variables and the imaginary unit I.",[16267],{"_16":498,"_22":16268,"_69":6},"- The expression to extract the real part from.",[],{"_16":16271,"_18":16272,"_20":16273,"_22":16273,"_24":16274,"_28":15119,"_30":16275},"sym.Reals","sym.Reals()","Creates the set of real numbers ℝ.",[],[],{"_16":16277,"_18":16278,"_20":16279,"_22":16280,"_24":16281,"_28":15119,"_30":16284},"sym.rewrite_as_cos","sym.rewrite_as_cos(expr)","Rewrites trigonometric functions in terms of cosine only.\r","Rewrites trigonometric functions in terms of cosine only.\r\n\r\nConverts all trigonometric functions in an expression to use only\r\nthe cosine function, using identities like sin(x) = cos(π/2 - x).",[16282],{"_16":15115,"_22":16283,"_69":6},"- The expression to rewrite.",[],{"_16":16286,"_18":16287,"_20":16288,"_22":16289,"_24":16290,"_28":15119,"_30":16292},"sym.rewrite_as_exp","sym.rewrite_as_exp(expr)","Rewrites trigonometric functions in terms of complex exponentials.\r","Rewrites trigonometric functions in terms of complex exponentials.\r\n\r\nUses Euler's formula to convert sine and cosine to exponential form:\r\n- sin(x) = (e^(ix) - e^(-ix)) / (2i)\r\n- cos(x) = (e^(ix) + e^(-ix)) / 2",[16291],{"_16":15115,"_22":16283,"_69":6},[],{"_16":16294,"_18":16295,"_20":16296,"_22":16297,"_24":16298,"_28":15119,"_30":16300},"sym.rewrite_as_sin","sym.rewrite_as_sin(expr)","Rewrites trigonometric functions in terms of sine only.\r","Rewrites trigonometric functions in terms of sine only.\r\n\r\nConverts all trigonometric functions in an expression to use only\r\nthe sine function, using identities like cos(x) = sin(π/2 - x).",[16299],{"_16":15115,"_22":16283,"_69":6},[],{"_16":16302,"_18":16303,"_20":16304,"_22":16305,"_24":16306,"_28":15119,"_30":16308},"sym.sec","sym.sec(x)","Computes the secant of a symbolic expression.\r","Computes the secant of a symbolic expression.\r\n\r\nThe secant function is defined as sec(x) = 1/cos(x), representing\r\nthe ratio of the hypotenuse to the adjacent side.",[16307],{"_16":498,"_22":15441,"_69":6},[],{"_16":16310,"_18":16311,"_20":16312,"_22":16313,"_24":16314,"_28":15119,"_30":16316},"sym.sech","sym.sech(x)","Computes the hyperbolic secant of a symbolic expression.\r","Computes the hyperbolic secant of a symbolic expression.\r\n\r\nThe hyperbolic secant is defined as sech(x) = 1/cosh(x) = 2/(e^x + e^(-x)).",[16315],{"_16":498,"_22":15450,"_69":6},[],{"_16":16318,"_18":16319,"_20":16320,"_22":16321,"_24":16322,"_28":15119,"_30":16325},"sym.sign","sym.sign(x)","Computes the sign (signum) function of a symbolic expression.\r","Computes the sign (signum) function of a symbolic expression.\r\n\r\nReturns -1 if x < 0, 0 if x = 0, and +1 if x > 0. For complex numbers,\r\nreturns x/|x| (the unit complex number in the direction of x).",[16323],{"_16":498,"_22":16324,"_69":6},"- The expression to compute the sign of.",[],{"_16":16327,"_18":16328,"_20":16329,"_22":16330,"_24":16331,"_28":15119,"_30":16335},"sym.simplify","sym.simplify(expr, assumptions?)","Simplifies an expression using heuristic algorithms.\r","Simplifies an expression using heuristic algorithms.\r\n\r\nApplies various simplification rules to reduce an expression to a simpler\r\nequivalent form. This includes combining like terms, canceling common factors,\r\nand applying algebraic identities.\r\n\r\nWhen assumptions are provided, the expression is first refined using those\r\nassumptions before applying simplification rules. This enables simplifications\r\nlike `sqrt(x^2) → x` when `x` is known to be positive.",[16332,16333],{"_16":15115,"_22":16212,"_69":6},{"_16":3973,"_22":16334,"_69":11},"- Optional assumptions about symbols (e.g., x is positive).",[],{"_16":16337,"_18":16338,"_20":16339,"_22":16340,"_24":16341,"_28":15119,"_30":16343},"sym.sin","sym.sin(x)","Computes the sine of a symbolic expression.\r","Computes the sine of a symbolic expression.\r\n\r\nThe sine function returns the ratio of the opposite side to the hypotenuse\r\nin a right triangle. For symbolic expressions, it creates a symbolic sin(x)\r\nthat can be manipulated algebraically.",[16342],{"_16":498,"_22":15441,"_69":6},[],{"_16":16345,"_18":16346,"_20":16347,"_22":16348,"_24":16349,"_28":15119,"_30":16351},"sym.sinh","sym.sinh(x)","Computes the hyperbolic sine of a symbolic expression.\r","Computes the hyperbolic sine of a symbolic expression.\r\n\r\nThe hyperbolic sine is defined as sinh(x) = (e^x - e^(-x)) / 2.\r\nIt represents the y-coordinate of a point on the unit hyperbola.",[16350],{"_16":498,"_22":15450,"_69":6},[],{"_16":16353,"_18":16354,"_20":16355,"_22":16356,"_24":16357,"_28":15996,"_30":16362},"sym.solve","sym.solve(expr, symbol)","Solves an equation for a given symbol.\r","Solves an equation for a given symbol.\r\n\r\nGiven an expression treated as `expr = 0`, finds all values of the symbol\r\nthat satisfy the equation. This is a general solver that can handle\r\npolynomial, rational, and some transcendental equations.",[16358,16360],{"_16":15115,"_22":16359,"_69":6},"- The equation to solve (treated as `expr = 0`).",{"_16":15131,"_22":16361,"_69":6},"- The symbol to solve for.",[],{"_16":16364,"_18":16365,"_20":16366,"_22":16367,"_24":16368,"_28":15996,"_30":16373},"sym.solve_poly","sym.solve_poly(f, x)","Solve a polynomial equation for a variable.\r","Solve a polynomial equation for a variable.\r\n\r\nFinds all solutions to the equation f(x) = 0 where f is a polynomial\r\nin x. Only works when the solution set is finite.",[16369,16371],{"_16":3860,"_22":16370,"_69":6},"- The polynomial equation (set equal to zero).",{"_16":498,"_22":16372,"_69":6},"- The variable to solve for.",[],{"_16":16375,"_18":16376,"_20":16377,"_22":16378,"_24":16379,"_28":15996,"_30":16383},"sym.solve_rational","sym.solve_rational(expr, symbol)","Solves a rational equation for a given symbol.\r","Solves a rational equation for a given symbol.\r\n\r\nSpecialized solver for equations involving ratios of polynomials.\r\nThis solver is more efficient than the general `solve` function\r\nfor purely rational equations.",[16380,16382],{"_16":15115,"_22":16381,"_69":6},"- The rational equation to solve (treated as `expr = 0`).",{"_16":15131,"_22":16361,"_69":6},[],{"_16":16385,"_18":16386,"_20":16387,"_22":16388,"_24":16389,"_28":15996,"_30":16393},"sym.solve_trig","sym.solve_trig(expr, symbol)","Solves a trigonometric equation for a given symbol.\r","Solves a trigonometric equation for a given symbol.\r\n\r\nSpecialized solver for equations involving trigonometric functions\r\n(sin, cos, tan, etc.). Returns finite solutions when possible.",[16390,16392],{"_16":15115,"_22":16391,"_69":6},"- The trigonometric equation to solve (treated as `expr = 0`).",{"_16":15131,"_22":16361,"_69":6},[],{"_16":16395,"_18":16396,"_20":16397,"_22":16398,"_24":16399,"_28":15119,"_30":16401},"sym.sqrt","sym.sqrt(x)","Computes the square root of a symbolic expression.\r","Computes the square root of a symbolic expression.\r\n\r\nReturns the principal square root of x. Equivalent to pow(x, 1/2) or x^(1/2).\r\nFor negative real numbers, returns a complex result involving I.",[16400],{"_16":498,"_22":15366,"_69":6},[],{"_16":16403,"_18":16404,"_20":16405,"_22":16405,"_24":16406,"_28":15119,"_30":16409},"sym.sub","sym.sub(a, b)","Subtract two expressions: a - b",[16407,16408],{"_16":433,"_22":15244,"_69":6},{"_16":436,"_22":15246,"_69":6},[],{"_16":16411,"_18":16412,"_20":16413,"_22":16413,"_24":16414,"_28":15119,"_30":16417},"sym.sup","sym.sup(set)","Computes the supremum (least upper bound) of a set.",[16415],{"_16":2592,"_22":16416,"_69":6},"- The set to find the supremum of.",[],{"_16":16419,"_18":16420,"_20":16421,"_22":16422,"_24":16423,"_28":16429,"_30":16430},"sym.symbols","sym.symbols(names, assumptions?)","Create multiple symbols at once.\r","Create multiple symbols at once.\r\nMirrors sympy.symbols.",[16424,16427],{"_16":16425,"_22":16426,"_69":6},"names","Space-separated or comma-separated symbol names",{"_16":3973,"_22":16428,"_69":11},"Optional assumptions to apply to all symbols","Symbol_2[]",[],{"_16":16432,"_18":16433,"_20":16434,"_22":16435,"_24":16436,"_28":15119,"_30":16438},"sym.tan","sym.tan(x)","Computes the tangent of a symbolic expression.\r","Computes the tangent of a symbolic expression.\r\n\r\nThe tangent function is defined as tan(x) = sin(x)/cos(x), representing\r\nthe ratio of the opposite side to the adjacent side in a right triangle.",[16437],{"_16":498,"_22":15441,"_69":6},[],{"_16":16440,"_18":16441,"_20":16442,"_22":16443,"_24":16444,"_28":15119,"_30":16446},"sym.tanh","sym.tanh(x)","Computes the hyperbolic tangent of a symbolic expression.\r","Computes the hyperbolic tangent of a symbolic expression.\r\n\r\nThe hyperbolic tangent is defined as tanh(x) = sinh(x)/cosh(x) = (e^x - e^(-x))/(e^x + e^(-x)).\r\nIt is a sigmoid-like function bounded between -1 and 1.",[16445],{"_16":498,"_22":15450,"_69":6},[],{"_16":16448,"_18":16449,"_20":16450,"_22":16451,"_24":16452,"_28":6108,"_30":16455},"sym.toCCode","sym.toCCode(expr)","Converts an expression to C code.\r","Converts an expression to C code.\r\n\r\nGenerates a C code string that evaluates the expression.\r\nUseful for code generation and numerical computation.",[16453],{"_16":15115,"_22":16454,"_69":6},"- The expression to convert.",[],{"_16":16457,"_18":16458,"_20":16459,"_22":16460,"_24":16461,"_28":6108,"_30":16463},"sym.toJSCode","sym.toJSCode(expr)","Converts an expression to JavaScript code.\r","Converts an expression to JavaScript code.\r\n\r\nGenerates a JavaScript code string that evaluates the expression.\r\nUseful for generating runtime code or numerical computation.",[16462],{"_16":15115,"_22":16454,"_69":6},[],{"_16":16465,"_18":16466,"_20":16467,"_22":16468,"_24":16469,"_28":6108,"_30":16471},"sym.toJuliaCode","sym.toJuliaCode(expr)","Converts an expression to Julia code.\r","Converts an expression to Julia code.\r\n\r\nGenerates a Julia code string that evaluates the expression.\r\nUseful for interoperability with Julia-based numerical computation.",[16470],{"_16":15115,"_22":16454,"_69":6},[],{"_16":16473,"_18":16474,"_20":16475,"_22":16476,"_24":16477,"_28":6108,"_30":16479},"sym.toLatex","sym.toLatex(expr)","Converts an expression to LaTeX format.\r","Converts an expression to LaTeX format.\r\n\r\nGenerates a LaTeX string representation suitable for rendering\r\nin mathematical documents or web pages using MathJax/KaTeX.",[16478],{"_16":15115,"_22":16454,"_69":6},[],{"_16":16481,"_18":16482,"_20":16483,"_22":16484,"_24":16485,"_28":6108,"_30":16487},"sym.toMathML","sym.toMathML(expr)","Converts an expression to MathML format.\r","Converts an expression to MathML format.\r\n\r\nGenerates a MathML string representation for web-based\r\nmathematical rendering.",[16486],{"_16":15115,"_22":16454,"_69":6},[],{"_16":16489,"_18":16490,"_20":16491,"_22":16492,"_24":16493,"_28":15119,"_30":16495},"sym.trigsimp","sym.trigsimp(expr)","Simplifies trigonometric expressions using trigonometric identities.\r","Simplifies trigonometric expressions using trigonometric identities.\r\n\r\nApplies identities such as sin²(x) + cos²(x) = 1 to simplify\r\nexpressions involving trigonometric functions.",[16494],{"_16":15115,"_22":16212,"_69":6},[],{"_16":16497,"_18":16498,"_20":16499,"_22":16499,"_24":16500,"_28":15119,"_30":16503},"sym.union","sym.union(a, b)","Computes the union of two sets.",[16501,16502],{"_16":433,"_22":15760,"_69":6},{"_16":436,"_22":15762,"_69":6},[],{"_16":16505,"_18":16506,"_20":16507,"_22":16507,"_24":16508,"_28":15119,"_30":16509},"sym.UniversalSet","sym.UniversalSet()","Creates the universal set (contains all elements).",[],[],{"_16":16511,"_18":16512,"_20":16513,"_22":16514,"_24":16515,"_28":15119,"_30":16519},"sym.uppergamma","sym.uppergamma(s, x)","Computes the upper incomplete gamma function of symbolic expressions.\r","Computes the upper incomplete gamma function of symbolic expressions.\r\n\r\nThe upper incomplete gamma function Γ(s, x) is defined as the integral\r\nof t^(s-1)e^(-t) from x to infinity. It's the complement of the lower\r\nincomplete gamma function.",[16516,16517],{"_16":3799,"_22":16029,"_69":6},{"_16":498,"_22":16518,"_69":6},"- The lower limit of integration (as a symbolic expression).",[],{"_16":16521,"_18":16522,"_20":16523,"_22":16523,"_24":16524,"_28":15514,"_30":16527},"sym.zeros","sym.zeros(rows, cols)","Create a matrix of zeros.",[16525,16526],{"_16":2472,"_22":360,"_69":6},{"_16":2475,"_22":363,"_69":6},[],{"_16":16529,"_18":16530,"_20":16531,"_22":16532,"_24":16533,"_28":15119,"_30":16535},"sym.zeta","sym.zeta(s)","Computes the Riemann zeta function of a symbolic expression.\r","Computes the Riemann zeta function of a symbolic expression.\r\n\r\nThe Riemann zeta function ζ(s) is defined as Σ(n=1 to ∞) 1/n^s for Re(s) > 1,\r\nand extended to other values by analytic continuation. It is fundamental\r\nin number theory and has deep connections to the distribution of prime numbers.",[16534],{"_16":3799,"_22":15450,"_69":6},[],{"_43":16537,"_16":16538,"_22":16539,"_47":48,"_49":1466,"_51":16540,"_52":16541},"eigen-generated","Linear Algebra (Eigen)","Eigen linear algebra library for matrix operations.","eigen",[16542,16550,16557,16563,16571,16578,16587,16595,16601,16611,16621,16630,16638,16646,16654,16663,16674,16684,16692,16699,16708,16716,16726,16734,16742,16750,16757,16764,16771,16780,16787,16796,16805,16814,16823,16830,16841,16850,16858,16865,16873,16880,16888,16899,16907,16916,16924,16931,16942,16949,16956,16963,16970,16978,16988,16998,17007,17017,17025,17033,17043,17050,17059,17067,17075,17084,17092,17100,17107,17115,17125,17138,17148,17156,17164,17172,17179,17186,17193,17200,17207,17214,17221,17228,17235,17242,17249,17256,17263,17272,17279,17287,17296,17303,17311,17319,17327,17335,17343,17351,17359,17367,17375,17382,17389,17395,17403,17410,17419,17426,17434,17445,17455,17468,17475,17485,17499,17506,17515,17523,17532,17542,17550,17557,17565,17572,17580,17588,17598,17608,17618,17626,17637,17647,17655,17664,17673,17682,17690,17700,17707,17716,17724,17731,17747,17758,17769,17777,17786,17793,17800,17811,17824,17834,17844,17852,17859,17869,17881,17893,17900,17907,17921,17931,17951,17960,17968,17977,17986,17994,18007,18015,18024,18033,18045,18056,18066,18076,18083,18089,18096,18103,18114,18123,18132,18140,18148,18155,18164,18176,18185,18195,18204,18213,18221,18230,18238,18245,18254,18263,18272,18280,18288,18295,18304,18311,18320,18327,18338,18345,18352,18363,18373,18381,18390,18399,18406,18413,18421,18429,18436,18446,18454,18464,18472,18481,18489,18497,18504,18511,18518,18525,18533,18541,18548,18555,18562,18571,18579,18586,18592,18598,18604,18610,18616,18623,18631],{"_16":16543,"_18":16544,"_20":16545,"_22":16546,"_24":16547,"_28":1426,"_30":16549},"eigen.core.configureEigen","eigen.core.configureEigen(config)","Configure the Eigen WASM module loader.\r","Configure the Eigen WASM module loader.\r\n\r\nMust be called before loadEigenModule() if custom configuration is needed.",[16548],{"_16":8097,"_22":8790,"_69":6},[],{"_16":16551,"_18":16552,"_20":16553,"_22":16553,"_24":16554,"_28":16555,"_30":16556},"eigen.core.getEigenModule","eigen.core.getEigenModule()","Get the loaded Eigen WASM module.",[],"EigenModule",[],{"_16":16558,"_18":16559,"_20":16560,"_22":16560,"_24":16561,"_28":6903,"_30":16562},"eigen.core.isEigenLoaded","eigen.core.isEigenLoaded()","Check if the Eigen WASM module has been loaded.",[],[],{"_16":16564,"_18":16565,"_20":16566,"_22":16567,"_24":16568,"_28":16569,"_30":16570},"eigen.core.loadEigenModule","eigen.core.loadEigenModule()","Load and initialize the Eigen WASM module.\r","Load and initialize the Eigen WASM module.\r\n\r\nThis function is safe to call multiple times - the module is only loaded once\r\nand subsequent calls return the cached module.",[],"Promise",[],{"_16":16572,"_18":16573,"_20":16574,"_22":16575,"_24":16576,"_28":1426,"_30":16577},"eigen.core.resetEigenModule","eigen.core.resetEigenModule()","Reset the Eigen WASM module state.\r","Reset the Eigen WASM module state.\r\n\r\nThis clears the cached module and allows reconfiguration.\r\nUseful for testing or when module needs to be reloaded.",[],[],{"_16":16579,"_18":16580,"_20":16581,"_22":16582,"_24":16583,"_28":5703,"_30":16586},"eigen.core.allocateFloat64Array","eigen.core.allocateFloat64Array(size)","Eigen WASM Memory Management Utilities\r","Eigen WASM Memory Management Utilities\r\n\r\nHelper functions for managing memory transfers between JavaScript and WASM.\r\nEigen uses column-major storage order (Fortran-style), same as LAPACK.",[16584],{"_16":193,"_22":16585,"_69":6},"- Number of float64 elements to allocate",[],{"_16":16588,"_18":16589,"_20":16590,"_22":16590,"_24":16591,"_28":5703,"_30":16594},"eigen.core.allocateInt32Array","eigen.core.allocateInt32Array(size)","Allocate memory for an Int32Array on the WASM heap.",[16592],{"_16":193,"_22":16593,"_69":6},"- Number of int32 elements to allocate",[],{"_16":16596,"_18":16597,"_20":16598,"_22":16598,"_24":16599,"_28":5703,"_30":16600},"eigen.core.allocatePointer","eigen.core.allocatePointer()","Allocate memory for a pointer (used for output parameters).",[],[],{"_16":16602,"_18":16603,"_20":16604,"_22":16604,"_24":16605,"_28":4840,"_30":16610},"eigen.core.columnMajorToRowMajor","eigen.core.columnMajorToRowMajor(data, rows, cols)","Convert a column-major Float64Array to 2D row-major array.",[16606,16608,16609],{"_16":84,"_22":16607,"_69":6},"- Column-major data",{"_16":2472,"_22":4979,"_69":6},{"_16":2475,"_22":5507,"_69":6},[],{"_16":16612,"_18":16613,"_20":16614,"_22":16614,"_24":16615,"_28":5450,"_30":16620},"eigen.core.copyFromWasm","eigen.core.copyFromWasm(ptr, size)","Copy data from WASM heap memory to a new Float64Array.",[16616,16618],{"_16":4648,"_22":16617,"_69":6},"- Pointer to source data in WASM memory",{"_16":193,"_22":16619,"_69":6},"- Number of float64 elements to copy",[],{"_16":16622,"_18":16623,"_20":16624,"_22":16624,"_24":16625,"_28":4757,"_30":16629},"eigen.core.copyInt32FromWasm","eigen.core.copyInt32FromWasm(ptr, size)","Copy Int32 data from WASM heap memory to a new Int32Array.",[16626,16627],{"_16":4648,"_22":16617,"_69":6},{"_16":193,"_22":16628,"_69":6},"- Number of int32 elements to copy",[],{"_16":16631,"_18":16632,"_20":16633,"_22":16633,"_24":16634,"_28":5703,"_30":16637},"eigen.core.copyInt32ToWasm","eigen.core.copyInt32ToWasm(data)","Copy Int32 data to WASM heap memory.",[16635],{"_16":84,"_22":16636,"_69":6},"- Source data (Int32Array or number[])",[],{"_16":16639,"_18":16640,"_20":16641,"_22":16641,"_24":16642,"_28":5703,"_30":16645},"eigen.core.copyToWasm","eigen.core.copyToWasm(data)","Copy a JavaScript array to WASM heap memory.",[16643],{"_16":84,"_22":16644,"_69":6},"- Source data (Float64Array or number[])",[],{"_16":16647,"_18":16648,"_20":16649,"_22":16649,"_24":16650,"_28":1426,"_30":16653},"eigen.core.freeMemory","eigen.core.freeMemory(ptr)","Free memory on the WASM heap.",[16651],{"_16":4648,"_22":16652,"_69":6},"- Pointer to free (obtained from allocate* functions or _malloc)",[],{"_16":16655,"_18":16656,"_20":16657,"_22":16657,"_24":16658,"_28":5703,"_30":16662},"eigen.core.readPointer","eigen.core.readPointer(ptrPtr)","Read a pointer value from WASM memory.",[16659],{"_16":16660,"_22":16661,"_69":6},"ptrPtr","- Pointer to the pointer to read",[],{"_16":16664,"_18":16665,"_20":16666,"_22":16667,"_24":16668,"_28":16672,"_30":16673},"eigen.core.rowMajorToColumnMajor","eigen.core.rowMajorToColumnMajor(arr2d)","Convert a 2D row-major array to column-major Float64Array.\r","Convert a 2D row-major array to column-major Float64Array.\r\n\r\nEigen uses column-major storage (like Fortran/MATLAB), while JavaScript\r\ntypically uses row-major ordering. This function converts between them.",[16669],{"_16":16670,"_22":16671,"_69":6},"arr2d","- 2D array in row-major order (arr[row][col])","{\r\n data: Float64Array;\r\n rows: number;\r\n cols: number;\r\n}",[],{"_16":16675,"_18":16676,"_20":16677,"_22":16677,"_24":16678,"_28":5450,"_30":16683},"eigen.core.viewWasmMemory","eigen.core.viewWasmMemory(ptr, size)","Create a view into WASM heap memory without copying.",[16679,16681],{"_16":4648,"_22":16680,"_69":6},"- Pointer to data in WASM memory",{"_16":193,"_22":16682,"_69":6},"- Number of float64 elements",[],{"_16":16685,"_18":16686,"_20":16687,"_22":16688,"_24":16689,"_28":16690,"_30":16691},"eigen.core.getEigenWrappers","eigen.core.getEigenWrappers()","Get type-safe wrapped functions for all Eigen WASM operations.\r","Get type-safe wrapped functions for all Eigen WASM operations.\r\n\r\nThe wrappers are cached after first creation for performance.",[],"EigenWrappers",[],{"_16":16693,"_18":16694,"_20":16695,"_22":16696,"_24":16697,"_28":1426,"_30":16698},"eigen.core.resetWrappers","eigen.core.resetWrappers()","Reset the cached wrappers.\r","Reset the cached wrappers.\r\n\r\nCalled internally when the module is reset.",[],[],{"_16":16700,"_18":16701,"_20":16702,"_22":16702,"_24":16703,"_28":16706,"_30":16707},"eigen.decompositions.cholesky","eigen.decompositions.cholesky(A)","Compute Cholesky decomposition: A = LL^T",[16704],{"_16":659,"_22":16705,"_69":6},"- Symmetric positive-definite matrix","CholeskyResult",[],{"_16":16709,"_18":16710,"_20":16711,"_22":16711,"_24":16712,"_28":6903,"_30":16715},"eigen.decompositions.isPositiveDefinite","eigen.decompositions.isPositiveDefinite(A)","Check if a matrix is positive-definite by attempting Cholesky decomposition.",[16713],{"_16":659,"_22":16714,"_69":6},"- Symmetric matrix",[],{"_16":16717,"_18":16718,"_20":16719,"_22":16719,"_24":16720,"_28":6903,"_30":16725},"eigen.decompositions.isSymmetric","eigen.decompositions.isSymmetric(A, tol?)","Check if a matrix is symmetric within a tolerance.",[16721,16723],{"_16":659,"_22":16722,"_69":6},"- Matrix to check",{"_16":3719,"_22":16724,"_69":11},"- Tolerance for element comparison (default: 1e-10)",[],{"_16":16727,"_18":16728,"_20":16729,"_22":16729,"_24":16730,"_28":16732,"_30":16733},"eigen.decompositions.eig","eigen.decompositions.eig(A)","Compute eigenvalue decomposition for general (non-symmetric) matrices.",[16731],{"_16":659,"_22":12588,"_69":6},"EigResult",[],{"_16":16735,"_18":16736,"_20":16737,"_22":16737,"_24":16738,"_28":16740,"_30":16741},"eigen.decompositions.eigSymmetric","eigen.decompositions.eigSymmetric(A)","Compute eigenvalue decomposition for symmetric matrices: A = V * D * V^T",[16739],{"_16":659,"_22":16714,"_69":6},"EigSymmetricResult",[],{"_16":16743,"_18":16744,"_20":16745,"_22":16745,"_24":16746,"_28":16748,"_30":16749},"eigen.decompositions.eigvals","eigen.decompositions.eigvals(A)","Compute eigenvalues only for general matrices.",[16747],{"_16":659,"_22":12588,"_69":6},"{\r\n real: Float64Array;\r\n imag: Float64Array;\r\n}",[],{"_16":16751,"_18":16752,"_20":16753,"_22":16753,"_24":16754,"_28":5450,"_30":16756},"eigen.decompositions.eigvalsSymmetric","eigen.decompositions.eigvalsSymmetric(A)","Compute eigenvalues only for symmetric matrices.",[16755],{"_16":659,"_22":16714,"_69":6},[],{"_16":16758,"_18":16759,"_20":16760,"_22":16760,"_24":16761,"_28":6903,"_30":16763},"eigen.decompositions.hasNegativeEigenvalues","eigen.decompositions.hasNegativeEigenvalues(A)","Check if all eigenvalues have negative real parts.",[16762],{"_16":659,"_22":12588,"_69":6},[],{"_16":16765,"_18":16766,"_20":16767,"_22":16767,"_24":16768,"_28":6903,"_30":16770},"eigen.decompositions.hasPositiveEigenvalues","eigen.decompositions.hasPositiveEigenvalues(A)","Check if all eigenvalues have positive real parts.",[16769],{"_16":659,"_22":12588,"_69":6},[],{"_16":16772,"_18":16773,"_20":16774,"_22":16774,"_24":16775,"_28":6903,"_30":16779},"eigen.decompositions.hasRealEigenvalues","eigen.decompositions.hasRealEigenvalues(A, tol?)","Check if all eigenvalues are real (within tolerance).",[16776,16777],{"_16":659,"_22":12588,"_69":6},{"_16":3719,"_22":16778,"_69":11},"- Tolerance for imaginary parts (default: 1e-10)",[],{"_16":16781,"_18":16782,"_20":16783,"_22":16783,"_24":16784,"_28":5703,"_30":16786},"eigen.decompositions.spectralRadius","eigen.decompositions.spectralRadius(A)","Compute the spectral radius of a matrix.",[16785],{"_16":659,"_22":12588,"_69":6},[],{"_16":16788,"_18":16789,"_20":16790,"_22":16790,"_24":16791,"_28":6903,"_30":16795},"eigen.decompositions.isSingular","eigen.decompositions.isSingular(A, tol?)","Check if a matrix is singular (has zero or near-zero determinant).",[16792,16793],{"_16":659,"_22":12588,"_69":6},{"_16":3719,"_22":16794,"_69":11},"- Tolerance for zero comparison (default: 1e-14)",[],{"_16":16797,"_18":16798,"_20":16799,"_22":16799,"_24":16800,"_28":16803,"_30":16804},"eigen.decompositions.lu","eigen.decompositions.lu(A)","Compute LU decomposition with partial pivoting: PA = LU",[16801],{"_16":659,"_22":16802,"_69":6},"- Square matrix to decompose","LUResult",[],{"_16":16806,"_18":16807,"_20":16808,"_22":16808,"_24":16809,"_28":16812,"_30":16813},"eigen.decompositions.qr","eigen.decompositions.qr(A)","Compute QR decomposition: A = QR",[16810],{"_16":659,"_22":16811,"_69":6},"- Matrix to decompose (m × n)","QRResult",[],{"_16":16815,"_18":16816,"_20":16817,"_22":16817,"_24":16818,"_28":5703,"_30":16822},"eigen.decompositions.rankQR","eigen.decompositions.rankQR(A, tol?)","Compute the numerical rank of a matrix using QR decomposition.",[16819,16820],{"_16":659,"_22":10136,"_69":6},{"_16":3719,"_22":16821,"_69":11},"- Tolerance for zero diagonal elements (default: 1e-10)",[],{"_16":16824,"_18":16825,"_20":16826,"_22":16826,"_24":16827,"_28":5703,"_30":16829},"eigen.decompositions.condSVD","eigen.decompositions.condSVD(A)","Compute the condition number of a matrix using SVD.",[16828],{"_16":659,"_22":10136,"_69":6},[],{"_16":16831,"_18":16832,"_20":16833,"_22":16833,"_24":16834,"_28":16839,"_30":16840},"eigen.decompositions.pinv","eigen.decompositions.pinv(A, tol?)","Compute the Moore-Penrose pseudoinverse using SVD.",[16835,16837],{"_16":659,"_22":16836,"_69":6},"- Matrix (m × n)",{"_16":3719,"_22":16838,"_69":11},"- Tolerance for zero singular values","MatrixHandle",[],{"_16":16842,"_18":16843,"_20":16844,"_22":16844,"_24":16845,"_28":5703,"_30":16849},"eigen.decompositions.rankSVD","eigen.decompositions.rankSVD(A, tol?)","Compute the numerical rank of a matrix using SVD.",[16846,16847],{"_16":659,"_22":10136,"_69":6},{"_16":3719,"_22":16848,"_69":11},"- Tolerance for zero singular values (default: max(m,n) * eps * s[0])",[],{"_16":16851,"_18":16852,"_20":16853,"_22":16853,"_24":16854,"_28":16856,"_30":16857},"eigen.decompositions.svd","eigen.decompositions.svd(A)","Compute the Singular Value Decomposition: A = U * diag(S) * V^T",[16855],{"_16":659,"_22":16811,"_69":6},"SVDResult",[],{"_16":16859,"_18":16860,"_20":16861,"_22":16861,"_24":16862,"_28":5450,"_30":16864},"eigen.decompositions.svdvals","eigen.decompositions.svdvals(A)","Compute only the singular values of a matrix.",[16863],{"_16":659,"_22":16836,"_69":6},[],{"_16":16866,"_18":16867,"_20":16868,"_22":16868,"_24":16869,"_28":5703,"_30":16872},"eigen.dense.cols","eigen.dense.cols(A)","Get the number of columns in a matrix.",[16870],{"_16":659,"_22":16871,"_69":6},"- Matrix handle",[],{"_16":16874,"_18":16875,"_20":16876,"_22":16876,"_24":16877,"_28":5703,"_30":16879},"eigen.dense.dataPtr","eigen.dense.dataPtr(A)","Get the raw data pointer for a matrix.",[16878],{"_16":659,"_22":16871,"_69":6},[],{"_16":16881,"_18":16882,"_20":16883,"_22":16883,"_24":16884,"_28":1426,"_30":16887},"eigen.dense.destroy","eigen.dense.destroy(A)","Free the memory associated with a matrix.",[16885],{"_16":659,"_22":16886,"_69":6},"- Matrix handle to destroy",[],{"_16":16889,"_18":16890,"_20":16891,"_22":16891,"_24":16892,"_28":5703,"_30":16898},"eigen.dense.get","eigen.dense.get(A, i, j)","Get a single element from a matrix.",[16893,16894,16896],{"_16":659,"_22":16871,"_69":6},{"_16":6743,"_22":16895,"_69":6},"- Row index (0-based)",{"_16":6745,"_22":16897,"_69":6},"- Column index (0-based)",[],{"_16":16900,"_18":16901,"_20":16902,"_22":16902,"_24":16903,"_28":5450,"_30":16906},"eigen.dense.getCol","eigen.dense.getCol(A, j)","Get a column from a matrix as a Float64Array.",[16904,16905],{"_16":659,"_22":16871,"_69":6},{"_16":6745,"_22":16897,"_69":6},[],{"_16":16908,"_18":16909,"_20":16910,"_22":16910,"_24":16911,"_28":5450,"_30":16915},"eigen.dense.getDiag","eigen.dense.getDiag(A, k?)","Get the diagonal of a matrix as a Float64Array.",[16912,16913],{"_16":659,"_22":16871,"_69":6},{"_16":1114,"_22":16914,"_69":11},"- Diagonal offset (0 = main diagonal, >0 = above, <0 = below)",[],{"_16":16917,"_18":16918,"_20":16919,"_22":16919,"_24":16920,"_28":5450,"_30":16923},"eigen.dense.getRow","eigen.dense.getRow(A, i)","Get a row from a matrix as a Float64Array.",[16921,16922],{"_16":659,"_22":16871,"_69":6},{"_16":6743,"_22":16895,"_69":6},[],{"_16":16925,"_18":16926,"_20":16927,"_22":16927,"_24":16928,"_28":5703,"_30":16930},"eigen.dense.rows","eigen.dense.rows(A)","Get the number of rows in a matrix.",[16929],{"_16":659,"_22":16871,"_69":6},[],{"_16":16932,"_18":16933,"_20":16934,"_22":16934,"_24":16935,"_28":1426,"_30":16941},"eigen.dense.set","eigen.dense.set(A, i, j, value)","Set a single element in a matrix.",[16936,16937,16938,16939],{"_16":659,"_22":16871,"_69":6},{"_16":6743,"_22":16895,"_69":6},{"_16":6745,"_22":16897,"_69":6},{"_16":235,"_22":16940,"_69":6},"- Value to set",[],{"_16":16943,"_18":16944,"_20":16945,"_22":16945,"_24":16946,"_28":11164,"_30":16948},"eigen.dense.shape","eigen.dense.shape(A)","Get the shape of a matrix as [rows, cols].",[16947],{"_16":659,"_22":16871,"_69":6},[],{"_16":16950,"_18":16951,"_20":16952,"_22":16952,"_24":16953,"_28":5703,"_30":16955},"eigen.dense.size","eigen.dense.size(A)","Get the total number of elements in a matrix.",[16954],{"_16":659,"_22":16871,"_69":6},[],{"_16":16957,"_18":16958,"_20":16959,"_22":16959,"_24":16960,"_28":5450,"_30":16962},"eigen.dense.toArray","eigen.dense.toArray(A)","Convert a matrix to a Float64Array (column-major order).",[16961],{"_16":659,"_22":16871,"_69":6},[],{"_16":16964,"_18":16965,"_20":16966,"_22":16966,"_24":16967,"_28":4840,"_30":16969},"eigen.dense.toArray2D","eigen.dense.toArray2D(A)","Convert a matrix to a 2D JavaScript array (row-major order).",[16968],{"_16":659,"_22":16871,"_69":6},[],{"_16":16971,"_18":16972,"_20":16973,"_22":16974,"_24":16975,"_28":16839,"_30":16977},"eigen.dense.abs","eigen.dense.abs(A)","Eigenwasm - High-level TypeScript API for Eigen Linear Algebra Library\r","Eigenwasm - High-level TypeScript API for Eigen Linear Algebra Library\r\n\r\nThis package provides TypeScript bindings for the Eigen C++ linear algebra library\r\ncompiled to WebAssembly. It offers both functional and object-oriented APIs for\r\ndense matrices, vectors, sparse matrices, decompositions, and linear solvers.",[16976],{"_16":659,"_22":10136,"_69":6},[],{"_16":16979,"_18":16980,"_20":16981,"_22":16981,"_24":16982,"_28":16839,"_30":16987},"eigen.dense.add","eigen.dense.add(A, B)","Add two matrices: C = A + B",[16983,16985],{"_16":659,"_22":16984,"_69":6},"- First matrix",{"_16":656,"_22":16986,"_69":6},"- Second matrix (must have same dimensions as A)",[],{"_16":16989,"_18":16990,"_20":16991,"_22":16991,"_24":16992,"_28":16839,"_30":16997},"eigen.dense.addScalar","eigen.dense.addScalar(A, scalar)","Add a scalar to all elements: C = A + scalar",[16993,16994],{"_16":659,"_22":10136,"_69":6},{"_16":16995,"_22":16996,"_69":6},"scalar","- Scalar value to add",[],{"_16":16999,"_18":17000,"_20":17001,"_22":17001,"_24":17002,"_28":16839,"_30":17006},"eigen.dense.divScalar","eigen.dense.divScalar(A, scalar)","Divide all elements by a scalar: C = A / scalar",[17003,17004],{"_16":659,"_22":10136,"_69":6},{"_16":16995,"_22":17005,"_69":6},"- Scalar divisor",[],{"_16":17008,"_18":17009,"_20":17010,"_22":17010,"_24":17011,"_28":16839,"_30":17016},"eigen.dense.elementDiv","eigen.dense.elementDiv(A, B)","Element-wise division: C = A ./ B",[17012,17014],{"_16":659,"_22":17013,"_69":6},"- First matrix (numerator)",{"_16":656,"_22":17015,"_69":6},"- Second matrix (denominator, must have same dimensions as A)",[],{"_16":17018,"_18":17019,"_20":17020,"_22":17020,"_24":17021,"_28":16839,"_30":17024},"eigen.dense.elementMul","eigen.dense.elementMul(A, B)","Element-wise multiplication: C = A .* B",[17022,17023],{"_16":659,"_22":16984,"_69":6},{"_16":656,"_22":16986,"_69":6},[],{"_16":17026,"_18":17027,"_20":17028,"_22":17028,"_24":17029,"_28":16839,"_30":17032},"eigen.dense.elementPow","eigen.dense.elementPow(A, p)","Compute the power of each element: C = A .^ p",[17030,17031],{"_16":659,"_22":10136,"_69":6},{"_16":1645,"_22":5327,"_69":6},[],{"_16":17034,"_18":17035,"_20":17036,"_22":17036,"_24":17037,"_28":16839,"_30":17042},"eigen.dense.mul","eigen.dense.mul(A, B)","Multiply two matrices: C = A * B",[17038,17040],{"_16":659,"_22":17039,"_69":6},"- First matrix (m × k)",{"_16":656,"_22":17041,"_69":6},"- Second matrix (k × n)",[],{"_16":17044,"_18":17045,"_20":17046,"_22":17046,"_24":17047,"_28":16839,"_30":17049},"eigen.dense.neg","eigen.dense.neg(A)","Negate a matrix: C = -A",[17048],{"_16":659,"_22":10136,"_69":6},[],{"_16":17051,"_18":17052,"_20":17053,"_22":17053,"_24":17054,"_28":16839,"_30":17058},"eigen.dense.scale","eigen.dense.scale(A, scalar)","Multiply a matrix by a scalar: C = A * scalar",[17055,17056],{"_16":659,"_22":10136,"_69":6},{"_16":16995,"_22":17057,"_69":6},"- Scalar value",[],{"_16":17060,"_18":17061,"_20":17062,"_22":17062,"_24":17063,"_28":16839,"_30":17066},"eigen.dense.sqrt","eigen.dense.sqrt(A)","Compute element-wise square root: C = sqrt(A)",[17064],{"_16":659,"_22":17065,"_69":6},"- Matrix (elements should be non-negative)",[],{"_16":17068,"_18":17069,"_20":17070,"_22":17070,"_24":17071,"_28":16839,"_30":17074},"eigen.dense.sub","eigen.dense.sub(A, B)","Subtract two matrices: C = A - B",[17072,17073],{"_16":659,"_22":16984,"_69":6},{"_16":656,"_22":16986,"_69":6},[],{"_16":17076,"_18":17077,"_20":17078,"_22":17078,"_24":17079,"_28":16839,"_30":17083},"eigen.dense.subScalar","eigen.dense.subScalar(A, scalar)","Subtract a scalar from all elements: C = A - scalar",[17080,17081],{"_16":659,"_22":10136,"_69":6},{"_16":16995,"_22":17082,"_69":6},"- Scalar value to subtract",[],{"_16":17085,"_18":17086,"_20":17087,"_22":17087,"_24":17088,"_28":16839,"_30":17091},"eigen.dense.clone","eigen.dense.clone(A)","Create a deep copy of a matrix.",[17089],{"_16":659,"_22":17090,"_69":6},"- Matrix handle to copy",[],{"_16":17093,"_18":17094,"_20":17095,"_22":17095,"_24":17096,"_28":16839,"_30":17099},"eigen.dense.diag","eigen.dense.diag(values)","Create a diagonal matrix from a vector of diagonal values.",[17097],{"_16":2320,"_22":17098,"_69":6},"- Values to place on the diagonal",[],{"_16":17101,"_18":17102,"_20":15620,"_22":15620,"_24":17103,"_28":16839,"_30":17106},"eigen.dense.eye","eigen.dense.eye(n)",[17104],{"_16":362,"_22":17105,"_69":6},"- Size of the square matrix",[],{"_16":17108,"_18":17109,"_20":17110,"_22":17110,"_24":17111,"_28":16839,"_30":17114},"eigen.dense.fromArray2D","eigen.dense.fromArray2D(arr2d)","Create a matrix from a 2D JavaScript array (row-major order).",[17112],{"_16":16670,"_22":17113,"_69":6},"- 2D array where arr2d[i][j] is element at row i, column j",[],{"_16":17116,"_18":17117,"_20":17118,"_22":17118,"_24":17119,"_28":16839,"_30":17124},"eigen.dense.full","eigen.dense.full(rows, cols, value)","Create a matrix filled with a constant value.",[17120,17121,17122],{"_16":2472,"_22":4979,"_69":6},{"_16":2475,"_22":5507,"_69":6},{"_16":235,"_22":17123,"_69":6},"- Value to fill the matrix with",[],{"_16":17126,"_18":17127,"_20":17128,"_22":17129,"_24":17130,"_28":16839,"_30":17137},"eigen.dense.linspace","eigen.dense.linspace(start, end, n)","Create a matrix with linearly spaced values.\r","Create a matrix with linearly spaced values.\r\n\r\nCreates a row vector with `n` values linearly spaced between `start` and `end`.",[17131,17133,17135],{"_16":9325,"_22":17132,"_69":6},"- Starting value",{"_16":9328,"_22":17134,"_69":6},"- Ending value (inclusive)",{"_16":362,"_22":17136,"_69":6},"- Number of values",[],{"_16":17139,"_18":17140,"_20":17141,"_22":17141,"_24":17142,"_28":16839,"_30":17147},"eigen.dense.matrix","eigen.dense.matrix(data, rows, cols)","Create a matrix from a Float64Array (column-major order).",[17143,17145,17146],{"_16":84,"_22":17144,"_69":6},"- Matrix data in column-major order",{"_16":2472,"_22":4979,"_69":6},{"_16":2475,"_22":5507,"_69":6},[],{"_16":17149,"_18":17150,"_20":17151,"_22":17151,"_24":17152,"_28":16839,"_30":17155},"eigen.dense.ones","eigen.dense.ones(rows, cols)","Create a matrix filled with ones.",[17153,17154],{"_16":2472,"_22":4979,"_69":6},{"_16":2475,"_22":5507,"_69":6},[],{"_16":17157,"_18":17158,"_20":17159,"_22":17159,"_24":17160,"_28":16839,"_30":17163},"eigen.dense.random","eigen.dense.random(rows, cols)","Create a matrix with random values in the range [-1, 1].",[17161,17162],{"_16":2472,"_22":4979,"_69":6},{"_16":2475,"_22":5507,"_69":6},[],{"_16":17165,"_18":17166,"_20":17167,"_22":17167,"_24":17168,"_28":16839,"_30":17171},"eigen.dense.zeros","eigen.dense.zeros(rows, cols)","Create a matrix filled with zeros.",[17169,17170],{"_16":2472,"_22":4979,"_69":6},{"_16":2475,"_22":5507,"_69":6},[],{"_16":17173,"_18":17174,"_20":17175,"_22":17175,"_24":17176,"_28":6903,"_30":17178},"eigen.dense.allFinite","eigen.dense.allFinite(A)","Check if all matrix elements are finite (not NaN or Infinity).",[17177],{"_16":659,"_22":10136,"_69":6},[],{"_16":17180,"_18":17181,"_20":17182,"_22":17182,"_24":17183,"_28":5703,"_30":17185},"eigen.dense.det","eigen.dense.det(A)","Compute the determinant of a square matrix.",[17184],{"_16":659,"_22":12588,"_69":6},[],{"_16":17187,"_18":17188,"_20":17189,"_22":17189,"_24":17190,"_28":6903,"_30":17192},"eigen.dense.hasInf","eigen.dense.hasInf(A)","Check if a matrix contains any infinite values.",[17191],{"_16":659,"_22":10136,"_69":6},[],{"_16":17194,"_18":17195,"_20":17196,"_22":17196,"_24":17197,"_28":6903,"_30":17199},"eigen.dense.hasNaN","eigen.dense.hasNaN(A)","Check if a matrix contains any NaN values.",[17198],{"_16":659,"_22":10136,"_69":6},[],{"_16":17201,"_18":17202,"_20":17203,"_22":17203,"_24":17204,"_28":5703,"_30":17206},"eigen.dense.max","eigen.dense.max(A)","Find the maximum element in a matrix.",[17205],{"_16":659,"_22":10136,"_69":6},[],{"_16":17208,"_18":17209,"_20":17210,"_22":17210,"_24":17211,"_28":5703,"_30":17213},"eigen.dense.mean","eigen.dense.mean(A)","Compute the mean of all elements in a matrix.",[17212],{"_16":659,"_22":10136,"_69":6},[],{"_16":17215,"_18":17216,"_20":17217,"_22":17217,"_24":17218,"_28":5703,"_30":17220},"eigen.dense.min","eigen.dense.min(A)","Find the minimum element in a matrix.",[17219],{"_16":659,"_22":10136,"_69":6},[],{"_16":17222,"_18":17223,"_20":17224,"_22":17224,"_24":17225,"_28":5703,"_30":17227},"eigen.dense.norm","eigen.dense.norm(A)","Compute the Frobenius norm of a matrix: ||A||_F = sqrt(sum(a_ij^2))",[17226],{"_16":659,"_22":10136,"_69":6},[],{"_16":17229,"_18":17230,"_20":17231,"_22":17231,"_24":17232,"_28":5703,"_30":17234},"eigen.dense.norm1","eigen.dense.norm1(A)","Compute the 1-norm (maximum absolute column sum).",[17233],{"_16":659,"_22":10136,"_69":6},[],{"_16":17236,"_18":17237,"_20":17238,"_22":17238,"_24":17239,"_28":5703,"_30":17241},"eigen.dense.normInf","eigen.dense.normInf(A)","Compute the infinity-norm (maximum absolute row sum).",[17240],{"_16":659,"_22":10136,"_69":6},[],{"_16":17243,"_18":17244,"_20":17245,"_22":17245,"_24":17246,"_28":5703,"_30":17248},"eigen.dense.normMax","eigen.dense.normMax(A)","Compute the max norm (maximum absolute element).",[17247],{"_16":659,"_22":10136,"_69":6},[],{"_16":17250,"_18":17251,"_20":17252,"_22":17252,"_24":17253,"_28":5703,"_30":17255},"eigen.dense.normSquared","eigen.dense.normSquared(A)","Compute the squared Frobenius norm: ||A||_F^2 = sum(a_ij^2)",[17254],{"_16":659,"_22":10136,"_69":6},[],{"_16":17257,"_18":17258,"_20":17259,"_22":17259,"_24":17260,"_28":5703,"_30":17262},"eigen.dense.prod","eigen.dense.prod(A)","Compute the product of all elements in a matrix.",[17261],{"_16":659,"_22":10136,"_69":6},[],{"_16":17264,"_18":17265,"_20":17266,"_22":17266,"_24":17267,"_28":5703,"_30":17271},"eigen.dense.std","eigen.dense.std(A, ddof?)","Compute the standard deviation of all elements in a matrix.",[17268,17269],{"_16":659,"_22":10136,"_69":6},{"_16":10260,"_22":17270,"_69":11},"- Delta degrees of freedom (0 for population, 1 for sample std)",[],{"_16":17273,"_18":17274,"_20":17275,"_22":17275,"_24":17276,"_28":5703,"_30":17278},"eigen.dense.sum","eigen.dense.sum(A)","Compute the sum of all elements in a matrix.",[17277],{"_16":659,"_22":10136,"_69":6},[],{"_16":17280,"_18":17281,"_20":17282,"_22":17282,"_24":17283,"_28":5703,"_30":17286},"eigen.dense.trace","eigen.dense.trace(A)","Compute the trace of a matrix (sum of diagonal elements).",[17284],{"_16":659,"_22":17285,"_69":6},"- Matrix (typically square)",[],{"_16":17288,"_18":17289,"_20":17290,"_22":17290,"_24":17291,"_28":5703,"_30":17295},"eigen.dense.variance","eigen.dense.variance(A, ddof?)","Compute the variance of all elements in a matrix.",[17292,17293],{"_16":659,"_22":10136,"_69":6},{"_16":10260,"_22":17294,"_69":11},"- Delta degrees of freedom (0 for population, 1 for sample variance)",[],{"_16":17297,"_18":17298,"_20":17299,"_22":17299,"_24":17300,"_28":16839,"_30":17302},"eigen.dense.adjoint","eigen.dense.adjoint(A)","Compute the adjoint (conjugate transpose) of a matrix: B = A^H",[17301],{"_16":659,"_22":10136,"_69":6},[],{"_16":17304,"_18":17305,"_20":17306,"_22":17306,"_24":17307,"_28":16839,"_30":17310},"eigen.dense.conjugate","eigen.dense.conjugate(A)","Compute the complex conjugate of a matrix.",[17308],{"_16":659,"_22":17309,"_69":6},"- Matrix to conjugate",[],{"_16":17312,"_18":17313,"_20":17314,"_22":17314,"_24":17315,"_28":16839,"_30":17318},"eigen.dense.inverse","eigen.dense.inverse(A)","Compute the inverse of a square matrix: B = A^(-1)",[17316],{"_16":659,"_22":17317,"_69":6},"- Square matrix to invert",[],{"_16":17320,"_18":17321,"_20":17322,"_22":17322,"_24":17323,"_28":16839,"_30":17326},"eigen.dense.normalize","eigen.dense.normalize(A)","Compute the normalized matrix (divide by Frobenius norm).",[17324],{"_16":659,"_22":17325,"_69":6},"- Matrix to normalize",[],{"_16":17328,"_18":17329,"_20":17330,"_22":17330,"_24":17331,"_28":1426,"_30":17334},"eigen.dense.normalizeInPlace","eigen.dense.normalizeInPlace(A)","Normalize a matrix in-place (divide by Frobenius norm).",[17332],{"_16":659,"_22":17333,"_69":6},"- Matrix to normalize (modified in-place)",[],{"_16":17336,"_18":17337,"_20":17338,"_22":17338,"_24":17339,"_28":1426,"_30":17342},"eigen.dense.setIdentity","eigen.dense.setIdentity(A)","Set a matrix to identity in-place.",[17340],{"_16":659,"_22":17341,"_69":6},"- Square matrix to set to identity (modified in-place)",[],{"_16":17344,"_18":17345,"_20":17346,"_22":17346,"_24":17347,"_28":1426,"_30":17350},"eigen.dense.setOnes","eigen.dense.setOnes(A)","Set all matrix elements to one in-place.",[17348],{"_16":659,"_22":17349,"_69":6},"- Matrix to fill with ones (modified in-place)",[],{"_16":17352,"_18":17353,"_20":17354,"_22":17354,"_24":17355,"_28":1426,"_30":17358},"eigen.dense.setRandom","eigen.dense.setRandom(A)","Set all matrix elements to random values in [-1, 1] in-place.",[17356],{"_16":659,"_22":17357,"_69":6},"- Matrix to randomize (modified in-place)",[],{"_16":17360,"_18":17361,"_20":17362,"_22":17362,"_24":17363,"_28":1426,"_30":17366},"eigen.dense.setZero","eigen.dense.setZero(A)","Set all matrix elements to zero in-place.",[17364],{"_16":659,"_22":17365,"_69":6},"- Matrix to zero (modified in-place)",[],{"_16":17368,"_18":17369,"_20":17370,"_22":17370,"_24":17371,"_28":16839,"_30":17374},"eigen.dense.transpose","eigen.dense.transpose(A)","Compute the transpose of a matrix: B = A^T",[17372],{"_16":659,"_22":17373,"_69":6},"- Matrix to transpose",[],{"_16":17376,"_18":17377,"_20":17167,"_22":17167,"_24":17378,"_28":15514,"_30":17381},"eigen.dense.Matrix.zeros","eigen.dense.Matrix.zeros(rows, cols)",[17379,17380],{"_16":2472,"_22":5703,"_69":6},{"_16":2475,"_22":5703,"_69":6},[],{"_16":17383,"_18":17384,"_20":17151,"_22":17151,"_24":17385,"_28":15514,"_30":17388},"eigen.dense.Matrix.ones","eigen.dense.Matrix.ones(rows, cols)",[17386,17387],{"_16":2472,"_22":5703,"_69":6},{"_16":2475,"_22":5703,"_69":6},[],{"_16":17390,"_18":17391,"_20":15620,"_22":15620,"_24":17392,"_28":15514,"_30":17394},"eigen.dense.Matrix.eye","eigen.dense.Matrix.eye(n)",[17393],{"_16":362,"_22":5703,"_69":6},[],{"_16":17396,"_18":17397,"_20":17398,"_22":17398,"_24":17399,"_28":15514,"_30":17402},"eigen.dense.Matrix.random","eigen.dense.Matrix.random(rows, cols)","Create a matrix with random values in [-1, 1].",[17400,17401],{"_16":2472,"_22":5703,"_69":6},{"_16":2475,"_22":5703,"_69":6},[],{"_16":17404,"_18":17405,"_20":17406,"_22":17406,"_24":17407,"_28":15514,"_30":17409},"eigen.dense.Matrix.from","eigen.dense.Matrix.from(arr2d)","Create a matrix from a 2D array.",[17408],{"_16":16670,"_22":4840,"_69":6},[],{"_16":17411,"_18":17412,"_20":17413,"_22":17413,"_24":17414,"_28":15514,"_30":17418},"eigen.dense.Matrix.fromData","eigen.dense.Matrix.fromData(data, rows, cols)","Create a matrix from a Float64Array (column-major).",[17415,17416,17417],{"_16":84,"_22":5450,"_69":6},{"_16":2472,"_22":5703,"_69":6},{"_16":2475,"_22":5703,"_69":6},[],{"_16":17420,"_18":17421,"_20":17422,"_22":17422,"_24":17423,"_28":15514,"_30":17425},"eigen.dense.Matrix.diag","eigen.dense.Matrix.diag(values)","Create a diagonal matrix.",[17424],{"_16":2320,"_22":4712,"_69":6},[],{"_16":17427,"_18":17428,"_20":17118,"_22":17118,"_24":17429,"_28":15514,"_30":17433},"eigen.dense.Matrix.full","eigen.dense.Matrix.full(rows, cols, value)",[17430,17431,17432],{"_16":2472,"_22":5703,"_69":6},{"_16":2475,"_22":5703,"_69":6},{"_16":235,"_22":5703,"_69":6},[],{"_16":17435,"_18":17436,"_20":17437,"_22":17437,"_24":17438,"_28":17443,"_30":17444},"eigen.operators.addOp","eigen.operators.addOp(A, B)","Add two linear operators: (A + B) * x = A * x + B * x",[17439,17441],{"_16":659,"_22":17440,"_69":6},"- First linear operator",{"_16":656,"_22":17442,"_69":6},"- Second linear operator","LinearOperator",[],{"_16":17446,"_18":17447,"_20":17448,"_22":17448,"_24":17449,"_28":17443,"_30":17454},"eigen.operators.affineOp","eigen.operators.affineOp(A, b)","Create an operator that applies A and then adds a constant vector.",[17450,17452],{"_16":659,"_22":17451,"_69":6},"- Linear operator",{"_16":436,"_22":17453,"_69":6},"- Constant vector to add",[],{"_16":17456,"_18":17457,"_20":17458,"_22":17458,"_24":17459,"_28":17443,"_30":17467},"eigen.operators.blockDiagonalOp","eigen.operators.blockDiagonalOp(operators, inputDims, outputDims)","Create a block diagonal operator from multiple operators.",[17460,17463,17465],{"_16":17461,"_22":17462,"_69":6},"operators","- Array of linear operators for each block",{"_16":17464,"_22":4712,"_69":6},"inputDims",{"_16":17466,"_22":4712,"_69":6},"outputDims",[],{"_16":17469,"_18":17470,"_20":17471,"_22":17471,"_24":17472,"_28":17443,"_30":17474},"eigen.operators.cacheOp","eigen.operators.cacheOp(A)","Wrap an operator to cache its result for repeated calls with the same input.",[17473],{"_16":659,"_22":17451,"_69":6},[],{"_16":17476,"_18":17477,"_20":17478,"_22":17478,"_24":17479,"_28":17443,"_30":17484},"eigen.operators.composeOp","eigen.operators.composeOp(A, B)","Compose two linear operators: (A * B) * x = A(B(x))",[17480,17482],{"_16":659,"_22":17481,"_69":6},"- Outer operator (applied second)",{"_16":656,"_22":17483,"_69":6},"- Inner operator (applied first)",[],{"_16":17486,"_18":17487,"_20":17488,"_22":17488,"_24":17489,"_28":17443,"_30":17498},"eigen.operators.linearCombinationOp","eigen.operators.linearCombinationOp(alpha, A, beta, B)","Create a linear combination of operators: (alpha*A + beta*B) * x",[17490,17492,17494,17496],{"_16":4399,"_22":17491,"_69":6},"- Coefficient for A",{"_16":659,"_22":17493,"_69":6},"- First operator",{"_16":2011,"_22":17495,"_69":6},"- Coefficient for B",{"_16":656,"_22":17497,"_69":6},"- Second operator",[],{"_16":17500,"_18":17501,"_20":17502,"_22":17502,"_24":17503,"_28":17443,"_30":17505},"eigen.operators.negOp","eigen.operators.negOp(A)","Negate a linear operator: (-A) * x = -(A * x)",[17504],{"_16":659,"_22":17451,"_69":6},[],{"_16":17507,"_18":17508,"_20":17509,"_22":17509,"_24":17510,"_28":17443,"_30":17514},"eigen.operators.scaleOp","eigen.operators.scaleOp(A, alpha)","Scale a linear operator: (alpha * A) * x = alpha * (A * x)",[17511,17512],{"_16":659,"_22":17451,"_69":6},{"_16":4399,"_22":17513,"_69":6},"- Scalar multiplier",[],{"_16":17516,"_18":17517,"_20":17518,"_22":17518,"_24":17519,"_28":17443,"_30":17522},"eigen.operators.stackOp","eigen.operators.stackOp(operators)","Create an operator that applies multiple operators and returns the concatenated result.",[17520],{"_16":17461,"_22":17521,"_69":6},"- Array of linear operators",[],{"_16":17524,"_18":17525,"_20":17526,"_22":17526,"_24":17527,"_28":17443,"_30":17531},"eigen.operators.subOp","eigen.operators.subOp(A, B)","Subtract two linear operators: (A - B) * x = A * x - B * x",[17528,17529],{"_16":659,"_22":17440,"_69":6},{"_16":656,"_22":17530,"_69":6},"- Second linear operator (subtracted)",[],{"_16":17533,"_18":17534,"_20":17535,"_22":17535,"_24":17536,"_28":17443,"_30":17541},"eigen.operators.transposeOp","eigen.operators.transposeOp(_A, transposeOperator)","Create the transpose operator: A^T where A^T(y) = A^*(y) in the dual sense.",[17537,17539],{"_16":17538,"_22":17443,"_69":6},"_A",{"_16":17540,"_22":17443,"_69":6},"transposeOperator",[],{"_16":17543,"_18":17544,"_20":17545,"_22":17545,"_24":17546,"_28":17443,"_30":17549},"eigen.operators.denseMatvec","eigen.operators.denseMatvec(A)","Create a matrix-vector multiplication operator from a dense matrix.",[17547],{"_16":659,"_22":17548,"_69":6},"- Dense matrix handle",[],{"_16":17551,"_18":17552,"_20":17553,"_22":17553,"_24":17554,"_28":17443,"_30":17556},"eigen.operators.denseMatvecTranspose","eigen.operators.denseMatvecTranspose(A)","Create a transpose matrix-vector operator: x -> A^T * x",[17555],{"_16":659,"_22":17548,"_69":6},[],{"_16":17558,"_18":17559,"_20":17560,"_22":17560,"_24":17561,"_28":17443,"_30":17564},"eigen.operators.diagMatvec","eigen.operators.diagMatvec(d)","Create a diagonal matrix-vector operator from a vector of diagonal elements.",[17562],{"_16":1946,"_22":17563,"_69":6},"- Vector of diagonal elements",[],{"_16":17566,"_18":17567,"_20":17568,"_22":17568,"_24":17569,"_28":17443,"_30":17571},"eigen.operators.identityOp","eigen.operators.identityOp(n)","Create an identity operator: x -> x (copy)",[17570],{"_16":362,"_22":5401,"_69":6},[],{"_16":17573,"_18":17574,"_20":17575,"_22":17575,"_24":17576,"_28":17443,"_30":17579},"eigen.operators.sparseMatvec","eigen.operators.sparseMatvec(S)","Create a matrix-vector multiplication operator from a sparse matrix.",[17577],{"_16":2115,"_22":17578,"_69":6},"- Sparse matrix handle",[],{"_16":17581,"_18":17582,"_20":17583,"_22":17583,"_24":17584,"_28":17443,"_30":17587},"eigen.operators.symmetricMatvec","eigen.operators.symmetricMatvec(A)","Create a symmetric matrix-vector operator with only lower triangular storage.",[17585],{"_16":659,"_22":17586,"_69":6},"- Lower triangular part of a symmetric matrix",[],{"_16":17589,"_18":17590,"_20":17591,"_22":17591,"_24":17592,"_28":17443,"_30":17597},"eigen.operators.zeroOp","eigen.operators.zeroOp(m, n?)","Create a zero operator: x -> 0",[17593,17595],{"_16":359,"_22":17594,"_69":6},"- Output dimension",{"_16":362,"_22":17596,"_69":11},"- Input dimension (optional, defaults to m)",[],{"_16":17599,"_18":17600,"_20":17601,"_22":17601,"_24":17602,"_28":16839,"_30":17607},"eigen.solvers.solveCholesky","eigen.solvers.solveCholesky(A, b)","Solve the linear system Ax = b using Cholesky decomposition.",[17603,17605],{"_16":659,"_22":17604,"_69":6},"- Symmetric positive-definite coefficient matrix (n × n)",{"_16":436,"_22":17606,"_69":6},"- Right-hand side (n × 1 or n × k for multiple RHS)",[],{"_16":17609,"_18":17610,"_20":17611,"_22":17611,"_24":17612,"_28":16839,"_30":17617},"eigen.solvers.solveNormalEquations","eigen.solvers.solveNormalEquations(A, b)","Solve the normal equations A^T A x = A^T b using Cholesky decomposition.",[17613,17615],{"_16":659,"_22":17614,"_69":6},"- Coefficient matrix (m × n)",{"_16":436,"_22":17616,"_69":6},"- Right-hand side (m × 1)",[],{"_16":17619,"_18":17620,"_20":17621,"_22":17621,"_24":17622,"_28":16839,"_30":17625},"eigen.solvers.lstsq","eigen.solvers.lstsq(A, b)","Solve the least squares problem: minimize ||Ax - b||_2",[17623,17624],{"_16":659,"_22":17614,"_69":6},{"_16":436,"_22":17616,"_69":6},[],{"_16":17627,"_18":17628,"_20":17629,"_22":17629,"_24":17630,"_28":17635,"_30":17636},"eigen.solvers.lstsqFull","eigen.solvers.lstsqFull(A, b, rcond?)","Solve least squares with full diagnostic output.",[17631,17632,17633],{"_16":659,"_22":17614,"_69":6},{"_16":436,"_22":17616,"_69":6},{"_16":9884,"_22":17634,"_69":11},"- Cutoff for small singular values (default: machine epsilon * max(m,n))","LeastSquaresResult",[],{"_16":17638,"_18":17639,"_20":17640,"_22":17640,"_24":17641,"_28":16839,"_30":17646},"eigen.solvers.lstsqWeighted","eigen.solvers.lstsqWeighted(A, b, weights)","Solve weighted least squares: minimize ||W^(1/2)(Ax - b)||_2",[17642,17643,17644],{"_16":659,"_22":17614,"_69":6},{"_16":436,"_22":17616,"_69":6},{"_16":9614,"_22":17645,"_69":6},"- Weights vector (m × 1), non-negative",[],{"_16":17648,"_18":17649,"_20":17650,"_22":17650,"_24":17651,"_28":16839,"_30":17654},"eigen.solvers.inverseLU","eigen.solvers.inverseLU(A)","Compute the inverse of a matrix using LU decomposition.",[17652],{"_16":659,"_22":17653,"_69":6},"- Square matrix (n × n)",[],{"_16":17656,"_18":17657,"_20":17658,"_22":17658,"_24":17659,"_28":16839,"_30":17663},"eigen.solvers.solveLU","eigen.solvers.solveLU(A, b)","Solve the linear system Ax = b using LU decomposition.",[17660,17662],{"_16":659,"_22":17661,"_69":6},"- Square coefficient matrix (n × n)",{"_16":436,"_22":17606,"_69":6},[],{"_16":17665,"_18":17666,"_20":17667,"_22":17667,"_24":17668,"_28":16839,"_30":17672},"eigen.solvers.leastSquaresQR","eigen.solvers.leastSquaresQR(A, b)","Solve a least squares problem: minimize ||Ax - b||_2",[17669,17671],{"_16":659,"_22":17670,"_69":6},"- Coefficient matrix (m × n, typically m ≥ n)",{"_16":436,"_22":17616,"_69":6},[],{"_16":17674,"_18":17675,"_20":17676,"_22":17676,"_24":17677,"_28":16839,"_30":17681},"eigen.solvers.solveQR","eigen.solvers.solveQR(A, b)","Solve the linear system Ax = b using QR decomposition.",[17678,17680],{"_16":659,"_22":17679,"_69":6},"- Coefficient matrix (m × n, m ≥ n)",{"_16":436,"_22":17616,"_69":6},[],{"_16":17683,"_18":17684,"_20":6341,"_22":6341,"_24":17685,"_28":16839,"_30":17689},"eigen.solvers.solve","eigen.solvers.solve(A, b)",[17686,17688],{"_16":659,"_22":17687,"_69":6},"- Coefficient matrix (n × n for square, m × n for least squares)",{"_16":436,"_22":17606,"_69":6},[],{"_16":17691,"_18":17692,"_20":17693,"_22":17693,"_24":17694,"_28":16839,"_30":17699},"eigen.solvers.solveMultiple","eigen.solvers.solveMultiple(A, B)","Solve multiple linear systems with the same coefficient matrix.",[17695,17697],{"_16":659,"_22":17696,"_69":6},"- Coefficient matrix (n × n)",{"_16":656,"_22":17698,"_69":6},"- Right-hand sides matrix (n × k)",[],{"_16":17701,"_18":17702,"_20":17703,"_22":17703,"_24":17704,"_28":1426,"_30":17706},"eigen.sparse.destroySparse","eigen.sparse.destroySparse(S)","Destroy a sparse matrix and free its memory.",[17705],{"_16":2115,"_22":17578,"_69":6},[],{"_16":17708,"_18":17709,"_20":17710,"_22":17710,"_24":17711,"_28":17714,"_30":17715},"eigen.sparse.sparse","eigen.sparse.sparse(rows, cols)","Create an empty sparse matrix with given dimensions.",[17712,17713],{"_16":2472,"_22":4979,"_69":6},{"_16":2475,"_22":5507,"_69":6},"SparseMatrixHandle",[],{"_16":17717,"_18":17718,"_20":17719,"_22":17719,"_24":17720,"_28":17714,"_30":17723},"eigen.sparse.sparseDiag","eigen.sparse.sparseDiag(diagonal)","Create a sparse diagonal matrix.",[17721],{"_16":17722,"_22":17098,"_69":6},"diagonal",[],{"_16":17725,"_18":17726,"_20":17727,"_22":17727,"_24":17728,"_28":17714,"_30":17730},"eigen.sparse.sparseEye","eigen.sparse.sparseEye(n)","Create a sparse identity matrix.",[17729],{"_16":362,"_22":11569,"_69":6},[],{"_16":17732,"_18":17733,"_20":17734,"_22":17734,"_24":17735,"_28":17714,"_30":17746},"eigen.sparse.sparseFromCOO","eigen.sparse.sparseFromCOO(rows, cols, rowIndices, colIndices, values)","Create a sparse matrix from COO (Coordinate) format arrays.",[17736,17737,17738,17741,17744],{"_16":2472,"_22":4979,"_69":6},{"_16":2475,"_22":5507,"_69":6},{"_16":17739,"_22":17740,"_69":6},"rowIndices","- Array of row indices",{"_16":17742,"_22":17743,"_69":6},"colIndices","- Array of column indices",{"_16":2320,"_22":17745,"_69":6},"- Array of values",[],{"_16":17748,"_18":17749,"_20":17750,"_22":17750,"_24":17751,"_28":17714,"_30":17757},"eigen.sparse.sparseFromDense","eigen.sparse.sparseFromDense(denseHandle, tol?)","Create a sparse matrix from a dense matrix, keeping only non-zero elements.",[17752,17755],{"_16":17753,"_22":17754,"_69":6},"denseHandle","- Handle to dense matrix",{"_16":3719,"_22":17756,"_69":11},"- Tolerance for considering values as zero (default: 0)",[],{"_16":17759,"_18":17760,"_20":17761,"_22":17761,"_24":17762,"_28":17714,"_30":17768},"eigen.sparse.sparseFromTriplets","eigen.sparse.sparseFromTriplets(rows, cols, triplets)","Create a sparse matrix from a list of triplets (COO format).",[17763,17764,17765],{"_16":2472,"_22":4979,"_69":6},{"_16":2475,"_22":5507,"_69":6},{"_16":17766,"_22":17767,"_69":6},"triplets","- Array of {row, col, value} objects",[],{"_16":17770,"_18":17771,"_20":17772,"_22":17772,"_24":17773,"_28":17775,"_30":17776},"eigen.sparse.createMatvec","eigen.sparse.createMatvec(S)","Create a sparse matrix-vector product function (closure).",[17774],{"_16":2115,"_22":8321,"_69":6},"(x: VectorHandle) => VectorHandle",[],{"_16":17778,"_18":17779,"_20":17780,"_22":17780,"_24":17781,"_28":5703,"_30":17785},"eigen.sparse.density","eigen.sparse.density(S, rows, cols)","Get the density of a sparse matrix (nnz / total elements).",[17782,17783,17784],{"_16":2115,"_22":17578,"_69":6},{"_16":2472,"_22":4979,"_69":6},{"_16":2475,"_22":5507,"_69":6},[],{"_16":17787,"_18":17788,"_20":17789,"_22":17789,"_24":17790,"_28":6903,"_30":17792},"eigen.sparse.isEmpty","eigen.sparse.isEmpty(S)","Check if a sparse matrix is empty (has no non-zeros).",[17791],{"_16":2115,"_22":17578,"_69":6},[],{"_16":17794,"_18":17795,"_20":17796,"_22":17796,"_24":17797,"_28":5703,"_30":17799},"eigen.sparse.nnz","eigen.sparse.nnz(S)","Get the number of non-zero elements in a sparse matrix.",[17798],{"_16":2115,"_22":17578,"_69":6},[],{"_16":17801,"_18":17802,"_20":17803,"_22":17803,"_24":17804,"_28":17809,"_30":17810},"eigen.sparse.sparseMV","eigen.sparse.sparseMV(S, x)","Compute sparse matrix-vector product: y = S * x",[17805,17807],{"_16":2115,"_22":17806,"_69":6},"- Sparse matrix (m × n)",{"_16":498,"_22":17808,"_69":6},"- Input vector (n × 1)","VectorHandle",[],{"_16":17812,"_18":17813,"_20":17814,"_22":17814,"_24":17815,"_28":17809,"_30":17823},"eigen.sparse.sparseSolve","eigen.sparse.sparseSolve(S, b, method?)","Solve sparse linear system with automatic method selection.",[17816,17818,17820],{"_16":2115,"_22":17817,"_69":6},"- Sparse coefficient matrix (n × n)",{"_16":436,"_22":17819,"_69":6},"- Right-hand side vector (n × 1)",{"_16":17821,"_22":17822,"_69":11},"method","- Solver method: 'auto', 'lu', 'cg', 'bicgstab'",[],{"_16":17825,"_18":17826,"_20":17827,"_22":17827,"_24":17828,"_28":17809,"_30":17833},"eigen.sparse.sparseSolveBiCGSTAB","eigen.sparse.sparseSolveBiCGSTAB(S, b, _options?)","Solve sparse linear system Ax = b using BiCGSTAB method.",[17829,17830,17831],{"_16":2115,"_22":17817,"_69":6},{"_16":436,"_22":17819,"_69":6},{"_16":8336,"_22":17832,"_69":11},"IterativeSolverOptions",[],{"_16":17835,"_18":17836,"_20":17837,"_22":17837,"_24":17838,"_28":17809,"_30":17843},"eigen.sparse.sparseSolveCG","eigen.sparse.sparseSolveCG(S, b, _options?)","Solve sparse linear system Ax = b using Conjugate Gradient method.",[17839,17841,17842],{"_16":2115,"_22":17840,"_69":6},"- Sparse coefficient matrix (n × n), must be symmetric positive-definite",{"_16":436,"_22":17819,"_69":6},{"_16":8336,"_22":17832,"_69":11},[],{"_16":17845,"_18":17846,"_20":17847,"_22":17847,"_24":17848,"_28":17809,"_30":17851},"eigen.sparse.sparseSolveLU","eigen.sparse.sparseSolveLU(S, b)","Solve sparse linear system Ax = b using SparseLU (direct method).",[17849,17850],{"_16":2115,"_22":17817,"_69":6},{"_16":436,"_22":17819,"_69":6},[],{"_16":17853,"_18":17854,"_20":17710,"_22":17710,"_24":17855,"_28":4577,"_30":17858},"eigen.sparse.SparseMatrix.create","eigen.sparse.SparseMatrix.create(rows, cols)",[17856,17857],{"_16":2472,"_22":5703,"_69":6},{"_16":2475,"_22":5703,"_69":6},[],{"_16":17860,"_18":17861,"_20":17862,"_22":17862,"_24":17863,"_28":4577,"_30":17868},"eigen.sparse.SparseMatrix.fromTriplets","eigen.sparse.SparseMatrix.fromTriplets(rows, cols, triplets)","Create a sparse matrix from triplets (COO format).",[17864,17865,17866],{"_16":2472,"_22":4979,"_69":6},{"_16":2475,"_22":5507,"_69":6},{"_16":17766,"_22":17867,"_69":6},"- Array of {row, col, value} triplets",[],{"_16":17870,"_18":17871,"_20":17872,"_22":17872,"_24":17873,"_28":4577,"_30":17880},"eigen.sparse.SparseMatrix.fromCOO","eigen.sparse.SparseMatrix.fromCOO(rows, cols, rowIndices, colIndices, values)","Create a sparse matrix from separate COO arrays.",[17874,17875,17876,17877,17878],{"_16":2472,"_22":4979,"_69":6},{"_16":2475,"_22":5507,"_69":6},{"_16":17739,"_22":17740,"_69":6},{"_16":17742,"_22":17743,"_69":6},{"_16":2320,"_22":17879,"_69":6},"- Array of non-zero values",[],{"_16":17882,"_18":17883,"_20":17884,"_22":17885,"_24":17886,"_28":4577,"_30":17892},"eigen.sparse.SparseMatrix.fromDense","eigen.sparse.SparseMatrix.fromDense(data, tolerance?)","Create a sparse matrix from a dense 2D array.\r","Create a sparse matrix from a dense 2D array.\r\nOnly non-zero values are stored.",[17887,17889],{"_16":84,"_22":17888,"_69":6},"- 2D array in row-major order",{"_16":17890,"_22":17891,"_69":11},"tolerance","- Values with |value| < tolerance are treated as zero",[],{"_16":17894,"_18":17895,"_20":17727,"_22":17727,"_24":17896,"_28":4577,"_30":17899},"eigen.sparse.SparseMatrix.eye","eigen.sparse.SparseMatrix.eye(n)",[17897],{"_16":362,"_22":17898,"_69":6},"- Matrix dimension (n × n)",[],{"_16":17901,"_18":17902,"_20":17719,"_22":17719,"_24":17903,"_28":4577,"_30":17906},"eigen.sparse.SparseMatrix.diag","eigen.sparse.SparseMatrix.diag(diagonal)",[17904],{"_16":17722,"_22":17905,"_69":6},"- Diagonal values",[],{"_16":17908,"_18":17909,"_20":17910,"_22":17910,"_24":17911,"_28":4577,"_30":17920},"eigen.sparse.SparseMatrix.tridiag","eigen.sparse.SparseMatrix.tridiag(n, lower, main, upper)","Create a sparse tridiagonal matrix.",[17912,17913,17915,17918],{"_16":362,"_22":5524,"_69":6},{"_16":1123,"_22":17914,"_69":6},"- Value on sub-diagonal",{"_16":17916,"_22":17917,"_69":6},"main","- Value on main diagonal",{"_16":1137,"_22":17919,"_69":6},"- Value on super-diagonal",[],{"_16":17922,"_18":17923,"_20":17924,"_22":17924,"_24":17925,"_28":4577,"_30":17930},"eigen.sparse.SparseMatrix.banded","eigen.sparse.SparseMatrix.banded(n, bands)","Create a sparse matrix from a banded structure.",[17926,17927],{"_16":362,"_22":5524,"_69":6},{"_16":17928,"_22":17929,"_69":6},"bands","- Array of {offset, values} where offset is band position",[],{"_16":17932,"_18":17933,"_20":17934,"_22":17934,"_24":17935,"_28":16839,"_30":17950},"eigen.utilities.block","eigen.utilities.block(A, startRow, startCol, numRows, numCols)","Extract a submatrix (block) from a matrix.",[17936,17938,17941,17944,17947],{"_16":659,"_22":17937,"_69":6},"- Source matrix handle",{"_16":17939,"_22":17940,"_69":6},"startRow","- Starting row index (0-based)",{"_16":17942,"_22":17943,"_69":6},"startCol","- Starting column index (0-based)",{"_16":17945,"_22":17946,"_69":6},"numRows","- Number of rows in the block",{"_16":17948,"_22":17949,"_69":6},"numCols","- Number of columns in the block",[],{"_16":17952,"_18":17953,"_20":17954,"_22":17954,"_24":17955,"_28":16839,"_30":17959},"eigen.utilities.blockDiag","eigen.utilities.blockDiag(matrices)","Create a block diagonal matrix from multiple matrices.",[17956],{"_16":17957,"_22":17958,"_69":6},"matrices","- Array of matrix handles to place on the diagonal",[],{"_16":17961,"_18":17962,"_20":17963,"_22":17963,"_24":17964,"_28":17809,"_30":17967},"eigen.utilities.col","eigen.utilities.col(A, j)","Extract a column from a matrix as a vector.",[17965,17966],{"_16":659,"_22":16871,"_69":6},{"_16":6745,"_22":16897,"_69":6},[],{"_16":17969,"_18":17970,"_20":17971,"_22":17971,"_24":17972,"_28":17809,"_30":17976},"eigen.utilities.diagonal","eigen.utilities.diagonal(A, k?)","Extract the diagonal of a matrix as a vector.",[17973,17974],{"_16":659,"_22":16871,"_69":6},{"_16":1114,"_22":17975,"_69":11},"- Diagonal offset (0 = main, positive = above, negative = below)",[],{"_16":17978,"_18":17979,"_20":17980,"_22":17980,"_24":17981,"_28":17809,"_30":17985},"eigen.utilities.flatten","eigen.utilities.flatten(A, order?)","Flatten a matrix to a vector.",[17982,17983],{"_16":659,"_22":16871,"_69":6},{"_16":5562,"_22":17984,"_69":11},"- 'F' for column-major (default), 'C' for row-major",[],{"_16":17987,"_18":17988,"_20":17989,"_22":17989,"_24":17990,"_28":16839,"_30":17993},"eigen.utilities.hstack","eigen.utilities.hstack(matrices)","Horizontally concatenate matrices: [A, B, C, ...]",[17991],{"_16":17957,"_22":17992,"_69":6},"- Array of matrix handles to concatenate",[],{"_16":17995,"_18":17996,"_20":17997,"_22":17997,"_24":17998,"_28":16839,"_30":18006},"eigen.utilities.reshape","eigen.utilities.reshape(A, newRows, newCols)","Reshape a matrix to new dimensions.",[17999,18000,18003],{"_16":659,"_22":16871,"_69":6},{"_16":18001,"_22":18002,"_69":6},"newRows","- New number of rows",{"_16":18004,"_22":18005,"_69":6},"newCols","- New number of columns",[],{"_16":18008,"_18":18009,"_20":18010,"_22":18010,"_24":18011,"_28":17809,"_30":18014},"eigen.utilities.row","eigen.utilities.row(A, i)","Extract a row from a matrix as a vector.",[18012,18013],{"_16":659,"_22":16871,"_69":6},{"_16":6743,"_22":16895,"_69":6},[],{"_16":18016,"_18":18017,"_20":18018,"_22":18018,"_24":18019,"_28":16839,"_30":18023},"eigen.utilities.selectCols","eigen.utilities.selectCols(A, indices)","Extract columns from a matrix.",[18020,18021],{"_16":659,"_22":16871,"_69":6},{"_16":9786,"_22":18022,"_69":6},"- Array of column indices to extract",[],{"_16":18025,"_18":18026,"_20":18027,"_22":18027,"_24":18028,"_28":16839,"_30":18032},"eigen.utilities.selectRows","eigen.utilities.selectRows(A, indices)","Extract rows from a matrix.",[18029,18030],{"_16":659,"_22":16871,"_69":6},{"_16":9786,"_22":18031,"_69":6},"- Array of row indices to extract",[],{"_16":18034,"_18":18035,"_20":18036,"_22":18036,"_24":18037,"_28":1426,"_30":18044},"eigen.utilities.setBlock","eigen.utilities.setBlock(A, startRow, startCol, B)","Set a block of a matrix to values from another matrix.",[18038,18040,18041,18042],{"_16":659,"_22":18039,"_69":6},"- Target matrix handle (modified in place)",{"_16":17939,"_22":17940,"_69":6},{"_16":17942,"_22":17943,"_69":6},{"_16":656,"_22":18043,"_69":6},"- Source matrix containing values to set",[],{"_16":18046,"_18":18047,"_20":18048,"_22":18048,"_24":18049,"_28":1426,"_30":18055},"eigen.utilities.setCol","eigen.utilities.setCol(A, j, v)","Set a column of a matrix from a vector.",[18050,18052,18053],{"_16":659,"_22":18051,"_69":6},"- Matrix handle (modified in place)",{"_16":6745,"_22":16897,"_69":6},{"_16":2897,"_22":18054,"_69":6},"- Vector containing new column values",[],{"_16":18057,"_18":18058,"_20":18059,"_22":18059,"_24":18060,"_28":1426,"_30":18065},"eigen.utilities.setDiagonal","eigen.utilities.setDiagonal(A, v, k?)","Set the diagonal of a matrix from a vector.",[18061,18062,18064],{"_16":659,"_22":18051,"_69":6},{"_16":2897,"_22":18063,"_69":6},"- Vector containing diagonal values",{"_16":1114,"_22":17975,"_69":11},[],{"_16":18067,"_18":18068,"_20":18069,"_22":18069,"_24":18070,"_28":1426,"_30":18075},"eigen.utilities.setRow","eigen.utilities.setRow(A, i, v)","Set a row of a matrix from a vector.",[18071,18072,18073],{"_16":659,"_22":18051,"_69":6},{"_16":6743,"_22":16895,"_69":6},{"_16":2897,"_22":18074,"_69":6},"- Vector containing new row values",[],{"_16":18077,"_18":18078,"_20":18079,"_22":18079,"_24":18080,"_28":16839,"_30":18082},"eigen.utilities.vstack","eigen.utilities.vstack(matrices)","Vertically concatenate matrices: [A; B; C; ...]",[18081],{"_16":17957,"_22":17992,"_69":6},[],{"_16":18084,"_18":18085,"_20":16826,"_22":16826,"_24":18086,"_28":5703,"_30":18088},"eigen.utilities.cond","eigen.utilities.cond(A)",[18087],{"_16":659,"_22":16871,"_69":6},[],{"_16":18090,"_18":18091,"_20":18092,"_22":18092,"_24":18093,"_28":5703,"_30":18095},"eigen.utilities.frobeniusNorm","eigen.utilities.frobeniusNorm(A)","Compute the Frobenius norm of a matrix.",[18094],{"_16":659,"_22":16871,"_69":6},[],{"_16":18097,"_18":18098,"_20":18099,"_22":18099,"_24":18100,"_28":5703,"_30":18102},"eigen.utilities.nuclearNorm","eigen.utilities.nuclearNorm(A)","Compute the nuclear norm (trace norm) of a matrix.",[18101],{"_16":659,"_22":16871,"_69":6},[],{"_16":18104,"_18":18105,"_20":18106,"_22":18106,"_24":18107,"_28":18112,"_30":18113},"eigen.utilities.nullspace","eigen.utilities.nullspace(A, tolerance?)","Compute an orthonormal basis for the null space of A.",[18108,18110],{"_16":659,"_22":18109,"_69":6},"- Matrix handle (m × n)",{"_16":17890,"_22":18111,"_69":11},"- Singular values below this define the null space","VectorHandle[]",[],{"_16":18115,"_18":18116,"_20":18117,"_22":18117,"_24":18118,"_28":5703,"_30":18122},"eigen.utilities.numericalRank","eigen.utilities.numericalRank(A, tolerance?)","Compute the numerical rank using a tolerance.",[18119,18120],{"_16":659,"_22":16871,"_69":6},{"_16":17890,"_22":18121,"_69":11},"- Absolute tolerance for considering a singular value as zero",[],{"_16":18124,"_18":18125,"_20":18126,"_22":18126,"_24":18127,"_28":16839,"_30":18131},"eigen.utilities.pinv","eigen.utilities.pinv(A, tolerance?)","Compute the Moore-Penrose pseudoinverse of a matrix.",[18128,18129],{"_16":659,"_22":18109,"_69":6},{"_16":17890,"_22":18130,"_69":11},"- Singular values below this are treated as zero",[],{"_16":18133,"_18":18134,"_20":18135,"_22":18135,"_24":18136,"_28":18112,"_30":18139},"eigen.utilities.range","eigen.utilities.range(A, tolerance?)","Compute an orthonormal basis for the column space (range) of A.",[18137,18138],{"_16":659,"_22":18109,"_69":6},{"_16":17890,"_22":18130,"_69":11},[],{"_16":18141,"_18":18142,"_20":18143,"_22":18143,"_24":18144,"_28":5703,"_30":18147},"eigen.utilities.rank","eigen.utilities.rank(A, tolerance?)","Compute the matrix rank using SVD.",[18145,18146],{"_16":659,"_22":16871,"_69":6},{"_16":17890,"_22":18130,"_69":11},[],{"_16":18149,"_18":18150,"_20":18151,"_22":18151,"_24":18152,"_28":5703,"_30":18154},"eigen.utilities.spectralNorm","eigen.utilities.spectralNorm(A)","Compute the spectral norm (2-norm) of a matrix.",[18153],{"_16":659,"_22":16871,"_69":6},[],{"_16":18156,"_18":18157,"_20":18158,"_22":18158,"_24":18159,"_28":6903,"_30":18163},"eigen.utilities.isDiagonal","eigen.utilities.isDiagonal(A, tolerance?)","Check if a matrix is diagonal.",[18160,18161],{"_16":659,"_22":16871,"_69":6},{"_16":17890,"_22":18162,"_69":11},"- Maximum allowed off-diagonal value",[],{"_16":18165,"_18":18166,"_20":18167,"_22":18167,"_24":18168,"_28":6903,"_30":18175},"eigen.utilities.isEqual","eigen.utilities.isEqual(A, B, tolerance?)","Check if two matrices are equal within a tolerance.",[18169,18171,18173],{"_16":659,"_22":18170,"_69":6},"- First matrix handle",{"_16":656,"_22":18172,"_69":6},"- Second matrix handle",{"_16":17890,"_22":18174,"_69":11},"- Maximum allowed element-wise difference",[],{"_16":18177,"_18":18178,"_20":18179,"_22":18179,"_24":18180,"_28":6903,"_30":18184},"eigen.utilities.isIdentity","eigen.utilities.isIdentity(A, tolerance?)","Check if a matrix is the identity matrix.",[18181,18182],{"_16":659,"_22":16871,"_69":6},{"_16":17890,"_22":18183,"_69":11},"- Maximum allowed deviation",[],{"_16":18186,"_18":18187,"_20":18188,"_22":18188,"_24":18189,"_28":6903,"_30":18194},"eigen.utilities.isInvertible","eigen.utilities.isInvertible(A, tolerance?)","Check if a matrix is invertible (non-singular).",[18190,18192],{"_16":659,"_22":18191,"_69":6},"- Matrix handle (must be square)",{"_16":17890,"_22":18193,"_69":11},"- Tolerance for determinant check",[],{"_16":18196,"_18":18197,"_20":18198,"_22":18198,"_24":18199,"_28":6903,"_30":18203},"eigen.utilities.isLowerTriangular","eigen.utilities.isLowerTriangular(A, tolerance?)","Check if a matrix is lower triangular.",[18200,18201],{"_16":659,"_22":16871,"_69":6},{"_16":17890,"_22":18202,"_69":11},"- Maximum allowed above-diagonal value",[],{"_16":18205,"_18":18206,"_20":18207,"_22":18207,"_24":18208,"_28":6903,"_30":18212},"eigen.utilities.isOrthogonal","eigen.utilities.isOrthogonal(A, tolerance?)","Check if a matrix is orthogonal (A^T * A = I).",[18209,18210],{"_16":659,"_22":18191,"_69":6},{"_16":17890,"_22":18211,"_69":11},"- Maximum allowed deviation from identity",[],{"_16":18214,"_18":18215,"_20":18216,"_22":18216,"_24":18217,"_28":6903,"_30":18220},"eigen.utilities.isPositiveDefinite","eigen.utilities.isPositiveDefinite(A)","Check if a matrix is positive definite.",[18218],{"_16":659,"_22":18219,"_69":6},"- Matrix handle (must be square and symmetric)",[],{"_16":18222,"_18":18223,"_20":18224,"_22":18224,"_24":18225,"_28":6903,"_30":18229},"eigen.utilities.isPositiveSemiDefinite","eigen.utilities.isPositiveSemiDefinite(A, tolerance?)","Check if a matrix is positive semi-definite.",[18226,18227],{"_16":659,"_22":18191,"_69":6},{"_16":17890,"_22":18228,"_69":11},"- Tolerance for eigenvalue check",[],{"_16":18231,"_18":18232,"_20":18233,"_22":18233,"_24":18234,"_28":6903,"_30":18237},"eigen.utilities.isSingular","eigen.utilities.isSingular(A, tolerance?)","Check if a matrix is singular (determinant is zero).",[18235,18236],{"_16":659,"_22":18191,"_69":6},{"_16":17890,"_22":18193,"_69":11},[],{"_16":18239,"_18":18240,"_20":18241,"_22":18241,"_24":18242,"_28":6903,"_30":18244},"eigen.utilities.isSquare","eigen.utilities.isSquare(A)","Check if a matrix is square (rows == cols).",[18243],{"_16":659,"_22":16871,"_69":6},[],{"_16":18246,"_18":18247,"_20":18248,"_22":18248,"_24":18249,"_28":6903,"_30":18253},"eigen.utilities.isSymmetric","eigen.utilities.isSymmetric(A, tolerance?)","Check if a matrix is symmetric (A == A^T) within a tolerance.",[18250,18251],{"_16":659,"_22":18191,"_69":6},{"_16":17890,"_22":18252,"_69":11},"- Maximum allowed difference between A[i,j] and A[j,i]",[],{"_16":18255,"_18":18256,"_20":18257,"_22":18257,"_24":18258,"_28":6903,"_30":18262},"eigen.utilities.isUpperTriangular","eigen.utilities.isUpperTriangular(A, tolerance?)","Check if a matrix is upper triangular.",[18259,18260],{"_16":659,"_22":16871,"_69":6},{"_16":17890,"_22":18261,"_69":11},"- Maximum allowed below-diagonal value",[],{"_16":18264,"_18":18265,"_20":18266,"_22":18266,"_24":18267,"_28":6903,"_30":18271},"eigen.utilities.isZero","eigen.utilities.isZero(A, tolerance?)","Check if a matrix is the zero matrix.",[18268,18269],{"_16":659,"_22":16871,"_69":6},{"_16":17890,"_22":18270,"_69":11},"- Maximum allowed value",[],{"_16":18273,"_18":18274,"_20":18275,"_22":18275,"_24":18276,"_28":5703,"_30":18279},"eigen.vector.dataPtrVec","eigen.vector.dataPtrVec(v)","Get the raw data pointer for a vector.",[18277],{"_16":2897,"_22":18278,"_69":6},"- Vector handle",[],{"_16":18281,"_18":18282,"_20":18283,"_22":18283,"_24":18284,"_28":1426,"_30":18287},"eigen.vector.destroyVec","eigen.vector.destroyVec(v)","Free the memory associated with a vector.",[18285],{"_16":2897,"_22":18286,"_69":6},"- Vector handle to destroy",[],{"_16":18289,"_18":18290,"_20":18291,"_22":18291,"_24":18292,"_28":5703,"_30":18294},"eigen.vector.firstVec","eigen.vector.firstVec(v)","Get the first element of a vector.",[18293],{"_16":2897,"_22":18278,"_69":6},[],{"_16":18296,"_18":18297,"_20":18298,"_22":18298,"_24":18299,"_28":5703,"_30":18303},"eigen.vector.getVec","eigen.vector.getVec(v, i)","Get a single element from a vector.",[18300,18301],{"_16":2897,"_22":18278,"_69":6},{"_16":6743,"_22":18302,"_69":6},"- Index (0-based)",[],{"_16":18305,"_18":18306,"_20":18307,"_22":18307,"_24":18308,"_28":5703,"_30":18310},"eigen.vector.lastVec","eigen.vector.lastVec(v)","Get the last element of a vector.",[18309],{"_16":2897,"_22":18278,"_69":6},[],{"_16":18312,"_18":18313,"_20":18314,"_22":18314,"_24":18315,"_28":1426,"_30":18319},"eigen.vector.setVec","eigen.vector.setVec(v, i, value)","Set a single element in a vector.",[18316,18317,18318],{"_16":2897,"_22":18278,"_69":6},{"_16":6743,"_22":18302,"_69":6},{"_16":235,"_22":16940,"_69":6},[],{"_16":18321,"_18":18322,"_20":18323,"_22":18323,"_24":18324,"_28":5703,"_30":18326},"eigen.vector.sizeVec","eigen.vector.sizeVec(v)","Get the size (length) of a vector.",[18325],{"_16":2897,"_22":18278,"_69":6},[],{"_16":18328,"_18":18329,"_20":18330,"_22":18330,"_24":18331,"_28":5450,"_30":18337},"eigen.vector.sliceVec","eigen.vector.sliceVec(v, start, end)","Get a slice of a vector as a new Float64Array.",[18332,18333,18335],{"_16":2897,"_22":18278,"_69":6},{"_16":9325,"_22":18334,"_69":6},"- Start index (inclusive, 0-based)",{"_16":9328,"_22":18336,"_69":6},"- End index (exclusive)",[],{"_16":18339,"_18":18340,"_20":18341,"_22":18341,"_24":18342,"_28":5450,"_30":18344},"eigen.vector.toArrayVec","eigen.vector.toArrayVec(v)","Convert a vector to a Float64Array.",[18343],{"_16":2897,"_22":18278,"_69":6},[],{"_16":18346,"_18":18347,"_20":18348,"_22":18348,"_24":18349,"_28":4712,"_30":18351},"eigen.vector.toJSArrayVec","eigen.vector.toJSArrayVec(v)","Convert a vector to a JavaScript array.",[18350],{"_16":2897,"_22":18278,"_69":6},[],{"_16":18353,"_18":18354,"_20":18355,"_22":18355,"_24":18356,"_28":17809,"_30":18362},"eigen.vector.arangeVec","eigen.vector.arangeVec(start, end, step?)","Create a vector with values from start to end with given step.",[18357,18358,18360],{"_16":9325,"_22":17132,"_69":6},{"_16":9328,"_22":18359,"_69":6},"- Ending value (exclusive)",{"_16":9331,"_22":18361,"_69":11},"- Step size (default: 1)",[],{"_16":18364,"_18":18365,"_20":18366,"_22":18366,"_24":18367,"_28":17809,"_30":18372},"eigen.vector.basisVec","eigen.vector.basisVec(n, i)","Create a standard basis vector (one-hot vector).",[18368,18370],{"_16":362,"_22":18369,"_69":6},"- Vector length",{"_16":6743,"_22":18371,"_69":6},"- Index of the 1 element (0-based)",[],{"_16":18374,"_18":18375,"_20":18376,"_22":18376,"_24":18377,"_28":17809,"_30":18380},"eigen.vector.cloneVec","eigen.vector.cloneVec(v)","Create a copy of a vector.",[18378],{"_16":2897,"_22":18379,"_69":6},"- Vector to copy",[],{"_16":18382,"_18":18383,"_20":18384,"_22":18384,"_24":18385,"_28":17809,"_30":18389},"eigen.vector.fullVec","eigen.vector.fullVec(n, value)","Create a vector filled with a constant value.",[18386,18387],{"_16":362,"_22":18369,"_69":6},{"_16":235,"_22":18388,"_69":6},"- Fill value",[],{"_16":18391,"_18":18392,"_20":18393,"_22":18393,"_24":18394,"_28":17809,"_30":18398},"eigen.vector.linspaceVec","eigen.vector.linspaceVec(start, end, n)","Create a vector with linearly spaced values.",[18395,18396,18397],{"_16":9325,"_22":17132,"_69":6},{"_16":9328,"_22":17134,"_69":6},{"_16":362,"_22":17136,"_69":6},[],{"_16":18400,"_18":18401,"_20":18402,"_22":18402,"_24":18403,"_28":17809,"_30":18405},"eigen.vector.onesVec","eigen.vector.onesVec(n)","Create a vector filled with ones.",[18404],{"_16":362,"_22":18369,"_69":6},[],{"_16":18407,"_18":18408,"_20":18409,"_22":18409,"_24":18410,"_28":17809,"_30":18412},"eigen.vector.randomVec","eigen.vector.randomVec(n)","Create a vector with random values in [-1, 1].",[18411],{"_16":362,"_22":18369,"_69":6},[],{"_16":18414,"_18":18415,"_20":18416,"_22":18416,"_24":18417,"_28":17809,"_30":18420},"eigen.vector.vector","eigen.vector.vector(data)","Create a vector from a Float64Array.",[18418],{"_16":84,"_22":18419,"_69":6},"- Vector data",[],{"_16":18422,"_18":18423,"_20":18424,"_22":18424,"_24":18425,"_28":17809,"_30":18428},"eigen.vector.vectorFromArray","eigen.vector.vectorFromArray(arr)","Create a vector from a JavaScript array.",[18426],{"_16":9285,"_22":18427,"_69":6},"- Array of numbers",[],{"_16":18430,"_18":18431,"_20":18432,"_22":18432,"_24":18433,"_28":17809,"_30":18435},"eigen.vector.zerosVec","eigen.vector.zerosVec(n)","Create a vector filled with zeros.",[18434],{"_16":362,"_22":18369,"_69":6},[],{"_16":18437,"_18":18438,"_20":18439,"_22":18439,"_24":18440,"_28":17809,"_30":18445},"eigen.vector.addVec","eigen.vector.addVec(u, v)","Add two vectors: w = u + v",[18441,18443],{"_16":334,"_22":18442,"_69":6},"- First vector",{"_16":2897,"_22":18444,"_69":6},"- Second vector (must have same length)",[],{"_16":18447,"_18":18448,"_20":18449,"_22":18449,"_24":18450,"_28":5703,"_30":18453},"eigen.vector.angleVec","eigen.vector.angleVec(u, v)","Compute the angle between two vectors in radians.",[18451,18452],{"_16":334,"_22":18442,"_69":6},{"_16":2897,"_22":18444,"_69":6},[],{"_16":18455,"_18":18456,"_20":18457,"_22":18457,"_24":18458,"_28":17809,"_30":18463},"eigen.vector.cross","eigen.vector.cross(u, v)","Compute the cross product of two 3D vectors: u × v",[18459,18461],{"_16":334,"_22":18460,"_69":6},"- First 3D vector",{"_16":2897,"_22":18462,"_69":6},"- Second 3D vector",[],{"_16":18465,"_18":18466,"_20":18467,"_22":18467,"_24":18468,"_28":5703,"_30":18471},"eigen.vector.distanceVec","eigen.vector.distanceVec(u, v)","Compute the distance between two vectors: ||u - v||_2",[18469,18470],{"_16":334,"_22":18442,"_69":6},{"_16":2897,"_22":18444,"_69":6},[],{"_16":18473,"_18":18474,"_20":18475,"_22":18475,"_24":18476,"_28":5703,"_30":18480},"eigen.vector.dot","eigen.vector.dot(u, v)","Compute the dot product of two vectors: u · v",[18477,18478],{"_16":334,"_22":18442,"_69":6},{"_16":2897,"_22":18479,"_69":6},"- Second vector (must have same length as u)",[],{"_16":18482,"_18":18483,"_20":18484,"_22":18484,"_24":18485,"_28":17809,"_30":18488},"eigen.vector.elementMulVec","eigen.vector.elementMulVec(u, v)","Compute element-wise product: w_i = u_i * v_i",[18486,18487],{"_16":334,"_22":18442,"_69":6},{"_16":2897,"_22":18444,"_69":6},[],{"_16":18490,"_18":18491,"_20":18492,"_22":18492,"_24":18493,"_28":5703,"_30":18496},"eigen.vector.maxVec","eigen.vector.maxVec(v)","Find the maximum element.",[18494],{"_16":2897,"_22":18495,"_69":6},"- Vector",[],{"_16":18498,"_18":18499,"_20":18500,"_22":18500,"_24":18501,"_28":5703,"_30":18503},"eigen.vector.meanVec","eigen.vector.meanVec(v)","Compute the mean of all elements.",[18502],{"_16":2897,"_22":18495,"_69":6},[],{"_16":18505,"_18":18506,"_20":18507,"_22":18507,"_24":18508,"_28":5703,"_30":18510},"eigen.vector.minVec","eigen.vector.minVec(v)","Find the minimum element.",[18509],{"_16":2897,"_22":18495,"_69":6},[],{"_16":18512,"_18":18513,"_20":18514,"_22":18514,"_24":18515,"_28":17809,"_30":18517},"eigen.vector.negVec","eigen.vector.negVec(v)","Negate a vector: w = -v",[18516],{"_16":2897,"_22":18495,"_69":6},[],{"_16":18519,"_18":18520,"_20":18521,"_22":18521,"_24":18522,"_28":5703,"_30":18524},"eigen.vector.norm1Vec","eigen.vector.norm1Vec(v)","Compute the L1 norm (Manhattan norm): ||v||_1 = sum(|v_i|)",[18523],{"_16":2897,"_22":18495,"_69":6},[],{"_16":18526,"_18":18527,"_20":18528,"_22":18528,"_24":18529,"_28":17809,"_30":18532},"eigen.vector.normalizeVec","eigen.vector.normalizeVec(v)","Return a normalized copy of a vector.",[18530],{"_16":2897,"_22":18531,"_69":6},"- Vector to normalize",[],{"_16":18534,"_18":18535,"_20":18536,"_22":18536,"_24":18537,"_28":1426,"_30":18540},"eigen.vector.normalizeVecInPlace","eigen.vector.normalizeVecInPlace(v)","Normalize a vector in-place (divide by its norm).",[18538],{"_16":2897,"_22":18539,"_69":6},"- Vector to normalize (modified in-place)",[],{"_16":18542,"_18":18543,"_20":18544,"_22":18544,"_24":18545,"_28":5703,"_30":18547},"eigen.vector.normInfVec","eigen.vector.normInfVec(v)","Compute the infinity norm (max norm): ||v||_∞ = max(|v_i|)",[18546],{"_16":2897,"_22":18495,"_69":6},[],{"_16":18549,"_18":18550,"_20":18551,"_22":18551,"_24":18552,"_28":5703,"_30":18554},"eigen.vector.normSquaredVec","eigen.vector.normSquaredVec(v)","Compute the squared Euclidean norm: ||v||_2^2 = sum(v_i^2)",[18553],{"_16":2897,"_22":18495,"_69":6},[],{"_16":18556,"_18":18557,"_20":18558,"_22":18558,"_24":18559,"_28":5703,"_30":18561},"eigen.vector.normVec","eigen.vector.normVec(v)","Compute the Euclidean (L2) norm of a vector: ||v||_2 = sqrt(sum(v_i^2))",[18560],{"_16":2897,"_22":18495,"_69":6},[],{"_16":18563,"_18":18564,"_20":18565,"_22":18565,"_24":18566,"_28":17809,"_30":18570},"eigen.vector.scaleVec","eigen.vector.scaleVec(v, scalar)","Scale a vector: w = scalar * v",[18567,18568],{"_16":2897,"_22":18495,"_69":6},{"_16":16995,"_22":18569,"_69":6},"- Scale factor",[],{"_16":18572,"_18":18573,"_20":18574,"_22":18574,"_24":18575,"_28":17809,"_30":18578},"eigen.vector.subVec","eigen.vector.subVec(u, v)","Subtract two vectors: w = u - v",[18576,18577],{"_16":334,"_22":18442,"_69":6},{"_16":2897,"_22":18444,"_69":6},[],{"_16":18580,"_18":18581,"_20":18582,"_22":18582,"_24":18583,"_28":5703,"_30":18585},"eigen.vector.sumVec","eigen.vector.sumVec(v)","Compute the sum of all elements.",[18584],{"_16":2897,"_22":18495,"_69":6},[],{"_16":18587,"_18":18588,"_20":18432,"_22":18432,"_24":18589,"_28":6775,"_30":18591},"eigen.vector.Vector.zeros","eigen.vector.Vector.zeros(n)",[18590],{"_16":362,"_22":5703,"_69":6},[],{"_16":18593,"_18":18594,"_20":18402,"_22":18402,"_24":18595,"_28":6775,"_30":18597},"eigen.vector.Vector.ones","eigen.vector.Vector.ones(n)",[18596],{"_16":362,"_22":5703,"_69":6},[],{"_16":18599,"_18":18600,"_20":18409,"_22":18409,"_24":18601,"_28":6775,"_30":18603},"eigen.vector.Vector.random","eigen.vector.Vector.random(n)",[18602],{"_16":362,"_22":5703,"_69":6},[],{"_16":18605,"_18":18606,"_20":18424,"_22":18424,"_24":18607,"_28":6775,"_30":18609},"eigen.vector.Vector.from","eigen.vector.Vector.from(arr)",[18608],{"_16":9285,"_22":4712,"_69":6},[],{"_16":18611,"_18":18612,"_20":18416,"_22":18416,"_24":18613,"_28":6775,"_30":18615},"eigen.vector.Vector.fromData","eigen.vector.Vector.fromData(data)",[18614],{"_16":84,"_22":5450,"_69":6},[],{"_16":18617,"_18":18618,"_20":18384,"_22":18384,"_24":18619,"_28":6775,"_30":18622},"eigen.vector.Vector.full","eigen.vector.Vector.full(n, value)",[18620,18621],{"_16":362,"_22":5703,"_69":6},{"_16":235,"_22":5703,"_69":6},[],{"_16":18624,"_18":18625,"_20":18626,"_22":18626,"_24":18627,"_28":6775,"_30":18630},"eigen.vector.Vector.basis","eigen.vector.Vector.basis(n, i)","Create a standard basis vector (one-hot).",[18628,18629],{"_16":362,"_22":5703,"_69":6},{"_16":6743,"_22":5703,"_69":6},[],{"_16":18632,"_18":18633,"_20":18393,"_22":18393,"_24":18634,"_28":6775,"_30":18638},"eigen.vector.Vector.linspace","eigen.vector.Vector.linspace(start, end, n)",[18635,18636,18637],{"_16":9325,"_22":5703,"_69":6},{"_16":9328,"_22":5703,"_69":6},{"_16":362,"_22":5703,"_69":6},[],{"_43":18640,"_16":18641,"_22":18642,"_47":48,"_49":18643,"_51":18644,"_52":18645},"quad-generated","Numerical Integration (QUADPACK)","QUADPACK numerical integration routines.","∫","quad",[18646,18662,18676,18690,18701,18714,18725,18738,18748,18760,18773,18786,18795,18804,18811,18817,18824,18835,18843,18854,18865,18872,18879,18888,18895],{"_16":18647,"_18":18648,"_20":18649,"_22":18650,"_24":18651,"_28":18660,"_30":18661},"quad.integrateFns.integrate","quad.integrateFns.integrate(f, a, b, options?)","Compute the definite integral of f(x).\r","Compute the definite integral of f(x).\r\n\r\nThis is the unified integration API that automatically selects the\r\nmost appropriate QUADPACK routine based on the integration bounds\r\nand options provided.\r\n\r\n**Auto-detection logic:**\r\n1. If bounds include ±Infinity:\r\n - If omega specified: quad_fourier (Fourier transform)\r\n - Otherwise: quad_inf (infinite interval)\r\n2. If omega specified: quad_osc (oscillatory)\r\n3. If c specified: quad_cauchy (Cauchy principal value)\r\n4. If alfa or beta specified: quad_singular (algebraic singularities)\r\n5. If points specified: quad_break (user break points)\r\n6. If rule specified: quad_rule (explicit GK rule)\r\n7. Otherwise: quad (general adaptive)",[18652,18654,18656,18658],{"_16":3860,"_22":18653,"_69":6},"- The integrand function f(x)",{"_16":433,"_22":18655,"_69":6},"- Lower limit of integration (use -Infinity for lower infinite)",{"_16":436,"_22":18657,"_69":6},"- Upper limit of integration (use Infinity for upper infinite)",{"_16":4789,"_22":18659,"_69":11},"- Integration options","Promise",[],{"_16":18663,"_18":18664,"_20":18665,"_22":18666,"_24":18667,"_28":18660,"_30":18675},"quad.quadBreakFns.quad_break","quad.quadBreakFns.quad_break(f, a, b, options)","Compute the integral of f(x) over [a, b] with user-specified break points.\r","Compute the integral of f(x) over [a, b] with user-specified break points.\r\n\r\nUses QUADPACK's DQAGP routine. This is designed for integrands that have\r\nknown difficulties (discontinuities, peaks, rapid changes) at specific\r\npoints within the integration interval.\r\n\r\nThe algorithm subdivides at the specified break points, ensuring that\r\nno subinterval crosses these difficult locations.",[18668,18669,18671,18673],{"_16":3860,"_22":18653,"_69":6},{"_16":433,"_22":18670,"_69":6},"- Lower limit of integration",{"_16":436,"_22":18672,"_69":6},"- Upper limit of integration",{"_16":4789,"_22":18674,"_69":6},"- Integration options including break points",[],{"_16":18677,"_18":18678,"_20":18679,"_22":18680,"_24":18681,"_28":18688,"_30":18689},"quad.quadFixedFns.quad_fixed","quad.quadFixedFns.quad_fixed(f, a, b, rule)","Evaluate the integral of f(x) over [a, b] using a fixed Gauss-Kronrod rule.\r","Evaluate the integral of f(x) over [a, b] using a fixed Gauss-Kronrod rule.\r\n\r\nThis function applies a single Gauss-Kronrod quadrature rule without\r\nany adaptive subdivision. It's useful for:\r\n- Building custom integration strategies\r\n- Quick estimates when you know the function is smooth\r\n- Performance-critical code where overhead must be minimized\r\n\r\nAvailable rules:\r\n- 15-point: 7 Gauss + 8 Kronrod points (fastest)\r\n- 21-point: 10 Gauss + 11 Kronrod points\r\n- 31-point: 15 Gauss + 16 Kronrod points\r\n- 41-point: 20 Gauss + 21 Kronrod points\r\n- 51-point: 25 Gauss + 26 Kronrod points\r\n- 61-point: 30 Gauss + 31 Kronrod points (most accurate)",[18682,18683,18684,18685],{"_16":3860,"_22":18653,"_69":6},{"_16":433,"_22":18670,"_69":6},{"_16":436,"_22":18672,"_69":6},{"_16":18686,"_22":18687,"_69":6},"rule","- Gauss-Kronrod rule order (15, 21, 31, 41, 51, or 61)","Promise",[],{"_16":18691,"_18":18692,"_20":18693,"_22":18694,"_24":18695,"_28":18660,"_30":18700},"quad.quadFns.quad","quad.quadFns.quad(f, a, b, options?)","Compute the definite integral of f(x) over [a, b].\r","Compute the definite integral of f(x) over [a, b].\r\n\r\nUses QUADPACK's DQAGS routine, which is the best general-purpose\r\nadaptive integrator. It handles most integrands well, including\r\nthose with integrable singularities.",[18696,18697,18698,18699],{"_16":3860,"_22":18653,"_69":6},{"_16":433,"_22":18670,"_69":6},{"_16":436,"_22":18672,"_69":6},{"_16":4789,"_22":18659,"_69":11},[],{"_16":18702,"_18":18703,"_20":18704,"_22":18705,"_24":18706,"_28":18660,"_30":18713},"quad.quadInfFns.quad_inf","quad.quadInfFns.quad_inf(f, a, b, options?)","Compute the integral of f(x) over an infinite or semi-infinite interval.\r","Compute the integral of f(x) over an infinite or semi-infinite interval.\r\n\r\nUses QUADPACK's DQAGI routine. The interval type is determined\r\nautomatically from the bounds:\r\n- [a, Infinity]: Semi-infinite upper (∫[a,∞) f(x) dx)\r\n- [-Infinity, b]: Semi-infinite lower (∫(-∞,b] f(x) dx)\r\n- [-Infinity, Infinity]: Doubly infinite (∫(-∞,∞) f(x) dx)",[18707,18708,18710,18712],{"_16":3860,"_22":18653,"_69":6},{"_16":433,"_22":18709,"_69":6},"- Lower limit (use -Infinity for lower infinite)",{"_16":436,"_22":18711,"_69":6},"- Upper limit (use Infinity for upper infinite)",{"_16":4789,"_22":18659,"_69":11},[],{"_16":18715,"_18":18716,"_20":18717,"_22":18718,"_24":18719,"_28":18660,"_30":18724},"quad.quadNgFns.quad_ng","quad.quadNgFns.quad_ng(f, a, b, options?)","Compute the integral of f(x) over [a, b] using non-adaptive integration.\r","Compute the integral of f(x) over [a, b] using non-adaptive integration.\r\n\r\nUses QUADPACK's DQNG routine, which applies progressively higher-order\r\nGauss-Kronrod rules (10, 21, 43, 87 points) until the requested accuracy\r\nis achieved or all rules are exhausted.\r\n\r\nThis is the fastest integration routine but only suitable for smooth,\r\nwell-behaved functions without singularities or rapid oscillations.",[18720,18721,18722,18723],{"_16":3860,"_22":18653,"_69":6},{"_16":433,"_22":18670,"_69":6},{"_16":436,"_22":18672,"_69":6},{"_16":4789,"_22":18659,"_69":11},[],{"_16":18726,"_18":18727,"_20":18728,"_22":18729,"_24":18730,"_28":18660,"_30":18737},"quad.quadOscFns.quad_osc","quad.quadOscFns.quad_osc(f, a, b, options)","Compute the integral of f(x) * w(x) over [a, b] where w(x) is oscillatory.\r","Compute the integral of f(x) * w(x) over [a, b] where w(x) is oscillatory.\r\n\r\nUses QUADPACK's DQAWO routine. Computes integrals of the form:\r\n- ∫[a,b] f(x) * cos(ω*x) dx (when weight='cos')\r\n- ∫[a,b] f(x) * sin(ω*x) dx (when weight='sin')",[18731,18733,18734,18735],{"_16":3860,"_22":18732,"_69":6},"- The integrand function f(x) (without the oscillatory weight)",{"_16":433,"_22":18670,"_69":6},{"_16":436,"_22":18672,"_69":6},{"_16":4789,"_22":18736,"_69":6},"- Integration options (omega is required)",[],{"_16":18739,"_18":18740,"_20":18741,"_22":18742,"_24":18743,"_28":18660,"_30":18747},"quad.quadOscFns.quad_fourier","quad.quadOscFns.quad_fourier(f, a, options)","Compute the Fourier integral of f(x) * w(x) over [a, ∞).\r","Compute the Fourier integral of f(x) * w(x) over [a, ∞).\r\n\r\nUses QUADPACK's DQAWF routine. Computes integrals of the form:\r\n- ∫[a,∞) f(x) * cos(ω*x) dx (when weight='cos')\r\n- ∫[a,∞) f(x) * sin(ω*x) dx (when weight='sin')\r\n\r\nThe function f(x) should decay sufficiently fast as x → ∞.",[18744,18745,18746],{"_16":3860,"_22":18732,"_69":6},{"_16":433,"_22":18670,"_69":6},{"_16":4789,"_22":18736,"_69":6},[],{"_16":18749,"_18":18750,"_20":18751,"_22":18752,"_24":18753,"_28":18660,"_30":18759},"quad.quadRuleFns.quad_rule","quad.quadRuleFns.quad_rule(f, a, b, options?)","Compute the integral of f(x) over [a, b] with explicit Gauss-Kronrod rule.\r","Compute the integral of f(x) over [a, b] with explicit Gauss-Kronrod rule.\r\n\r\nUses QUADPACK's DQAG routine. This is similar to quad() but allows you\r\nto specify which Gauss-Kronrod rule to use for each subinterval.\r\n\r\nHigher-order rules are more efficient for smooth functions:\r\n- Rule 1 (GK15): 15-point rule, fastest per subdivision\r\n- Rule 2 (GK21): 21-point rule\r\n- Rule 3 (GK31): 31-point rule, good default\r\n- Rule 4 (GK41): 41-point rule\r\n- Rule 5 (GK51): 51-point rule\r\n- Rule 6 (GK61): 61-point rule, most accurate per subdivision",[18754,18755,18756,18757],{"_16":3860,"_22":18653,"_69":6},{"_16":433,"_22":18670,"_69":6},{"_16":436,"_22":18672,"_69":6},{"_16":4789,"_22":18758,"_69":11},"- Integration options including rule selection",[],{"_16":18761,"_18":18762,"_20":18763,"_22":18764,"_24":18765,"_28":18660,"_30":18772},"quad.quadSingularFns.quad_singular","quad.quadSingularFns.quad_singular(f, a, b, options)","Compute the integral of f(x) * w(x) over [a, b] with singular weight.\r","Compute the integral of f(x) * w(x) over [a, b] with singular weight.\r\n\r\nUses QUADPACK's DQAWS routine. Computes integrals of the form:\r\n∫[a,b] f(x) * (x-a)^α * (b-x)^β * v(x) dx\r\n\r\nwhere v(x) is an optional logarithmic factor:\r\n- wgtfunc=1: v(x) = 1\r\n- wgtfunc=2: v(x) = log(x-a)\r\n- wgtfunc=3: v(x) = log(b-x)\r\n- wgtfunc=4: v(x) = log(x-a) * log(b-x)",[18766,18768,18769,18770],{"_16":3860,"_22":18767,"_69":6},"- The integrand function f(x) (without the singular weight)",{"_16":433,"_22":18670,"_69":6},{"_16":436,"_22":18672,"_69":6},{"_16":4789,"_22":18771,"_69":6},"- Integration options (alfa and beta are required)",[],{"_16":18774,"_18":18775,"_20":18776,"_22":18777,"_24":18778,"_28":18660,"_30":18785},"quad.quadSingularFns.quad_cauchy","quad.quadSingularFns.quad_cauchy(f, a, b, options)","Compute the Cauchy principal value of f(x)/(x-c) over [a, b].\r","Compute the Cauchy principal value of f(x)/(x-c) over [a, b].\r\n\r\nUses QUADPACK's DQAWC routine. Computes:\r\nP.V. ∫[a,b] f(x) / (x-c) dx\r\n\r\nwhere c is a point in the open interval (a, b).",[18779,18781,18782,18783],{"_16":3860,"_22":18780,"_69":6},"- The integrand function f(x) (the numerator)",{"_16":433,"_22":18670,"_69":6},{"_16":436,"_22":18672,"_69":6},{"_16":4789,"_22":18784,"_69":6},"- Integration options (c is required)",[],{"_16":18787,"_18":18788,"_20":18789,"_22":18790,"_24":18791,"_28":1426,"_30":18794},"quad.configureQUADPACK","quad.configureQUADPACK(config)","QuadWasm - QUADPACK WebAssembly Module\r","QuadWasm - QUADPACK WebAssembly Module\r\n\r\nThis package provides a WebAssembly build of QUADPACK (Quadrature PACKage),\r\na Fortran library for numerical integration of one-dimensional functions.\r\n\r\n## High-Level API\r\n\r\nFor most use cases, use the high-level functions that handle all the\r\ncomplexity of memory management and callback registration:",[18792],{"_16":8097,"_22":18793,"_69":6},"QUADPACKLoadConfig",[],{"_16":18796,"_18":18797,"_20":18798,"_22":18798,"_24":18799,"_28":6108,"_30":18803},"quad.getQuadpackMessage","quad.getQuadpackMessage(ier)","Get human-readable error message for QUADPACK error code.",[18800],{"_16":18801,"_22":18802,"_69":6},"ier","- QUADPACK error code",[],{"_16":18805,"_18":18806,"_20":18807,"_22":5456,"_24":18808,"_28":18809,"_30":18810},"quad.getQUADPACKModule","quad.getQUADPACKModule()","getQUADPACKModule",[],"QUADPACKModule",[],{"_16":18812,"_18":18813,"_20":18814,"_22":5456,"_24":18815,"_28":6903,"_30":18816},"quad.isQUADPACKLoaded","quad.isQUADPACKLoaded()","isQUADPACKLoaded",[],[],{"_16":18818,"_18":18819,"_20":18820,"_22":5456,"_24":18821,"_28":18822,"_30":18823},"quad.loadQUADPACKModule","quad.loadQUADPACKModule()","loadQUADPACKModule",[],"Promise",[],{"_16":18825,"_18":18826,"_20":18827,"_22":18827,"_24":18828,"_28":5703,"_30":18834},"quad.quadBreakIworkSize","quad.quadBreakIworkSize(limit, npts)","Calculate integer workspace size for break point routines (DQAGP).",[18829,18832],{"_16":18830,"_22":18831,"_69":6},"limit","- Maximum number of subdivisions",{"_16":7130,"_22":18833,"_69":6},"- Number of break points (not including a and b)",[],{"_16":18836,"_18":18837,"_20":18838,"_22":18838,"_24":18839,"_28":5703,"_30":18842},"quad.quadBreakWorkSize","quad.quadBreakWorkSize(limit, npts)","Calculate workspace size for break point routines (DQAGP).",[18840,18841],{"_16":18830,"_22":18831,"_69":6},{"_16":7130,"_22":18833,"_69":6},[],{"_16":18844,"_18":18845,"_20":18846,"_22":18846,"_24":18847,"_28":5703,"_30":18853},"quad.quadFourierIworkSize","quad.quadFourierIworkSize(limlst, limit)","Calculate integer workspace size for Fourier routines (DQAWF).",[18848,18851],{"_16":18849,"_22":18850,"_69":6},"limlst","- Maximum number of cycles",{"_16":18830,"_22":18852,"_69":6},"- Maximum subdivisions per cycle",[],{"_16":18855,"_18":18856,"_20":18857,"_22":18857,"_24":18858,"_28":5703,"_30":18864},"quad.quadFourierWorkSize","quad.quadFourierWorkSize(limlst, limit, maxp1)","Calculate workspace size for Fourier routines (DQAWF).",[18859,18860,18861],{"_16":18849,"_22":18850,"_69":6},{"_16":18830,"_22":18852,"_69":6},{"_16":18862,"_22":18863,"_69":6},"maxp1","- Maximum Chebyshev moments",[],{"_16":18866,"_18":18867,"_20":18868,"_22":18868,"_24":18869,"_28":5703,"_30":18871},"quad.quadIworkSize","quad.quadIworkSize(limit)","Calculate integer workspace size for basic adaptive routines.",[18870],{"_16":18830,"_22":18831,"_69":6},[],{"_16":18873,"_18":18874,"_20":18875,"_22":18875,"_24":18876,"_28":5703,"_30":18878},"quad.quadOscIworkSize","quad.quadOscIworkSize(limit)","Calculate integer workspace size for oscillatory routines (DQAWO).",[18877],{"_16":18830,"_22":18831,"_69":6},[],{"_16":18880,"_18":18881,"_20":18882,"_22":18882,"_24":18883,"_28":5703,"_30":18887},"quad.quadOscWorkSize","quad.quadOscWorkSize(limit, maxp1)","Calculate workspace size for oscillatory routines (DQAWO).",[18884,18885],{"_16":18830,"_22":18831,"_69":6},{"_16":18862,"_22":18886,"_69":6},"- Maximum number of Chebyshev moments",[],{"_16":18889,"_18":18890,"_20":18891,"_22":18891,"_24":18892,"_28":5703,"_30":18894},"quad.quadWorkSize","quad.quadWorkSize(limit)","Calculate workspace size for basic adaptive routines (DQAGS, DQAG, etc.).",[18893],{"_16":18830,"_22":18831,"_69":6},[],{"_16":18896,"_18":18897,"_20":18898,"_22":5456,"_24":18899,"_28":1426,"_30":18900},"quad.resetQUADPACKModule","quad.resetQUADPACKModule()","resetQUADPACKModule",[],[],{"_43":18902,"_16":18903,"_22":18904,"_47":48,"_49":18905,"_51":18906,"_52":18907},"ar-generated","Eigenvalue Solvers (ARPACK)","ARPACK eigenvalue solvers for large sparse matrices.","λ","ar",[18908,18931,18947,18969,18989,19005,19018,19037,19053,19066,19078,19091,19104,19114,19122,19142,19158,19180,19197,19212,19226,19243,19257,19269,19285,19300,19312,19322,19337,19350,19362,19372,19384,19400,19409,19420,19428,19441,19451,19459,19466,19476,19488,19501,19511,19524,19539,19551,19564,19576,19588,19600,19615,19627,19636,19647,19656,19666,19679,19690,19705,19722,19737,19754,19773,19788,19801,19813,19821,19833,19842,19849,19857,19864,19872,19879,19886,19893,19900,19907,19913,19920,19926,19933,19940],{"_16":18909,"_18":18910,"_20":18911,"_22":18912,"_24":18913,"_28":8301,"_30":18930},"ar.advanced.bucklingEigs","ar.advanced.bucklingEigs(Kmatvec, Kgmatvec, solveShifted, n, nev, sigma, options?)","Compute buckling eigenvalues and modes.\r","Compute buckling eigenvalues and modes.\r\n\r\nSolves the buckling problem K*x = λ*Kg*x where:\r\n- K is the stiffness matrix (symmetric positive definite)\r\n- Kg is the geometric stiffness matrix (symmetric)\r\n- λ is the buckling load factor\r\n\r\nUses shift-invert buckling mode (ARPACK mode 4) to find eigenvalues\r\nnearest to the shift sigma.",[18914,18917,18920,18923,18924,18927,18929],{"_16":18915,"_22":18916,"_69":6},"Kmatvec","- Stiffness matrix operator K*x",{"_16":18918,"_22":18919,"_69":6},"Kgmatvec","- Geometric stiffness matrix operator Kg*x",{"_16":18921,"_22":18922,"_69":6},"solveShifted","- Solves (K - sigma*Kg)*y = x, returns y",{"_16":362,"_22":5524,"_69":6},{"_16":18925,"_22":18926,"_69":6},"nev","- Number of buckling modes to compute",{"_16":4421,"_22":18928,"_69":6},"- Shift value (find eigenvalues near sigma)",{"_16":4789,"_22":8287,"_69":11},[],{"_16":18932,"_18":18933,"_20":18934,"_22":18935,"_24":18936,"_28":18945,"_30":18946},"ar.advanced.criticalBucklingLoad","ar.advanced.criticalBucklingLoad(Kmatvec, Kgmatvec, solveShifted, n, options?)","Compute critical buckling load and mode.\r","Compute critical buckling load and mode.\r\n\r\nConvenience function that finds the smallest positive buckling\r\neigenvalue and its corresponding mode shape.",[18937,18939,18941,18943,18944],{"_16":18915,"_22":18938,"_69":6},"- Stiffness matrix operator",{"_16":18918,"_22":18940,"_69":6},"- Geometric stiffness matrix operator",{"_16":18921,"_22":18942,"_69":6},"- Solver for (K - sigma*Kg)*y = x",{"_16":362,"_22":5524,"_69":6},{"_16":4789,"_22":8287,"_69":11},"Promise",[],{"_16":18948,"_18":18949,"_20":18950,"_22":18951,"_24":18952,"_28":8301,"_30":18968},"ar.advanced.cayleyEigs","ar.advanced.cayleyEigs(Amatvec, Bmatvec, solveCayleyMinus, n, nev, sigma, options?)","Compute eigenvalues using the Cayley transform.\r","Compute eigenvalues using the Cayley transform.\r\n\r\nSolves A*x = λ*B*x using the Cayley transformation, which is useful\r\nwhen you want eigenvalues on both sides of a shift sigma.\r\n\r\nThe Cayley operator is: OP = inv(A - sigma*B) * (A + sigma*B)",[18953,18956,18959,18962,18963,18965,18967],{"_16":18954,"_22":18955,"_69":6},"Amatvec","- Matrix operator A*x",{"_16":18957,"_22":18958,"_69":6},"Bmatvec","- Matrix operator B*x (B must be symmetric positive definite)",{"_16":18960,"_22":18961,"_69":6},"solveCayleyMinus","- Solves (A - sigma*B)*y = x, returns y",{"_16":362,"_22":5524,"_69":6},{"_16":18925,"_22":18964,"_69":6},"- Number of eigenvalues to compute",{"_16":4421,"_22":18966,"_69":6},"- Shift value",{"_16":4789,"_22":8287,"_69":11},[],{"_16":18970,"_18":18971,"_20":18972,"_22":18973,"_24":18974,"_28":8301,"_30":18988},"ar.advanced.eigsInInterval","ar.advanced.eigsInInterval(Amatvec, Bmatvec, createSolver, n, nev, interval, options?)","Compute eigenvalues in an interval using Cayley transform.\r","Compute eigenvalues in an interval using Cayley transform.\r\n\r\nUses multiple Cayley transforms to find eigenvalues in a given interval\r\n[a, b] by placing the shift at the midpoint.",[18975,18976,18978,18981,18982,18984,18987],{"_16":18954,"_22":18955,"_69":6},{"_16":18957,"_22":18977,"_69":6},"- Matrix operator B*x",{"_16":18979,"_22":18980,"_69":6},"createSolver","- Function that creates a solver for (A - sigma*B)*y = x",{"_16":362,"_22":5524,"_69":6},{"_16":18925,"_22":18983,"_69":6},"- Number of eigenvalues to find",{"_16":18985,"_22":18986,"_69":6},"interval","- Interval [a, b] to search for eigenvalues",{"_16":4789,"_22":8287,"_69":11},[],{"_16":18990,"_18":18991,"_20":18992,"_22":18993,"_24":18994,"_28":19003,"_30":19004},"ar.complex.zeigs","ar.complex.zeigs(matvec, n, nev, options?)","Compute eigenvalues and eigenvectors of a complex matrix.\r","Compute eigenvalues and eigenvectors of a complex matrix.\r\n\r\nUses ARPACK's ZNAUPD/ZNEUPD routines with the Implicitly Restarted\r\nArnoldi Method. This is efficient for large sparse complex matrices\r\nwhere only a few eigenvalues are needed.",[18995,18998,19000,19002],{"_16":18996,"_22":18997,"_69":6},"matvec","- Function computing y = A*x where A is a complex matrix",{"_16":362,"_22":18999,"_69":6},"- Dimension of the matrix (A is n×n)",{"_16":18925,"_22":19001,"_69":6},"- Number of eigenvalues to compute (must satisfy 0 < nev < n-1)",{"_16":4789,"_22":8287,"_69":11},"Promise",[],{"_16":19006,"_18":19007,"_20":19008,"_22":19009,"_24":19010,"_28":19016,"_30":19017},"ar.complex.zeigsh","ar.complex.zeigsh(matvec, n, nev, options?)","Compute eigenvalues and eigenvectors of a complex Hermitian matrix.\r","Compute eigenvalues and eigenvectors of a complex Hermitian matrix.\r\n\r\nUses ARPACK's ZNAUPD/ZNEUPD routines with the Implicitly Restarted\r\nArnoldi Method. For Hermitian matrices, the eigenvalues are guaranteed\r\nto be real, but the eigenvectors are complex.",[19011,19013,19014,19015],{"_16":18996,"_22":19012,"_69":6},"- Function computing y = A*x where A is Hermitian (A = A^H)",{"_16":362,"_22":18999,"_69":6},{"_16":18925,"_22":19001,"_69":6},{"_16":4789,"_22":8287,"_69":11},"Promise",[],{"_16":19019,"_18":19020,"_20":19021,"_22":19022,"_24":19023,"_28":8301,"_30":19036},"ar.continuation.eigsDeflated","ar.continuation.eigsDeflated(matvec, n, nev, knownEigenvectors, knownEigenvalues?, options?)","Compute eigenvalues with deflation against known eigenvectors.\r","Compute eigenvalues with deflation against known eigenvectors.\r\n\r\nThis modifies the matrix operator to project out the known eigenvectors,\r\nensuring that the new eigenvalues are orthogonal to the known subspace.",[19024,19026,19027,19029,19032,19035],{"_16":18996,"_22":19025,"_69":6},"- Symmetric matrix operator A*x",{"_16":362,"_22":5524,"_69":6},{"_16":18925,"_22":19028,"_69":6},"- Number of new eigenvalues to compute",{"_16":19030,"_22":19031,"_69":6},"knownEigenvectors","- Known eigenvectors to deflate",{"_16":19033,"_22":19034,"_69":11},"knownEigenvalues","- Eigenvalues corresponding to known eigenvectors (optional)",{"_16":4789,"_22":8287,"_69":11},[],{"_16":19038,"_18":19039,"_20":19040,"_22":19041,"_24":19042,"_28":8301,"_30":19052},"ar.continuation.eigsContinue","ar.continuation.eigsContinue(matvec, n, additionalNev, previousResult, options?)","Continue eigenvalue computation from a previous result.\r","Continue eigenvalue computation from a previous result.\r\n\r\nComputes additional eigenvalues while excluding those already found.",[19043,19044,19045,19048,19051],{"_16":18996,"_22":18955,"_69":6},{"_16":362,"_22":5524,"_69":6},{"_16":19046,"_22":19047,"_69":6},"additionalNev","- Number of additional eigenvalues to compute",{"_16":19049,"_22":19050,"_69":6},"previousResult","- Result from previous eigs call",{"_16":4789,"_22":8287,"_69":11},[],{"_16":19054,"_18":19055,"_20":19056,"_22":19056,"_24":19057,"_28":19064,"_30":19065},"ar.continuation.eignDeflated","ar.continuation.eignDeflated(matvec, n, nev, knownEigenvectors, options?)","Compute non-symmetric eigenvalues with deflation.",[19058,19060,19061,19062,19063],{"_16":18996,"_22":19059,"_69":6},"- Non-symmetric matrix operator A*x",{"_16":362,"_22":5524,"_69":6},{"_16":18925,"_22":18964,"_69":6},{"_16":19030,"_22":19031,"_69":6},{"_16":4789,"_22":8287,"_69":11},"Promise",[],{"_16":19067,"_18":19068,"_20":19069,"_22":19070,"_24":19071,"_28":19064,"_30":19077},"ar.core.eign","ar.core.eign(matvec, n, nev, options?)","Compute eigenvalues and eigenvectors of a real non-symmetric matrix.\r","Compute eigenvalues and eigenvectors of a real non-symmetric matrix.\r\n\r\nUses ARPACK's DNAUPD/DNEUPD routines with the Implicitly Restarted\r\nArnoldi Method. This handles general (non-symmetric) matrices where\r\neigenvalues may be complex.",[19072,19074,19075,19076],{"_16":18996,"_22":19073,"_69":6},"- Function computing y = A*x",{"_16":362,"_22":18999,"_69":6},{"_16":18925,"_22":19001,"_69":6},{"_16":4789,"_22":8287,"_69":11},[],{"_16":19079,"_18":19080,"_20":19081,"_22":19082,"_24":19083,"_28":8301,"_30":19090},"ar.core.eigs","ar.core.eigs(matvec, n, nev, options?)","Compute eigenvalues and eigenvectors of a real symmetric matrix.\r","Compute eigenvalues and eigenvectors of a real symmetric matrix.\r\n\r\nUses ARPACK's DSAUPD/DSEUPD routines with the Implicitly Restarted\r\nLanczos Method. This is efficient for large sparse symmetric matrices\r\nwhere only a few eigenvalues are needed.",[19084,19086,19087,19089],{"_16":18996,"_22":19085,"_69":6},"- Function computing y = A*x where A is symmetric",{"_16":362,"_22":18999,"_69":6},{"_16":18925,"_22":19088,"_69":6},"- Number of eigenvalues to compute (must satisfy 0 < nev < n)",{"_16":4789,"_22":8287,"_69":11},[],{"_16":19092,"_18":19093,"_20":19094,"_22":19095,"_24":19096,"_28":19102,"_30":19103},"ar.core.eigsh","ar.core.eigsh(matvec, n, nev, options?)","Compute eigenvalues and eigenvectors of a sparse matrix.\r","Compute eigenvalues and eigenvectors of a sparse matrix.\r\n\r\nThis is the unified API that dispatches to the appropriate solver:\r\n- 'symmetric' (default): Uses Lanczos method (more efficient for symmetric matrices)\r\n- 'nonsymmetric': Uses Arnoldi method (handles non-symmetric matrices, complex eigenvalues)",[19097,19098,19099,19100],{"_16":18996,"_22":19073,"_69":6},{"_16":362,"_22":18999,"_69":6},{"_16":18925,"_22":18964,"_69":6},{"_16":4789,"_22":19101,"_69":11},"- Solver options including problem type","Promise",[],{"_16":19105,"_18":19106,"_20":19107,"_22":19107,"_24":19108,"_28":19112,"_30":19113},"ar.core.isEigsResult","ar.core.isEigsResult(result)","Type guard to check if a result is from the symmetric solver.",[19109],{"_16":19110,"_22":19111,"_69":6},"result","- Result from eigsh","result is EigsResult",[],{"_16":19115,"_18":19116,"_20":19117,"_22":19117,"_24":19118,"_28":19120,"_30":19121},"ar.core.isEignResult","ar.core.isEignResult(result)","Type guard to check if a result is from the non-symmetric solver.",[19119],{"_16":19110,"_22":19111,"_69":6},"result is EignResult",[],{"_16":19123,"_18":19124,"_20":19125,"_22":19126,"_24":19127,"_28":19140,"_30":19141},"ar.dimred.spectralEmbedding","ar.dimred.spectralEmbedding(affinityMatvec, degrees, n, nComponents, options?)","Compute spectral embedding (Laplacian Eigenmaps) for dimensionality reduction.\r","Compute spectral embedding (Laplacian Eigenmaps) for dimensionality reduction.\r\n\r\nProjects data points to a lower-dimensional space by computing the\r\nsmallest eigenvectors of the graph Laplacian of an affinity matrix.",[19128,19131,19134,19136,19139],{"_16":19129,"_22":19130,"_69":6},"affinityMatvec","- Function computing y = W*x where W is the affinity matrix",{"_16":19132,"_22":19133,"_69":6},"degrees","- Degree of each node (row sums of W), or function computing D*x",{"_16":362,"_22":19135,"_69":6},"- Number of data points",{"_16":19137,"_22":19138,"_69":6},"nComponents","- Number of dimensions in the embedding",{"_16":4789,"_22":8287,"_69":11},"Promise",[],{"_16":19143,"_18":19144,"_20":19145,"_22":19146,"_24":19147,"_28":19156,"_30":19157},"ar.dimred.truncatedPCA","ar.dimred.truncatedPCA(covarianceMatvec, n, nComponents, options?)","Compute truncated PCA via eigendecomposition of the covariance matrix.\r","Compute truncated PCA via eigendecomposition of the covariance matrix.\r\n\r\nFinds the top principal components by computing the largest eigenvalues\r\nand eigenvectors of X^T * X / (n-1) or a provided covariance matvec.",[19148,19151,19153,19155],{"_16":19149,"_22":19150,"_69":6},"covarianceMatvec","- Function computing y = C*x where C is the covariance matrix",{"_16":362,"_22":19152,"_69":6},"- Dimensionality (number of features)",{"_16":19137,"_22":19154,"_69":6},"- Number of principal components to compute",{"_16":4789,"_22":8287,"_69":11},"Promise",[],{"_16":19159,"_18":19160,"_20":19161,"_22":19162,"_24":19163,"_28":19156,"_30":19179},"ar.dimred.truncatedPCAfromData","ar.dimred.truncatedPCAfromData(dataMatvec, dataMatvecT, nSamples, nFeatures, nComponents, options?)","Compute truncated PCA directly from a data matrix via SVD.\r","Compute truncated PCA directly from a data matrix via SVD.\r\n\r\nThis version uses SVD of the centered data matrix X, which is\r\nequivalent to eigendecomposition of the covariance matrix but\r\ncan be more numerically stable.",[19164,19167,19170,19173,19176,19178],{"_16":19165,"_22":19166,"_69":6},"dataMatvec","- Function computing y = X*v (nSamples x nFeatures matrix times nFeatures-vector)",{"_16":19168,"_22":19169,"_69":6},"dataMatvecT","- Function computing y = X^T*v (nFeatures x nSamples matrix times nSamples-vector)",{"_16":19171,"_22":19172,"_69":6},"nSamples","- Number of samples (rows)",{"_16":19174,"_22":19175,"_69":6},"nFeatures","- Number of features (columns)",{"_16":19137,"_22":19177,"_69":6},"- Number of principal components",{"_16":4789,"_22":8287,"_69":11},[],{"_16":19181,"_18":19182,"_20":19183,"_22":19184,"_24":19185,"_28":19064,"_30":19196},"ar.generalized.eignNear","ar.generalized.eignNear(matvec, solveShifted, n, nev, sigma, options?)","Find eigenvalues of a non-symmetric matrix nearest to a target value.\r","Find eigenvalues of a non-symmetric matrix nearest to a target value.\r\n\r\nThis is a convenience wrapper for shift-invert mode. You provide a\r\nfunction to solve (A - σI)x = b and this function finds eigenvalues\r\nclosest to σ.\r\n\r\nFor non-symmetric matrices, the shift σ can be complex. When σ is\r\ncomplex, the solver uses the real arithmetic formulation with both\r\nreal and imaginary shift components.",[19186,19187,19189,19191,19192,19194],{"_16":18996,"_22":19073,"_69":6},{"_16":18921,"_22":19188,"_69":6},"- Function solving (A - σI)x = b for real σ,\r\n or the appropriate shifted system for complex σ",{"_16":362,"_22":19190,"_69":6},"- Dimension of the matrix",{"_16":18925,"_22":18983,"_69":6},{"_16":4421,"_22":19193,"_69":6},"- Target value (real number or complex {re, im})",{"_16":4789,"_22":19195,"_69":11},"- Additional solver options",[],{"_16":19198,"_18":19199,"_20":19200,"_22":19201,"_24":19202,"_28":8301,"_30":19211},"ar.generalized.eigsNear","ar.generalized.eigsNear(matvec, solveShifted, n, nev, sigma, options?)","Find eigenvalues of a symmetric matrix nearest to a target value.\r","Find eigenvalues of a symmetric matrix nearest to a target value.\r\n\r\nThis is a convenience wrapper for shift-invert mode that handles\r\nthe setup automatically. You provide a function to solve (A - σI)x = b\r\nand this function finds eigenvalues closest to σ.",[19203,19204,19206,19207,19208,19210],{"_16":18996,"_22":19085,"_69":6},{"_16":18921,"_22":19205,"_69":6},"- Function solving (A - σI)x = b, i.e., returns inv(A - σI)*b",{"_16":362,"_22":19190,"_69":6},{"_16":18925,"_22":18983,"_69":6},{"_16":4421,"_22":19209,"_69":6},"- Target value - finds eigenvalues closest to this",{"_16":4789,"_22":19195,"_69":11},[],{"_16":19213,"_18":19214,"_20":19215,"_22":19216,"_24":19217,"_28":8301,"_30":19225},"ar.generalized.geigs","ar.generalized.geigs(Amatvec, Bmatvec, n, nev, options?)","Compute eigenvalues and eigenvectors of a generalized eigenvalue problem.\r","Compute eigenvalues and eigenvectors of a generalized eigenvalue problem.\r\n\r\nSolves A*x = λ*B*x where:\r\n- A is a symmetric matrix\r\n- B is a symmetric positive definite matrix",[19218,19219,19221,19223,19224],{"_16":18954,"_22":19073,"_69":6},{"_16":18957,"_22":19220,"_69":6},"- Function computing y = B*x (B must be symmetric positive definite)",{"_16":362,"_22":19222,"_69":6},"- Dimension of the matrices (A, B are n×n)",{"_16":18925,"_22":18964,"_69":6},{"_16":4789,"_22":8287,"_69":11},[],{"_16":19227,"_18":19228,"_20":19229,"_22":19230,"_24":19231,"_28":19241,"_30":19242},"ar.graph.laplacianEigs","ar.graph.laplacianEigs(adjacencyMatvec, degrees, n, nev, options?)","Compute eigenvalues of the graph Laplacian for spectral clustering.\r","Compute eigenvalues of the graph Laplacian for spectral clustering.\r\n\r\nThis function computes the smallest eigenvalues of the graph Laplacian,\r\nwhich are used for spectral clustering and graph partitioning.",[19232,19235,19237,19239,19240],{"_16":19233,"_22":19234,"_69":6},"adjacencyMatvec","- Function computing y = A*x where A is the adjacency matrix",{"_16":19132,"_22":19236,"_69":6},"- Degree of each node (row sums of adjacency matrix), or function to compute D*x",{"_16":362,"_22":19238,"_69":6},"- Number of nodes in the graph",{"_16":18925,"_22":18964,"_69":6},{"_16":4789,"_22":8287,"_69":11},"Promise",[],{"_16":19244,"_18":19245,"_20":19246,"_22":19247,"_24":19248,"_28":19255,"_30":19256},"ar.graph.pagerank","ar.graph.pagerank(outlinksMatvec, n, options?)","Compute PageRank scores for a directed graph.\r","Compute PageRank scores for a directed graph.\r\n\r\nUses power iteration to find the dominant eigenvector of the\r\nGoogle matrix G = d*M + (1-d)*v*e^T, where:\r\n- M is the column-stochastic transition matrix\r\n- d is the damping factor\r\n- v is the personalization vector\r\n- e is the all-ones vector",[19249,19252,19253],{"_16":19250,"_22":19251,"_69":6},"outlinksMatvec","- Function computing y = M*x where M is column-stochastic\r\n (columns sum to 1, or 0 for dangling nodes)",{"_16":362,"_22":19238,"_69":6},{"_16":4789,"_22":19254,"_69":11},"- Algorithm options","Promise",[],{"_16":19258,"_18":19259,"_20":19260,"_22":19261,"_24":19262,"_28":19255,"_30":19268},"ar.graph.pagerankEigs","ar.graph.pagerankEigs(outlinksMatvec, n, options?)","Alternative PageRank using ARPACK eigenvalue solver.\r","Alternative PageRank using ARPACK eigenvalue solver.\r\n\r\nFinds the dominant eigenvector of the Google matrix directly.\r\nThis may be more efficient for very large graphs or when high\r\nprecision is needed.",[19263,19265,19267],{"_16":19250,"_22":19264,"_69":6},"- Function computing y = M*x",{"_16":362,"_22":19266,"_69":6},"- Number of nodes",{"_16":4789,"_22":19254,"_69":11},[],{"_16":19270,"_18":19271,"_20":19272,"_22":19273,"_24":19274,"_28":19283,"_30":19284},"ar.linalg.condest","ar.linalg.condest(matvec, matvecT, n, options?)","Estimate the condition number of a matrix.\r","Estimate the condition number of a matrix.\r\n\r\nComputes both the largest and smallest singular values to estimate\r\nthe 2-norm condition number κ(A) = σ_max / σ_min.",[19275,19277,19280,19282],{"_16":18996,"_22":19276,"_69":6},"- Function computing y = A*x (m×n matrix times n-vector)",{"_16":19278,"_22":19279,"_69":6},"matvecT","- Function computing y = A^T*x (n×m matrix times m-vector)",{"_16":362,"_22":19281,"_69":6},"- Number of columns (for square matrices, n = m)",{"_16":4789,"_22":8287,"_69":11},"Promise",[],{"_16":19286,"_18":19287,"_20":19288,"_22":19289,"_24":19290,"_28":19298,"_30":19299},"ar.linalg.nuclearNormApprox","ar.linalg.nuclearNormApprox(matvec, matvecT, m, n, k, options?)","Approximate the nuclear norm by summing the k largest singular values.\r","Approximate the nuclear norm by summing the k largest singular values.\r\n\r\nFor matrices where most singular values are small, summing the largest k\r\ngives a good approximation. This is a lower bound on the true nuclear norm.",[19291,19292,19293,19294,19295,19297],{"_16":18996,"_22":19276,"_69":6},{"_16":19278,"_22":19279,"_69":6},{"_16":359,"_22":4979,"_69":6},{"_16":362,"_22":5507,"_69":6},{"_16":1114,"_22":19296,"_69":6},"- Number of singular values to compute",{"_16":4789,"_22":8287,"_69":11},"Promise",[],{"_16":19301,"_18":19302,"_20":19303,"_22":19304,"_24":19305,"_28":8077,"_30":19311},"ar.linalg.spectralNorm","ar.linalg.spectralNorm(matvec, matvecT, m, n, options?)","Compute the spectral norm (2-norm) of a matrix.\r","Compute the spectral norm (2-norm) of a matrix.\r\n\r\nThe spectral norm is the largest singular value, which equals\r\nthe square root of the largest eigenvalue of A^T*A.",[19306,19307,19308,19309,19310],{"_16":18996,"_22":19276,"_69":6},{"_16":19278,"_22":19279,"_69":6},{"_16":359,"_22":4979,"_69":6},{"_16":362,"_22":5507,"_69":6},{"_16":4789,"_22":8287,"_69":11},[],{"_16":19313,"_18":19314,"_20":19315,"_22":19316,"_24":19317,"_28":8077,"_30":19321},"ar.linalg.spectralRadius","ar.linalg.spectralRadius(matvec, n, options?)","Compute the spectral radius of a matrix.\r","Compute the spectral radius of a matrix.\r\n\r\nThe spectral radius is the largest magnitude eigenvalue.",[19318,19319,19320],{"_16":18996,"_22":19073,"_69":6},{"_16":362,"_22":19190,"_69":6},{"_16":4789,"_22":8287,"_69":11},[],{"_16":19323,"_18":19324,"_20":19325,"_22":19326,"_24":19327,"_28":19335,"_30":19336},"ar.matfun.expmv","ar.matfun.expmv(matvec, v, t, options?)","Compute y = exp(t*A) * v using Krylov subspace approximation.\r","Compute y = exp(t*A) * v using Krylov subspace approximation.\r\n\r\nThis function computes the action of the matrix exponential on a vector\r\nwithout explicitly forming exp(t*A). This is efficient for large sparse\r\nmatrices where only matrix-vector products are available.",[19328,19329,19331,19334],{"_16":18996,"_22":18955,"_69":6},{"_16":2897,"_22":19330,"_69":6},"- Input vector",{"_16":19332,"_22":19333,"_69":6},"t","- Time/scaling parameter",{"_16":4789,"_22":8349,"_69":11},"ExpmvResult",[],{"_16":19338,"_18":19339,"_20":19340,"_22":19341,"_24":19342,"_28":19348,"_30":19349},"ar.matfun.expmvMultiple","ar.matfun.expmvMultiple(matvec, v, times, options?)","Compute y = exp(t*A) * v for multiple time points.\r","Compute y = exp(t*A) * v for multiple time points.\r\n\r\nMore efficient than calling expmv multiple times as it reuses\r\nthe Krylov basis.",[19343,19344,19345,19347],{"_16":18996,"_22":18955,"_69":6},{"_16":2897,"_22":19330,"_69":6},{"_16":7197,"_22":19346,"_69":6},"- Array of time points",{"_16":4789,"_22":8349,"_69":11},"ExpmvResult[]",[],{"_16":19351,"_18":19352,"_20":19353,"_22":19354,"_24":19355,"_28":19360,"_30":19361},"ar.matfun.sqrtmv","ar.matfun.sqrtmv(matvec, v, options?)","Compute y = A^(1/2) * v for symmetric positive definite A.\r","Compute y = A^(1/2) * v for symmetric positive definite A.\r\n\r\nUses a partial eigendecomposition to approximate A^(1/2).\r\nThe approximation is: A^(1/2) ≈ Σ sqrt(λ_i) * v_i * v_i^T",[19356,19358,19359],{"_16":18996,"_22":19357,"_69":6},"- Symmetric positive definite matrix operator A*x",{"_16":2897,"_22":19330,"_69":6},{"_16":4789,"_22":8349,"_69":11},"Promise",[],{"_16":19363,"_18":19364,"_20":19365,"_22":19366,"_24":19367,"_28":19360,"_30":19371},"ar.matfun.invsqrtmv","ar.matfun.invsqrtmv(matvec, v, options?)","Compute y = A^(-1/2) * v for symmetric positive definite A.\r","Compute y = A^(-1/2) * v for symmetric positive definite A.\r\n\r\nUses a partial eigendecomposition to approximate A^(-1/2).",[19368,19369,19370],{"_16":18996,"_22":19357,"_69":6},{"_16":2897,"_22":19330,"_69":6},{"_16":4789,"_22":8349,"_69":11},[],{"_16":19373,"_18":19374,"_20":19375,"_22":19376,"_24":19377,"_28":19360,"_30":19383},"ar.matfun.matpowv","ar.matfun.matpowv(matvec, v, p, options?)","Compute y = A^p * v for symmetric positive definite A and any real power p.\r","Compute y = A^p * v for symmetric positive definite A and any real power p.\r\n\r\nGeneralizes sqrtmv (p=0.5) and invsqrtmv (p=-0.5).",[19378,19379,19380,19382],{"_16":18996,"_22":19357,"_69":6},{"_16":2897,"_22":19330,"_69":6},{"_16":1645,"_22":19381,"_69":6},"- Power to raise the matrix to",{"_16":4789,"_22":8349,"_69":11},[],{"_16":19385,"_18":19386,"_20":19387,"_22":19388,"_24":19389,"_28":19398,"_30":19399},"ar.operators.addMatvec","ar.operators.addMatvec(A, B, alpha?, beta?)","ARWasm - ARPACK WebAssembly Module\r","ARWasm - ARPACK WebAssembly Module\r\n\r\nThis package provides a WebAssembly build of ARPACK (ARnoldi PACKage),\r\na collection of Fortran77 subroutines designed to solve large scale\r\neigenvalue problems.\r\n\r\nARPACK provides routines for:\r\n- Real symmetric eigenvalue problems (dsaupd/dseupd, ssaupd/sseupd)\r\n- Real nonsymmetric eigenvalue problems (dnaupd/dneupd, snaupd/sneupd)\r\n- Complex eigenvalue problems (cnaupd/cneupd, znaupd/zneupd)\r\n\r\n## High-Level API\r\n\r\nFor most use cases, use the high-level functions that handle all the\r\ncomplexity of the reverse communication interface:",[19390,19392,19394,19396],{"_16":659,"_22":19391,"_69":6},"- First matrix operator",{"_16":656,"_22":19393,"_69":6},"- Second matrix operator",{"_16":4399,"_22":19395,"_69":11},"- Scalar multiplier for A (default 1)",{"_16":2011,"_22":19397,"_69":11},"- Scalar multiplier for B (default 1)","MatVecFunction",[],{"_16":19401,"_18":19402,"_20":19403,"_22":19404,"_24":19405,"_28":19398,"_30":19408},"ar.operators.mulMatvec","ar.operators.mulMatvec(A, B)","Create a product operator: y = A * B * x\r","Create a product operator: y = A * B * x\r\n\r\nComputes the composition of two operators. Note: this computes B first,\r\nthen A, matching mathematical notation A*B*x = A*(B*x).",[19406,19407],{"_16":659,"_22":17481,"_69":6},{"_16":656,"_22":17483,"_69":6},[],{"_16":19410,"_18":19411,"_20":19412,"_22":19413,"_24":19414,"_28":19398,"_30":19419},"ar.operators.shiftMatvec","ar.operators.shiftMatvec(matvec, sigma)","Create a shifted operator: y = (A - σI) * x\r","Create a shifted operator: y = (A - σI) * x\r\n\r\nUseful for shift-invert mode where you need to work with A - σI.",[19415,19417],{"_16":18996,"_22":19416,"_69":6},"- Matrix operator A",{"_16":4421,"_22":19418,"_69":6},"- Shift value σ",[],{"_16":19421,"_18":19422,"_20":19423,"_22":19423,"_24":19424,"_28":19398,"_30":19427},"ar.operators.scaleMatvec","ar.operators.scaleMatvec(matvec, alpha)","Create a scaled operator: y = α * A * x",[19425,19426],{"_16":18996,"_22":19416,"_69":6},{"_16":4399,"_22":17513,"_69":6},[],{"_16":19429,"_18":19430,"_20":19431,"_22":19432,"_24":19433,"_28":19398,"_30":19440},"ar.operators.transposeMatvec","ar.operators.transposeMatvec(matvec, m, n)","Create a transpose operator via explicit computation.\r","Create a transpose operator via explicit computation.\r\n\r\nThis builds A^T by probing A with standard basis vectors.\r\nWARNING: This is O(n²) and should only be used for small matrices\r\nor when no other option exists.\r\n\r\nFor large matrices, prefer providing an explicit transpose operator.",[19434,19436,19438],{"_16":18996,"_22":19435,"_69":6},"- Matrix operator A (m x n)",{"_16":359,"_22":19437,"_69":6},"- Number of rows in A",{"_16":362,"_22":19439,"_69":6},"- Number of columns in A",[],{"_16":19442,"_18":19443,"_20":19444,"_22":19445,"_24":19446,"_28":19398,"_30":19450},"ar.operators.symmetrizeMatvec","ar.operators.symmetrizeMatvec(matvec, matvecT)","Create a symmetrized operator: y = (A + A^T)/2 * x\r","Create a symmetrized operator: y = (A + A^T)/2 * x\r\n\r\nThis makes a non-symmetric operator symmetric. Requires both A and A^T.",[19447,19448],{"_16":18996,"_22":19416,"_69":6},{"_16":19278,"_22":19449,"_69":6},"- Transpose operator A^T",[],{"_16":19452,"_18":19453,"_20":19454,"_22":19454,"_24":19455,"_28":19398,"_30":19458},"ar.operators.identityMatvec","ar.operators.identityMatvec(n)","Create an identity operator: y = x",[19456],{"_16":362,"_22":19457,"_69":6},"- Dimension",[],{"_16":19460,"_18":19461,"_20":19462,"_22":19462,"_24":19463,"_28":19398,"_30":19465},"ar.operators.negateMatvec","ar.operators.negateMatvec(matvec)","Create a negated operator: y = -A * x",[19464],{"_16":18996,"_22":19416,"_69":6},[],{"_16":19467,"_18":19468,"_20":19469,"_22":19470,"_24":19471,"_28":19398,"_30":19475},"ar.operators.powerMatvec","ar.operators.powerMatvec(matvec, k)","Create a power operator: y = A^k * x\r","Create a power operator: y = A^k * x\r\n\r\nComputes the k-th power of an operator by repeated application.",[19472,19473],{"_16":18996,"_22":19416,"_69":6},{"_16":1114,"_22":19474,"_69":6},"- Power (must be non-negative integer)",[],{"_16":19477,"_18":19478,"_20":19479,"_22":19480,"_24":19481,"_28":19398,"_30":19487},"ar.operators.blockDiagMatvec","ar.operators.blockDiagMatvec(operators, sizes)","Create a block diagonal operator from multiple sub-operators.\r","Create a block diagonal operator from multiple sub-operators.\r\n\r\nGiven operators A₁, A₂, ..., Aₖ, creates:\r\n```\r\n[A₁ 0 0 ]\r\n[ 0 A₂ 0 ]\r\n[ 0 0 A₃ ]\r\n```",[19482,19484],{"_16":17461,"_22":19483,"_69":6},"- Array of matrix operators",{"_16":19485,"_22":19486,"_69":6},"sizes","- Array of dimensions for each operator",[],{"_16":19489,"_18":19490,"_20":19491,"_22":19492,"_24":19493,"_28":19398,"_30":19500},"ar.sparse.bandedMatvec","ar.sparse.bandedMatvec(bands, offsets, n)","Create a matrix-vector product function from a banded matrix.\r","Create a matrix-vector product function from a banded matrix.\r\n\r\nA banded matrix has non-zero entries only on certain diagonals.\r\nEach diagonal is specified by its offset from the main diagonal:\r\n- offset = 0: main diagonal\r\n- offset > 0: super-diagonals (above main)\r\n- offset < 0: sub-diagonals (below main)",[19494,19496,19498],{"_16":17928,"_22":19495,"_69":6},"- Array of diagonal entries, one Float64Array per band",{"_16":4625,"_22":19497,"_69":6},"- Offset for each band (0 = main diagonal, positive = super, negative = sub)",{"_16":362,"_22":19499,"_69":6},"- Matrix dimension (square matrix)",[],{"_16":19502,"_18":19503,"_20":19504,"_22":19505,"_24":19506,"_28":19398,"_30":19510},"ar.sparse.symBandedMatvec","ar.sparse.symBandedMatvec(bands, n)","Create a symmetric banded matrix-vector product function.\r","Create a symmetric banded matrix-vector product function.\r\n\r\nFor symmetric banded matrices, only the upper (or lower) bands need\r\nto be specified. This function mirrors them automatically.",[19507,19509],{"_16":17928,"_22":19508,"_69":6},"- Upper bands (including main diagonal), indexed by offset (0, 1, 2, ...)",{"_16":362,"_22":5524,"_69":6},[],{"_16":19512,"_18":19513,"_20":19514,"_22":19515,"_24":19516,"_28":19398,"_30":19523},"ar.sparse.toeplitzBandedMatvec","ar.sparse.toeplitzBandedMatvec(bandValues, offsets, n)","Create a Toeplitz banded matrix-vector product function.\r","Create a Toeplitz banded matrix-vector product function.\r\n\r\nFor banded matrices where each diagonal has a constant value.",[19517,19520,19522],{"_16":19518,"_22":19519,"_69":6},"bandValues","- Value for each band",{"_16":4625,"_22":19521,"_69":6},"- Offset for each band",{"_16":362,"_22":5524,"_69":6},[],{"_16":19525,"_18":19526,"_20":19527,"_22":19528,"_24":19529,"_28":19398,"_30":19538},"ar.sparse.cooMatvec","ar.sparse.cooMatvec(rows, cols, values, shape)","Create a matrix-vector product function from COO sparse matrix format.\r","Create a matrix-vector product function from COO sparse matrix format.\r\n\r\nCOO format stores a sparse matrix using three arrays:\r\n- rows: Row indices for each non-zero entry\r\n- cols: Column indices for each non-zero entry\r\n- values: Non-zero values",[19530,19532,19534,19536],{"_16":2472,"_22":19531,"_69":6},"- Row indices array",{"_16":2475,"_22":19533,"_69":6},"- Column indices array",{"_16":2320,"_22":19535,"_69":6},"- Non-zero values array",{"_16":8461,"_22":19537,"_69":6},"- Matrix dimensions [m, n] (rows, cols)",[],{"_16":19540,"_18":19541,"_20":19542,"_22":19543,"_24":19544,"_28":19398,"_30":19550},"ar.sparse.cooMatvecT","ar.sparse.cooMatvecT(rows, cols, values, shape)","Create a transpose matrix-vector product function from COO format.\r","Create a transpose matrix-vector product function from COO format.\r\n\r\nComputes y = A^T * x using COO format.",[19545,19546,19547,19548],{"_16":2472,"_22":19531,"_69":6},{"_16":2475,"_22":19533,"_69":6},{"_16":2320,"_22":19535,"_69":6},{"_16":8461,"_22":19549,"_69":6},"- Matrix dimensions [m, n]",[],{"_16":19552,"_18":19553,"_20":19554,"_22":19555,"_24":19556,"_28":19398,"_30":19563},"ar.sparse.cscMatvec","ar.sparse.cscMatvec(indptr, indices, data, shape)","Create a matrix-vector product function from CSC sparse matrix format.\r","Create a matrix-vector product function from CSC sparse matrix format.\r\n\r\nCSC format stores a sparse matrix using three arrays:\r\n- indptr: Column pointers (length n+1). indptr[j] to indptr[j+1] gives the\r\n range of indices in data/indices for column j.\r\n- indices: Row indices for each non-zero entry\r\n- data: Non-zero values",[19557,19560,19561,19562],{"_16":19558,"_22":19559,"_69":6},"indptr","- Column pointer array (length n+1)",{"_16":9786,"_22":19531,"_69":6},{"_16":84,"_22":19535,"_69":6},{"_16":8461,"_22":19537,"_69":6},[],{"_16":19565,"_18":19566,"_20":19567,"_22":19568,"_24":19569,"_28":19398,"_30":19575},"ar.sparse.cscMatvecT","ar.sparse.cscMatvecT(indptr, indices, data, shape)","Create a transpose matrix-vector product function from CSC format.\r","Create a transpose matrix-vector product function from CSC format.\r\n\r\nComputes y = A^T * x efficiently using CSC format.\r\nThis is equivalent to CSR matvec on the original matrix.",[19570,19572,19573,19574],{"_16":19558,"_22":19571,"_69":6},"- Column pointer array",{"_16":9786,"_22":19531,"_69":6},{"_16":84,"_22":19535,"_69":6},{"_16":8461,"_22":19549,"_69":6},[],{"_16":19577,"_18":19578,"_20":19579,"_22":19580,"_24":19581,"_28":19398,"_30":19587},"ar.sparse.csrMatvec","ar.sparse.csrMatvec(indptr, indices, data, shape)","Create a matrix-vector product function from CSR sparse matrix format.\r","Create a matrix-vector product function from CSR sparse matrix format.\r\n\r\nCSR format stores a sparse matrix using three arrays:\r\n- indptr: Row pointers (length m+1). indptr[i] to indptr[i+1] gives the\r\n range of indices in data/indices for row i.\r\n- indices: Column indices for each non-zero entry\r\n- data: Non-zero values",[19582,19584,19585,19586],{"_16":19558,"_22":19583,"_69":6},"- Row pointer array (length m+1)",{"_16":9786,"_22":19533,"_69":6},{"_16":84,"_22":19535,"_69":6},{"_16":8461,"_22":19537,"_69":6},[],{"_16":19589,"_18":19590,"_20":19591,"_22":19592,"_24":19593,"_28":19398,"_30":19599},"ar.sparse.csrMatvecT","ar.sparse.csrMatvecT(indptr, indices, data, shape)","Create a transpose matrix-vector product function from CSR format.\r","Create a transpose matrix-vector product function from CSR format.\r\n\r\nComputes y = A^T * x efficiently using CSR format.",[19594,19596,19597,19598],{"_16":19558,"_22":19595,"_69":6},"- Row pointer array",{"_16":9786,"_22":19533,"_69":6},{"_16":84,"_22":19535,"_69":6},{"_16":8461,"_22":19549,"_69":6},[],{"_16":19601,"_18":19602,"_20":19603,"_22":19604,"_24":19605,"_28":19398,"_30":19614},"ar.sparse.denseMatvec","ar.sparse.denseMatvec(matrix, m, n, rowMajor?)","Create a matrix-vector product function from a dense matrix.\r","Create a matrix-vector product function from a dense matrix.\r\n\r\nThe matrix is stored as a flat Float64Array in either row-major\r\n(C-style) or column-major (Fortran-style) order.",[19606,19609,19610,19611],{"_16":19607,"_22":19608,"_69":6},"matrix","- Flat array containing matrix elements (length m*n)",{"_16":359,"_22":4979,"_69":6},{"_16":362,"_22":5507,"_69":6},{"_16":19612,"_22":19613,"_69":11},"rowMajor","- If true, matrix is row-major (default). If false, column-major.",[],{"_16":19616,"_18":19617,"_20":19618,"_22":19618,"_24":19619,"_28":19398,"_30":19626},"ar.sparse.denseMatvecT","ar.sparse.denseMatvecT(matrix, m, n, rowMajor?)","Create a transpose matrix-vector product function from a dense matrix.",[19620,19622,19623,19624],{"_16":19607,"_22":19621,"_69":6},"- Flat array containing matrix elements",{"_16":359,"_22":4979,"_69":6},{"_16":362,"_22":5507,"_69":6},{"_16":19612,"_22":19625,"_69":11},"- If true, matrix is row-major. If false, column-major.",[],{"_16":19628,"_18":19629,"_20":19630,"_22":19631,"_24":19632,"_28":19398,"_30":19635},"ar.sparse.diagMatvec","ar.sparse.diagMatvec(diagonal)","Create a matrix-vector product function from a diagonal matrix.\r","Create a matrix-vector product function from a diagonal matrix.\r\n\r\nFor a diagonal matrix D with diagonal entries d[i], computes:\r\ny[i] = d[i] * x[i]",[19633],{"_16":17722,"_22":19634,"_69":6},"- Diagonal entries (length n)",[],{"_16":19637,"_18":19638,"_20":19639,"_22":19640,"_24":19641,"_28":19398,"_30":19646},"ar.sparse.diagMatvecInv","ar.sparse.diagMatvecInv(diagonal, tol?)","Create an inverse diagonal matrix-vector product function.\r","Create an inverse diagonal matrix-vector product function.\r\n\r\nComputes y = D^{-1} * x where D is diagonal.\r\nUseful for preconditioning.",[19642,19644],{"_16":17722,"_22":19643,"_69":6},"- Diagonal entries (must be non-zero)",{"_16":3719,"_22":19645,"_69":11},"- Tolerance for \"zero\" entries (default 1e-14)",[],{"_16":19648,"_18":19649,"_20":19650,"_22":19651,"_24":19652,"_28":19398,"_30":19655},"ar.sparse.diagMatvecSqrt","ar.sparse.diagMatvecSqrt(diagonal)","Create a sqrt-diagonal matrix-vector product function.\r","Create a sqrt-diagonal matrix-vector product function.\r\n\r\nComputes y = D^{1/2} * x where D is diagonal with non-negative entries.\r\nUseful for symmetric normalization.",[19653],{"_16":17722,"_22":19654,"_69":6},"- Diagonal entries (must be non-negative)",[],{"_16":19657,"_18":19658,"_20":19659,"_22":19660,"_24":19661,"_28":19398,"_30":19665},"ar.sparse.diagMatvecInvSqrt","ar.sparse.diagMatvecInvSqrt(diagonal, tol?)","Create an inverse-sqrt-diagonal matrix-vector product function.\r","Create an inverse-sqrt-diagonal matrix-vector product function.\r\n\r\nComputes y = D^{-1/2} * x where D is diagonal with positive entries.\r\nUseful for symmetric normalization of Laplacians.",[19662,19664],{"_16":17722,"_22":19663,"_69":6},"- Diagonal entries (must be positive)",{"_16":3719,"_22":19645,"_69":11},[],{"_16":19667,"_18":19668,"_20":19669,"_22":19670,"_24":19671,"_28":19398,"_30":19678},"ar.sparse.tridiagMatvec","ar.sparse.tridiagMatvec(lower, diag, upper)","Create a matrix-vector product function from a tridiagonal matrix.\r","Create a matrix-vector product function from a tridiagonal matrix.\r\n\r\nA tridiagonal matrix has non-zero entries only on the main diagonal\r\nand the immediately adjacent diagonals:\r\n\r\n```\r\n[d0 u0 0 0 ]\r\n[l0 d1 u1 0 ]\r\n[ 0 l1 d2 u2 ]\r\n[ 0 0 l2 d3 ]\r\n```",[19672,19674,19676],{"_16":1123,"_22":19673,"_69":6},"- Sub-diagonal entries (length n-1)",{"_16":403,"_22":19675,"_69":6},"- Main diagonal entries (length n)",{"_16":1137,"_22":19677,"_69":6},"- Super-diagonal entries (length n-1)",[],{"_16":19680,"_18":19681,"_20":19682,"_22":19683,"_24":19684,"_28":19398,"_30":19689},"ar.sparse.symTridiagMatvec","ar.sparse.symTridiagMatvec(diag, offdiag)","Create a symmetric tridiagonal matrix-vector product function.\r","Create a symmetric tridiagonal matrix-vector product function.\r\n\r\nFor symmetric tridiagonal matrices where lower = upper.\r\nUses only two arrays instead of three.",[19685,19686],{"_16":403,"_22":19675,"_69":6},{"_16":19687,"_22":19688,"_69":6},"offdiag","- Off-diagonal entries (length n-1)",[],{"_16":19691,"_18":19692,"_20":19693,"_22":19694,"_24":19695,"_28":19398,"_30":19704},"ar.sparse.toeplitzTridiagMatvec","ar.sparse.toeplitzTridiagMatvec(lower, diagVal, upper, n)","Create a Toeplitz tridiagonal matrix-vector product function.\r","Create a Toeplitz tridiagonal matrix-vector product function.\r\n\r\nFor constant-coefficient tridiagonal matrices where all diagonal\r\nentries are the same.",[19696,19698,19701,19703],{"_16":1123,"_22":19697,"_69":6},"- Sub-diagonal value",{"_16":19699,"_22":19700,"_69":6},"diagVal","- Main diagonal value",{"_16":1137,"_22":19702,"_69":6},"- Super-diagonal value",{"_16":362,"_22":5524,"_69":6},[],{"_16":19706,"_18":19707,"_20":19708,"_22":19709,"_24":19710,"_28":8325,"_30":19721},"ar.svd.svds","ar.svd.svds(matvec, matvecT, m, n, k, options?)","Compute partial singular value decomposition of a sparse matrix.\r","Compute partial singular value decomposition of a sparse matrix.\r\n\r\nFinds the k largest or smallest singular values and optionally the\r\ncorresponding left and right singular vectors.",[19711,19713,19715,19717,19719,19720],{"_16":18996,"_22":19712,"_69":6},"- Function computing y = A*x (m×n matrix applied to n-vector)",{"_16":19278,"_22":19714,"_69":6},"- Function computing y = A^T*x (n×m matrix applied to m-vector)",{"_16":359,"_22":19716,"_69":6},"- Number of rows in the matrix",{"_16":362,"_22":19718,"_69":6},"- Number of columns in the matrix",{"_16":1114,"_22":19296,"_69":6},{"_16":4789,"_22":8287,"_69":11},[],{"_16":19723,"_18":19724,"_20":19725,"_22":19726,"_24":19727,"_28":19735,"_30":19736},"ar.validation.verifyEigs","ar.validation.verifyEigs(matvec, eigenvalues, eigenvectors, options?)","Verify eigenvalue/eigenvector pairs.\r","Verify eigenvalue/eigenvector pairs.\r\n\r\nFor each eigenpair (λ, v), computes the residual ||A*v - λ*v||\r\nand checks orthogonality of eigenvectors.",[19728,19729,19731,19733],{"_16":18996,"_22":19416,"_69":6},{"_16":6724,"_22":19730,"_69":6},"- Computed eigenvalues",{"_16":5496,"_22":19732,"_69":6},"- Computed eigenvectors",{"_16":4789,"_22":19734,"_69":11},"- Verification options","VerifyEigsResult",[],{"_16":19738,"_18":19739,"_20":19740,"_22":19741,"_24":19742,"_28":19735,"_30":19753},"ar.validation.verifyEign","ar.validation.verifyEign(matvec, eigenvaluesReal, eigenvaluesImag, eigenvectors, options?)","Verify non-symmetric eigenvalue/eigenvector pairs.\r","Verify non-symmetric eigenvalue/eigenvector pairs.\r\n\r\nFor non-symmetric matrices, eigenvalues may be complex.\r\nThis verifies pairs where eigenvaluesImag[i] != 0 indicates\r\ncomplex conjugate pairs.",[19743,19744,19747,19750,19752],{"_16":18996,"_22":19416,"_69":6},{"_16":19745,"_22":19746,"_69":6},"eigenvaluesReal","- Real parts of eigenvalues",{"_16":19748,"_22":19749,"_69":6},"eigenvaluesImag","- Imaginary parts of eigenvalues",{"_16":5496,"_22":19751,"_69":6},"- Eigenvectors (see EignResult for format)",{"_16":4789,"_22":19734,"_69":11},[],{"_16":19755,"_18":19756,"_20":19757,"_22":19758,"_24":19759,"_28":19771,"_30":19772},"ar.validation.verifySvds","ar.validation.verifySvds(matvec, matvecT, U, s, Vt, options?)","Verify singular value decomposition.\r","Verify singular value decomposition.\r\n\r\nChecks that:\r\n- A*v_i ≈ σ_i * u_i\r\n- A^T*u_i ≈ σ_i * v_i\r\n- U vectors are orthonormal\r\n- V vectors are orthonormal",[19760,19761,19763,19765,19767,19770],{"_16":18996,"_22":18955,"_69":6},{"_16":19278,"_22":19762,"_69":6},"- Transpose operator A^T*x",{"_16":2144,"_22":19764,"_69":6},"- Left singular vectors",{"_16":3799,"_22":19766,"_69":6},"- Singular values",{"_16":19768,"_22":19769,"_69":6},"Vt","- Right singular vectors (rows)",{"_16":4789,"_22":19734,"_69":11},"VerifySvdsResult",[],{"_16":19774,"_18":19775,"_20":19776,"_22":19777,"_24":19778,"_28":19786,"_30":19787},"ar.validation.checkSymmetry","ar.validation.checkSymmetry(matvec, n, nProbes?, tol?)","Check if a matrix is symmetric via random probing.\r","Check if a matrix is symmetric via random probing.\r\n\r\nTests whether x^T*A*y ≈ y^T*A*x for random vectors x, y.\r\nThis is a probabilistic test that can detect asymmetry but\r\ncannot prove symmetry.",[19779,19780,19781,19784],{"_16":18996,"_22":19416,"_69":6},{"_16":362,"_22":5524,"_69":6},{"_16":19782,"_22":19783,"_69":11},"nProbes","- Number of random probe pairs (default 10)",{"_16":3719,"_22":19785,"_69":11},"- Tolerance for asymmetry (default 1e-10)","SymmetryCheckResult",[],{"_16":19789,"_18":19790,"_20":19791,"_22":19792,"_24":19793,"_28":19799,"_30":19800},"ar.validation.checkPositiveDefinite","ar.validation.checkPositiveDefinite(matvec, n, tol?)","Check if a matrix is positive definite.\r","Check if a matrix is positive definite.\r\n\r\nComputes the smallest eigenvalue using eigs and checks if it's positive.\r\nNote: This requires the eigs function to be available.",[19794,19796,19797],{"_16":18996,"_22":19795,"_69":6},"- Matrix operator A (must be symmetric)",{"_16":362,"_22":5524,"_69":6},{"_16":3719,"_22":19798,"_69":11},"- Tolerance for positive eigenvalue (default 0)","Promise",[],{"_16":19802,"_18":19803,"_20":19804,"_22":19805,"_24":19806,"_28":19811,"_30":19812},"ar.validation.checkNormalization","ar.validation.checkNormalization(eigenvectors, tol?)","Check normalization of eigenvectors.\r","Check normalization of eigenvectors.\r\n\r\nVerifies that each eigenvector has unit norm.",[19807,19809],{"_16":5496,"_22":19808,"_69":6},"- Array of eigenvectors",{"_16":3719,"_22":19810,"_69":11},"- Tolerance for unit norm (default 1e-10)","{\r\n isNormalized: boolean;\r\n norms: Float64Array;\r\n maxDeviation: number;\r\n}",[],{"_16":19814,"_18":19815,"_20":19816,"_22":5456,"_24":19817,"_28":1426,"_30":19820},"ar.configureARPACK","ar.configureARPACK(config)","configureARPACK",[19818],{"_16":8097,"_22":19819,"_69":6},"ARPACKLoadConfig",[],{"_16":19822,"_18":19823,"_20":19824,"_22":19824,"_24":19825,"_28":5703,"_30":19832},"ar.defaultNcv","ar.defaultNcv(n, nev, symmetric)","Calculate default ncv value.",[19826,19827,19829],{"_16":362,"_22":5524,"_69":6},{"_16":18925,"_22":19828,"_69":6},"- Number of eigenvalues requested",{"_16":19830,"_22":19831,"_69":6},"symmetric","- Whether the problem is symmetric",[],{"_16":19834,"_18":19835,"_20":19836,"_22":19836,"_24":19837,"_28":5703,"_30":19841},"ar.dnaupdWorklSize","ar.dnaupdWorklSize(ncv)","Calculate required workl size for non-symmetric problems (dnaupd).",[19838],{"_16":19839,"_22":19840,"_69":6},"ncv","- Number of Arnoldi vectors",[],{"_16":19843,"_18":19844,"_20":19845,"_22":19845,"_24":19846,"_28":5703,"_30":19848},"ar.dneupdWorkevSize","ar.dneupdWorkevSize(ncv)","Calculate required workev size for non-symmetric extraction (dneupd).",[19847],{"_16":19839,"_22":19840,"_69":6},[],{"_16":19850,"_18":19851,"_20":19852,"_22":19852,"_24":19853,"_28":5703,"_30":19856},"ar.dsaupdWorklSize","ar.dsaupdWorklSize(ncv)","Calculate required workl size for symmetric problems (dsaupd).",[19854],{"_16":19839,"_22":19855,"_69":6},"- Number of Lanczos vectors",[],{"_16":19858,"_18":19859,"_20":19860,"_22":5456,"_24":19861,"_28":19862,"_30":19863},"ar.getARPACKModule","ar.getARPACKModule()","getARPACKModule",[],"ARPACKModule",[],{"_16":19865,"_18":19866,"_20":19867,"_22":19867,"_24":19868,"_28":6108,"_30":19871},"ar.getDnaupdMessage","ar.getDnaupdMessage(info)","Get error message for dnaupd info code.",[19869],{"_16":19870,"_22":5703,"_69":6},"info",[],{"_16":19873,"_18":19874,"_20":19875,"_22":19875,"_24":19876,"_28":6108,"_30":19878},"ar.getDneupdMessage","ar.getDneupdMessage(info)","Get error message for dneupd info code.",[19877],{"_16":19870,"_22":5703,"_69":6},[],{"_16":19880,"_18":19881,"_20":19882,"_22":19882,"_24":19883,"_28":6108,"_30":19885},"ar.getDsaupdMessage","ar.getDsaupdMessage(info)","Get error message for dsaupd info code.",[19884],{"_16":19870,"_22":5703,"_69":6},[],{"_16":19887,"_18":19888,"_20":19889,"_22":19889,"_24":19890,"_28":6108,"_30":19892},"ar.getDseupdMessage","ar.getDseupdMessage(info)","Get error message for dseupd info code.",[19891],{"_16":19870,"_22":5703,"_69":6},[],{"_16":19894,"_18":19895,"_20":19896,"_22":19896,"_24":19897,"_28":6108,"_30":19899},"ar.getZnaupdMessage","ar.getZnaupdMessage(info)","Get error message for znaupd info code.",[19898],{"_16":19870,"_22":5703,"_69":6},[],{"_16":19901,"_18":19902,"_20":19903,"_22":19903,"_24":19904,"_28":6108,"_30":19906},"ar.getZneupdMessage","ar.getZneupdMessage(info)","Get error message for zneupd info code.",[19905],{"_16":19870,"_22":5703,"_69":6},[],{"_16":19908,"_18":19909,"_20":19910,"_22":5456,"_24":19911,"_28":6903,"_30":19912},"ar.isARPACKLoaded","ar.isARPACKLoaded()","isARPACKLoaded",[],[],{"_16":19914,"_18":19915,"_20":19916,"_22":5456,"_24":19917,"_28":19918,"_30":19919},"ar.loadARPACKModule","ar.loadARPACKModule()","loadARPACKModule",[],"Promise",[],{"_16":19921,"_18":19922,"_20":19923,"_22":5456,"_24":19924,"_28":1426,"_30":19925},"ar.resetARPACKModule","ar.resetARPACKModule()","resetARPACKModule",[],[],{"_16":19927,"_18":19928,"_20":19929,"_22":19929,"_24":19930,"_28":5703,"_30":19932},"ar.znaupdRworkSize","ar.znaupdRworkSize(ncv)","Calculate required rwork size for complex problems (znaupd).",[19931],{"_16":19839,"_22":19840,"_69":6},[],{"_16":19934,"_18":19935,"_20":19936,"_22":19936,"_24":19937,"_28":5703,"_30":19939},"ar.znaupdWorklSize","ar.znaupdWorklSize(ncv)","Calculate required workl size for complex problems (znaupd).",[19938],{"_16":19839,"_22":19840,"_69":6},[],{"_16":19941,"_18":19942,"_20":19943,"_22":19943,"_24":19944,"_28":5703,"_30":19946},"ar.zneupdWorkevSize","ar.zneupdWorkevSize(ncv)","Calculate required workev size for complex extraction (zneupd).",[19945],{"_16":19839,"_22":19840,"_69":6},[],{"_43":19948,"_16":19949,"_22":19950,"_47":48,"_49":19951,"_51":19952,"_52":19953},"la-generated","LAPACK/BLAS","LAPACK and BLAS linear algebra routines.","🧮","la",[19954,19968,19979,19992,20005,20018,20029,20039,20052,20063,20075,20087,20099,20109,20118,20131,20143,20154,20164,20173,20182,20193,20203,20213,20228,20241,20254,20267,20279,20288,20302,20312,20322,20334,20345,20356,20365,20374,20384,20395,20406,20417,20428,20438,20456,20472,20484,20495,20506,20519,20537,20553,20567,20580,20597,20606,20617,20626,20637,20646,20660,20669,20680,20691,20701,20711,20721,20731,20741,20751,20761,20771,20781,20792,20803,20814,20823,20832,20843,20852,20861,20869,20880,20890,20901,20911,20921,20931,20941,20951,20959,20969,20976,20982,20989,20998,21006,21012],{"_16":19955,"_18":19956,"_20":19957,"_22":19958,"_24":19959,"_28":19966,"_30":19967},"la.blas.her2k","la.blas.her2k(A, B, options?)","Compute Hermitian rank-2k update.\r","Compute Hermitian rank-2k update.\r\n\r\nFor real matrices, this is equivalent to symmetric rank-2k update:\r\nIf trans='N': C = alpha*A*B^T + alpha*B*A^T + beta*C\r\nIf trans='C': C = alpha*A^T*B + alpha*B^T*A + beta*C\r\n\r\nThe result C is Hermitian (symmetric for real matrices).",[19960,19962,19964],{"_16":659,"_22":19961,"_69":6},"- First input matrix",{"_16":656,"_22":19963,"_69":6},"- Second input matrix (same dimensions as A)",{"_16":4789,"_22":19965,"_69":11},"- Update options","Her2kResult",[],{"_16":19969,"_18":19970,"_20":19971,"_22":19972,"_24":19973,"_28":19977,"_30":19978},"la.blas.herk","la.blas.herk(A, options?)","Compute Hermitian rank-k update C = alpha*A*A^H + beta*C or C = alpha*A^H*A + beta*C.\r","Compute Hermitian rank-k update C = alpha*A*A^H + beta*C or C = alpha*A^H*A + beta*C.\r\n\r\nFor real matrices, this is equivalent to symmetric rank-k update (SYRK).\r\nThe result C is Hermitian (symmetric for real matrices).",[19974,19976],{"_16":659,"_22":19975,"_69":6},"- Input matrix",{"_16":4789,"_22":19965,"_69":11},"HerkResult",[],{"_16":19980,"_18":19981,"_20":19982,"_22":19983,"_24":19984,"_28":19990,"_30":19991},"la.blas.matmul","la.blas.matmul(A, B, options?)","Compute general matrix multiplication C = alpha*op(A)*op(B) + beta*C.\r","Compute general matrix multiplication C = alpha*op(A)*op(B) + beta*C.\r\n\r\nUses DGEMM from BLAS.",[19985,19986,19988],{"_16":659,"_22":19961,"_69":6},{"_16":656,"_22":19987,"_69":6},"- Second input matrix",{"_16":4789,"_22":19989,"_69":11},"- Multiplication options","MatmulResult",[],{"_16":19993,"_18":19994,"_20":19995,"_22":19996,"_24":19997,"_28":20003,"_30":20004},"la.blas.matmulTriangular","la.blas.matmulTriangular(A, B, options?)","Compute triangular matrix multiplication B = alpha*op(A)*B or B = alpha*B*op(A).\r","Compute triangular matrix multiplication B = alpha*op(A)*B or B = alpha*B*op(A).\r\n\r\nUses DTRMM from BLAS.",[19998,20000,20002],{"_16":659,"_22":19999,"_69":6},"- Triangular matrix (n × n)",{"_16":656,"_22":20001,"_69":6},"- General matrix (m × n or n × m depending on side)",{"_16":4789,"_22":19989,"_69":11},"MatmulTriangularResult",[],{"_16":20006,"_18":20007,"_20":20008,"_22":20009,"_24":20010,"_28":20016,"_30":20017},"la.blas.solveMatrixTriangular","la.blas.solveMatrixTriangular(A, B, options?)","Solve a triangular matrix system op(A)*X = alpha*B or X*op(A) = alpha*B.\r","Solve a triangular matrix system op(A)*X = alpha*B or X*op(A) = alpha*B.\r\n\r\nUses DTRSM from BLAS.",[20011,20012,20014],{"_16":659,"_22":19999,"_69":6},{"_16":656,"_22":20013,"_69":6},"- Right-hand side matrix",{"_16":4789,"_22":20015,"_69":11},"- Solve options","SolveMatrixTriangularResult",[],{"_16":20019,"_18":20020,"_20":20021,"_22":20022,"_24":20023,"_28":20027,"_30":20028},"la.blas.syr2k","la.blas.syr2k(A, B, options?)","Compute symmetric rank-2k update.\r","Compute symmetric rank-2k update.\r\n\r\nIf trans='N': C = alpha*A*B^T + alpha*B*A^T + beta*C\r\nIf trans='T': C = alpha*A^T*B + alpha*B^T*A + beta*C\r\n\r\nUses DSYR2K from BLAS. The result C is symmetric.",[20024,20025,20026],{"_16":659,"_22":19961,"_69":6},{"_16":656,"_22":19963,"_69":6},{"_16":4789,"_22":19965,"_69":11},"Syr2kResult",[],{"_16":20030,"_18":20031,"_20":20032,"_22":20033,"_24":20034,"_28":20037,"_30":20038},"la.blas.syrk","la.blas.syrk(A, options?)","Compute symmetric rank-k update C = alpha*A*A^T + beta*C or C = alpha*A^T*A + beta*C.\r","Compute symmetric rank-k update C = alpha*A*A^T + beta*C or C = alpha*A^T*A + beta*C.\r\n\r\nUses DSYRK from BLAS. The result C is symmetric.",[20035,20036],{"_16":659,"_22":19975,"_69":6},{"_16":4789,"_22":19965,"_69":11},"SyrkResult",[],{"_16":20040,"_18":20041,"_20":20042,"_22":20043,"_24":20044,"_28":20050,"_30":20051},"la.blas.ger","la.blas.ger(x, y, options?)","Compute rank-1 update A = alpha*x*y^T + A.\r","Compute rank-1 update A = alpha*x*y^T + A.\r\n\r\nUses DGER from BLAS.",[20045,20047,20049],{"_16":498,"_22":20046,"_69":6},"- Column vector (length m)",{"_16":501,"_22":20048,"_69":6},"- Row vector (length n)",{"_16":4789,"_22":19965,"_69":11},"GerResult",[],{"_16":20053,"_18":20054,"_20":20055,"_22":20056,"_24":20057,"_28":20061,"_30":20062},"la.blas.her","la.blas.her(x, options?)","Compute Hermitian rank-1 update A = alpha*x*x^H + A.\r","Compute Hermitian rank-1 update A = alpha*x*x^H + A.\r\n\r\nFor real matrices, this is equivalent to symmetric rank-1 update.\r\nThe result A is Hermitian (symmetric for real matrices).",[20058,20060],{"_16":498,"_22":20059,"_69":6},"- Vector (length n)",{"_16":4789,"_22":19965,"_69":11},"HerResult",[],{"_16":20064,"_18":20065,"_20":20066,"_22":20067,"_24":20068,"_28":20073,"_30":20074},"la.blas.matvec","la.blas.matvec(A, x, options?)","Compute matrix-vector multiplication y = alpha*op(A)*x + beta*y.\r","Compute matrix-vector multiplication y = alpha*op(A)*x + beta*y.\r\n\r\nUses DGEMV from BLAS.",[20069,20071,20072],{"_16":659,"_22":20070,"_69":6},"- Input matrix (m × n)",{"_16":498,"_22":19330,"_69":6},{"_16":4789,"_22":19989,"_69":11},"MatvecResult",[],{"_16":20076,"_18":20077,"_20":20078,"_22":20079,"_24":20080,"_28":20085,"_30":20086},"la.blas.matvecTriangular","la.blas.matvecTriangular(A, x, options?)","Compute triangular matrix-vector multiplication x = op(A)*x.\r","Compute triangular matrix-vector multiplication x = op(A)*x.\r\n\r\nUses DTRMV from BLAS. The input vector x is overwritten with the result.",[20081,20082,20084],{"_16":659,"_22":19999,"_69":6},{"_16":498,"_22":20083,"_69":6},"- Input/output vector (length n)",{"_16":4789,"_22":19989,"_69":11},"MatvecTriangularResult",[],{"_16":20088,"_18":20089,"_20":20090,"_22":20091,"_24":20092,"_28":20097,"_30":20098},"la.blas.solveVectorTriangular","la.blas.solveVectorTriangular(A, b, options?)","Solve triangular system op(A)*x = b.\r","Solve triangular system op(A)*x = b.\r\n\r\nUses DTRSV from BLAS. The input vector b is overwritten with the solution x.",[20093,20094,20096],{"_16":659,"_22":19999,"_69":6},{"_16":436,"_22":20095,"_69":6},"- Right-hand side vector (length n)",{"_16":4789,"_22":20015,"_69":11},"SolveVectorTriangularResult",[],{"_16":20100,"_18":20101,"_20":20102,"_22":20103,"_24":20104,"_28":20107,"_30":20108},"la.blas.syr","la.blas.syr(x, options?)","Compute symmetric rank-1 update A = alpha*x*x^T + A.\r","Compute symmetric rank-1 update A = alpha*x*x^T + A.\r\n\r\nUses DSYR from BLAS. The result A is symmetric.",[20105,20106],{"_16":498,"_22":20059,"_69":6},{"_16":4789,"_22":19965,"_69":11},"SyrResult",[],{"_16":20110,"_18":20111,"_20":20112,"_22":20113,"_24":20114,"_28":20116,"_30":20117},"la.blas.asum","la.blas.asum(x)","LAWasm - LAPACK + BLAS WebAssembly Module\r","LAWasm - LAPACK + BLAS WebAssembly Module\r\n\r\nThis package provides a WebAssembly build of LAPACK (Linear Algebra PACKage)\r\nwith BLAS (Basic Linear Algebra Subprograms) bundled internally.\r\n\r\nLAPACK provides routines for:\r\n- Solving systems of linear equations\r\n- Least squares solutions\r\n- Eigenvalue problems\r\n- Singular value decomposition\r\n- Matrix factorizations (LU, Cholesky, QR, etc.)",[20115],{"_16":498,"_22":19330,"_69":6},"AsumResult",[],{"_16":20119,"_18":20120,"_20":20121,"_22":20122,"_24":20123,"_28":20129,"_30":20130},"la.blas.axpy","la.blas.axpy(alpha, x, y)","Compute y = alpha*x + y.\r","Compute y = alpha*x + y.\r\n\r\nUses DAXPY from BLAS.",[20124,20125,20127],{"_16":4399,"_22":17513,"_69":6},{"_16":498,"_22":20126,"_69":6},"- Vector to add",{"_16":501,"_22":20128,"_69":6},"- Vector to accumulate into","AxpyResult",[],{"_16":20132,"_18":20133,"_20":20134,"_22":20135,"_24":20136,"_28":20141,"_30":20142},"la.blas.copy","la.blas.copy(x, y?)","Copy vector x to y.\r","Copy vector x to y.\r\n\r\nUses DCOPY from BLAS.",[20137,20139],{"_16":498,"_22":20138,"_69":6},"- Source vector",{"_16":501,"_22":20140,"_69":11},"- Destination vector (optional, created if not provided)","CopyResult",[],{"_16":20144,"_18":20145,"_20":20146,"_22":20147,"_24":20148,"_28":20152,"_30":20153},"la.blas.dot","la.blas.dot(x, y)","Compute dot product x^T * y.\r","Compute dot product x^T * y.\r\n\r\nUses DDOT from BLAS.",[20149,20150],{"_16":498,"_22":18442,"_69":6},{"_16":501,"_22":20151,"_69":6},"- Second vector (same length as x)","DotResult",[],{"_16":20155,"_18":20156,"_20":20157,"_22":20158,"_24":20159,"_28":20162,"_30":20163},"la.blas.dotc","la.blas.dotc(x, y)","Compute conjugate dot product x^H * y.\r","Compute conjugate dot product x^H * y.\r\n\r\nFor real vectors, this is equivalent to the regular dot product.\r\nFor complex vectors (stored as interleaved real/imag pairs),\r\nthis computes the conjugate dot product.",[20160,20161],{"_16":498,"_22":18442,"_69":6},{"_16":501,"_22":20151,"_69":6},"DotcResult",[],{"_16":20165,"_18":20166,"_20":20167,"_22":20168,"_24":20169,"_28":20171,"_30":20172},"la.blas.iamax","la.blas.iamax(x)","Find index of element with maximum absolute value.\r","Find index of element with maximum absolute value.\r\n\r\nUses IDAMAX from BLAS. Returns 0-based index.",[20170],{"_16":498,"_22":19330,"_69":6},"IamaxResult",[],{"_16":20174,"_18":20175,"_20":20176,"_22":20177,"_24":20178,"_28":20180,"_30":20181},"la.blas.nrm2","la.blas.nrm2(x)","Compute Euclidean (L2) norm of a vector.\r","Compute Euclidean (L2) norm of a vector.\r\n\r\nUses DNRM2 from BLAS.",[20179],{"_16":498,"_22":19330,"_69":6},"Nrm2Result",[],{"_16":20183,"_18":20184,"_20":20185,"_22":20186,"_24":20187,"_28":20191,"_30":20192},"la.blas.scal","la.blas.scal(alpha, x)","Compute x = alpha*x.\r","Compute x = alpha*x.\r\n\r\nUses DSCAL from BLAS.",[20188,20189],{"_16":4399,"_22":17513,"_69":6},{"_16":498,"_22":20190,"_69":6},"- Vector to scale","ScalResult",[],{"_16":20194,"_18":20195,"_20":20196,"_22":20197,"_24":20198,"_28":20201,"_30":20202},"la.blas.swap","la.blas.swap(x, y)","Swap vectors x and y.\r","Swap vectors x and y.\r\n\r\nUses DSWAP from BLAS.",[20199,20200],{"_16":498,"_22":18442,"_69":6},{"_16":501,"_22":20151,"_69":6},"SwapResult",[],{"_16":20204,"_18":20205,"_20":20206,"_22":20207,"_24":20208,"_28":16732,"_30":20212},"la.eigenvalues.eig","la.eigenvalues.eig(A, options?)","Compute eigenvalues and optionally eigenvectors of a general n×n matrix A.\r","Compute eigenvalues and optionally eigenvectors of a general n×n matrix A.\r\n\r\nFor a general real matrix, eigenvalues may be complex. Complex eigenvalues\r\nappear in conjugate pairs.",[20209,20211],{"_16":659,"_22":20210,"_69":6},"- Input square matrix (n × n). Can be 2D array (row-major) or 1D array (column-major).",{"_16":4789,"_22":8349,"_69":11},[],{"_16":20214,"_18":20215,"_20":20216,"_22":20217,"_24":20218,"_28":20226,"_30":20227},"la.eigenvalues.eigBanded","la.eigenvalues.eigBanded(A, n, kd, options?)","Compute eigenvalues and eigenvectors of a symmetric banded n×n matrix.\r","Compute eigenvalues and eigenvectors of a symmetric banded n×n matrix.\r\n\r\nThe matrix is stored in banded format where:\r\n- A[i][j] represents element (i, j-i+kd) of the original matrix\r\n- kd is the number of super-diagonals (or sub-diagonals)\r\n\r\nFor a symmetric matrix, only the upper or lower triangle needs to be stored.",[20219,20221,20222,20225],{"_16":659,"_22":20220,"_69":6},"- Banded matrix in LAPACK band storage format",{"_16":362,"_22":5524,"_69":6},{"_16":20223,"_22":20224,"_69":6},"kd","- Number of super-diagonals (bandwidth - 1)",{"_16":4789,"_22":8349,"_69":11},"EigBandedResult",[],{"_16":20229,"_18":20230,"_20":20231,"_22":20232,"_24":20233,"_28":20239,"_30":20240},"la.eigenvalues.eigGeneralized","la.eigenvalues.eigGeneralized(A, B, options?)","Solve the generalized eigenvalue problem Ax = λBx.\r","Solve the generalized eigenvalue problem Ax = λBx.\r\n\r\nComputes eigenvalues λ and eigenvectors x such that A*x = λ*B*x.\r\n\r\nThis implementation requires B to be symmetric positive definite.\r\nIt reduces the problem to standard form using Cholesky factorization:\r\nIf B = L*L^T, then Ax = λBx becomes (L^-1 * A * L^-T) * y = λ * y\r\nwhere x = L^-T * y.",[20234,20236,20238],{"_16":659,"_22":20235,"_69":6},"- First matrix (n × n)",{"_16":656,"_22":20237,"_69":6},"- Second matrix (n × n), must be symmetric positive definite",{"_16":4789,"_22":8349,"_69":11},"EigGeneralizedResult",[],{"_16":20242,"_18":20243,"_20":20244,"_22":20245,"_24":20246,"_28":20252,"_30":20253},"la.eigenvalues.eigGeneralizedSymmetric","la.eigenvalues.eigGeneralizedSymmetric(A, B, options?)","Solve the symmetric generalized eigenvalue problem.\r","Solve the symmetric generalized eigenvalue problem.\r\n\r\nComputes eigenvalues and eigenvectors of one of three forms:\r\n- itype=1: A*x = λ*B*x\r\n- itype=2: A*B*x = λ*x\r\n- itype=3: B*A*x = λ*x\r\n\r\nwhere A is symmetric and B is symmetric positive definite.\r\nAll eigenvalues are guaranteed to be real.",[20247,20249,20251],{"_16":659,"_22":20248,"_69":6},"- Symmetric matrix (n × n)",{"_16":656,"_22":20250,"_69":6},"- Symmetric positive definite matrix (n × n)",{"_16":4789,"_22":8349,"_69":11},"EigGeneralizedSymmetricResult",[],{"_16":20255,"_18":20256,"_20":20257,"_22":20258,"_24":20259,"_28":20265,"_30":20266},"la.eigenvalues.eigHermitian","la.eigenvalues.eigHermitian(A, n, options?)","Compute eigenvalues and optionally eigenvectors of a complex Hermitian n×n matrix A.\r","Compute eigenvalues and optionally eigenvectors of a complex Hermitian n×n matrix A.\r\n\r\nFor a Hermitian matrix (A = A^H), all eigenvalues are real and the eigenvectors\r\nform a unitary basis.\r\n\r\nInput format: The matrix A should be provided as interleaved real/imaginary pairs.\r\nFor an n×n matrix, provide 2*n*n values where pairs (A[2k], A[2k+1]) represent\r\nthe real and imaginary parts of complex element k.",[20260,20262,20264],{"_16":659,"_22":20261,"_69":6},"- Input Hermitian matrix as interleaved complex array.\r\n For 2D array input, each element should be [re, im].\r\n For 1D input, provide interleaved real/imaginary values.",{"_16":362,"_22":20263,"_69":6},"- Matrix dimension (must be provided for complex matrices)",{"_16":4789,"_22":8349,"_69":11},"EigHermitianResult",[],{"_16":20268,"_18":20269,"_20":20270,"_22":20271,"_24":20272,"_28":20277,"_30":20278},"la.eigenvalues.eigSelect","la.eigenvalues.eigSelect(A, options?)","Compute selected eigenvalues and eigenvectors of a real symmetric n×n matrix A.\r","Compute selected eigenvalues and eigenvectors of a real symmetric n×n matrix A.\r\n\r\nUses the Relatively Robust Representations (RRR) algorithm which can efficiently\r\ncompute a subset of eigenvalues.",[20273,20275],{"_16":659,"_22":20274,"_69":6},"- Input symmetric matrix (n × n). Only the specified triangle is accessed.",{"_16":4789,"_22":20276,"_69":11},"- Selection and computation options","EigSelectResult",[],{"_16":20280,"_18":20281,"_20":20282,"_22":20283,"_24":20284,"_28":16740,"_30":20287},"la.eigenvalues.eigSymmetric","la.eigenvalues.eigSymmetric(A, options?)","Compute eigenvalues and optionally eigenvectors of a real symmetric n×n matrix A.\r","Compute eigenvalues and optionally eigenvectors of a real symmetric n×n matrix A.\r\n\r\nFor a symmetric matrix, all eigenvalues are real and the eigenvectors\r\nform an orthonormal basis.",[20285,20286],{"_16":659,"_22":20274,"_69":6},{"_16":4789,"_22":8349,"_69":11},[],{"_16":20289,"_18":20290,"_20":20291,"_22":20292,"_24":20293,"_28":20300,"_30":20301},"la.eigenvalues.eigTridiagonal","la.eigenvalues.eigTridiagonal(d, e, options?)","Compute eigenvalues and eigenvectors of a symmetric tridiagonal matrix.\r","Compute eigenvalues and eigenvectors of a symmetric tridiagonal matrix.\r\n\r\nThe matrix is defined by:\r\n- d: diagonal elements [d0, d1, ..., d(n-1)]\r\n- e: off-diagonal elements [e0, e1, ..., e(n-2)]\r\n\r\nThe matrix T is:\r\n[d0 e0 0 0 ...]\r\n[e0 d1 e1 0 ...]\r\n[0 e1 d2 e2 ...]\r\n[.................]",[20294,20296,20299],{"_16":1946,"_22":20295,"_69":6},"- Diagonal elements (length n)",{"_16":20297,"_22":20298,"_69":6},"e","- Off-diagonal elements (length n-1)",{"_16":4789,"_22":8349,"_69":11},"EigTridiagonalResult",[],{"_16":20303,"_18":20304,"_20":20305,"_22":20306,"_24":20307,"_28":20310,"_30":20311},"la.eigenvalues.eigvals","la.eigenvalues.eigvals(A, options?)","Compute only the eigenvalues of a general n×n matrix A.\r","Compute only the eigenvalues of a general n×n matrix A.\r\n\r\nThis is faster than computing the full eigendecomposition when only\r\neigenvalues are needed.",[20308,20309],{"_16":659,"_22":20210,"_69":6},{"_16":4789,"_22":8349,"_69":11},"EigvalsResult",[],{"_16":20313,"_18":20314,"_20":20315,"_22":20316,"_24":20317,"_28":16706,"_30":20321},"la.factorizations.cholesky","la.factorizations.cholesky(A, options?)","Compute the Cholesky factorization of a symmetric positive definite matrix A.\r","Compute the Cholesky factorization of a symmetric positive definite matrix A.\r\n\r\nIf upper=false (default): A = L * L^T where L is lower triangular\r\nIf upper=true: A = U^T * U where U is upper triangular",[20318,20320],{"_16":659,"_22":20319,"_69":6},"- Symmetric positive definite matrix (n × n).\r\n Only the specified triangle (upper or lower) is referenced.",{"_16":4789,"_22":8275,"_69":11},[],{"_16":20323,"_18":20324,"_20":20325,"_22":20326,"_24":20327,"_28":20332,"_30":20333},"la.factorizations.hessenberg","la.factorizations.hessenberg(A, options?)","Reduce a general n×n matrix A to upper Hessenberg form.\r","Reduce a general n×n matrix A to upper Hessenberg form.\r\n\r\nA = Q * H * Q^T\r\n\r\nwhere H is upper Hessenberg (zero below the first subdiagonal)\r\nand Q is orthogonal.\r\n\r\nUpper Hessenberg form is useful as a preprocessing step for\r\neigenvalue computations.",[20328,20330],{"_16":659,"_22":20329,"_69":6},"- Input square matrix (n × n).",{"_16":4789,"_22":20331,"_69":11},"- Reduction options","HessenbergResult",[],{"_16":20335,"_18":20336,"_20":20337,"_22":20338,"_24":20339,"_28":20343,"_30":20344},"la.factorizations.ldl","la.factorizations.ldl(A, options?)","Compute the LDL^T factorization of a symmetric n×n matrix A.\r","Compute the LDL^T factorization of a symmetric n×n matrix A.\r\n\r\nA = L * D * L^T (or A = U * D * U^T if upper=true)\r\n\r\nwhere L (or U) is unit triangular and D is block diagonal with\r\n1×1 and 2×2 blocks.\r\n\r\nThis factorization is useful for symmetric indefinite matrices\r\n(which cannot use Cholesky).\r\n\r\nNote: This is a simplified implementation. For production use with\r\nill-conditioned matrices, the full LAPACK DSYTRF with Bunch-Kaufman\r\npivoting is recommended.",[20340,20342],{"_16":659,"_22":20341,"_69":6},"- Symmetric matrix (n × n). Only the specified triangle is used.",{"_16":4789,"_22":8275,"_69":11},"LDLResult",[],{"_16":20346,"_18":20347,"_20":20348,"_22":20349,"_24":20350,"_28":20354,"_30":20355},"la.factorizations.lq","la.factorizations.lq(A, options?)","Compute the LQ factorization of a general m×n matrix A.\r","Compute the LQ factorization of a general m×n matrix A.\r\n\r\nA = L * Q\r\n\r\nwhere L is lower triangular (m×k) and Q is orthogonal (k×n),\r\nwith k = min(m, n).\r\n\r\nImplementation note: This uses QR of A^T since DGELQF is not exported.\r\nA = L * Q implies A^T = Q^T * L^T, so we compute QR of A^T.",[20351,20353],{"_16":659,"_22":20352,"_69":6},"- Input matrix (m × n). Can be 2D array (row-major) or 1D array (column-major).",{"_16":4789,"_22":8275,"_69":11},"LQResult",[],{"_16":20357,"_18":20358,"_20":20359,"_22":20360,"_24":20361,"_28":16803,"_30":20364},"la.factorizations.lu","la.factorizations.lu(A, options?)","Compute the LU factorization of a general m×n matrix A.\r","Compute the LU factorization of a general m×n matrix A.\r\n\r\nA = P * L * U\r\n\r\nwhere P is a permutation matrix, L is lower triangular with unit diagonal,\r\nand U is upper triangular.",[20362,20363],{"_16":659,"_22":20352,"_69":6},{"_16":4789,"_22":8275,"_69":11},[],{"_16":20366,"_18":20367,"_20":20368,"_22":20369,"_24":20370,"_28":16812,"_30":20373},"la.factorizations.qr","la.factorizations.qr(A, options?)","Compute the QR factorization of a general m×n matrix A.\r","Compute the QR factorization of a general m×n matrix A.\r\n\r\nA = Q * R\r\n\r\nwhere Q is orthogonal (m×m or m×k) and R is upper triangular (m×n or k×n),\r\nwith k = min(m, n).",[20371,20372],{"_16":659,"_22":20352,"_69":6},{"_16":4789,"_22":8275,"_69":11},[],{"_16":20375,"_18":20376,"_20":20377,"_22":20378,"_24":20379,"_28":20382,"_30":20383},"la.factorizations.qrPivoted","la.factorizations.qrPivoted(A, options?)","Compute the QR factorization with column pivoting of a general m×n matrix A.\r","Compute the QR factorization with column pivoting of a general m×n matrix A.\r\n\r\nA * P = Q * R\r\n\r\nwhere P is a permutation matrix, Q is orthogonal, and R is upper triangular\r\nwith diagonal elements of decreasing magnitude.\r\n\r\nThis is useful for rank-revealing factorization: the numerical rank of A\r\ncan be estimated from the diagonal of R.",[20380,20381],{"_16":659,"_22":20352,"_69":6},{"_16":4789,"_22":8275,"_69":11},"QRPivotedResult",[],{"_16":20385,"_18":20386,"_20":20387,"_22":20388,"_24":20389,"_28":20393,"_30":20394},"la.factorizations.schur","la.factorizations.schur(A, options?)","Compute the Schur decomposition of a general n×n matrix A.\r","Compute the Schur decomposition of a general n×n matrix A.\r\n\r\nA = Z * T * Z^T\r\n\r\nwhere T is quasi-upper triangular (real Schur form) and Z is orthogonal.\r\n\r\nThe diagonal of T contains 1×1 blocks (real eigenvalues) and 2×2 blocks\r\n(complex conjugate pairs of eigenvalues).\r\n\r\nNote: This implementation uses DGEEV to compute eigenvalues. The full\r\nSchur decomposition with DGEES would provide the actual quasi-triangular\r\nform, but DGEES is not currently exported.",[20390,20391],{"_16":659,"_22":20329,"_69":6},{"_16":4789,"_22":20392,"_69":11},"- Decomposition options","SchurResult",[],{"_16":20396,"_18":20397,"_20":20398,"_22":20399,"_24":20400,"_28":20404,"_30":20405},"la.inverses.inv","la.inverses.inv(A, options?)","Compute the inverse of a general n×n matrix A.\r","Compute the inverse of a general n×n matrix A.\r\n\r\nUses LU factorization with partial pivoting: A = P*L*U,\r\nthen computes A^(-1) from this factorization.",[20401,20403],{"_16":659,"_22":20402,"_69":6},"- Input square matrix (n × n)",{"_16":4789,"_22":8349,"_69":11},"InvResult",[],{"_16":20407,"_18":20408,"_20":20409,"_22":20410,"_24":20411,"_28":20415,"_30":20416},"la.inverses.invSymmetric","la.inverses.invSymmetric(A, options?)","Compute the inverse of a symmetric positive definite n×n matrix A.\r","Compute the inverse of a symmetric positive definite n×n matrix A.\r\n\r\nUses Cholesky factorization: A = L*L^T (or U^T*U),\r\nthen computes A^(-1) from this factorization.\r\n\r\nThis is more efficient than general matrix inversion when A is known\r\nto be symmetric positive definite.",[20412,20414],{"_16":659,"_22":20413,"_69":6},"- Input symmetric positive definite matrix (n × n)",{"_16":4789,"_22":8349,"_69":11},"InvSymmetricResult",[],{"_16":20418,"_18":20419,"_20":20420,"_22":20421,"_24":20422,"_28":20426,"_30":20427},"la.inverses.invTriangular","la.inverses.invTriangular(A, options?)","Compute the inverse of a triangular n×n matrix A.\r","Compute the inverse of a triangular n×n matrix A.\r\n\r\nFor upper triangular A, the inverse is also upper triangular.\r\nFor lower triangular A, the inverse is also lower triangular.",[20423,20425],{"_16":659,"_22":20424,"_69":6},"- Input triangular matrix (n × n)",{"_16":4789,"_22":8349,"_69":11},"InvTriangularResult",[],{"_16":20429,"_18":20430,"_20":20431,"_22":20432,"_24":20433,"_28":20436,"_30":20437},"la.inverses.pinv","la.inverses.pinv(A, options?)","Compute the Moore-Penrose pseudoinverse of an m×n matrix A.\r","Compute the Moore-Penrose pseudoinverse of an m×n matrix A.\r\n\r\nThe pseudoinverse A^+ satisfies:\r\n- A * A^+ * A = A\r\n- A^+ * A * A^+ = A^+\r\n- (A * A^+)^T = A * A^+\r\n- (A^+ * A)^T = A^+ * A\r\n\r\nFor full-rank matrices:\r\n- If m >= n (overdetermined): A^+ = (A^T*A)^(-1) * A^T\r\n- If m < n (underdetermined): A^+ = A^T * (A*A^T)^(-1)\r\n\r\nThis implementation uses SVD: A = U * S * V^T => A^+ = V * S^+ * U^T\r\nwhere S^+ is the pseudoinverse of the diagonal singular value matrix.",[20434,20435],{"_16":659,"_22":20070,"_69":6},{"_16":4789,"_22":8349,"_69":11},"PinvResult",[],{"_16":20439,"_18":20440,"_20":20441,"_22":20442,"_24":20443,"_28":20454,"_30":20455},"la.leastSquares.constrainedLstSq","la.leastSquares.constrainedLstSq(A, b, C, d, _options?)","Solve an equality-constrained least squares problem.\r","Solve an equality-constrained least squares problem.\r\n\r\nminimize ||Ax - b||_2 subject to Cx = d\r\n\r\nThis is useful when you have hard constraints that must be satisfied exactly,\r\nalong with a least squares objective.\r\n\r\nRequirements:\r\n- C must have full row rank (p <= n)\r\n- The system Cx = d must be consistent",[20444,20446,20448,20450,20452],{"_16":659,"_22":20445,"_69":6},"- Objective matrix (m × n)",{"_16":436,"_22":20447,"_69":6},"- Objective vector (m)",{"_16":2170,"_22":20449,"_69":6},"- Constraint matrix (p × n)",{"_16":1946,"_22":20451,"_69":6},"- Constraint vector (p)",{"_16":8336,"_22":20453,"_69":11},"ConstrainedLstSqOptions","ConstrainedLstSqResult",[],{"_16":20457,"_18":20458,"_20":20459,"_22":20460,"_24":20461,"_28":20470,"_30":20471},"la.leastSquares.generalizedLstSq","la.leastSquares.generalizedLstSq(A, B, d, _options?)","Solve a generalized least squares problem.\r","Solve a generalized least squares problem.\r\n\r\nminimize ||y||_2 subject to Ax + By = d\r\n\r\nThis is also known as the Gauss-Markov linear model problem.\r\nIt arises when fitting a model y = Ax with correlated errors,\r\nwhere the error covariance is proportional to B*B^T.\r\n\r\nRequirements:\r\n- [A B] must have full row rank (p = n + m)\r\n- m >= p - n (enough degrees of freedom)",[20462,20464,20466,20468],{"_16":659,"_22":20463,"_69":6},"- Design matrix for x (p × n)",{"_16":656,"_22":20465,"_69":6},"- Design matrix for y (p × m)",{"_16":1946,"_22":20467,"_69":6},"- Target vector (p)",{"_16":8336,"_22":20469,"_69":11},"GeneralizedLstSqOptions","GeneralizedLstSqResult",[],{"_16":20473,"_18":20474,"_20":20475,"_22":20476,"_24":20477,"_28":20482,"_30":20483},"la.leastSquares.lstsq","la.leastSquares.lstsq(A, b, options?)","Solve a least squares problem using QR factorization.\r","Solve a least squares problem using QR factorization.\r\n\r\nFor overdetermined systems (m >= n): minimize ||Ax - b||_2\r\nFor underdetermined systems (m < n): find minimum norm solution to Ax = b\r\n\r\nThis function assumes A has full rank. For rank-deficient matrices,\r\nuse lstsqSVD or lstsqGelsy instead.",[20478,20479,20481],{"_16":659,"_22":17614,"_69":6},{"_16":436,"_22":20480,"_69":6},"- Right-hand side vector/matrix (m × nrhs)",{"_16":4789,"_22":8349,"_69":11},"LstSqResult",[],{"_16":20485,"_18":20486,"_20":20487,"_22":20488,"_24":20489,"_28":20493,"_30":20494},"la.leastSquares.lstsqGelsy","la.leastSquares.lstsqGelsy(A, b, options?)","Solve a least squares problem using QR with column pivoting.\r","Solve a least squares problem using QR with column pivoting.\r\n\r\nComputes the minimum-norm solution to: minimize ||Ax - b||_2\r\nusing a complete orthogonal factorization of A.\r\n\r\nThis method is generally faster than SVD-based methods for rank-deficient problems.",[20490,20491,20492],{"_16":659,"_22":17614,"_69":6},{"_16":436,"_22":20480,"_69":6},{"_16":4789,"_22":8349,"_69":11},"LstSqGelsyResult",[],{"_16":20496,"_18":20497,"_20":20498,"_22":20499,"_24":20500,"_28":20504,"_30":20505},"la.leastSquares.lstsqSVD","la.leastSquares.lstsqSVD(A, b, options?)","Solve a least squares problem using SVD.\r","Solve a least squares problem using SVD.\r\n\r\nComputes the minimum-norm solution to: minimize ||Ax - b||_2\r\n\r\nThis method is safe for rank-deficient matrices. Singular values\r\nbelow rcond * max(s) are treated as zero.",[20501,20502,20503],{"_16":659,"_22":17614,"_69":6},{"_16":436,"_22":20480,"_69":6},{"_16":4789,"_22":8349,"_69":11},"LstSqSVDResult",[],{"_16":20507,"_18":20508,"_20":20509,"_22":20510,"_24":20511,"_28":20517,"_30":20518},"la.linearSolvers.solve","la.linearSolvers.solve(A, b, options?)","Solve a system of linear equations Ax = b for a general matrix A.\r","Solve a system of linear equations Ax = b for a general matrix A.\r\n\r\nUses LU decomposition with partial pivoting (DGESV).",[20512,20514,20516],{"_16":659,"_22":20513,"_69":6},"- Coefficient matrix (n × n). Can be 2D array (row-major) or 1D array (column-major).",{"_16":436,"_22":20515,"_69":6},"- Right-hand side vector or matrix (n × nrhs).",{"_16":4789,"_22":8287,"_69":11},"SolveResult",[],{"_16":20520,"_18":20521,"_20":20522,"_22":20523,"_24":20524,"_28":20517,"_30":20536},"la.linearSolvers.solveBanded","la.linearSolvers.solveBanded(AB, b, n, kl, ku)","Solve a banded system Ax = b where A is a general banded matrix.\r","Solve a banded system Ax = b where A is a general banded matrix.\r\n\r\nA banded matrix has non-zero elements only within kl diagonals below\r\nand ku diagonals above the main diagonal.\r\n\r\nThe banded matrix is stored in band storage format:\r\n- Row i of the band array contains diagonal (i - kl)\r\n- The band array has (2*kl + ku + 1) rows and n columns\r\n\r\nNote: This function converts the banded format to dense and uses\r\nthe general solver. For large sparse banded systems, consider using\r\nspecialized routines.",[20525,20527,20529,20530,20533],{"_16":20526,"_22":20220,"_69":6},"AB",{"_16":436,"_22":20528,"_69":6},"- Right-hand side vector or matrix",{"_16":362,"_22":5524,"_69":6},{"_16":20531,"_22":20532,"_69":6},"kl","- Number of sub-diagonals",{"_16":20534,"_22":20535,"_69":6},"ku","- Number of super-diagonals",[],{"_16":20538,"_18":20539,"_20":20540,"_22":20541,"_24":20542,"_28":20551,"_30":20552},"la.linearSolvers.solveHermitian","la.linearSolvers.solveHermitian(A, b, n, options?)","Solve a complex Hermitian positive definite system Ax = b.\r","Solve a complex Hermitian positive definite system Ax = b.\r\n\r\nUses complex Cholesky decomposition (ZPOSV).\r\n\r\nComplex values are stored as interleaved real/imaginary pairs:\r\n[re0, im0, re1, im1, ...]",[20543,20545,20547,20549],{"_16":659,"_22":20544,"_69":6},"- Hermitian positive definite matrix in interleaved complex format.\r\n Size should be 2 * n * n where n is the matrix dimension.",{"_16":436,"_22":20546,"_69":6},"- Right-hand side in interleaved complex format.",{"_16":362,"_22":20548,"_69":6},"- Matrix dimension (number of rows/columns).",{"_16":4789,"_22":20550,"_69":11},"- Solver options.","SolveComplexResult",[],{"_16":20554,"_18":20555,"_20":20556,"_22":20557,"_24":20558,"_28":20565,"_30":20566},"la.linearSolvers.solveSymmetric","la.linearSolvers.solveSymmetric(A, b, options?)","Solve a symmetric positive definite system Ax = b.\r","Solve a symmetric positive definite system Ax = b.\r\n\r\nUses Cholesky decomposition (DPOSV) which is more efficient than LU\r\nfor symmetric positive definite matrices.",[20559,20561,20563],{"_16":659,"_22":20560,"_69":6},"- Symmetric positive definite matrix (n × n). Only the upper or lower\r\n triangle is referenced based on the `upper` option.",{"_16":436,"_22":20562,"_69":6},"- Right-hand side vector or matrix.",{"_16":4789,"_22":20564,"_69":11},"- Solver options including which triangle to use.","SolveSymmetricResult",[],{"_16":20568,"_18":20569,"_20":20570,"_22":20571,"_24":20572,"_28":20578,"_30":20579},"la.linearSolvers.solveTriangular","la.linearSolvers.solveTriangular(A, b, options?)","Solve a triangular system Ax = b where A is upper or lower triangular.\r","Solve a triangular system Ax = b where A is upper or lower triangular.\r\n\r\nUses DTRTRS for efficient triangular solve without factorization.",[20573,20575,20576],{"_16":659,"_22":20574,"_69":6},"- Triangular coefficient matrix (n × n).",{"_16":436,"_22":20562,"_69":6},{"_16":4789,"_22":20577,"_69":11},"- Solver options including triangle type and transpose mode.","SolveTriangularResult",[],{"_16":20581,"_18":20582,"_20":20583,"_22":20584,"_24":20585,"_28":20595,"_30":20596},"la.linearSolvers.solveTridiagonal","la.linearSolvers.solveTridiagonal(dl, d, du, b)","Solve a tridiagonal system Ax = b where A is tridiagonal.\r","Solve a tridiagonal system Ax = b where A is tridiagonal.\r\n\r\nA tridiagonal matrix has non-zero elements only on the main diagonal\r\nand the diagonals immediately above and below it.\r\n\r\nUses the Thomas algorithm (tridiagonal matrix algorithm) for efficient O(n) solution.",[20586,20589,20591,20594],{"_16":20587,"_22":20588,"_69":6},"dl","- Sub-diagonal elements (length n-1)",{"_16":1946,"_22":20590,"_69":6},"- Main diagonal elements (length n)",{"_16":20592,"_22":20593,"_69":6},"du","- Super-diagonal elements (length n-1)",{"_16":436,"_22":20528,"_69":6},"SolveTridiagonalResult",[],{"_16":20598,"_18":20599,"_20":20600,"_22":20601,"_24":20602,"_28":20604,"_30":20605},"la.matrixFunctions.expm","la.matrixFunctions.expm(A)","Compute the matrix exponential e^A.\r","Compute the matrix exponential e^A.\r\n\r\nUses the scaling and squaring method with Padé approximation.\r\nThis is a pure TypeScript implementation.",[20603],{"_16":659,"_22":20402,"_69":6},"ExpmResult",[],{"_16":20607,"_18":20608,"_20":20609,"_22":20610,"_24":20611,"_28":20615,"_30":20616},"la.matrixFunctions.funm","la.matrixFunctions.funm(A, f)","Compute a general matrix function f(A).\r","Compute a general matrix function f(A).\r\n\r\nComputes f(A) where f is a scalar function, using eigendecomposition.\r\nFor a matrix A = V * D * V^(-1) where D is diagonal,\r\nf(A) = V * f(D) * V^(-1) where f(D) applies f to each diagonal element.",[20612,20613],{"_16":659,"_22":20402,"_69":6},{"_16":3860,"_22":20614,"_69":6},"- Scalar function to apply","FunmResult",[],{"_16":20618,"_18":20619,"_20":20620,"_22":20621,"_24":20622,"_28":20624,"_30":20625},"la.matrixFunctions.logm","la.matrixFunctions.logm(A)","Compute the principal matrix logarithm log(A).\r","Compute the principal matrix logarithm log(A).\r\n\r\nUses the inverse scaling and squaring method.\r\nThe matrix A must have no eigenvalues on the closed negative real axis.",[20623],{"_16":659,"_22":20402,"_69":6},"LogmResult",[],{"_16":20627,"_18":20628,"_20":20629,"_22":20630,"_24":20631,"_28":20635,"_30":20636},"la.matrixFunctions.powm","la.matrixFunctions.powm(A, p)","Compute matrix power A^p.\r","Compute matrix power A^p.\r\n\r\nFor integer p >= 0: uses binary exponentiation.\r\nFor integer p < 0: computes inverse then uses binary exponentiation.\r\nFor non-integer p: uses A^p = expm(p * logm(A)).",[20632,20633],{"_16":659,"_22":20402,"_69":6},{"_16":1645,"_22":20634,"_69":6},"- Power (integer or real)","PowmResult",[],{"_16":20638,"_18":20639,"_20":20640,"_22":20641,"_24":20642,"_28":20644,"_30":20645},"la.matrixFunctions.sqrtm","la.matrixFunctions.sqrtm(A)","Compute the principal matrix square root.\r","Compute the principal matrix square root.\r\n\r\nFinds S such that S*S = A, where S has eigenvalues with positive real parts.\r\nUses the Denman-Beavers iteration.",[20643],{"_16":659,"_22":20402,"_69":6},"SqrtmResult",[],{"_16":20647,"_18":20648,"_20":20649,"_22":20650,"_24":20651,"_28":20658,"_30":20659},"la.matrixFunctions.csd","la.matrixFunctions.csd(X, p, q)","Compute the Cosine-Sine Decomposition of a partitioned unitary matrix.\r","Compute the Cosine-Sine Decomposition of a partitioned unitary matrix.\r\n\r\nGiven a unitary matrix X partitioned as:\r\n X = [ X11 X12 ] where X11 is p×q\r\n [ X21 X22 ]\r\n\r\nThe CSD computes:\r\n X11 = U1 * C * V1'\r\n X21 = U2 * S * V1'\r\n X12 = -U1 * S * V2'\r\n X22 = U2 * C * V2'\r\n\r\nwhere C = diag(cos(theta)) and S = diag(sin(theta)).\r\n\r\nThis is a simplified implementation using SVD of X11.",[20652,20654,20656],{"_16":579,"_22":20653,"_69":6},"- Input unitary matrix (m × m)",{"_16":1645,"_22":20655,"_69":6},"- Row partition size",{"_16":12844,"_22":20657,"_69":6},"- Column partition size","CSDResult",[],{"_16":20661,"_18":20662,"_20":20663,"_22":20664,"_24":20665,"_28":20667,"_30":20668},"la.matrixFunctions.polarDecomposition","la.matrixFunctions.polarDecomposition(A)","Compute the polar decomposition A = U*P.\r","Compute the polar decomposition A = U*P.\r\n\r\nU is unitary (orthogonal for real matrices) and P is positive semidefinite.\r\nUses SVD: if A = W*S*Vt, then U = W*Vt and P = V*S*Vt.",[20666],{"_16":659,"_22":20070,"_69":6},"PolarDecompositionResult",[],{"_16":20670,"_18":20671,"_20":20672,"_22":20673,"_24":20674,"_28":20678,"_30":20679},"la.matrixFunctions.rrqr","la.matrixFunctions.rrqr(A, options?)","Compute rank-revealing QR decomposition with column pivoting.\r","Compute rank-revealing QR decomposition with column pivoting.\r\n\r\nComputes A*P = Q*R where P is a permutation matrix chosen to\r\nreveal the numerical rank of A.\r\n\r\nUses DGEQP3 from LAPACK.",[20675,20676],{"_16":659,"_22":20070,"_69":6},{"_16":4789,"_22":20677,"_69":11},"- RRQR options","RRQRResult",[],{"_16":20681,"_18":20682,"_20":20683,"_22":20684,"_24":20685,"_28":20689,"_30":20690},"la.matrixFunctions.choleskyHermitian","la.matrixFunctions.choleskyHermitian(A, options?)","Compute Cholesky factorization of a Hermitian positive definite matrix.\r","Compute Cholesky factorization of a Hermitian positive definite matrix.\r\n\r\nFor real matrices, this is equivalent to standard Cholesky factorization.\r\nFor complex Hermitian matrices, A = L*L^H or A = U^H*U.\r\n\r\nUses DPOTRF from LAPACK (for real matrices).",[20686,20688],{"_16":659,"_22":20687,"_69":6},"- Input Hermitian positive definite matrix (n × n)",{"_16":4789,"_22":8275,"_69":11},"CholeskyHermitianResult",[],{"_16":20692,"_18":20693,"_20":20694,"_22":20695,"_24":20696,"_28":20699,"_30":20700},"la.norms.cond","la.norms.cond(A, options?)","Compute the condition number of a matrix.\r","Compute the condition number of a matrix.\r\n\r\nThe condition number κ(A) = ||A|| * ||A^(-1)||\r\n\r\nFor ord=2, this is the ratio of largest to smallest singular value.\r\nFor ord=1 or 'inf', uses LU factorization and DGECON.",[20697,20698],{"_16":659,"_22":20402,"_69":6},{"_16":4789,"_22":8349,"_69":11},"CondResult",[],{"_16":20702,"_18":20703,"_20":20704,"_22":20705,"_24":20706,"_28":20709,"_30":20710},"la.norms.condEst","la.norms.condEst(A, options?)","Compute a fast estimate of the condition number.\r","Compute a fast estimate of the condition number.\r\n\r\nUses LU factorization (DGETRF) followed by condition estimation (DGECON).\r\nThis is faster than computing the exact condition number via SVD.",[20707,20708],{"_16":659,"_22":20402,"_69":6},{"_16":4789,"_22":8349,"_69":11},"CondEstResult",[],{"_16":20712,"_18":20713,"_20":20714,"_22":20715,"_24":20716,"_28":20719,"_30":20720},"la.norms.det","la.norms.det(A, options?)","Compute the determinant of a square matrix.\r","Compute the determinant of a square matrix.\r\n\r\nUses LU factorization: A = P*L*U, then det(A) = det(P) * det(L) * det(U)\r\nSince L has unit diagonal, det(L) = 1.\r\ndet(U) = product of diagonal elements.\r\ndet(P) = (-1)^(number of row interchanges).\r\n\r\nWARNING: For large matrices, the determinant can overflow or underflow.\r\nUse logdet() or slogdet() for numerically stable computation.",[20717,20718],{"_16":659,"_22":20402,"_69":6},{"_16":4789,"_22":8349,"_69":11},"DetResult",[],{"_16":20722,"_18":20723,"_20":20724,"_22":20725,"_24":20726,"_28":20729,"_30":20730},"la.norms.logdet","la.norms.logdet(A, options?)","Compute the natural logarithm of the absolute value of the determinant.\r","Compute the natural logarithm of the absolute value of the determinant.\r\n\r\nThis is numerically more stable than computing det() for large matrices\r\nor matrices with very large/small determinants.\r\n\r\nlog|det(A)| = sum of log|diagonal elements of U from LU factorization|",[20727,20728],{"_16":659,"_22":20402,"_69":6},{"_16":4789,"_22":8349,"_69":11},"LogDetResult",[],{"_16":20732,"_18":20733,"_20":20734,"_22":20734,"_24":20735,"_28":20739,"_30":20740},"la.norms.norm","la.norms.norm(A, options?)","Compute a matrix norm.",[20736,20737],{"_16":659,"_22":20070,"_69":6},{"_16":4789,"_22":20738,"_69":11},"- Norm options","NormResult",[],{"_16":20742,"_18":20743,"_20":20744,"_22":20745,"_24":20746,"_28":20749,"_30":20750},"la.norms.rank","la.norms.rank(A, options?)","Compute the numerical rank of a matrix.\r","Compute the numerical rank of a matrix.\r\n\r\nThe rank is computed as the number of singular values greater than\r\na tolerance threshold. By default, the tolerance is:\r\n tol = max(m, n) * eps * max(singular values)\r\n\r\nwhere eps is the machine epsilon (~2.22e-16 for double precision).",[20747,20748],{"_16":659,"_22":20070,"_69":6},{"_16":4789,"_22":8349,"_69":11},"RankResult",[],{"_16":20752,"_18":20753,"_20":20754,"_22":20755,"_24":20756,"_28":20759,"_30":20760},"la.norms.rcond","la.norms.rcond(A, options?)","Compute the reciprocal of the condition number of a matrix.\r","Compute the reciprocal of the condition number of a matrix.\r\n\r\nThe reciprocal condition number rcond = 1/κ(A) = 1/(||A|| * ||A^(-1)||)\r\n\r\nA small rcond (e.g., < machine_epsilon * n) indicates an ill-conditioned\r\nor nearly singular matrix.\r\n\r\nUses LU factorization (DGETRF) followed by DGECON.",[20757,20758],{"_16":659,"_22":20402,"_69":6},{"_16":4789,"_22":8349,"_69":11},"RcondResult",[],{"_16":20762,"_18":20763,"_20":20764,"_22":20765,"_24":20766,"_28":20769,"_30":20770},"la.norms.slogdet","la.norms.slogdet(A, options?)","Compute the sign and natural logarithm of the absolute value of the determinant.\r","Compute the sign and natural logarithm of the absolute value of the determinant.\r\n\r\nReturns (sign, logabsdet) such that det(A) = sign * exp(logabsdet).\r\n\r\nThis is the most numerically stable way to work with determinants,\r\nespecially for large matrices or matrices with very large/small determinants.",[20767,20768],{"_16":659,"_22":20402,"_69":6},{"_16":4789,"_22":8349,"_69":11},"SlogDetResult",[],{"_16":20772,"_18":20773,"_20":20774,"_22":20775,"_24":20776,"_28":16856,"_30":20780},"la.svdModule.svd","la.svdModule.svd(A, options?)","Compute the Singular Value Decomposition of a general m×n matrix A.\r","Compute the Singular Value Decomposition of a general m×n matrix A.\r\n\r\nA = U * S * V^T\r\n\r\nwhere U is m×m (or m×k) orthogonal, S is a diagonal matrix with singular values,\r\nand V is n×n (or k×n) orthogonal, with k = min(m, n).",[20777,20778],{"_16":659,"_22":20352,"_69":6},{"_16":4789,"_22":20779,"_69":11},"- SVD options",[],{"_16":20782,"_18":20783,"_20":20784,"_22":20785,"_24":20786,"_28":16856,"_30":20791},"la.svdModule.svdCompact","la.svdModule.svdCompact(A, algorithm?)","Compute the compact (economy-size) SVD of a general m×n matrix A.\r","Compute the compact (economy-size) SVD of a general m×n matrix A.\r\n\r\nA = U * S * V^T\r\n\r\nThis is equivalent to `svd(A, { mode: 'reduced' })` but with a simpler interface.\r\n\r\nFor an m×n matrix with k = min(m, n):\r\n- U is m×k\r\n- S is k×k diagonal (returned as vector s of length k)\r\n- Vt is k×n",[20787,20788],{"_16":659,"_22":20352,"_69":6},{"_16":20789,"_22":20790,"_69":11},"algorithm","- Which algorithm to use: 'gesvd' (more accurate) or 'gesdd' (faster)",[],{"_16":20793,"_18":20794,"_20":20795,"_22":20796,"_24":20797,"_28":20801,"_30":20802},"la.svdModule.svdRank","la.svdModule.svdRank(A, options?)","Estimate the numerical rank of a matrix using SVD.\r","Estimate the numerical rank of a matrix using SVD.\r\n\r\nThe rank is estimated by counting the number of singular values above\r\na tolerance threshold. This is the most reliable method for determining\r\nnumerical rank.",[20798,20799],{"_16":659,"_22":20352,"_69":6},{"_16":4789,"_22":20800,"_69":11},"- Options including tolerance","SVDRankResult",[],{"_16":20804,"_18":20805,"_20":20806,"_22":20807,"_24":20808,"_28":20812,"_30":20813},"la.svdModule.svdvals","la.svdModule.svdvals(A, options?)","Compute only the singular values of a general m×n matrix A.\r","Compute only the singular values of a general m×n matrix A.\r\n\r\nThis is faster than computing the full SVD when only singular values are needed.",[20809,20810],{"_16":659,"_22":20352,"_69":6},{"_16":4789,"_22":20811,"_69":11},"- Options","SVDValsResult",[],{"_16":20815,"_18":20816,"_20":20817,"_22":20818,"_24":20819,"_28":20821,"_30":20822},"la.utilities.balance","la.utilities.balance(A)","Balance a matrix to improve eigenvalue computation.\r","Balance a matrix to improve eigenvalue computation.\r\n\r\nBalancing uses diagonal similarity transformations to make the rows\r\nand columns of the matrix as close in norm as possible. This can\r\nimprove the accuracy of eigenvalue computations.\r\n\r\nThis is a pure TypeScript implementation of matrix balancing.",[20820],{"_16":659,"_22":20402,"_69":6},"BalanceResult",[],{"_16":20824,"_18":20825,"_20":20826,"_22":20827,"_24":20828,"_28":20830,"_30":20831},"la.utilities.conjugate","la.utilities.conjugate(A)","Compute the complex conjugate of a matrix.\r","Compute the complex conjugate of a matrix.\r\n\r\nFor real matrices, this returns a copy of the matrix.\r\nFor complex matrices (stored as interleaved real/imag pairs),\r\nthis negates the imaginary parts.",[20829],{"_16":659,"_22":20070,"_69":6},"ConjugateResult",[],{"_16":20833,"_18":20834,"_20":20835,"_22":20836,"_24":20837,"_28":20841,"_30":20842},"la.utilities.diag","la.utilities.diag(A, k?)","Extract the diagonal from a matrix, or create a diagonal matrix from a vector.\r","Extract the diagonal from a matrix, or create a diagonal matrix from a vector.\r\n\r\nIf input is a matrix (2D), extracts the diagonal elements.\r\nIf input is a vector (1D), creates a diagonal matrix.",[20838,20840],{"_16":659,"_22":20839,"_69":6},"- Input matrix or vector",{"_16":1114,"_22":17975,"_69":11},"DiagResult",[],{"_16":20844,"_18":20845,"_20":20846,"_22":20847,"_24":20848,"_28":20850,"_30":20851},"la.utilities.hermitian","la.utilities.hermitian(A)","Compute the conjugate transpose (Hermitian transpose) of a matrix.\r","Compute the conjugate transpose (Hermitian transpose) of a matrix.\r\n\r\nFor real matrices, this is the same as the regular transpose.\r\nFor complex matrices, this transposes and conjugates.",[20849],{"_16":659,"_22":20070,"_69":6},"HermitianResult",[],{"_16":20853,"_18":20854,"_20":20855,"_22":20856,"_24":20857,"_28":20859,"_30":20860},"la.utilities.trace","la.utilities.trace(A)","Compute the trace of a matrix (sum of diagonal elements).\r","Compute the trace of a matrix (sum of diagonal elements).\r\n\r\nThe trace is only defined for square matrices.",[20858],{"_16":659,"_22":20402,"_69":6},"TraceResult",[],{"_16":20862,"_18":20863,"_20":20864,"_22":20864,"_24":20865,"_28":20867,"_30":20868},"la.utilities.transpose","la.utilities.transpose(A)","Compute the transpose of a matrix.",[20866],{"_16":659,"_22":20070,"_69":6},"TransposeResult",[],{"_16":20870,"_18":20871,"_20":20872,"_22":20873,"_24":20874,"_28":20878,"_30":20879},"la.utilities.tril","la.utilities.tril(A, options?)","Extract the lower triangular part of a matrix.\r","Extract the lower triangular part of a matrix.\r\n\r\nReturns a matrix with elements above the k-th diagonal zeroed.",[20875,20876],{"_16":659,"_22":20070,"_69":6},{"_16":4789,"_22":20877,"_69":11},"- Extraction options","TrilResult",[],{"_16":20881,"_18":20882,"_20":20883,"_22":20884,"_24":20885,"_28":20888,"_30":20889},"la.utilities.triu","la.utilities.triu(A, options?)","Extract the upper triangular part of a matrix.\r","Extract the upper triangular part of a matrix.\r\n\r\nReturns a matrix with elements below the k-th diagonal zeroed.",[20886,20887],{"_16":659,"_22":20070,"_69":6},{"_16":4789,"_22":20877,"_69":11},"TriuResult",[],{"_16":20891,"_18":20892,"_20":20893,"_22":20894,"_24":20895,"_28":20899,"_30":20900},"la.utilities.isHermitian","la.utilities.isHermitian(A, options?)","Test if a matrix is Hermitian (A = A^H).\r","Test if a matrix is Hermitian (A = A^H).\r\n\r\nA matrix is Hermitian if A[i,j] = conj(A[j,i]) for all i,j.\r\nFor real matrices, this is equivalent to being symmetric.",[20896,20897],{"_16":659,"_22":20402,"_69":6},{"_16":4789,"_22":20898,"_69":11},"- Test options","IsHermitianResult",[],{"_16":20902,"_18":20903,"_20":20904,"_22":20905,"_24":20906,"_28":20909,"_30":20910},"la.utilities.isOrthogonal","la.utilities.isOrthogonal(A, options?)","Test if a matrix is orthogonal (Q^T * Q = I).\r","Test if a matrix is orthogonal (Q^T * Q = I).\r\n\r\nAn orthogonal matrix has orthonormal columns and rows.\r\nQ^T * Q = Q * Q^T = I, and det(Q) = ±1.",[20907,20908],{"_16":659,"_22":20402,"_69":6},{"_16":4789,"_22":20898,"_69":11},"IsOrthogonalResult",[],{"_16":20912,"_18":20913,"_20":20914,"_22":20915,"_24":20916,"_28":20919,"_30":20920},"la.utilities.isPositiveDefinite","la.utilities.isPositiveDefinite(A)","Test if a matrix is positive definite.\r","Test if a matrix is positive definite.\r\n\r\nA symmetric matrix is positive definite if all its eigenvalues are positive,\r\nor equivalently, if Cholesky factorization succeeds.",[20917],{"_16":659,"_22":20918,"_69":6},"- Input square symmetric matrix (n × n)","IsPositiveDefiniteResult",[],{"_16":20922,"_18":20923,"_20":20924,"_22":20925,"_24":20926,"_28":20929,"_30":20930},"la.utilities.isSingular","la.utilities.isSingular(A, options?)","Test if a matrix is singular (non-invertible).\r","Test if a matrix is singular (non-invertible).\r\n\r\nA matrix is singular if its determinant is zero, or equivalently,\r\nif it has a zero singular value.",[20927,20928],{"_16":659,"_22":20402,"_69":6},{"_16":4789,"_22":20898,"_69":11},"IsSingularResult",[],{"_16":20932,"_18":20933,"_20":20934,"_22":20935,"_24":20936,"_28":20939,"_30":20940},"la.utilities.isSymmetric","la.utilities.isSymmetric(A, options?)","Test if a matrix is symmetric (A = A^T).\r","Test if a matrix is symmetric (A = A^T).\r\n\r\nA matrix is symmetric if A[i,j] = A[j,i] for all i,j.",[20937,20938],{"_16":659,"_22":20402,"_69":6},{"_16":4789,"_22":20898,"_69":11},"IsSymmetricResult",[],{"_16":20942,"_18":20943,"_20":20944,"_22":20945,"_24":20946,"_28":20949,"_30":20950},"la.utilities.isUnitary","la.utilities.isUnitary(A, options?)","Test if a matrix is unitary (Q^H * Q = I).\r","Test if a matrix is unitary (Q^H * Q = I).\r\n\r\nA unitary matrix has orthonormal columns and rows under the Hermitian inner product.\r\nFor real matrices, this is equivalent to being orthogonal.",[20947,20948],{"_16":659,"_22":20402,"_69":6},{"_16":4789,"_22":20898,"_69":11},"IsUnitaryResult",[],{"_16":20952,"_18":20953,"_20":20954,"_22":5456,"_24":20955,"_28":1426,"_30":20958},"la.configureLAPACK","la.configureLAPACK(config)","configureLAPACK",[20956],{"_16":8097,"_22":20957,"_69":6},"LAPACKLoadConfig",[],{"_16":20960,"_18":20961,"_20":20962,"_22":20962,"_24":20963,"_28":4840,"_30":20968},"la.fromColumnMajor","la.fromColumnMajor(data, m, n)","Convert a column-major 1D array to row-major 2D array.",[20964,20966,20967],{"_16":84,"_22":20965,"_69":6},"- Column-major 1D array",{"_16":359,"_22":4979,"_69":6},{"_16":362,"_22":5507,"_69":6},[],{"_16":20970,"_18":20971,"_20":20972,"_22":5456,"_24":20973,"_28":20974,"_30":20975},"la.getLAPACKModule","la.getLAPACKModule()","getLAPACKModule",[],"LAPACKModule",[],{"_16":20977,"_18":20978,"_20":20979,"_22":5456,"_24":20980,"_28":6903,"_30":20981},"la.isLAPACKLoaded","la.isLAPACKLoaded()","isLAPACKLoaded",[],[],{"_16":20983,"_18":20984,"_20":20985,"_22":5456,"_24":20986,"_28":20987,"_30":20988},"la.loadLAPACKModule","la.loadLAPACKModule()","loadLAPACKModule",[],"Promise",[],{"_16":20990,"_18":20991,"_20":20992,"_22":20993,"_24":20994,"_28":5450,"_30":20997},"la.prepareMatrix","la.prepareMatrix(matrix)","Prepare a matrix for LAPACK: convert to column-major Float64Array.\r","Prepare a matrix for LAPACK: convert to column-major Float64Array.\r\nHandles both 2D arrays (row-major) and 1D arrays (assumed column-major).",[20995],{"_16":19607,"_22":20996,"_69":6},"- Input matrix (2D row-major or 1D column-major)",[],{"_16":20999,"_18":21000,"_20":21001,"_22":21001,"_24":21002,"_28":5450,"_30":21005},"la.prepareVector","la.prepareVector(vector)","Prepare a vector for LAPACK.",[21003],{"_16":21004,"_22":19330,"_69":6},"vector",[],{"_16":21007,"_18":21008,"_20":21009,"_22":5456,"_24":21010,"_28":1426,"_30":21011},"la.resetLAPACKModule","la.resetLAPACKModule()","resetLAPACKModule",[],[],{"_16":21013,"_18":21014,"_20":21015,"_22":21016,"_24":21017,"_28":5450,"_30":21020},"la.toColumnMajor","la.toColumnMajor(matrix)","Convert a row-major 2D array to column-major 1D array (Fortran order).\r","Convert a row-major 2D array to column-major 1D array (Fortran order).\r\nLAPACK expects column-major ordering.",[21018],{"_16":19607,"_22":21019,"_69":6},"- Row-major 2D array [row][col]",[],{"_43":21022,"_16":21023,"_22":21024,"_47":48,"_49":21025,"_51":21026,"_52":21027},"slu-generated","Sparse Direct Solver (SuperLU)","SuperLU sparse direct solver.","⚡","slu",[21028,21040,21055,21072,21084,21100,21108,21120,21126,21135,21143,21150,21160,21171,21185,21194,21203,21215,21226,21237,21245,21254,21261,21270,21278,21288,21298,21306,21315,21327,21335,21342,21349,21363,21374,21383,21393,21402,21411,21420,21429,21437,21445,21452,21459,21467,21474,21484,21492,21503,21512,21522,21528,21537,21547,21562,21573,21583,21593,21604,21614,21623,21631,21644,21662,21678,21694,21703,21712,21719,21728,21741,21751,21759,21767,21774,21785,21793,21801,21809,21817,21824,21835,21843,21852,21863,21873,21882,21895,21905,21915,21923,21932,21942,21954,21964,21973,21987,21996,22005,22020,22032,22046,22058,22068,22078,22088,22099,22111,22125,22137,22149,22160,22173,22183,22194,22204,22214,22228,22235,22242,22250,22258],{"_16":21029,"_18":21030,"_20":21031,"_22":21032,"_24":21033,"_28":21038,"_30":21039},"slu.analysis.computeMatrixNorm","slu.analysis.computeMatrixNorm(A, normType?)","Compute the norm of a sparse matrix.\r","Compute the norm of a sparse matrix.\r\n\r\nSupported norms:\r\n- **one**: 1-norm (maximum column sum of absolute values)\r\n- **infinity**: ∞-norm (maximum row sum of absolute values)\r\n- **frobenius**: Frobenius norm (sqrt of sum of squared elements)\r\n- **max**: Max norm (maximum absolute element)",[21034,21036],{"_16":659,"_22":21035,"_69":6},"- Sparse matrix in CSC format",{"_16":5785,"_22":21037,"_69":11},"- Type of norm to compute","MatrixNormResult",[],{"_16":21041,"_18":21042,"_20":21043,"_22":21044,"_24":21045,"_28":21053,"_30":21054},"slu.analysis.estimateConditionNumber","slu.analysis.estimateConditionNumber(lu, normType?, matrixNorm?)","Estimate the condition number of a matrix using its LU factorization.\r","Estimate the condition number of a matrix using its LU factorization.\r\n\r\nThe condition number κ(A) = ||A|| * ||A^{-1}|| measures how sensitive\r\nthe solution of Ax = b is to perturbations in A and b. A large condition\r\nnumber indicates an ill-conditioned matrix where small changes in input\r\ncan cause large changes in output.\r\n\r\nThis function uses the SuperLU dgscon routine to estimate the reciprocal\r\ncondition number efficiently without computing A^{-1} explicitly.",[21046,21048,21050],{"_16":1547,"_22":21047,"_69":6},"- LU factorization from sparseLU()",{"_16":5785,"_22":21049,"_69":11},"- Norm type for the estimate",{"_16":21051,"_22":21052,"_69":11},"matrixNorm","- Original matrix norm ||A|| (optional, will compute if not provided)","ConditionNumberResult",[],{"_16":21056,"_18":21057,"_20":21058,"_22":21059,"_24":21060,"_28":21070,"_30":21071},"slu.analysis.iterativelyRefine","slu.analysis.iterativelyRefine(A, lu, b, x, options?)","Improve the accuracy of a computed solution using iterative refinement.\r","Improve the accuracy of a computed solution using iterative refinement.\r\n\r\nIterative refinement works by computing the residual r = b - A*x, solving\r\nfor a correction d from A*d = r, and updating x := x + d. This process\r\ncan significantly improve accuracy when the initial solution has small\r\nrelative errors.\r\n\r\nThis implementation uses the pre-computed LU factorization to solve the\r\ncorrection equations efficiently.",[21061,21063,21065,21066,21068],{"_16":659,"_22":21062,"_69":6},"- Original sparse matrix in CSC format",{"_16":1547,"_22":21064,"_69":6},"- Pre-computed LU factorization",{"_16":436,"_22":6345,"_69":6},{"_16":498,"_22":21067,"_69":6},"- Initial solution to refine (will be modified in place)",{"_16":4789,"_22":21069,"_69":11},"- Refinement options","RefinementResult",[],{"_16":21073,"_18":21074,"_20":21075,"_22":21076,"_24":21077,"_28":21082,"_30":21083},"slu.analysis.getEliminationTree","slu.analysis.getEliminationTree(A, columnPermutation?)","Compute the elimination tree for a sparse matrix.\r","Compute the elimination tree for a sparse matrix.\r\n\r\nThe elimination tree describes the structure of the LU factorization.\r\nNode i is the parent of node j if the first off-diagonal nonzero in\r\ncolumn j of L is in row i. The tree structure determines:\r\n- Dependencies between columns during factorization\r\n- Potential for parallelism\r\n- Fill-in pattern",[21078,21079],{"_16":659,"_22":21035,"_69":6},{"_16":21080,"_22":21081,"_69":11},"columnPermutation","- Optional column permutation","EliminationTreeResult",[],{"_16":21085,"_18":21086,"_20":21087,"_22":21088,"_24":21089,"_28":21098,"_30":21099},"slu.analysis.getEliminationTreeStatistics","slu.analysis.getEliminationTreeStatistics(etree, A, _columnPermutation?)","Compute statistics about the elimination tree.\r","Compute statistics about the elimination tree.\r\n\r\nAnalyzes the elimination tree structure to provide insights about\r\nthe factorization, including tree height, supernode count, and\r\nrough fill-in estimates.",[21090,21093,21095],{"_16":21091,"_22":21092,"_69":6},"etree","- Elimination tree from getEliminationTree",{"_16":659,"_22":21094,"_69":6},"- Original sparse matrix",{"_16":21096,"_22":21097,"_69":11},"_columnPermutation","IntArray","EliminationTreeStatistics",[],{"_16":21101,"_18":21102,"_20":21103,"_22":21104,"_24":21105,"_28":5703,"_30":21107},"slu.analysis.getFlopsEstimate","slu.analysis.getFlopsEstimate(A)","Estimate floating point operations for LU factorization.\r","Estimate floating point operations for LU factorization.\r\n\r\nProvides a rough estimate of the number of floating point operations\r\nrequired to factorize the matrix. Useful for comparing ordering\r\nstrategies and predicting factorization time.",[21106],{"_16":659,"_22":21035,"_69":6},[],{"_16":21109,"_18":21110,"_20":21111,"_22":21112,"_24":21113,"_28":21118,"_30":21119},"slu.analysis.predictFillIn","slu.analysis.predictFillIn(A, perm)","Predict fill-in for LU factorization.\r","Predict fill-in for LU factorization.\r\n\r\nComputes column counts for L and row counts for U, which determine\r\nthe fill-in pattern without performing numerical factorization.\r\nThis is useful for memory allocation and comparing ordering strategies.",[21114,21115],{"_16":659,"_22":21035,"_69":6},{"_16":21116,"_22":21117,"_69":6},"perm","- Column permutation","FillInPrediction",[],{"_16":21121,"_18":21122,"_20":21123,"_22":21123,"_24":21124,"_28":1426,"_30":21125},"slu.core.clearSolveHistory","slu.core.clearSolveHistory()","Clear the solve history.",[],[],{"_16":21127,"_18":21128,"_20":21129,"_22":21130,"_24":21131,"_28":1426,"_30":21134},"slu.core.enableDetailedLogging","slu.core.enableDetailedLogging(level?)","Enable or disable detailed logging.\r","Enable or disable detailed logging.\r\n\r\nControls the verbosity of diagnostic output from solve operations.\r\n\r\nLogging levels:\r\n- 0: Off (default)\r\n- 1: Basic (errors and warnings only)\r\n- 2: Detailed (includes timing and statistics)\r\n- 3: Verbose (includes internal operations)",[21132],{"_16":6375,"_22":21133,"_69":11},"- Logging level (0-3)",[],{"_16":21136,"_18":21137,"_20":21138,"_22":21139,"_24":21140,"_28":21141,"_30":21142},"slu.core.getLastSolveStatistics","slu.core.getLastSolveStatistics()","Get statistics from the last solve operation.\r","Get statistics from the last solve operation.\r\n\r\nReturns timing and other statistics from the most recent solve.\r\nThis is useful for performance monitoring and benchmarking.",[],"SolveStatistics | null",[],{"_16":21144,"_18":21145,"_20":21146,"_22":21146,"_24":21147,"_28":21148,"_30":21149},"slu.core.getLoggingLevel","slu.core.getLoggingLevel()","Get the current logging level.",[],"LogLevel",[],{"_16":21151,"_18":21152,"_20":21153,"_22":21154,"_24":21155,"_28":21158,"_30":21159},"slu.core.getSolveHistory","slu.core.getSolveHistory(limit?)","Get the solve history.\r","Get the solve history.\r\n\r\nReturns a record of recent solve operations for debugging\r\nand performance analysis.",[21156],{"_16":18830,"_22":21157,"_69":11},"- Maximum number of records to return","SolveRecord[]",[],{"_16":21161,"_18":21162,"_20":21163,"_22":21164,"_24":21165,"_28":21169,"_30":21170},"slu.core.getErrorMessage","slu.core.getErrorMessage(errorCode)","Get a human-readable error message for a SuperLU error code.\r","Get a human-readable error message for a SuperLU error code.\r\n\r\nSuperLU returns integer error codes from its routines. This function\r\ntranslates them into descriptive messages and provides suggestions\r\nfor resolution.\r\n\r\nError codes:\r\n- 0: Success\r\n- > 0: U[i,i] = 0, matrix is singular at column i\r\n- < 0: Invalid argument or internal error",[21166],{"_16":21167,"_22":21168,"_69":6},"errorCode","- Error code from SuperLU","SuperLUError",[],{"_16":21172,"_18":21173,"_20":21174,"_22":21175,"_24":21176,"_28":5703,"_30":21184},"slu.core.allocateDoubles","slu.core.allocateDoubles(module, values, size?)","# SuperLUWasm\r","# SuperLUWasm\r\n\r\nWebAssembly bindings for SuperLU, a library for the direct solution of\r\nlarge, sparse, nonsymmetric systems of linear equations.\r\n\r\n## Overview\r\n\r\nSuperLU uses LU factorization with partial pivoting and triangular\r\nsolves to compute the solution to sparse linear systems Ax = b.\r\nKey features include:\r\n\r\n- **Sparse LU Factorization**: Efficient factorization of sparse matrices\r\n- **Multiple Precisions**: Single (float32), double (float64), and complex variants\r\n- **Fill-Reducing Orderings**: Column permutations to minimize fill-in\r\n- **Numerical Stability**: Row permutations and equilibration\r\n- **Iterative Refinement**: Improve solution accuracy\r\n- **ILU Preconditioning**: Incomplete LU for iterative solvers\r\n\r\n## Quick Start\r\n\r\n```typescript\r\nimport { loadSuperLUModule, solveSparseCSC } from 'superluwasm';\r\n\r\n// 1. Load the WASM module (do this once at startup)\r\nawait loadSuperLUModule();\r\n\r\n// 2. Create a sparse matrix in CSC format\r\nconst A = {\r\n m: 3, n: 3,\r\n values: new Float64Array([4, 1, 1, 3, 2, 5]),\r\n rowIndices: new Int32Array([0, 1, 1, 2, 0, 2]),\r\n colPointers: new Int32Array([0, 2, 4, 6]),\r\n dtype: 'float64' as const\r\n};\r\n\r\n// 3. Solve Ax = b\r\nconst b = new Float64Array([1, 2, 3]);\r\nconst { x, statistics } = solveSparseCSC(A, b);\r\n\r\nconsole.log('Solution:', x);\r\nconsole.log('Time:', statistics.totalTime, 'ms');\r\n```\r\n\r\n## Matrix Formats\r\n\r\nSuperLU uses compressed sparse formats:\r\n\r\n- **CSC (Compressed Sparse Column)**: Native format, most efficient\r\n- **CSR (Compressed Sparse Row)**: Supported via automatic conversion\r\n\r\n## High-Level API\r\n\r\n### Solvers\r\n- - Solve Ax=b with CSC matrix\r\n- - Solve Ax=b with CSR matrix\r\n- - Solve A^T x = b\r\n- - Solve A^H x = b (complex)\r\n- - Full control over all options\r\n\r\n### Triangular Solvers\r\n- - Solve with precomputed LU factors\r\n- - Transpose solve with LU\r\n- - Direct triangular solve (CSC)\r\n- - Direct triangular solve (CSR)\r\n\r\n### Factorization\r\n- - Compute LU factorization\r\n- - Compute incomplete LU for preconditioning\r\n\r\n### Module Loading\r\n- - Initialize the WASM module\r\n- - Get the loaded module\r\n- - Check if loaded\r\n- - Configure WASM location",[21177,21180,21182],{"_16":21178,"_22":21179,"_69":6},"module","- SuperLU WASM module",{"_16":2320,"_22":21181,"_69":6},"- Initial values, or null for uninitialized allocation",{"_16":193,"_22":21183,"_69":11},"- Size to allocate (defaults to values.length)",[],{"_16":21186,"_18":21187,"_20":21188,"_22":21188,"_24":21189,"_28":5703,"_30":21193},"slu.core.allocateFloats","slu.core.allocateFloats(module, values, size?)","Allocate a Float32Array in WASM memory and optionally initialize with values.",[21190,21191,21192],{"_16":21178,"_22":21179,"_69":6},{"_16":2320,"_22":21181,"_69":6},{"_16":193,"_22":21183,"_69":11},[],{"_16":21195,"_18":21196,"_20":21197,"_22":21197,"_24":21198,"_28":5703,"_30":21202},"slu.core.allocateInts","slu.core.allocateInts(module, values, size?)","Allocate an Int32Array in WASM memory and optionally initialize with values.",[21199,21200,21201],{"_16":21178,"_22":21179,"_69":6},{"_16":2320,"_22":21181,"_69":6},{"_16":193,"_22":21183,"_69":11},[],{"_16":21204,"_18":21205,"_20":21206,"_22":21206,"_24":21207,"_28":5703,"_30":21214},"slu.core.allocateValues","slu.core.allocateValues(module, values, dtype, size?)","Allocate values based on data type.",[21208,21209,21211,21213],{"_16":21178,"_22":21179,"_69":6},{"_16":2320,"_22":21210,"_69":6},"- Initial values",{"_16":9117,"_22":21212,"_69":6},"- Data type",{"_16":193,"_22":5703,"_69":11},[],{"_16":21216,"_18":21217,"_20":21218,"_22":21218,"_24":21219,"_28":1426,"_30":21225},"slu.core.checkSuperLUError","slu.core.checkSuperLUError(info, routine)","Check SuperLU return code and throw if error.",[21220,21222],{"_16":19870,"_22":21221,"_69":6},"- Info code from SuperLU routine",{"_16":21223,"_22":21224,"_69":6},"routine","- Name of the routine",[],{"_16":21227,"_18":21228,"_20":21229,"_22":21230,"_24":21231,"_28":1426,"_30":21236},"slu.core.freeAll","slu.core.freeAll(module, ptrs)","Free multiple pointers at once.\r","Free multiple pointers at once.\r\nSafely handles zero/null pointers (skips them).",[21232,21233],{"_16":21178,"_22":21179,"_69":6},{"_16":21234,"_22":21235,"_69":6},"ptrs","- Array of pointers to free",[],{"_16":21238,"_18":21239,"_20":21240,"_22":21240,"_24":21241,"_28":5703,"_30":21244},"slu.core.getElementSize","slu.core.getElementSize(dtype)","Get element size in bytes for a data type.",[21242],{"_16":9117,"_22":21243,"_69":6},"DataType",[],{"_16":21246,"_18":21247,"_20":21248,"_22":21248,"_24":21249,"_28":6108,"_30":21253},"slu.core.getSuperLUErrorMessage","slu.core.getSuperLUErrorMessage(info, routine?)","Get error message for a SuperLU info code.",[21250,21251],{"_16":19870,"_22":21221,"_69":6},{"_16":21223,"_22":21252,"_69":11},"- Name of the routine (for context)",[],{"_16":21255,"_18":21256,"_20":21257,"_22":21257,"_24":21258,"_28":6903,"_30":21260},"slu.core.isComplexType","slu.core.isComplexType(dtype)","Check if a data type is complex.",[21259],{"_16":9117,"_22":21243,"_69":6},[],{"_16":21262,"_18":21263,"_20":21264,"_22":21264,"_24":21265,"_28":5703,"_30":21269},"slu.core.readByte","slu.core.readByte(module, ptr)","Read a single byte/char from WASM memory.",[21266,21267],{"_16":21178,"_22":21179,"_69":6},{"_16":4648,"_22":21268,"_69":6},"- Pointer to read from",[],{"_16":21271,"_18":21272,"_20":21273,"_22":21273,"_24":21274,"_28":5703,"_30":21277},"slu.core.readDouble","slu.core.readDouble(module, ptr)","Read a single double from WASM memory.",[21275,21276],{"_16":21178,"_22":21179,"_69":6},{"_16":4648,"_22":21268,"_69":6},[],{"_16":21279,"_18":21280,"_20":21281,"_22":21281,"_24":21282,"_28":5450,"_30":21287},"slu.core.readDoubles","slu.core.readDoubles(module, ptr, length)","Read doubles from WASM memory.",[21283,21284,21285],{"_16":21178,"_22":21179,"_69":6},{"_16":4648,"_22":21268,"_69":6},{"_16":987,"_22":21286,"_69":6},"- Number of elements to read",[],{"_16":21289,"_18":21290,"_20":21291,"_22":21291,"_24":21292,"_28":21296,"_30":21297},"slu.core.readFloats","slu.core.readFloats(module, ptr, length)","Read floats from WASM memory.",[21293,21294,21295],{"_16":21178,"_22":21179,"_69":6},{"_16":4648,"_22":21268,"_69":6},{"_16":987,"_22":21286,"_69":6},"Float32Array",[],{"_16":21299,"_18":21300,"_20":21301,"_22":21301,"_24":21302,"_28":5703,"_30":21305},"slu.core.readInt","slu.core.readInt(module, ptr)","Read a single integer from WASM memory.",[21303,21304],{"_16":21178,"_22":21179,"_69":6},{"_16":4648,"_22":21268,"_69":6},[],{"_16":21307,"_18":21308,"_20":21309,"_22":21309,"_24":21310,"_28":4757,"_30":21314},"slu.core.readInts","slu.core.readInts(module, ptr, length)","Read integers from WASM memory.",[21311,21312,21313],{"_16":21178,"_22":21179,"_69":6},{"_16":4648,"_22":21268,"_69":6},{"_16":987,"_22":21286,"_69":6},[],{"_16":21316,"_18":21317,"_20":21318,"_22":21318,"_24":21319,"_28":21325,"_30":21326},"slu.core.readValues","slu.core.readValues(module, ptr, length, dtype)","Read values based on data type.",[21320,21321,21322,21324],{"_16":21178,"_22":21179,"_69":6},{"_16":4648,"_22":21268,"_69":6},{"_16":987,"_22":21323,"_69":6},"- Number of elements",{"_16":9117,"_22":21212,"_69":6},"Float64Array | Float32Array",[],{"_16":21328,"_18":21329,"_20":21330,"_22":21330,"_24":21331,"_28":21296,"_30":21334},"slu.core.toFloat32Array","slu.core.toFloat32Array(arr)","Convert a JavaScript array to Float32Array.",[21332],{"_16":9285,"_22":21333,"_69":6},"RealArray",[],{"_16":21336,"_18":21337,"_20":21338,"_22":21338,"_24":21339,"_28":5450,"_30":21341},"slu.core.toFloat64Array","slu.core.toFloat64Array(arr)","Convert a JavaScript array to Float64Array.",[21340],{"_16":9285,"_22":21333,"_69":6},[],{"_16":21343,"_18":21344,"_20":21345,"_22":21345,"_24":21346,"_28":4757,"_30":21348},"slu.core.toInt32Array","slu.core.toInt32Array(arr)","Convert a JavaScript array to Int32Array.",[21347],{"_16":9285,"_22":21097,"_69":6},[],{"_16":21350,"_18":21351,"_20":21352,"_22":21353,"_24":21354,"_28":21361,"_30":21362},"slu.core.withAllocations","slu.core.withAllocations(module, allocations, fn)","RAII-style resource management.\r","RAII-style resource management.\r\nExecutes a function with allocated resources and ensures cleanup.",[21355,21356,21359],{"_16":21178,"_22":21179,"_69":6},{"_16":21357,"_22":21358,"_69":6},"allocations","- Object mapping names to allocation functions",{"_16":4908,"_22":21360,"_69":6},"- Function to execute with allocated pointers","Promise",[],{"_16":21364,"_18":21365,"_20":21366,"_22":21366,"_24":21367,"_28":1426,"_30":21373},"slu.core.writeByte","slu.core.writeByte(module, ptr, value)","Write a single byte to WASM memory.",[21368,21369,21371],{"_16":21178,"_22":21179,"_69":6},{"_16":4648,"_22":21370,"_69":6},"- Pointer to write to",{"_16":235,"_22":21372,"_69":6},"- Value to write",[],{"_16":21375,"_18":21376,"_20":21377,"_22":21377,"_24":21378,"_28":1426,"_30":21382},"slu.core.writeDouble","slu.core.writeDouble(module, ptr, value)","Write a single double to WASM memory.",[21379,21380,21381],{"_16":21178,"_22":21179,"_69":6},{"_16":4648,"_22":21370,"_69":6},{"_16":235,"_22":21372,"_69":6},[],{"_16":21384,"_18":21385,"_20":21386,"_22":21386,"_24":21387,"_28":1426,"_30":21392},"slu.core.writeDoubles","slu.core.writeDoubles(module, ptr, values)","Write doubles to WASM memory.",[21388,21389,21390],{"_16":21178,"_22":21179,"_69":6},{"_16":4648,"_22":21370,"_69":6},{"_16":2320,"_22":21391,"_69":6},"- Values to write",[],{"_16":21394,"_18":21395,"_20":21396,"_22":21396,"_24":21397,"_28":1426,"_30":21401},"slu.core.writeFloats","slu.core.writeFloats(module, ptr, values)","Write floats to WASM memory.",[21398,21399,21400],{"_16":21178,"_22":21179,"_69":6},{"_16":4648,"_22":21370,"_69":6},{"_16":2320,"_22":21391,"_69":6},[],{"_16":21403,"_18":21404,"_20":21405,"_22":21405,"_24":21406,"_28":1426,"_30":21410},"slu.core.writeInt","slu.core.writeInt(module, ptr, value)","Write a single integer to WASM memory.",[21407,21408,21409],{"_16":21178,"_22":21179,"_69":6},{"_16":4648,"_22":21370,"_69":6},{"_16":235,"_22":21372,"_69":6},[],{"_16":21412,"_18":21413,"_20":21414,"_22":21414,"_24":21415,"_28":1426,"_30":21419},"slu.core.writeInts","slu.core.writeInts(module, ptr, values)","Write integers to WASM memory.",[21416,21417,21418],{"_16":21178,"_22":21179,"_69":6},{"_16":4648,"_22":21370,"_69":6},{"_16":2320,"_22":21391,"_69":6},[],{"_16":21421,"_18":21422,"_20":21423,"_22":21424,"_24":21425,"_28":1426,"_30":21428},"slu.core.configureSuperLU","slu.core.configureSuperLU(config)","Configure SuperLU WASM module loading options.\r","Configure SuperLU WASM module loading options.\r\n\r\nCall this function BEFORE calling to customize\r\nwhere the WASM files are loaded from. This is useful for:\r\n- Loading from a CDN instead of bundled files\r\n- Using a custom-built WASM module\r\n- Deploying to environments with specific asset requirements\r\n\r\n**Important**: Configuration cannot be changed after the module starts loading.\r\nIf you need to change configuration, call first.",[21426],{"_16":8097,"_22":21427,"_69":6},"- Configuration options specifying WASM file locations",[],{"_16":21430,"_18":21431,"_20":21432,"_22":21433,"_24":21434,"_28":21435,"_30":21436},"slu.core.getSuperLUConfig","slu.core.getSuperLUConfig()","Get the current SuperLU loading configuration.\r","Get the current SuperLU loading configuration.\r\n\r\nReturns a readonly copy of the current configuration. Useful for:\r\n- Debugging loading issues\r\n- Verifying configuration was applied correctly\r\n- Logging the WASM URLs being used",[],"Readonly",[],{"_16":21438,"_18":21439,"_20":21440,"_22":21441,"_24":21442,"_28":21443,"_30":21444},"slu.core.getSuperLUModule","slu.core.getSuperLUModule()","Get the loaded SuperLU WASM module synchronously.\r","Get the loaded SuperLU WASM module synchronously.\r\n\r\nUse this function when you know the module has already been loaded\r\n(i.e., after successfully awaiting ).\r\nThis is useful in synchronous code paths where you can't use await.\r\n\r\n**Important**: This function throws if the module hasn't been loaded yet.\r\nAlways ensure has completed before calling this.",[],"SuperLUModule",[],{"_16":21446,"_18":21447,"_20":21448,"_22":21449,"_24":21450,"_28":6903,"_30":21451},"slu.core.isSuperLULoaded","slu.core.isSuperLULoaded()","Check if the SuperLU WASM module has been fully loaded.\r","Check if the SuperLU WASM module has been fully loaded.\r\n\r\nReturns `true` only after has successfully completed.\r\nReturns `false` if:\r\n- The module has never been loaded\r\n- Loading is still in progress\r\n- The module was reset via \r\n\r\nUse this to safely check before calling .",[],[],{"_16":21453,"_18":21454,"_20":21455,"_22":21456,"_24":21457,"_28":6903,"_30":21458},"slu.core.isSuperLULoading","slu.core.isSuperLULoading()","Check if the SuperLU WASM module is currently loading.\r","Check if the SuperLU WASM module is currently loading.\r\n\r\nReturns `true` if has been called but hasn't\r\ncompleted yet. Useful for showing loading indicators or preventing\r\nduplicate load attempts.",[],[],{"_16":21460,"_18":21461,"_20":21462,"_22":21463,"_24":21464,"_28":21465,"_30":21466},"slu.core.loadSuperLUModule","slu.core.loadSuperLUModule()","Load and initialize the SuperLU WASM module.\r","Load and initialize the SuperLU WASM module.\r\n\r\nThis is the main entry point for using SuperLU. Call this function once\r\nduring your application's initialization to load the WebAssembly module.\r\nSubsequent calls return the same module instance (idempotent).\r\n\r\nThe function automatically detects the runtime environment (Node.js or browser)\r\nand uses the appropriate loading strategy. In browsers, you can customize\r\nthe WASM file location using before calling this.\r\n\r\n**Performance**: Loading is async and may take a few hundred milliseconds\r\ndepending on network conditions and WASM file size (~1-2MB). Consider\r\nloading during application startup or showing a loading indicator.",[],"Promise",[],{"_16":21468,"_18":21469,"_20":21470,"_22":21471,"_24":21472,"_28":1426,"_30":21473},"slu.core.resetSuperLUModule","slu.core.resetSuperLUModule()","Reset the SuperLU module state completely.\r","Reset the SuperLU module state completely.\r\n\r\nThis function:\r\n1. Clears the cached module instance\r\n2. Cancels any in-progress loading\r\n3. Resets all configuration to defaults\r\n\r\nAfter calling this, you can reconfigure and reload the module.\r\nThis is useful for:\r\n- Testing (reset between test cases)\r\n- Switching to a different WASM build\r\n- Recovering from errors\r\n\r\n**Warning**: Any existing references to the old module will become invalid.\r\nEnsure no code is still using the module before calling this.",[],[],{"_16":21475,"_18":21476,"_20":21477,"_22":21478,"_24":21479,"_28":21482,"_30":21483},"slu.core.allocateWorkspace","slu.core.allocateWorkspace(size)","Allocate a workspace buffer in WASM memory.\r","Allocate a workspace buffer in WASM memory.\r\n\r\nThis allows pre-allocating workspace for factorization operations,\r\nwhich can reduce allocation overhead when performing many operations.",[21480],{"_16":193,"_22":21481,"_69":6},"- Size in bytes to allocate","WorkspaceAllocation",[],{"_16":21485,"_18":21486,"_20":21487,"_22":21487,"_24":21488,"_28":1426,"_30":21491},"slu.core.deallocateWorkspace","slu.core.deallocateWorkspace(ptr)","Deallocate a previously allocated workspace.",[21489],{"_16":4648,"_22":21490,"_69":6},"- WASM pointer from allocateWorkspace",[],{"_16":21493,"_18":21494,"_20":21495,"_22":21496,"_24":21497,"_28":21501,"_30":21502},"slu.core.estimateMemoryRequired","slu.core.estimateMemoryRequired(A, _options?)","Estimate memory required for LU factorization.\r","Estimate memory required for LU factorization.\r\n\r\nProvides a rough estimate of memory that will be needed to\r\nfactorize a matrix. This is useful for checking if factorization\r\nwill fit in available memory before attempting it.\r\n\r\nNote: This is a heuristic estimate. Actual memory usage depends\r\non the matrix structure and ordering strategy.",[21498,21499],{"_16":659,"_22":8321,"_69":6},{"_16":8336,"_22":21500,"_69":11},"LUFactorizationOptions","MemoryEstimate",[],{"_16":21504,"_18":21505,"_20":21506,"_22":21507,"_24":21508,"_28":1426,"_30":21511},"slu.core.freeFactorization","slu.core.freeFactorization(lu)","Free memory used by an LU factorization.\r","Free memory used by an LU factorization.\r\n\r\nThis is equivalent to calling lu.dispose() but provided as a\r\nstandalone function for consistency with the API.",[21509],{"_16":1547,"_22":21510,"_69":6},"- LU factorization to free",[],{"_16":21513,"_18":21514,"_20":21515,"_22":21516,"_24":21517,"_28":21520,"_30":21521},"slu.core.getMemoryUsage","slu.core.getMemoryUsage(lu)","Get memory usage of LU factors.\r","Get memory usage of LU factors.\r\n\r\nReturns the memory consumed by the L and U factors from a\r\nfactorization. This is useful for monitoring memory usage\r\nin applications that perform many factorizations.",[21518],{"_16":1547,"_22":21519,"_69":6},"- LU factorization","MemoryUsage",[],{"_16":21523,"_18":21524,"_20":21525,"_22":21525,"_24":21526,"_28":5703,"_30":21527},"slu.core.getWorkspaceSize","slu.core.getWorkspaceSize()","Get the current global workspace size limit.",[],[],{"_16":21529,"_18":21530,"_20":21531,"_22":21532,"_24":21533,"_28":21535,"_30":21536},"slu.core.queryFactorStatistics","slu.core.queryFactorStatistics(lu)","Query statistics about a completed factorization.\r","Query statistics about a completed factorization.\r\n\r\nReturns detailed information about the factorization including\r\nnonzero counts, fill-in ratio, and estimated operation count.",[21534],{"_16":1547,"_22":21519,"_69":6},"FactorStatistics",[],{"_16":21538,"_18":21539,"_20":21540,"_22":21541,"_24":21542,"_28":1426,"_30":21546},"slu.core.setWorkspaceSize","slu.core.setWorkspaceSize(bytes)","Set the global workspace size limit.\r","Set the global workspace size limit.\r\n\r\nThis sets a soft limit on the workspace that SuperLU can use.\r\nThe actual behavior depends on the SuperLU implementation.",[21543],{"_16":21544,"_22":21545,"_69":6},"bytes","- Maximum workspace size in bytes (0 for unlimited)",[],{"_16":21548,"_18":21549,"_20":21550,"_22":21551,"_24":21552,"_28":21560,"_30":21561},"slu.equilibration.applyEquilibrationScaling","slu.equilibration.applyEquilibrationScaling(A, rowScale, columnScale)","Apply equilibration scaling to a sparse matrix.\r","Apply equilibration scaling to a sparse matrix.\r\n\r\nComputes the scaled matrix: A_scaled = R * A * C\r\nwhere R = diag(rowScale) and C = diag(columnScale).",[21553,21554,21557],{"_16":659,"_22":21062,"_69":6},{"_16":21555,"_22":21556,"_69":6},"rowScale","- Row scaling factors",{"_16":21558,"_22":21559,"_69":6},"columnScale","- Column scaling factors","SparseMatrixCSC",[],{"_16":21563,"_18":21564,"_20":21565,"_22":21566,"_24":21567,"_28":21571,"_30":21572},"slu.equilibration.computeEquilibrationScaling","slu.equilibration.computeEquilibrationScaling(A, options?)","Compute equilibration scaling factors for a sparse matrix.\r","Compute equilibration scaling factors for a sparse matrix.\r\n\r\nThis function computes row and column scaling factors that, when applied,\r\nwill make the matrix better conditioned for LU factorization. The scaling\r\nis computed so that:\r\n- Row scaling makes max |A_{ij}| in each row ≈ 1\r\n- Column scaling makes max |A_{ij}| in each column ≈ 1\r\n\r\nThe returned factors can be used with applyEquilibrationScaling and\r\nundoEquilibrationScaling to transform the system.",[21568,21569],{"_16":659,"_22":21035,"_69":6},{"_16":4789,"_22":21570,"_69":11},"- Equilibration options","EquilibrationScaling",[],{"_16":21574,"_18":21575,"_20":21576,"_22":21577,"_24":21578,"_28":5450,"_30":21582},"slu.equilibration.scaleRightHandSide","slu.equilibration.scaleRightHandSide(b, rowScale)","Scale the right-hand side vector for equilibration.\r","Scale the right-hand side vector for equilibration.\r\n\r\nWhen solving R*A*C * y = R*b, the RHS must be scaled by R.",[21579,21581],{"_16":436,"_22":21580,"_69":6},"- Original right-hand side vector",{"_16":21555,"_22":21556,"_69":6},[],{"_16":21584,"_18":21585,"_20":21586,"_22":21587,"_24":21588,"_28":5450,"_30":21592},"slu.equilibration.undoEquilibrationScaling","slu.equilibration.undoEquilibrationScaling(x, columnScale)","Undo equilibration scaling on the solution vector.\r","Undo equilibration scaling on the solution vector.\r\n\r\nAfter solving the scaled system R*A*C * y = R*b, the original solution\r\nis recovered as x = C * y.",[21589,21591],{"_16":498,"_22":21590,"_69":6},"- Solution of the scaled system",{"_16":21558,"_22":21559,"_69":6},[],{"_16":21594,"_18":21595,"_20":21596,"_22":21597,"_24":21598,"_28":21602,"_30":21603},"slu.factorization.sparseILU","slu.factorization.sparseILU(A, options?)","Compute an Incomplete LU (ILU) factorization.\r","Compute an Incomplete LU (ILU) factorization.\r\n\r\nILU factorization produces approximate L and U factors by dropping\r\nelements during factorization. The resulting factors are sparser\r\nand cheaper to apply, making them useful as preconditioners for\r\niterative solvers like GMRES, BiCGSTAB, etc.\r\n\r\nThe factorization satisfies: Pr * A * Pc ≈ L * U",[21599,21600],{"_16":659,"_22":21035,"_69":6},{"_16":4789,"_22":21601,"_69":11},"- ILU factorization options","ILUFactorization",[],{"_16":21605,"_18":21606,"_20":21607,"_22":21608,"_24":21609,"_28":21612,"_30":21613},"slu.factorization.sparseLU","slu.factorization.sparseLU(A, options?)","Compute the LU factorization of a sparse matrix.\r","Compute the LU factorization of a sparse matrix.\r\n\r\nComputes the factorization Pr * A * Pc = L * U where:\r\n- L is unit lower triangular (stored in SuperLU's supernode format)\r\n- U is upper triangular (stored in compressed column format)\r\n- Pr is the row permutation matrix\r\n- Pc is the column permutation matrix\r\n\r\nThe factorization can be reused to solve multiple systems with the\r\nsame matrix but different right-hand sides.",[21610,21611],{"_16":659,"_22":21035,"_69":6},{"_16":4789,"_22":8275,"_69":11},"LUFactorization",[],{"_16":21615,"_18":21616,"_20":21617,"_22":21617,"_24":21618,"_28":21560,"_30":21622},"slu.matrix.cooToCSC","slu.matrix.cooToCSC(coo)","Convert COO format to CSC format.",[21619],{"_16":21620,"_22":21621,"_69":6},"coo","- COO sparse matrix",[],{"_16":21624,"_18":21625,"_20":21626,"_22":21626,"_24":21627,"_28":21629,"_30":21630},"slu.matrix.cooToCSR","slu.matrix.cooToCSR(coo)","Convert COO format to CSR format.",[21628],{"_16":21620,"_22":21621,"_69":6},"SparseMatrixCSR",[],{"_16":21632,"_18":21633,"_20":21634,"_22":21635,"_24":21636,"_28":5460,"_30":21643},"slu.matrix.createDenseMatrix","slu.matrix.createDenseMatrix(data, m, n, rowMajor?)","Create a dense matrix.\r","Create a dense matrix.\r\n\r\nDense matrices store all elements, including zeros. The data is stored\r\nin column-major order by default (Fortran-style), which is efficient\r\nfor most linear algebra operations.",[21637,21639,21640,21641],{"_16":84,"_22":21638,"_69":6},"- Matrix data",{"_16":359,"_22":4979,"_69":6},{"_16":362,"_22":5507,"_69":6},{"_16":19612,"_22":21642,"_69":11},"- If true, data is in row-major order (default: false)",[],{"_16":21645,"_18":21646,"_20":21647,"_22":21648,"_24":21649,"_28":21660,"_30":21661},"slu.matrix.createSparseCOO","slu.matrix.createSparseCOO(m, n, rows, cols, values, dtype?)","Create a sparse matrix in Coordinate (COO) format.\r","Create a sparse matrix in Coordinate (COO) format.\r\n\r\nCOO format (also called triplet format) stores each nonzero as a\r\n(row, column, value) triplet. This format is convenient for\r\nconstructing matrices incrementally but less efficient for arithmetic.",[21650,21651,21652,21654,21656,21658],{"_16":359,"_22":4979,"_69":6},{"_16":362,"_22":5507,"_69":6},{"_16":2472,"_22":21653,"_69":6},"- Row indices for each nonzero",{"_16":2475,"_22":21655,"_69":6},"- Column indices for each nonzero",{"_16":2320,"_22":21657,"_69":6},"- Nonzero values",{"_16":9117,"_22":21659,"_69":11},"- Data type (default: 'float64')","SparseMatrixCOO",[],{"_16":21663,"_18":21664,"_20":21665,"_22":21666,"_24":21667,"_28":21560,"_30":21677},"slu.matrix.createSparseCSC","slu.matrix.createSparseCSC(m, n, rowIndices, colPointers, values, dtype?)","Create a sparse matrix in Compressed Sparse Column (CSC) format.\r","Create a sparse matrix in Compressed Sparse Column (CSC) format.\r\n\r\nCSC format stores the matrix column by column:\r\n- `colPointers[j]` to `colPointers[j+1]-1` are indices into values/rowIndices for column j\r\n- `rowIndices[k]` is the row of the k-th nonzero\r\n- `values[k]` is the value of the k-th nonzero",[21668,21669,21670,21672,21675,21676],{"_16":359,"_22":4979,"_69":6},{"_16":362,"_22":5507,"_69":6},{"_16":17739,"_22":21671,"_69":6},"- Row index for each nonzero",{"_16":21673,"_22":21674,"_69":6},"colPointers","- Column pointers (length n+1)",{"_16":2320,"_22":21657,"_69":6},{"_16":9117,"_22":21659,"_69":11},[],{"_16":21679,"_18":21680,"_20":21681,"_22":21682,"_24":21683,"_28":21629,"_30":21693},"slu.matrix.createSparseCSR","slu.matrix.createSparseCSR(m, n, colIndices, rowPointers, values, dtype?)","Create a sparse matrix in Compressed Sparse Row (CSR) format.\r","Create a sparse matrix in Compressed Sparse Row (CSR) format.\r\n\r\nCSR format stores the matrix row by row:\r\n- `rowPointers[i]` to `rowPointers[i+1]-1` are indices into values/colIndices for row i\r\n- `colIndices[k]` is the column of the k-th nonzero\r\n- `values[k]` is the value of the k-th nonzero",[21684,21685,21686,21688,21691,21692],{"_16":359,"_22":4979,"_69":6},{"_16":362,"_22":5507,"_69":6},{"_16":17742,"_22":21687,"_69":6},"- Column index for each nonzero",{"_16":21689,"_22":21690,"_69":6},"rowPointers","- Row pointers (length m+1)",{"_16":2320,"_22":21657,"_69":6},{"_16":9117,"_22":21659,"_69":11},[],{"_16":21695,"_18":21696,"_20":21697,"_22":21697,"_24":21698,"_28":21560,"_30":21702},"slu.matrix.createSparseDiagonal","slu.matrix.createSparseDiagonal(diag, dtype?)","Create a sparse diagonal matrix in CSC format.",[21699,21701],{"_16":403,"_22":21700,"_69":6},"- Diagonal elements",{"_16":9117,"_22":21659,"_69":11},[],{"_16":21704,"_18":21705,"_20":21706,"_22":21706,"_24":21707,"_28":21560,"_30":21711},"slu.matrix.createSparseIdentity","slu.matrix.createSparseIdentity(n, dtype?)","Create a sparse identity matrix in CSC format.",[21708,21710],{"_16":362,"_22":21709,"_69":6},"- Size of the identity matrix",{"_16":9117,"_22":21659,"_69":11},[],{"_16":21713,"_18":21714,"_20":21715,"_22":21715,"_24":21716,"_28":21629,"_30":21718},"slu.matrix.convertCSCtoCSR","slu.matrix.convertCSCtoCSR(A)","Convert a CSC matrix to CSR format.",[21717],{"_16":659,"_22":21035,"_69":6},[],{"_16":21720,"_18":21721,"_20":21722,"_22":21723,"_24":21724,"_28":21560,"_30":21727},"slu.matrix.convertCSRtoCSC","slu.matrix.convertCSRtoCSC(A)","Convert a CSR matrix to CSC format.\r","Convert a CSR matrix to CSC format.\r\n\r\nCSR (Compressed Sparse Row) stores the matrix row by row, while\r\nCSC (Compressed Sparse Column) stores it column by column. CSC is\r\nSuperLU's native format, so this conversion is useful for preparing\r\nmatrices for solving.",[21725],{"_16":659,"_22":21726,"_69":6},"- Sparse matrix in CSR format",[],{"_16":21729,"_18":21730,"_20":21731,"_22":21731,"_24":21732,"_28":4577,"_30":21740},"slu.matrix.denseToSparse","slu.matrix.denseToSparse(dense, format?, tolerance?)","Convert a dense matrix to sparse format.",[21733,21736,21738],{"_16":21734,"_22":21735,"_69":6},"dense","- Dense matrix",{"_16":1294,"_22":21737,"_69":11},"- Output format ('csc' or 'csr')",{"_16":17890,"_22":21739,"_69":11},"- Values with |v| < tolerance are treated as zero",[],{"_16":21742,"_18":21743,"_20":21744,"_22":21745,"_24":21746,"_28":21560,"_30":21750},"slu.matrix.denseToSparseCSC","slu.matrix.denseToSparseCSC(dense, tolerance?)","Convert a dense matrix to sparse CSC format.\r","Convert a dense matrix to sparse CSC format.\r\n\r\nElements with absolute value below the tolerance are treated as zero.",[21747,21748],{"_16":21734,"_22":21735,"_69":6},{"_16":17890,"_22":21749,"_69":11},"- Values with |v| < tolerance are treated as zero (default: 0)",[],{"_16":21752,"_18":21753,"_20":21754,"_22":21754,"_24":21755,"_28":21629,"_30":21758},"slu.matrix.denseToSparseCSR","slu.matrix.denseToSparseCSR(dense, tolerance?)","Convert a dense matrix to sparse CSR format.",[21756,21757],{"_16":21734,"_22":21735,"_69":6},{"_16":17890,"_22":21749,"_69":11},[],{"_16":21760,"_18":21761,"_20":21762,"_22":21763,"_24":21764,"_28":21560,"_30":21766},"slu.matrix.getTransposeCSC","slu.matrix.getTransposeCSC(A)","Compute the transpose of a CSC matrix.\r","Compute the transpose of a CSC matrix.\r\n\r\nThe transpose of a CSC matrix is efficiently computed by interpreting\r\nthe CSC structure as CSR and then converting. This is more efficient\r\nthan explicitly transposing each element.",[21765],{"_16":659,"_22":21035,"_69":6},[],{"_16":21768,"_18":21769,"_20":21770,"_22":21770,"_24":21771,"_28":21629,"_30":21773},"slu.matrix.getTransposeCSR","slu.matrix.getTransposeCSR(A)","Compute the transpose of a CSR matrix.",[21772],{"_16":659,"_22":21726,"_69":6},[],{"_16":21775,"_18":21776,"_20":21777,"_22":21778,"_24":21779,"_28":5460,"_30":21784},"slu.matrix.sparseToDense","slu.matrix.sparseToDense(matrix, rowMajor?)","Convert a sparse matrix to a dense array.\r","Convert a sparse matrix to a dense array.\r\n\r\nWarning: This can consume a lot of memory for large matrices.\r\nUse only when the matrix is small enough to fit in memory as dense.",[21780,21782],{"_16":19607,"_22":21781,"_69":6},"- Sparse matrix in any format",{"_16":19612,"_22":21783,"_69":11},"- If true, return row-major array (default: false, column-major)",[],{"_16":21786,"_18":21787,"_20":21788,"_22":21788,"_24":21789,"_28":21660,"_30":21792},"slu.matrix.toCOO","slu.matrix.toCOO(matrix)","Convert any sparse matrix format to COO (coordinate) format.",[21790],{"_16":19607,"_22":21791,"_69":6},"- Sparse matrix in any supported format",[],{"_16":21794,"_18":21795,"_20":21796,"_22":21797,"_24":21798,"_28":21560,"_30":21800},"slu.matrix.toCSC","slu.matrix.toCSC(matrix)","Convert any sparse matrix format to CSC format.\r","Convert any sparse matrix format to CSC format.\r\n\r\nIf the matrix is already in CSC format, returns a copy.",[21799],{"_16":19607,"_22":21791,"_69":6},[],{"_16":21802,"_18":21803,"_20":21804,"_22":21805,"_24":21806,"_28":21629,"_30":21808},"slu.matrix.toCSR","slu.matrix.toCSR(matrix)","Convert any sparse matrix format to CSR format.\r","Convert any sparse matrix format to CSR format.\r\n\r\nIf the matrix is already in CSR format, returns a copy.",[21807],{"_16":19607,"_22":21791,"_69":6},[],{"_16":21810,"_18":21811,"_20":21812,"_22":21812,"_24":21813,"_28":4577,"_30":21816},"slu.matrix.copySparseMatrix","slu.matrix.copySparseMatrix(A)","Create a deep copy of a sparse matrix.",[21814],{"_16":659,"_22":21815,"_69":6},"- Sparse matrix to copy",[],{"_16":21818,"_18":21819,"_20":21820,"_22":21820,"_24":21821,"_28":5450,"_30":21823},"slu.matrix.getDiagonal","slu.matrix.getDiagonal(A)","Get the diagonal elements of a sparse matrix.",[21822],{"_16":659,"_22":8321,"_69":6},[],{"_16":21825,"_18":21826,"_20":21827,"_22":21827,"_24":21828,"_28":21833,"_30":21834},"slu.matrix.getMatrixNonzeros","slu.matrix.getMatrixNonzeros(A, maxEntries?)","Get information about the nonzero elements of a matrix.",[21829,21830],{"_16":659,"_22":8321,"_69":6},{"_16":21831,"_22":21832,"_69":11},"maxEntries","- Maximum number of entries to list (default: all)","NonzeroInfo",[],{"_16":21836,"_18":21837,"_20":21838,"_22":21838,"_24":21839,"_28":21841,"_30":21842},"slu.matrix.getMatrixStatistics","slu.matrix.getMatrixStatistics(A)","Compute statistics about a sparse matrix.",[21840],{"_16":659,"_22":8321,"_69":6},"MatrixStatistics",[],{"_16":21844,"_18":21845,"_20":21846,"_22":21847,"_24":21848,"_28":21850,"_30":21851},"slu.matrix.getSparsityPattern","slu.matrix.getSparsityPattern(A)","Extract the sparsity pattern (nonzero locations) of a matrix.\r","Extract the sparsity pattern (nonzero locations) of a matrix.\r\n\r\nReturns the row and column indices of all nonzeros, which can be\r\nused for visualization (e.g., spy plots).",[21849],{"_16":659,"_22":8321,"_69":6},"SparsityPattern",[],{"_16":21853,"_18":21854,"_20":21855,"_22":21856,"_24":21857,"_28":21861,"_30":21862},"slu.matrix.getSupernodeStructure","slu.matrix.getSupernodeStructure(A, perm?)","Analyze supernode structure of a matrix.\r","Analyze supernode structure of a matrix.\r\n\r\nSupernodes are groups of consecutive columns that have the same\r\nnonzero pattern below the diagonal. They enable efficient use of\r\nBLAS-3 operations during factorization.\r\n\r\nThis is a simplified analysis based on column structure similarity.",[21858,21859],{"_16":659,"_22":21035,"_69":6},{"_16":21116,"_22":21860,"_69":11},"- Column permutation (optional)","SupernodeStructure",[],{"_16":21864,"_18":21865,"_20":21866,"_22":21867,"_24":21868,"_28":1426,"_30":21872},"slu.matrix.scaleMatrixCols","slu.matrix.scaleMatrixCols(A, scale)","Scale the columns of a sparse matrix in-place.\r","Scale the columns of a sparse matrix in-place.\r\n\r\nComputes A = A * diag(scale)",[21869,21871],{"_16":659,"_22":21870,"_69":6},"- Sparse matrix (modified in-place)",{"_16":2150,"_22":21559,"_69":6},[],{"_16":21874,"_18":21875,"_20":21876,"_22":21877,"_24":21878,"_28":1426,"_30":21881},"slu.matrix.scaleMatrixRows","slu.matrix.scaleMatrixRows(A, scale)","Scale the rows of a sparse matrix in-place.\r","Scale the rows of a sparse matrix in-place.\r\n\r\nComputes A = diag(scale) * A",[21879,21880],{"_16":659,"_22":21870,"_69":6},{"_16":2150,"_22":21556,"_69":6},[],{"_16":21883,"_18":21884,"_20":21885,"_22":21886,"_24":21887,"_28":21893,"_30":21894},"slu.matrix.checkFactorization","slu.matrix.checkFactorization(_A, _lu, _tolerance?)","Verify that a factorization satisfies PAQ ≈ LU.\r","Verify that a factorization satisfies PAQ ≈ LU.\r\n\r\nComputes ||PAQ - LU|| and checks if it's small relative to ||A||.\r\n\r\nNote: This is an expensive operation that reconstructs the full\r\nfactored matrix. Use only for verification purposes.",[21888,21889,21891],{"_16":17538,"_22":21560,"_69":6},{"_16":21890,"_22":21612,"_69":6},"_lu",{"_16":21892,"_22":5703,"_69":11},"_tolerance","FactorizationCheckResult",[],{"_16":21896,"_18":21897,"_20":21898,"_22":21898,"_24":21899,"_28":21903,"_30":21904},"slu.matrix.detectMatrixProperties","slu.matrix.detectMatrixProperties(A, tolerance?)","Detect various properties of a sparse matrix.",[21900,21901],{"_16":659,"_22":8321,"_69":6},{"_16":17890,"_22":21902,"_69":11},"- Tolerance for numerical comparisons (default: 1e-14)","MatrixProperties",[],{"_16":21906,"_18":21907,"_20":21908,"_22":21909,"_24":21910,"_28":6903,"_30":21914},"slu.matrix.isHermitianSparse","slu.matrix.isHermitianSparse(A, tolerance?)","Check if a sparse matrix is Hermitian (A = A^H) within tolerance.\r","Check if a sparse matrix is Hermitian (A = A^H) within tolerance.\r\n\r\nFor real matrices, this is equivalent to checking symmetry.\r\nFor complex matrices, checks A[i,j] = conj(A[j,i]).\r\n\r\nNote: This implementation only handles real matrices (same as symmetric).",[21911,21912],{"_16":659,"_22":8321,"_69":6},{"_16":17890,"_22":21913,"_69":11},"- Tolerance for value comparison (default: 1e-14)",[],{"_16":21916,"_18":21917,"_20":21918,"_22":21919,"_24":21920,"_28":6903,"_30":21922},"slu.matrix.isPositiveDefiniteSparse","slu.matrix.isPositiveDefiniteSparse(A)","Check if a sparse matrix appears to be positive definite.\r","Check if a sparse matrix appears to be positive definite.\r\n\r\nThis performs heuristic checks:\r\n- Matrix must be symmetric\r\n- All diagonal elements must be positive\r\n- Diagonal dominance check (sufficient but not necessary)\r\n\r\nNote: This does not guarantee positive definiteness. For a definitive\r\ncheck, attempt Cholesky factorization.",[21921],{"_16":659,"_22":8321,"_69":6},[],{"_16":21924,"_18":21925,"_20":21926,"_22":21927,"_24":21928,"_28":6903,"_30":21931},"slu.matrix.isSymmetricSparse","slu.matrix.isSymmetricSparse(A, tolerance?)","Check if a sparse matrix is symmetric (A = A^T) within tolerance.\r","Check if a sparse matrix is symmetric (A = A^T) within tolerance.\r\n\r\nFor a matrix to be symmetric:\r\n- It must be square\r\n- A[i,j] = A[j,i] for all i,j",[21929,21930],{"_16":659,"_22":8321,"_69":6},{"_16":17890,"_22":21913,"_69":11},[],{"_16":21933,"_18":21934,"_20":21935,"_22":21936,"_24":21937,"_28":21940,"_30":21941},"slu.matrix.validateSparseMatrix","slu.matrix.validateSparseMatrix(A)","Validate a sparse matrix for format consistency.\r","Validate a sparse matrix for format consistency.\r\n\r\nChecks for:\r\n- Correct array lengths\r\n- Valid index ranges\r\n- Sorted indices within rows/columns\r\n- No duplicate entries\r\n- Consistent data types",[21938],{"_16":659,"_22":21939,"_69":6},"- Sparse matrix to validate","ValidationResult",[],{"_16":21943,"_18":21944,"_20":21945,"_22":21946,"_24":21947,"_28":21952,"_30":21953},"slu.permutation.computeColumnPermutation","slu.permutation.computeColumnPermutation(A, strategy?)","Compute a column permutation for fill-in reduction.\r","Compute a column permutation for fill-in reduction.\r\n\r\nColumn permutations reorder the columns of the matrix to reduce fill-in\r\nduring LU factorization. Different strategies trade off between computation\r\ntime and fill-in reduction quality:\r\n\r\n- **natural**: No reordering (identity permutation)\r\n- **mmd_ata**: Minimum degree on A^T * A\r\n- **mmd_at_plus_a**: Minimum degree on A^T + A\r\n- **colamd**: Column approximate minimum degree (recommended for most cases)\r\n- **metis**: METIS nested dissection (best for very large matrices)",[21948,21949],{"_16":659,"_22":21035,"_69":6},{"_16":21950,"_22":21951,"_69":11},"strategy","- Permutation strategy","ColumnPermutationResult",[],{"_16":21955,"_18":21956,"_20":21957,"_22":21958,"_24":21959,"_28":21962,"_30":21963},"slu.permutation.computeRowPermutation","slu.permutation.computeRowPermutation(A, strategy?)","Compute a row permutation for numerical stability.\r","Compute a row permutation for numerical stability.\r\n\r\nRow permutations reorder the rows to improve numerical stability during\r\nLU factorization by placing large elements on the diagonal:\r\n\r\n- **none**: No row permutation (identity)\r\n- **large_diag_mc64**: MC64 algorithm for large diagonal (recommended)\r\n- **large_diag_awpm**: Approximate weight perfect matching\r\n\r\nNote: Row permutation is typically computed during factorization.\r\nThis function provides a way to compute it separately.",[21960,21961],{"_16":659,"_22":21035,"_69":6},{"_16":21950,"_22":21951,"_69":11},"RowPermutationResult",[],{"_16":21965,"_18":21966,"_20":21967,"_22":21968,"_24":21969,"_28":4757,"_30":21972},"slu.permutation.invertPermutation","slu.permutation.invertPermutation(perm)","Compute the inverse of a permutation.\r","Compute the inverse of a permutation.\r\n\r\nGiven a permutation P where P[i] = j means element i maps to position j,\r\ncomputes the inverse permutation P^{-1} where P^{-1}[j] = i.",[21970],{"_16":21116,"_22":21971,"_69":6},"- Permutation array",[],{"_16":21974,"_18":21975,"_20":21976,"_22":21977,"_24":21978,"_28":21560,"_30":21986},"slu.permutation.permuteSparseMatrix","slu.permutation.permuteSparseMatrix(A, rowPerm, colPerm)","Apply row and column permutations to a sparse matrix.\r","Apply row and column permutations to a sparse matrix.\r\n\r\nComputes P * A * Q where P is the row permutation matrix and Q is the\r\ncolumn permutation matrix. The result is a new sparse matrix with\r\nreordered rows and columns.",[21979,21980,21983],{"_16":659,"_22":21035,"_69":6},{"_16":21981,"_22":21982,"_69":6},"rowPerm","- Row permutation (or null for identity)",{"_16":21984,"_22":21985,"_69":6},"colPerm","- Column permutation (or null for identity)",[],{"_16":21988,"_18":21989,"_20":21990,"_22":21991,"_24":21992,"_28":5450,"_30":21995},"slu.permutation.permuteVector","slu.permutation.permuteVector(x, perm)","Apply a permutation to a vector.\r","Apply a permutation to a vector.\r\n\r\nComputes y = P * x where P is a permutation matrix.\r\ny[perm[i]] = x[i] for all i.",[21993,21994],{"_16":498,"_22":19330,"_69":6},{"_16":21116,"_22":21971,"_69":6},[],{"_16":21997,"_18":21998,"_20":21999,"_22":22000,"_24":22001,"_28":5450,"_30":22004},"slu.permutation.permuteVectorInverse","slu.permutation.permuteVectorInverse(x, perm)","Apply inverse permutation to a vector.\r","Apply inverse permutation to a vector.\r\n\r\nComputes y = P^{-1} * x where P is a permutation matrix.\r\ny[i] = x[perm[i]] for all i.",[22002,22003],{"_16":498,"_22":19330,"_69":6},{"_16":21116,"_22":21971,"_69":6},[],{"_16":22006,"_18":22007,"_20":22008,"_22":22009,"_24":22010,"_28":22018,"_30":22019},"slu.solvers.solveMultipleRHS","slu.solvers.solveMultipleRHS(A, B, nrhs, options?)","Solve a sparse linear system AX = B with multiple right-hand sides.\r","Solve a sparse linear system AX = B with multiple right-hand sides.\r\n\r\nThis function efficiently solves for multiple right-hand sides at once,\r\nwhich is more efficient than calling solveSparseCSC multiple times when\r\nthe matrix A is the same for all systems.",[22011,22012,22014,22017],{"_16":659,"_22":21035,"_69":6},{"_16":656,"_22":22013,"_69":6},"- Right-hand side matrix (column-major, m x nrhs)",{"_16":22015,"_22":22016,"_69":6},"nrhs","- Number of right-hand sides (columns in B)",{"_16":4789,"_22":8287,"_69":11},"BatchSolveResult",[],{"_16":22021,"_18":22022,"_20":22023,"_22":22024,"_24":22025,"_28":22030,"_30":22031},"slu.solvers.solveReusedFactorization","slu.solvers.solveReusedFactorization(lu, b, options?)","Solve a sparse linear system using a pre-computed LU factorization.\r","Solve a sparse linear system using a pre-computed LU factorization.\r\n\r\nThis function is useful when you need to solve multiple systems with the\r\nsame matrix A but different right-hand sides. By reusing the factorization,\r\nyou avoid the expensive factorization step for subsequent solves.",[22026,22028,22029],{"_16":1547,"_22":22027,"_69":6},"- Pre-computed LU factorization from sparseLU()",{"_16":436,"_22":6345,"_69":6},{"_16":4789,"_22":20015,"_69":11},"ReusedFactorizationResult",[],{"_16":22033,"_18":22034,"_20":22035,"_22":22036,"_24":22037,"_28":22044,"_30":22045},"slu.solvers.solveWithDeflation","slu.solvers.solveWithDeflation(A, b, deflationVectors, options?)","Solve a sparse linear system using deflation.\r","Solve a sparse linear system using deflation.\r\n\r\nDeflation is a technique that projects out certain directions (typically\r\neigenvectors or approximate solutions) to improve the conditioning of\r\nthe system. This can be beneficial when:\r\n- The matrix has a few very small eigenvalues\r\n- You have approximate null space vectors\r\n- You want to accelerate convergence near singular systems\r\n\r\nThe deflation vectors W define a subspace. The solver computes:\r\n1. The coarse grid correction: W * (W^T A W)^(-1) * W^T * b\r\n2. The orthogonal complement solution\r\n3. Combines them for the full solution",[22038,22039,22040,22043],{"_16":659,"_22":21035,"_69":6},{"_16":436,"_22":6345,"_69":6},{"_16":22041,"_22":22042,"_69":6},"deflationVectors","- Array of deflation vectors (columns of W)",{"_16":4789,"_22":8287,"_69":11},"DeflationResult",[],{"_16":22047,"_18":22048,"_20":22049,"_22":22050,"_24":22051,"_28":20517,"_30":22057},"slu.solvers.solveSparseConjugateTranspose","slu.solvers.solveSparseConjugateTranspose(A, b, options?)","Solve A^H x = b (conjugate transpose) where A is complex.\r","Solve A^H x = b (conjugate transpose) where A is complex.\r\n\r\nSolves the system with the Hermitian (conjugate) transpose of A.\r\nOnly meaningful for complex matrices; for real matrices, this is\r\nequivalent to `solveSparseTranspose`.",[22052,22054,22056],{"_16":659,"_22":22053,"_69":6},"- Sparse complex matrix in CSC format",{"_16":436,"_22":22055,"_69":6},"- Right-hand side vector (complex, interleaved)",{"_16":4789,"_22":8287,"_69":11},[],{"_16":22059,"_18":22060,"_20":22061,"_22":22062,"_24":22063,"_28":20517,"_30":22067},"slu.solvers.solveSparseCSC","slu.solvers.solveSparseCSC(A, b, options?)","Solve a sparse linear system Ax = b where A is in CSC format.\r","Solve a sparse linear system Ax = b where A is in CSC format.\r\n\r\nUses SuperLU's simple driver (dgssv/sgssv) which performs:\r\n1. Column permutation for fill reduction\r\n2. Row permutation for numerical stability\r\n3. LU factorization: Pr * A * Pc = L * U\r\n4. Triangular solves to compute x",[22064,22065,22066],{"_16":659,"_22":21035,"_69":6},{"_16":436,"_22":6345,"_69":6},{"_16":4789,"_22":8287,"_69":11},[],{"_16":22069,"_18":22070,"_20":22071,"_22":22072,"_24":22073,"_28":20517,"_30":22077},"slu.solvers.solveSparseCSR","slu.solvers.solveSparseCSR(A, b, options?)","Solve a sparse linear system Ax = b where A is in CSR format.\r","Solve a sparse linear system Ax = b where A is in CSR format.\r\n\r\nThe CSR matrix is internally converted to CSC format (which is\r\nSuperLU's native format) before solving. For best performance\r\nwith repeated solves, consider pre-converting to CSC.",[22074,22075,22076],{"_16":659,"_22":21726,"_69":6},{"_16":436,"_22":6345,"_69":6},{"_16":4789,"_22":8287,"_69":11},[],{"_16":22079,"_18":22080,"_20":22081,"_22":22082,"_24":22083,"_28":20517,"_30":22087},"slu.solvers.solveSparseTranspose","slu.solvers.solveSparseTranspose(A, b, options?)","Solve A^T x = b (transpose system) where A is in CSC format.\r","Solve A^T x = b (transpose system) where A is in CSC format.\r\n\r\nSolves the system with the transpose of A. Useful when you have\r\nA but need to solve with its transpose without explicitly computing it.",[22084,22085,22086],{"_16":659,"_22":21035,"_69":6},{"_16":436,"_22":6345,"_69":6},{"_16":4789,"_22":8287,"_69":11},[],{"_16":22089,"_18":22090,"_20":22091,"_22":22092,"_24":22093,"_28":20517,"_30":22098},"slu.solvers.solveSparseExpert","slu.solvers.solveSparseExpert(A, b, options?)","Expert sparse solver with full control over all SuperLU options.\r","Expert sparse solver with full control over all SuperLU options.\r\n\r\nThis is the most flexible solver interface, providing access to:\r\n- Equilibration (row/column scaling) for numerical stability\r\n- Condition number estimation\r\n- Iterative refinement for improved accuracy\r\n- Forward and backward error bounds\r\n- Reuse of factorization for multiple right-hand sides",[22094,22095,22096],{"_16":659,"_22":21035,"_69":6},{"_16":436,"_22":6345,"_69":6},{"_16":4789,"_22":22097,"_69":11},"- Expert solver options",[],{"_16":22100,"_18":22101,"_20":22102,"_22":22103,"_24":22104,"_28":17635,"_30":22110},"slu.solvers.solveLeastSquaresSparse","slu.solvers.solveLeastSquaresSparse(A, b, options?)","Solve a sparse least squares problem min ||Ax - b||_2.\r","Solve a sparse least squares problem min ||Ax - b||_2.\r\n\r\nFor overdetermined systems (m > n), this finds the solution x that\r\nminimizes the 2-norm of the residual. The solver uses the normal\r\nequations approach: A^T A x = A^T b.\r\n\r\nFor square or underdetermined systems, consider using solveSparseCSC\r\ndirectly instead.",[22105,22107,22109],{"_16":659,"_22":22106,"_69":6},"- Sparse matrix in CSC format (m x n, m >= n)",{"_16":436,"_22":22108,"_69":6},"- Right-hand side vector (length m)",{"_16":4789,"_22":8287,"_69":11},[],{"_16":22112,"_18":22113,"_20":22114,"_22":22115,"_24":22116,"_28":22123,"_30":22124},"slu.solvers.solveWithIterativeRefinement","slu.solvers.solveWithIterativeRefinement(A, lu, b, x, options?)","Solve a sparse linear system with iterative refinement.\r","Solve a sparse linear system with iterative refinement.\r\n\r\nThis is a convenience function that combines triangular solve with\r\niterative refinement. It takes pre-computed L, U factors and permutations,\r\ncomputes an initial solution, and refines it.\r\n\r\nThis function is useful when you have already factored the matrix and\r\nwant to solve with high accuracy.",[22117,22118,22119,22120,22122],{"_16":659,"_22":21062,"_69":6},{"_16":1547,"_22":21064,"_69":6},{"_16":436,"_22":6345,"_69":6},{"_16":498,"_22":22121,"_69":6},"- Initial solution (from a previous solve)",{"_16":4789,"_22":21069,"_69":11},"RefinedSolveResult",[],{"_16":22126,"_18":22127,"_20":22128,"_22":22129,"_24":22130,"_28":22135,"_30":22136},"slu.solvers.solveShiftedSystem","slu.solvers.solveShiftedSystem(A, shift, b, options?)","Solve a shifted linear system (A - σI)x = b.\r","Solve a shifted linear system (A - σI)x = b.\r\n\r\nThis is commonly used in shift-invert eigenvalue methods where we need\r\nto solve (A - σI)x = b for various right-hand sides b. The shift σ is\r\nchosen close to a target eigenvalue.\r\n\r\nFor efficiency when solving multiple systems with the same shift,\r\nyou can save and reuse the factorization.",[22131,22132,22133,22134],{"_16":659,"_22":21035,"_69":6},{"_16":13768,"_22":19418,"_69":6},{"_16":436,"_22":6345,"_69":6},{"_16":4789,"_22":8287,"_69":11},"ShiftedSolveResult",[],{"_16":22138,"_18":22139,"_20":22140,"_22":22141,"_24":22142,"_28":20517,"_30":22148},"slu.solvers.solveHermitianSparse","slu.solvers.solveHermitianSparse(A, b, options?)","Solve a Hermitian sparse linear system Ax = b.\r","Solve a Hermitian sparse linear system Ax = b.\r\n\r\nThis solver is for complex Hermitian matrices where A = A^H (conjugate\r\ntranspose). Currently, this is implemented as a wrapper around the\r\nsymmetric solver since SuperLU's complex support handles conjugation.\r\n\r\nNote: For real matrices, this is equivalent to solveSymmetricSparse.",[22143,22145,22147],{"_16":659,"_22":22144,"_69":6},"- Hermitian sparse matrix in CSC format",{"_16":436,"_22":22146,"_69":6},"- Right-hand side vector (complex, interleaved format)",{"_16":4789,"_22":8287,"_69":11},[],{"_16":22150,"_18":22151,"_20":22152,"_22":22153,"_24":22154,"_28":20517,"_30":22159},"slu.solvers.solveSymmetricSparse","slu.solvers.solveSymmetricSparse(A, b, options?)","Solve a symmetric sparse linear system Ax = b.\r","Solve a symmetric sparse linear system Ax = b.\r\n\r\nThis solver is optimized for symmetric matrices where only one triangle\r\n(lower or upper) is stored. The solver automatically symmetrizes the\r\nmatrix before solving.\r\n\r\nFor general symmetric matrices, this uses a column permutation strategy\r\noptimized for symmetric structure (MMD on A^T + A).",[22155,22157,22158],{"_16":659,"_22":22156,"_69":6},"- Symmetric sparse matrix in CSC format (stored as triangle)",{"_16":436,"_22":6345,"_69":6},{"_16":4789,"_22":8287,"_69":11},[],{"_16":22161,"_18":22162,"_20":22163,"_22":22164,"_24":22165,"_28":22171,"_30":22172},"slu.solvers.solveTriangularCSC","slu.solvers.solveTriangularCSC(T, b, options?)","Solve a triangular system Tx = b where T is a sparse triangular CSC matrix.\r","Solve a triangular system Tx = b where T is a sparse triangular CSC matrix.\r\n\r\nThis directly solves with a triangular matrix without computing an\r\nLU factorization. Useful when you already have a triangular matrix\r\n(e.g., from a Cholesky factorization or as part of an iterative solver).",[22166,22168,22169],{"_16":14861,"_22":22167,"_69":6},"- Sparse triangular matrix in CSC format",{"_16":436,"_22":6345,"_69":6},{"_16":4789,"_22":22170,"_69":11},"- Triangular solve options","TriangularSolveResult",[],{"_16":22174,"_18":22175,"_20":22176,"_22":22176,"_24":22177,"_28":22171,"_30":22182},"slu.solvers.solveTriangularCSR","slu.solvers.solveTriangularCSR(T, b, options?)","Solve a triangular system Tx = b where T is a sparse triangular CSR matrix.",[22178,22180,22181],{"_16":14861,"_22":22179,"_69":6},"- Sparse triangular matrix in CSR format",{"_16":436,"_22":6345,"_69":6},{"_16":4789,"_22":22170,"_69":11},[],{"_16":22184,"_18":22185,"_20":22186,"_22":22187,"_24":22188,"_28":22171,"_30":22193},"slu.solvers.solveTriangularLU","slu.solvers.solveTriangularLU(lu, b, options?)","Solve Ax = b using precomputed LU factors.\r","Solve Ax = b using precomputed LU factors.\r\n\r\nGiven LU factors from `sparseLU`, solves the system:\r\nPr * A * Pc = L * U\r\n=> A * x = b\r\n=> Pc^T * U^{-1} * L^{-1} * Pr * b = x\r\n\r\nThis is much faster than `solveSparseCSC` when solving multiple\r\nsystems with the same matrix, as the expensive factorization is reused.",[22189,22191,22192],{"_16":1547,"_22":22190,"_69":6},"- LU factorization from sparseLU",{"_16":436,"_22":6345,"_69":6},{"_16":4789,"_22":20015,"_69":11},[],{"_16":22195,"_18":22196,"_20":22197,"_22":22198,"_24":22199,"_28":22171,"_30":22203},"slu.solvers.solveTriangularLUConjugateTranspose","slu.solvers.solveTriangularLUConjugateTranspose(lu, b, options?)","Solve A^H x = b using precomputed LU factors (complex matrices).\r","Solve A^H x = b using precomputed LU factors (complex matrices).\r\n\r\nSolves with the Hermitian (conjugate transpose) of A.\r\nFor real matrices, this is equivalent to `solveTriangularLUTranspose`.",[22200,22201,22202],{"_16":1547,"_22":22190,"_69":6},{"_16":436,"_22":6345,"_69":6},{"_16":4789,"_22":20015,"_69":11},[],{"_16":22205,"_18":22206,"_20":22207,"_22":22208,"_24":22209,"_28":22171,"_30":22213},"slu.solvers.solveTriangularLUTranspose","slu.solvers.solveTriangularLUTranspose(lu, b, options?)","Solve A^T x = b using precomputed LU factors.\r","Solve A^T x = b using precomputed LU factors.\r\n\r\nSolves the transposed system without recomputing the factorization.",[22210,22211,22212],{"_16":1547,"_22":22190,"_69":6},{"_16":436,"_22":6345,"_69":6},{"_16":4789,"_22":20015,"_69":11},[],{"_16":22215,"_18":22216,"_20":22217,"_22":22218,"_24":22219,"_28":22226,"_30":22227},"slu.testing.createTestMatrix","slu.testing.createTestMatrix(type, n, options?)","Create a standard test matrix.\r","Create a standard test matrix.\r\n\r\nGenerates matrices commonly used for testing and benchmarking\r\nsparse linear solvers. Each matrix type has known properties\r\nthat make it useful for specific tests.\r\n\r\nAvailable matrix types:\r\n- `'tridiagonal'`: Tridiagonal matrix (bandwidth 1)\r\n- `'laplacian_2d'`: 2D Laplacian / 5-point stencil\r\n- `'laplacian_3d'`: 3D Laplacian / 7-point stencil\r\n- `'random'`: Random dense matrix (diagonally dominant)\r\n- `'sparse_random'`: Random sparse matrix\r\n- `'poisson'`: Poisson problem matrix\r\n- `'diagonal'`: Random diagonal matrix\r\n- `'identity'`: Identity matrix\r\n- `'hilbert'`: Hilbert matrix (ill-conditioned)\r\n- `'lehmer'`: Lehmer matrix (positive definite)",[22220,22222,22224],{"_16":6485,"_22":22221,"_69":6},"- Type of test matrix to create",{"_16":362,"_22":22223,"_69":6},"- Matrix size (n x n)",{"_16":4789,"_22":22225,"_69":11},"- Generation options","TestMatrixResult",[],{"_16":22229,"_18":22230,"_20":22231,"_22":22231,"_24":22232,"_28":22233,"_30":22234},"slu.testing.getTestMatrixTypes","slu.testing.getTestMatrixTypes()","Get a list of available test matrix types with descriptions.",[],"{\r\n type: TestMatrixType;\r\n description: string;\r\n}[]",[],{"_16":22236,"_18":22237,"_20":22238,"_22":22238,"_24":22239,"_28":5703,"_30":22241},"slu.getNnz","slu.getNnz(matrix)","Get the number of nonzeros in a sparse matrix.",[22240],{"_16":19607,"_22":4577,"_69":6},[],{"_16":22243,"_18":22244,"_20":22245,"_22":22245,"_24":22246,"_28":21243,"_30":22249},"slu.inferDataType","slu.inferDataType(arr)","Infer the data type from an array.",[22247],{"_16":9285,"_22":22248,"_69":6},"RealArray | ComplexArray",[],{"_16":22251,"_18":22252,"_20":22253,"_22":22253,"_24":22254,"_28":22256,"_30":22257},"slu.isSparseMatrixCSC","slu.isSparseMatrixCSC(matrix)","Check if a sparse matrix is in CSC format.",[22255],{"_16":19607,"_22":4577,"_69":6},"matrix is SparseMatrixCSC",[],{"_16":22259,"_18":22260,"_20":22261,"_22":22261,"_24":22262,"_28":22264,"_30":22265},"slu.isSparseMatrixCSR","slu.isSparseMatrixCSR(matrix)","Check if a sparse matrix is in CSR format.",[22263],{"_16":19607,"_22":4577,"_69":6},"matrix is SparseMatrixCSR",[],{"_43":22267,"_16":22268,"_22":22269,"_47":48,"_49":22270,"_51":22271,"_52":22272},"xsf-generated","Special Functions","Special mathematical functions (Bessel, Gamma, Error functions, etc.).","ƒ","xsf",[22273,22281,22288,22296,22303,22310,22318,22324,22331,22339,22346,22353,22361,22368,22375,22383,22391,22399,22407,22414,22421,22428,22435,22442,22449,22456,22463,22471,22479,22487,22495,22502,22509,22516,22523,22529,22536,22543,22550,22558,22565,22572,22579,22588,22596,22605,22612,22619,22627,22635,22643,22651,22659,22667,22675,22685,22692,22699,22706,22715,22723,22731,22742,22751,22760,22769,22778,22786,22794,22802,22814,22823,22832,22842,22851,22860,22867,22874,22882,22890,22902,22910,22917,22923,22930],{"_16":22274,"_18":22275,"_20":22276,"_22":5456,"_24":22277,"_28":5450,"_30":22280},"xsf.analysisFns.zeta","xsf.analysisFns.zeta(x)","zeta",[22278],{"_16":498,"_22":22279,"_69":6},"ArrayInput",[],{"_16":22282,"_18":22283,"_20":22284,"_22":5456,"_24":22285,"_28":5450,"_30":22287},"xsf.analysisFns.zetac","xsf.analysisFns.zetac(x)","zetac",[22286],{"_16":498,"_22":22279,"_69":6},[],{"_16":22289,"_18":22290,"_20":22291,"_22":5456,"_24":22292,"_28":5450,"_30":22295},"xsf.analysisFns.lambertw","xsf.analysisFns.lambertw(x, k?)","lambertw",[22293,22294],{"_16":498,"_22":22279,"_69":6},{"_16":1114,"_22":5703,"_69":11},[],{"_16":22297,"_18":22298,"_20":22299,"_22":5456,"_24":22300,"_28":5450,"_30":22302},"xsf.besselFns.j0","xsf.besselFns.j0(x)","j0",[22301],{"_16":498,"_22":22279,"_69":6},[],{"_16":22304,"_18":22305,"_20":22306,"_22":5456,"_24":22307,"_28":5450,"_30":22309},"xsf.besselFns.j1","xsf.besselFns.j1(x)","j1",[22308],{"_16":498,"_22":22279,"_69":6},[],{"_16":22311,"_18":22312,"_20":22313,"_22":5456,"_24":22314,"_28":5450,"_30":22317},"xsf.besselFns.jv","xsf.besselFns.jv(v, x)","jv",[22315,22316],{"_16":2897,"_22":22279,"_69":6},{"_16":498,"_22":22279,"_69":6},[],{"_16":22319,"_18":22320,"_20":14940,"_22":5456,"_24":22321,"_28":5450,"_30":22323},"xsf.besselFns.y0","xsf.besselFns.y0(x)",[22322],{"_16":498,"_22":22279,"_69":6},[],{"_16":22325,"_18":22326,"_20":22327,"_22":5456,"_24":22328,"_28":5450,"_30":22330},"xsf.besselFns.y1","xsf.besselFns.y1(x)","y1",[22329],{"_16":498,"_22":22279,"_69":6},[],{"_16":22332,"_18":22333,"_20":22334,"_22":5456,"_24":22335,"_28":5450,"_30":22338},"xsf.besselFns.yv","xsf.besselFns.yv(v, x)","yv",[22336,22337],{"_16":2897,"_22":22279,"_69":6},{"_16":498,"_22":22279,"_69":6},[],{"_16":22340,"_18":22341,"_20":22342,"_22":5456,"_24":22343,"_28":5450,"_30":22345},"xsf.besselFns.i0","xsf.besselFns.i0(x)","i0",[22344],{"_16":498,"_22":22279,"_69":6},[],{"_16":22347,"_18":22348,"_20":22349,"_22":5456,"_24":22350,"_28":5450,"_30":22352},"xsf.besselFns.i1","xsf.besselFns.i1(x)","i1",[22351],{"_16":498,"_22":22279,"_69":6},[],{"_16":22354,"_18":22355,"_20":22356,"_22":5456,"_24":22357,"_28":5450,"_30":22360},"xsf.besselFns.iv","xsf.besselFns.iv(v, x)","iv",[22358,22359],{"_16":2897,"_22":22279,"_69":6},{"_16":498,"_22":22279,"_69":6},[],{"_16":22362,"_18":22363,"_20":22364,"_22":5456,"_24":22365,"_28":5450,"_30":22367},"xsf.besselFns.k0","xsf.besselFns.k0(x)","k0",[22366],{"_16":498,"_22":22279,"_69":6},[],{"_16":22369,"_18":22370,"_20":22371,"_22":5456,"_24":22372,"_28":5450,"_30":22374},"xsf.besselFns.k1","xsf.besselFns.k1(x)","k1",[22373],{"_16":498,"_22":22279,"_69":6},[],{"_16":22376,"_18":22377,"_20":22378,"_22":5456,"_24":22379,"_28":5450,"_30":22382},"xsf.besselFns.sphericalJn","xsf.besselFns.sphericalJn(n, x)","sphericalJn",[22380,22381],{"_16":362,"_22":5703,"_69":6},{"_16":498,"_22":22279,"_69":6},[],{"_16":22384,"_18":22385,"_20":22386,"_22":5456,"_24":22387,"_28":5450,"_30":22390},"xsf.besselFns.sphericalYn","xsf.besselFns.sphericalYn(n, x)","sphericalYn",[22388,22389],{"_16":362,"_22":5703,"_69":6},{"_16":498,"_22":22279,"_69":6},[],{"_16":22392,"_18":22393,"_20":22394,"_22":5456,"_24":22395,"_28":5450,"_30":22398},"xsf.besselFns.sphericalIn","xsf.besselFns.sphericalIn(n, x)","sphericalIn",[22396,22397],{"_16":362,"_22":5703,"_69":6},{"_16":498,"_22":22279,"_69":6},[],{"_16":22400,"_18":22401,"_20":22402,"_22":5456,"_24":22403,"_28":5450,"_30":22406},"xsf.besselFns.sphericalKn","xsf.besselFns.sphericalKn(n, x)","sphericalKn",[22404,22405],{"_16":362,"_22":5703,"_69":6},{"_16":498,"_22":22279,"_69":6},[],{"_16":22408,"_18":22409,"_20":22410,"_22":5456,"_24":22411,"_28":5450,"_30":22413},"xsf.besselFns.ber","xsf.besselFns.ber(x)","ber",[22412],{"_16":498,"_22":22279,"_69":6},[],{"_16":22415,"_18":22416,"_20":22417,"_22":5456,"_24":22418,"_28":5450,"_30":22420},"xsf.besselFns.bei","xsf.besselFns.bei(x)","bei",[22419],{"_16":498,"_22":22279,"_69":6},[],{"_16":22422,"_18":22423,"_20":22424,"_22":5456,"_24":22425,"_28":5450,"_30":22427},"xsf.besselFns.ker","xsf.besselFns.ker(x)","ker",[22426],{"_16":498,"_22":22279,"_69":6},[],{"_16":22429,"_18":22430,"_20":22431,"_22":5456,"_24":22432,"_28":5450,"_30":22434},"xsf.besselFns.kei","xsf.besselFns.kei(x)","kei",[22433],{"_16":498,"_22":22279,"_69":6},[],{"_16":22436,"_18":22437,"_20":22438,"_22":5456,"_24":22439,"_28":5450,"_30":22441},"xsf.besselFns.berp","xsf.besselFns.berp(x)","berp",[22440],{"_16":498,"_22":22279,"_69":6},[],{"_16":22443,"_18":22444,"_20":22445,"_22":5456,"_24":22446,"_28":5450,"_30":22448},"xsf.besselFns.beip","xsf.besselFns.beip(x)","beip",[22447],{"_16":498,"_22":22279,"_69":6},[],{"_16":22450,"_18":22451,"_20":22452,"_22":5456,"_24":22453,"_28":5450,"_30":22455},"xsf.besselFns.kerp","xsf.besselFns.kerp(x)","kerp",[22454],{"_16":498,"_22":22279,"_69":6},[],{"_16":22457,"_18":22458,"_20":22459,"_22":5456,"_24":22460,"_28":5450,"_30":22462},"xsf.besselFns.keip","xsf.besselFns.keip(x)","keip",[22461],{"_16":498,"_22":22279,"_69":6},[],{"_16":22464,"_18":22465,"_20":22466,"_22":5456,"_24":22467,"_28":5450,"_30":22470},"xsf.combinatoricsFns.binom","xsf.combinatoricsFns.binom(n, k)","binom",[22468,22469],{"_16":362,"_22":22279,"_69":6},{"_16":1114,"_22":22279,"_69":6},[],{"_16":22472,"_18":22473,"_20":22474,"_22":5456,"_24":22475,"_28":5450,"_30":22478},"xsf.combinatoricsFns.binomExact","xsf.combinatoricsFns.binomExact(n, k)","binomExact",[22476,22477],{"_16":362,"_22":22279,"_69":6},{"_16":1114,"_22":22279,"_69":6},[],{"_16":22480,"_18":22481,"_20":22482,"_22":5456,"_24":22483,"_28":5450,"_30":22486},"xsf.combinatoricsFns.poch","xsf.combinatoricsFns.poch(x, m)","poch",[22484,22485],{"_16":498,"_22":22279,"_69":6},{"_16":359,"_22":22279,"_69":6},[],{"_16":22488,"_18":22489,"_20":22490,"_22":5456,"_24":22491,"_28":5450,"_30":22494},"xsf.combinatoricsFns.permExact","xsf.combinatoricsFns.permExact(n, k)","permExact",[22492,22493],{"_16":362,"_22":22279,"_69":6},{"_16":1114,"_22":22279,"_69":6},[],{"_16":22496,"_18":22497,"_20":22498,"_22":5456,"_24":22499,"_28":5450,"_30":22501},"xsf.errorFns.erf","xsf.errorFns.erf(x)","erf",[22500],{"_16":498,"_22":22279,"_69":6},[],{"_16":22503,"_18":22504,"_20":22505,"_22":5456,"_24":22506,"_28":5450,"_30":22508},"xsf.errorFns.erfc","xsf.errorFns.erfc(x)","erfc",[22507],{"_16":498,"_22":22279,"_69":6},[],{"_16":22510,"_18":22511,"_20":22512,"_22":5456,"_24":22513,"_28":5450,"_30":22515},"xsf.errorFns.erfcx","xsf.errorFns.erfcx(x)","erfcx",[22514],{"_16":498,"_22":22279,"_69":6},[],{"_16":22517,"_18":22518,"_20":22519,"_22":5456,"_24":22520,"_28":5450,"_30":22522},"xsf.errorFns.erfi","xsf.errorFns.erfi(x)","erfi",[22521],{"_16":498,"_22":22279,"_69":6},[],{"_16":22524,"_18":22525,"_20":7742,"_22":5456,"_24":22526,"_28":5450,"_30":22528},"xsf.gammaFns.gamma","xsf.gammaFns.gamma(x)",[22527],{"_16":498,"_22":22279,"_69":6},[],{"_16":22530,"_18":22531,"_20":22532,"_22":5456,"_24":22533,"_28":5450,"_30":22535},"xsf.gammaFns.gammaln","xsf.gammaFns.gammaln(x)","gammaln",[22534],{"_16":498,"_22":22279,"_69":6},[],{"_16":22537,"_18":22538,"_20":22539,"_22":5456,"_24":22540,"_28":5450,"_30":22542},"xsf.gammaFns.rgamma","xsf.gammaFns.rgamma(x)","rgamma",[22541],{"_16":498,"_22":22279,"_69":6},[],{"_16":22544,"_18":22545,"_20":2011,"_22":5456,"_24":22546,"_28":5450,"_30":22549},"xsf.gammaFns.beta","xsf.gammaFns.beta(a, b)",[22547,22548],{"_16":433,"_22":22279,"_69":6},{"_16":436,"_22":22279,"_69":6},[],{"_16":22551,"_18":22552,"_20":22553,"_22":5456,"_24":22554,"_28":5450,"_30":22557},"xsf.gammaFns.betaln","xsf.gammaFns.betaln(a, b)","betaln",[22555,22556],{"_16":433,"_22":22279,"_69":6},{"_16":436,"_22":22279,"_69":6},[],{"_16":22559,"_18":22560,"_20":22561,"_22":5456,"_24":22562,"_28":5450,"_30":22564},"xsf.gammaFns.digamma","xsf.gammaFns.digamma(x)","digamma",[22563],{"_16":498,"_22":22279,"_69":6},[],{"_16":22566,"_18":22567,"_20":22568,"_22":5456,"_24":22569,"_28":5450,"_30":22571},"xsf.integralFns.ellipk","xsf.integralFns.ellipk(m)","ellipk",[22570],{"_16":359,"_22":22279,"_69":6},[],{"_16":22573,"_18":22574,"_20":22575,"_22":5456,"_24":22576,"_28":5450,"_30":22578},"xsf.integralFns.ellipe","xsf.integralFns.ellipe(m)","ellipe",[22577],{"_16":359,"_22":22279,"_69":6},[],{"_16":22580,"_18":22581,"_20":22582,"_22":5456,"_24":22583,"_28":5450,"_30":22587},"xsf.integralFns.ellipkinc","xsf.integralFns.ellipkinc(phi, m)","ellipkinc",[22584,22586],{"_16":22585,"_22":22279,"_69":6},"phi",{"_16":359,"_22":22279,"_69":6},[],{"_16":22589,"_18":22590,"_20":22591,"_22":5456,"_24":22592,"_28":5450,"_30":22595},"xsf.integralFns.ellipeinc","xsf.integralFns.ellipeinc(phi, m)","ellipeinc",[22593,22594],{"_16":22585,"_22":22279,"_69":6},{"_16":359,"_22":22279,"_69":6},[],{"_16":22597,"_18":22598,"_20":22599,"_22":5456,"_24":22600,"_28":22603,"_30":22604},"xsf.integralFns.ellipj","xsf.integralFns.ellipj(u, m)","ellipj",[22601,22602],{"_16":334,"_22":22279,"_69":6},{"_16":359,"_22":22279,"_69":6},"EllipjArrayResult",[],{"_16":22606,"_18":22607,"_20":22608,"_22":5456,"_24":22609,"_28":5450,"_30":22611},"xsf.integralFns.exp1","xsf.integralFns.exp1(x)","exp1",[22610],{"_16":498,"_22":22279,"_69":6},[],{"_16":22613,"_18":22614,"_20":22615,"_22":5456,"_24":22616,"_28":5450,"_30":22618},"xsf.integralFns.expi","xsf.integralFns.expi(x)","expi",[22617],{"_16":498,"_22":22279,"_69":6},[],{"_16":22620,"_18":22621,"_20":22622,"_22":5456,"_24":22623,"_28":22625,"_30":22626},"xsf.integralFns.fresnel","xsf.integralFns.fresnel(x)","fresnel",[22624],{"_16":498,"_22":22279,"_69":6},"FresnelArrayResult",[],{"_16":22628,"_18":22629,"_20":22630,"_22":5456,"_24":22631,"_28":22633,"_30":22634},"xsf.integralFns.sici","xsf.integralFns.sici(x)","sici",[22632],{"_16":498,"_22":22279,"_69":6},"SiCiArrayResult",[],{"_16":22636,"_18":22637,"_20":22638,"_22":5456,"_24":22639,"_28":22641,"_30":22642},"xsf.integralFns.shichi","xsf.integralFns.shichi(x)","shichi",[22640],{"_16":498,"_22":22279,"_69":6},"ShiChiArrayResult",[],{"_16":22644,"_18":22645,"_20":22646,"_22":5456,"_24":22647,"_28":22649,"_30":22650},"xsf.specialFns.airy","xsf.specialFns.airy(x)","airy",[22648],{"_16":498,"_22":22279,"_69":6},"AiryArrayResult",[],{"_16":22652,"_18":22653,"_20":22654,"_22":5456,"_24":22655,"_28":5450,"_30":22658},"xsf.specialFns.struveH","xsf.specialFns.struveH(v, x)","struveH",[22656,22657],{"_16":2897,"_22":22279,"_69":6},{"_16":498,"_22":22279,"_69":6},[],{"_16":22660,"_18":22661,"_20":22662,"_22":5456,"_24":22663,"_28":5450,"_30":22666},"xsf.specialFns.struveL","xsf.specialFns.struveL(v, x)","struveL",[22664,22665],{"_16":2897,"_22":22279,"_69":6},{"_16":498,"_22":22279,"_69":6},[],{"_16":22668,"_18":22669,"_20":22670,"_22":5456,"_24":22671,"_28":5450,"_30":22674},"xsf.specialFns.legendreP","xsf.specialFns.legendreP(n, x)","legendreP",[22672,22673],{"_16":362,"_22":5703,"_69":6},{"_16":498,"_22":22279,"_69":6},[],{"_16":22676,"_18":22677,"_20":22678,"_22":5456,"_24":22679,"_28":5450,"_30":22684},"xsf.specialFns.hyp2f1","xsf.specialFns.hyp2f1(a, b, c, x)","hyp2f1",[22680,22681,22682,22683],{"_16":433,"_22":5703,"_69":6},{"_16":436,"_22":5703,"_69":6},{"_16":2644,"_22":5703,"_69":6},{"_16":498,"_22":22279,"_69":6},[],{"_16":22686,"_18":22687,"_20":22688,"_22":5456,"_24":22689,"_28":5450,"_30":22691},"xsf.statsFns.ndtr","xsf.statsFns.ndtr(x)","ndtr",[22690],{"_16":498,"_22":22279,"_69":6},[],{"_16":22693,"_18":22694,"_20":22695,"_22":5456,"_24":22696,"_28":5450,"_30":22698},"xsf.statsFns.ndtri","xsf.statsFns.ndtri(p)","ndtri",[22697],{"_16":1645,"_22":22279,"_69":6},[],{"_16":22700,"_18":22701,"_20":22702,"_22":5456,"_24":22703,"_28":5450,"_30":22705},"xsf.statsFns.logNdtr","xsf.statsFns.logNdtr(x)","logNdtr",[22704],{"_16":498,"_22":22279,"_69":6},[],{"_16":22707,"_18":22708,"_20":22709,"_22":5456,"_24":22710,"_28":5450,"_30":22714},"xsf.statsFns.chdtr","xsf.statsFns.chdtr(df, x)","chdtr",[22711,22713],{"_16":22712,"_22":5703,"_69":6},"df",{"_16":498,"_22":22279,"_69":6},[],{"_16":22716,"_18":22717,"_20":22718,"_22":5456,"_24":22719,"_28":5450,"_30":22722},"xsf.statsFns.chdtrc","xsf.statsFns.chdtrc(df, x)","chdtrc",[22720,22721],{"_16":22712,"_22":5703,"_69":6},{"_16":498,"_22":22279,"_69":6},[],{"_16":22724,"_18":22725,"_20":22726,"_22":5456,"_24":22727,"_28":5450,"_30":22730},"xsf.statsFns.chdtri","xsf.statsFns.chdtri(df, p)","chdtri",[22728,22729],{"_16":22712,"_22":5703,"_69":6},{"_16":1645,"_22":22279,"_69":6},[],{"_16":22732,"_18":22733,"_20":22734,"_22":5456,"_24":22735,"_28":5450,"_30":22741},"xsf.statsFns.fdtr","xsf.statsFns.fdtr(dfn, dfd, x)","fdtr",[22736,22738,22740],{"_16":22737,"_22":5703,"_69":6},"dfn",{"_16":22739,"_22":5703,"_69":6},"dfd",{"_16":498,"_22":22279,"_69":6},[],{"_16":22743,"_18":22744,"_20":22745,"_22":5456,"_24":22746,"_28":5450,"_30":22750},"xsf.statsFns.fdtrc","xsf.statsFns.fdtrc(dfn, dfd, x)","fdtrc",[22747,22748,22749],{"_16":22737,"_22":5703,"_69":6},{"_16":22739,"_22":5703,"_69":6},{"_16":498,"_22":22279,"_69":6},[],{"_16":22752,"_18":22753,"_20":22754,"_22":5456,"_24":22755,"_28":5450,"_30":22759},"xsf.statsFns.fdtri","xsf.statsFns.fdtri(dfn, dfd, p)","fdtri",[22756,22757,22758],{"_16":22737,"_22":5703,"_69":6},{"_16":22739,"_22":5703,"_69":6},{"_16":1645,"_22":22279,"_69":6},[],{"_16":22761,"_18":22762,"_20":22763,"_22":5456,"_24":22764,"_28":5450,"_30":22768},"xsf.statsFns.gdtr","xsf.statsFns.gdtr(a, b, x)","gdtr",[22765,22766,22767],{"_16":433,"_22":5703,"_69":6},{"_16":436,"_22":5703,"_69":6},{"_16":498,"_22":22279,"_69":6},[],{"_16":22770,"_18":22771,"_20":22772,"_22":5456,"_24":22773,"_28":5450,"_30":22777},"xsf.statsFns.gdtrc","xsf.statsFns.gdtrc(a, b, x)","gdtrc",[22774,22775,22776],{"_16":433,"_22":5703,"_69":6},{"_16":436,"_22":5703,"_69":6},{"_16":498,"_22":22279,"_69":6},[],{"_16":22779,"_18":22780,"_20":22781,"_22":5456,"_24":22782,"_28":5450,"_30":22785},"xsf.statsFns.pdtr","xsf.statsFns.pdtr(k, m)","pdtr",[22783,22784],{"_16":1114,"_22":22279,"_69":6},{"_16":359,"_22":5703,"_69":6},[],{"_16":22787,"_18":22788,"_20":22789,"_22":5456,"_24":22790,"_28":5450,"_30":22793},"xsf.statsFns.pdtrc","xsf.statsFns.pdtrc(k, m)","pdtrc",[22791,22792],{"_16":1114,"_22":22279,"_69":6},{"_16":359,"_22":5703,"_69":6},[],{"_16":22795,"_18":22796,"_20":22797,"_22":22797,"_24":22798,"_28":5703,"_30":22801},"xsf.statsFns.pdtri","xsf.statsFns.pdtri(k, p)","Poisson distribution inverse CDF.",[22799,22800],{"_16":1114,"_22":5703,"_69":6},{"_16":1645,"_22":5703,"_69":6},[],{"_16":22803,"_18":22804,"_20":22805,"_22":22805,"_24":22806,"_28":5703,"_30":22813},"xsf.statsFns.bdtr","xsf.statsFns.bdtr(k, n, p)","Binomial distribution CDF.",[22807,22809,22811],{"_16":1114,"_22":22808,"_69":6},"- Number of successes",{"_16":362,"_22":22810,"_69":6},"- Number of trials",{"_16":1645,"_22":22812,"_69":6},"- Probability of success",[],{"_16":22815,"_18":22816,"_20":22817,"_22":22817,"_24":22818,"_28":5703,"_30":22822},"xsf.statsFns.bdtrc","xsf.statsFns.bdtrc(k, n, p)","Binomial distribution survival function.",[22819,22820,22821],{"_16":1114,"_22":5703,"_69":6},{"_16":362,"_22":5703,"_69":6},{"_16":1645,"_22":5703,"_69":6},[],{"_16":22824,"_18":22825,"_20":22826,"_22":22826,"_24":22827,"_28":5703,"_30":22831},"xsf.statsFns.bdtri","xsf.statsFns.bdtri(k, n, y)","Binomial distribution inverse CDF.",[22828,22829,22830],{"_16":1114,"_22":5703,"_69":6},{"_16":362,"_22":5703,"_69":6},{"_16":501,"_22":5703,"_69":6},[],{"_16":22833,"_18":22834,"_20":22835,"_22":22835,"_24":22836,"_28":5703,"_30":22841},"xsf.statsFns.nbdtr","xsf.statsFns.nbdtr(k, n, p)","Negative binomial distribution CDF.",[22837,22839,22840],{"_16":1114,"_22":22838,"_69":6},"- Number of failures",{"_16":362,"_22":22808,"_69":6},{"_16":1645,"_22":22812,"_69":6},[],{"_16":22843,"_18":22844,"_20":22845,"_22":22845,"_24":22846,"_28":5703,"_30":22850},"xsf.statsFns.nbdtrc","xsf.statsFns.nbdtrc(k, n, p)","Negative binomial distribution survival function.",[22847,22848,22849],{"_16":1114,"_22":5703,"_69":6},{"_16":362,"_22":5703,"_69":6},{"_16":1645,"_22":5703,"_69":6},[],{"_16":22852,"_18":22853,"_20":22854,"_22":22854,"_24":22855,"_28":5703,"_30":22859},"xsf.statsFns.nbdtri","xsf.statsFns.nbdtri(k, n, p)","Negative binomial distribution inverse CDF.",[22856,22857,22858],{"_16":1114,"_22":5703,"_69":6},{"_16":362,"_22":5703,"_69":6},{"_16":1645,"_22":5703,"_69":6},[],{"_16":22861,"_18":22862,"_20":22863,"_22":5456,"_24":22864,"_28":5450,"_30":22866},"xsf.statsFns.kolmogorov","xsf.statsFns.kolmogorov(x)","kolmogorov",[22865],{"_16":498,"_22":22279,"_69":6},[],{"_16":22868,"_18":22869,"_20":22870,"_22":5456,"_24":22871,"_28":5450,"_30":22873},"xsf.statsFns.kolmogi","xsf.statsFns.kolmogi(p)","kolmogi",[22872],{"_16":1645,"_22":22279,"_69":6},[],{"_16":22875,"_18":22876,"_20":22877,"_22":5456,"_24":22878,"_28":5450,"_30":22881},"xsf.statsFns.smirnov","xsf.statsFns.smirnov(n, x)","smirnov",[22879,22880],{"_16":362,"_22":5703,"_69":6},{"_16":498,"_22":22279,"_69":6},[],{"_16":22883,"_18":22884,"_20":22885,"_22":5456,"_24":22886,"_28":5450,"_30":22889},"xsf.statsFns.smirnovi","xsf.statsFns.smirnovi(n, p)","smirnovi",[22887,22888],{"_16":362,"_22":5703,"_69":6},{"_16":1645,"_22":22279,"_69":6},[],{"_16":22891,"_18":22892,"_20":22893,"_22":22894,"_24":22895,"_28":5703,"_30":22901},"xsf.statsFns.owensT","xsf.statsFns.owensT(h, a)","Owen's T function.\r","Owen's T function.\r\n\r\nT(h, a) = (1/2π) ∫₀^a exp(-h²(1+x²)/2) / (1+x²) dx\r\n\r\nUseful for computing bivariate normal probabilities.",[22896,22899],{"_16":22897,"_22":22898,"_69":6},"h","- First parameter",{"_16":433,"_22":22900,"_69":6},"- Second parameter",[],{"_16":22903,"_18":22904,"_20":22905,"_22":5456,"_24":22906,"_28":1426,"_30":22909},"xsf.configureXSF","xsf.configureXSF(config)","configureXSF",[22907],{"_16":8097,"_22":22908,"_69":6},"XSFLoadConfig",[],{"_16":22911,"_18":22912,"_20":22913,"_22":5456,"_24":22914,"_28":22915,"_30":22916},"xsf.getXSFModule","xsf.getXSFModule()","getXSFModule",[],"XSFModule",[],{"_16":22918,"_18":22919,"_20":22920,"_22":5456,"_24":22921,"_28":6903,"_30":22922},"xsf.isXSFLoaded","xsf.isXSFLoaded()","isXSFLoaded",[],[],{"_16":22924,"_18":22925,"_20":22926,"_22":5456,"_24":22927,"_28":22928,"_30":22929},"xsf.loadXSFModule","xsf.loadXSFModule()","loadXSFModule",[],"Promise",[],{"_16":22931,"_18":22932,"_20":22933,"_22":5456,"_24":22934,"_28":1426,"_30":22935},"xsf.resetXSFModule","xsf.resetXSFModule()","resetXSFModule",[],[],"actionData","errors"]

vtk.colormap

Syntax

Description

Parameters

Returns

Examples

See Also