[{"_1":2,"_22940":-5,"_22941":-5},"loaderData",{"_3":4,"_15":16},"root",{"_5":6,"_7":-5,"_8":9,"_11":12,"_13":14},"isAuthenticated",false,"user","features",{"_10":6},"billing","sentryDsn","https://44e842762f9225365bf1e143317d3fb2@o4510459115012096.ingest.de.sentry.io/4510877137567824","deployEnv","production","routes/functions.$functionId",{"_17":18,"_36":37,"_1335":1336},"function",{"_19":20,"_21":22,"_23":24,"_25":24,"_26":27,"_32":33,"_34":35},"name","slu.matrix.getTransposeCSR","signature","slu.matrix.getTransposeCSR(A)","summary","Compute the transpose of a CSR matrix.","description","params",[28],{"_19":29,"_25":30,"_31":6},"A","- Sparse matrix in CSR format","optional","returns","SparseMatrixCSR","examples",[],"package",{"_38":39,"_19":40,"_25":41,"_42":43,"_44":45,"_46":47,"_48":49},"id","slu-generated","Sparse Direct Solver (SuperLU)","SuperLU sparse direct solver.","tier","free","icon","⚡","namespace","slu","functions",[50,64,80,101,113,129,138,150,157,167,175,182,193,204,220,229,238,251,263,274,282,292,300,310,318,330,340,348,358,370,379,386,393,408,420,429,439,448,457,466,476,484,492,499,506,514,521,531,539,552,561,571,577,586,596,611,622,632,642,653,664,673,680,700,720,737,754,764,773,780,788,804,814,822,18,830,842,850,858,866,874,881,892,900,909,920,931,940,954,964,974,982,991,1001,1013,1023,1032,1046,1056,1065,1082,1095,1109,1122,1132,1142,1152,1163,1176,1190,1204,1216,1227,1241,1251,1262,1272,1282,1297,1304,1311,1319,1327],{"_19":51,"_21":52,"_23":53,"_25":54,"_26":55,"_32":62,"_34":63},"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)",[56,58],{"_19":29,"_25":57,"_31":6},"- Sparse matrix in CSC format",{"_19":59,"_25":60,"_31":61},"normType","- Type of norm to compute",true,"MatrixNormResult",[],{"_19":65,"_21":66,"_23":67,"_25":68,"_26":69,"_32":78,"_34":79},"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.",[70,73,75],{"_19":71,"_25":72,"_31":6},"lu","- LU factorization from sparseLU()",{"_19":59,"_25":74,"_31":61},"- Norm type for the estimate",{"_19":76,"_25":77,"_31":61},"matrixNorm","- Original matrix norm ||A|| (optional, will compute if not provided)","ConditionNumberResult",[],{"_19":81,"_21":82,"_23":83,"_25":84,"_26":85,"_32":99,"_34":100},"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.",[86,88,90,93,96],{"_19":29,"_25":87,"_31":6},"- Original sparse matrix in CSC format",{"_19":71,"_25":89,"_31":6},"- Pre-computed LU factorization",{"_19":91,"_25":92,"_31":6},"b","- Right-hand side vector",{"_19":94,"_25":95,"_31":6},"x","- Initial solution to refine (will be modified in place)",{"_19":97,"_25":98,"_31":61},"options","- Refinement options","RefinementResult",[],{"_19":102,"_21":103,"_23":104,"_25":105,"_26":106,"_32":111,"_34":112},"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",[107,108],{"_19":29,"_25":57,"_31":6},{"_19":109,"_25":110,"_31":61},"columnPermutation","- Optional column permutation","EliminationTreeResult",[],{"_19":114,"_21":115,"_23":116,"_25":117,"_26":118,"_32":127,"_34":128},"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.",[119,122,124],{"_19":120,"_25":121,"_31":6},"etree","- Elimination tree from getEliminationTree",{"_19":29,"_25":123,"_31":6},"- Original sparse matrix",{"_19":125,"_25":126,"_31":61},"_columnPermutation","IntArray","EliminationTreeStatistics",[],{"_19":130,"_21":131,"_23":132,"_25":133,"_26":134,"_32":136,"_34":137},"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.",[135],{"_19":29,"_25":57,"_31":6},"number",[],{"_19":139,"_21":140,"_23":141,"_25":142,"_26":143,"_32":148,"_34":149},"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.",[144,145],{"_19":29,"_25":57,"_31":6},{"_19":146,"_25":147,"_31":6},"perm","- Column permutation","FillInPrediction",[],{"_19":151,"_21":152,"_23":153,"_25":153,"_26":154,"_32":155,"_34":156},"slu.core.clearSolveHistory","slu.core.clearSolveHistory()","Clear the solve history.",[],"void",[],{"_19":158,"_21":159,"_23":160,"_25":161,"_26":162,"_32":155,"_34":166},"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)",[163],{"_19":164,"_25":165,"_31":61},"level","- Logging level (0-3)",[],{"_19":168,"_21":169,"_23":170,"_25":171,"_26":172,"_32":173,"_34":174},"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",[],{"_19":176,"_21":177,"_23":178,"_25":178,"_26":179,"_32":180,"_34":181},"slu.core.getLoggingLevel","slu.core.getLoggingLevel()","Get the current logging level.",[],"LogLevel",[],{"_19":183,"_21":184,"_23":185,"_25":186,"_26":187,"_32":191,"_34":192},"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.",[188],{"_19":189,"_25":190,"_31":61},"limit","- Maximum number of records to return","SolveRecord[]",[],{"_19":194,"_21":195,"_23":196,"_25":197,"_26":198,"_32":202,"_34":203},"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",[199],{"_19":200,"_25":201,"_31":6},"errorCode","- Error code from SuperLU","SuperLUError",[],{"_19":205,"_21":206,"_23":207,"_25":208,"_26":209,"_32":136,"_34":219},"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",[210,213,216],{"_19":211,"_25":212,"_31":6},"module","- SuperLU WASM module",{"_19":214,"_25":215,"_31":6},"values","- Initial values, or null for uninitialized allocation",{"_19":217,"_25":218,"_31":61},"size","- Size to allocate (defaults to values.length)",[],{"_19":221,"_21":222,"_23":223,"_25":223,"_26":224,"_32":136,"_34":228},"slu.core.allocateFloats","slu.core.allocateFloats(module, values, size?)","Allocate a Float32Array in WASM memory and optionally initialize with values.",[225,226,227],{"_19":211,"_25":212,"_31":6},{"_19":214,"_25":215,"_31":6},{"_19":217,"_25":218,"_31":61},[],{"_19":230,"_21":231,"_23":232,"_25":232,"_26":233,"_32":136,"_34":237},"slu.core.allocateInts","slu.core.allocateInts(module, values, size?)","Allocate an Int32Array in WASM memory and optionally initialize with values.",[234,235,236],{"_19":211,"_25":212,"_31":6},{"_19":214,"_25":215,"_31":6},{"_19":217,"_25":218,"_31":61},[],{"_19":239,"_21":240,"_23":241,"_25":241,"_26":242,"_32":136,"_34":250},"slu.core.allocateValues","slu.core.allocateValues(module, values, dtype, size?)","Allocate values based on data type.",[243,244,246,249],{"_19":211,"_25":212,"_31":6},{"_19":214,"_25":245,"_31":6},"- Initial values",{"_19":247,"_25":248,"_31":6},"dtype","- Data type",{"_19":217,"_25":136,"_31":61},[],{"_19":252,"_21":253,"_23":254,"_25":254,"_26":255,"_32":155,"_34":262},"slu.core.checkSuperLUError","slu.core.checkSuperLUError(info, routine)","Check SuperLU return code and throw if error.",[256,259],{"_19":257,"_25":258,"_31":6},"info","- Info code from SuperLU routine",{"_19":260,"_25":261,"_31":6},"routine","- Name of the routine",[],{"_19":264,"_21":265,"_23":266,"_25":267,"_26":268,"_32":155,"_34":273},"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).",[269,270],{"_19":211,"_25":212,"_31":6},{"_19":271,"_25":272,"_31":6},"ptrs","- Array of pointers to free",[],{"_19":275,"_21":276,"_23":277,"_25":277,"_26":278,"_32":136,"_34":281},"slu.core.getElementSize","slu.core.getElementSize(dtype)","Get element size in bytes for a data type.",[279],{"_19":247,"_25":280,"_31":6},"DataType",[],{"_19":283,"_21":284,"_23":285,"_25":285,"_26":286,"_32":290,"_34":291},"slu.core.getSuperLUErrorMessage","slu.core.getSuperLUErrorMessage(info, routine?)","Get error message for a SuperLU info code.",[287,288],{"_19":257,"_25":258,"_31":6},{"_19":260,"_25":289,"_31":61},"- Name of the routine (for context)","string",[],{"_19":293,"_21":294,"_23":295,"_25":295,"_26":296,"_32":298,"_34":299},"slu.core.isComplexType","slu.core.isComplexType(dtype)","Check if a data type is complex.",[297],{"_19":247,"_25":280,"_31":6},"boolean",[],{"_19":301,"_21":302,"_23":303,"_25":303,"_26":304,"_32":136,"_34":309},"slu.core.readByte","slu.core.readByte(module, ptr)","Read a single byte/char from WASM memory.",[305,306],{"_19":211,"_25":212,"_31":6},{"_19":307,"_25":308,"_31":6},"ptr","- Pointer to read from",[],{"_19":311,"_21":312,"_23":313,"_25":313,"_26":314,"_32":136,"_34":317},"slu.core.readDouble","slu.core.readDouble(module, ptr)","Read a single double from WASM memory.",[315,316],{"_19":211,"_25":212,"_31":6},{"_19":307,"_25":308,"_31":6},[],{"_19":319,"_21":320,"_23":321,"_25":321,"_26":322,"_32":328,"_34":329},"slu.core.readDoubles","slu.core.readDoubles(module, ptr, length)","Read doubles from WASM memory.",[323,324,325],{"_19":211,"_25":212,"_31":6},{"_19":307,"_25":308,"_31":6},{"_19":326,"_25":327,"_31":6},"length","- Number of elements to read","Float64Array",[],{"_19":331,"_21":332,"_23":333,"_25":333,"_26":334,"_32":338,"_34":339},"slu.core.readFloats","slu.core.readFloats(module, ptr, length)","Read floats from WASM memory.",[335,336,337],{"_19":211,"_25":212,"_31":6},{"_19":307,"_25":308,"_31":6},{"_19":326,"_25":327,"_31":6},"Float32Array",[],{"_19":341,"_21":342,"_23":343,"_25":343,"_26":344,"_32":136,"_34":347},"slu.core.readInt","slu.core.readInt(module, ptr)","Read a single integer from WASM memory.",[345,346],{"_19":211,"_25":212,"_31":6},{"_19":307,"_25":308,"_31":6},[],{"_19":349,"_21":350,"_23":351,"_25":351,"_26":352,"_32":356,"_34":357},"slu.core.readInts","slu.core.readInts(module, ptr, length)","Read integers from WASM memory.",[353,354,355],{"_19":211,"_25":212,"_31":6},{"_19":307,"_25":308,"_31":6},{"_19":326,"_25":327,"_31":6},"Int32Array",[],{"_19":359,"_21":360,"_23":361,"_25":361,"_26":362,"_32":368,"_34":369},"slu.core.readValues","slu.core.readValues(module, ptr, length, dtype)","Read values based on data type.",[363,364,365,367],{"_19":211,"_25":212,"_31":6},{"_19":307,"_25":308,"_31":6},{"_19":326,"_25":366,"_31":6},"- Number of elements",{"_19":247,"_25":248,"_31":6},"Float64Array | Float32Array",[],{"_19":371,"_21":372,"_23":373,"_25":373,"_26":374,"_32":338,"_34":378},"slu.core.toFloat32Array","slu.core.toFloat32Array(arr)","Convert a JavaScript array to Float32Array.",[375],{"_19":376,"_25":377,"_31":6},"arr","RealArray",[],{"_19":380,"_21":381,"_23":382,"_25":382,"_26":383,"_32":328,"_34":385},"slu.core.toFloat64Array","slu.core.toFloat64Array(arr)","Convert a JavaScript array to Float64Array.",[384],{"_19":376,"_25":377,"_31":6},[],{"_19":387,"_21":388,"_23":389,"_25":389,"_26":390,"_32":356,"_34":392},"slu.core.toInt32Array","slu.core.toInt32Array(arr)","Convert a JavaScript array to Int32Array.",[391],{"_19":376,"_25":126,"_31":6},[],{"_19":394,"_21":395,"_23":396,"_25":397,"_26":398,"_32":406,"_34":407},"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.",[399,400,403],{"_19":211,"_25":212,"_31":6},{"_19":401,"_25":402,"_31":6},"allocations","- Object mapping names to allocation functions",{"_19":404,"_25":405,"_31":6},"fn","- Function to execute with allocated pointers","Promise",[],{"_19":409,"_21":410,"_23":411,"_25":411,"_26":412,"_32":155,"_34":419},"slu.core.writeByte","slu.core.writeByte(module, ptr, value)","Write a single byte to WASM memory.",[413,414,416],{"_19":211,"_25":212,"_31":6},{"_19":307,"_25":415,"_31":6},"- Pointer to write to",{"_19":417,"_25":418,"_31":6},"value","- Value to write",[],{"_19":421,"_21":422,"_23":423,"_25":423,"_26":424,"_32":155,"_34":428},"slu.core.writeDouble","slu.core.writeDouble(module, ptr, value)","Write a single double to WASM memory.",[425,426,427],{"_19":211,"_25":212,"_31":6},{"_19":307,"_25":415,"_31":6},{"_19":417,"_25":418,"_31":6},[],{"_19":430,"_21":431,"_23":432,"_25":432,"_26":433,"_32":155,"_34":438},"slu.core.writeDoubles","slu.core.writeDoubles(module, ptr, values)","Write doubles to WASM memory.",[434,435,436],{"_19":211,"_25":212,"_31":6},{"_19":307,"_25":415,"_31":6},{"_19":214,"_25":437,"_31":6},"- Values to write",[],{"_19":440,"_21":441,"_23":442,"_25":442,"_26":443,"_32":155,"_34":447},"slu.core.writeFloats","slu.core.writeFloats(module, ptr, values)","Write floats to WASM memory.",[444,445,446],{"_19":211,"_25":212,"_31":6},{"_19":307,"_25":415,"_31":6},{"_19":214,"_25":437,"_31":6},[],{"_19":449,"_21":450,"_23":451,"_25":451,"_26":452,"_32":155,"_34":456},"slu.core.writeInt","slu.core.writeInt(module, ptr, value)","Write a single integer to WASM memory.",[453,454,455],{"_19":211,"_25":212,"_31":6},{"_19":307,"_25":415,"_31":6},{"_19":417,"_25":418,"_31":6},[],{"_19":458,"_21":459,"_23":460,"_25":460,"_26":461,"_32":155,"_34":465},"slu.core.writeInts","slu.core.writeInts(module, ptr, values)","Write integers to WASM memory.",[462,463,464],{"_19":211,"_25":212,"_31":6},{"_19":307,"_25":415,"_31":6},{"_19":214,"_25":437,"_31":6},[],{"_19":467,"_21":468,"_23":469,"_25":470,"_26":471,"_32":155,"_34":475},"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.",[472],{"_19":473,"_25":474,"_31":6},"config","- Configuration options specifying WASM file locations",[],{"_19":477,"_21":478,"_23":479,"_25":480,"_26":481,"_32":482,"_34":483},"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",[],{"_19":485,"_21":486,"_23":487,"_25":488,"_26":489,"_32":490,"_34":491},"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",[],{"_19":493,"_21":494,"_23":495,"_25":496,"_26":497,"_32":298,"_34":498},"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 .",[],[],{"_19":500,"_21":501,"_23":502,"_25":503,"_26":504,"_32":298,"_34":505},"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.",[],[],{"_19":507,"_21":508,"_23":509,"_25":510,"_26":511,"_32":512,"_34":513},"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",[],{"_19":515,"_21":516,"_23":517,"_25":518,"_26":519,"_32":155,"_34":520},"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.",[],[],{"_19":522,"_21":523,"_23":524,"_25":525,"_26":526,"_32":529,"_34":530},"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.",[527],{"_19":217,"_25":528,"_31":6},"- Size in bytes to allocate","WorkspaceAllocation",[],{"_19":532,"_21":533,"_23":534,"_25":534,"_26":535,"_32":155,"_34":538},"slu.core.deallocateWorkspace","slu.core.deallocateWorkspace(ptr)","Deallocate a previously allocated workspace.",[536],{"_19":307,"_25":537,"_31":6},"- WASM pointer from allocateWorkspace",[],{"_19":540,"_21":541,"_23":542,"_25":543,"_26":544,"_32":550,"_34":551},"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.",[545,547],{"_19":29,"_25":546,"_31":6},"- Sparse matrix",{"_19":548,"_25":549,"_31":61},"_options","LUFactorizationOptions","MemoryEstimate",[],{"_19":553,"_21":554,"_23":555,"_25":556,"_26":557,"_32":155,"_34":560},"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.",[558],{"_19":71,"_25":559,"_31":6},"- LU factorization to free",[],{"_19":562,"_21":563,"_23":564,"_25":565,"_26":566,"_32":569,"_34":570},"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.",[567],{"_19":71,"_25":568,"_31":6},"- LU factorization","MemoryUsage",[],{"_19":572,"_21":573,"_23":574,"_25":574,"_26":575,"_32":136,"_34":576},"slu.core.getWorkspaceSize","slu.core.getWorkspaceSize()","Get the current global workspace size limit.",[],[],{"_19":578,"_21":579,"_23":580,"_25":581,"_26":582,"_32":584,"_34":585},"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.",[583],{"_19":71,"_25":568,"_31":6},"FactorStatistics",[],{"_19":587,"_21":588,"_23":589,"_25":590,"_26":591,"_32":155,"_34":595},"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.",[592],{"_19":593,"_25":594,"_31":6},"bytes","- Maximum workspace size in bytes (0 for unlimited)",[],{"_19":597,"_21":598,"_23":599,"_25":600,"_26":601,"_32":609,"_34":610},"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).",[602,603,606],{"_19":29,"_25":87,"_31":6},{"_19":604,"_25":605,"_31":6},"rowScale","- Row scaling factors",{"_19":607,"_25":608,"_31":6},"columnScale","- Column scaling factors","SparseMatrixCSC",[],{"_19":612,"_21":613,"_23":614,"_25":615,"_26":616,"_32":620,"_34":621},"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.",[617,618],{"_19":29,"_25":57,"_31":6},{"_19":97,"_25":619,"_31":61},"- Equilibration options","EquilibrationScaling",[],{"_19":623,"_21":624,"_23":625,"_25":626,"_26":627,"_32":328,"_34":631},"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.",[628,630],{"_19":91,"_25":629,"_31":6},"- Original right-hand side vector",{"_19":604,"_25":605,"_31":6},[],{"_19":633,"_21":634,"_23":635,"_25":636,"_26":637,"_32":328,"_34":641},"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.",[638,640],{"_19":94,"_25":639,"_31":6},"- Solution of the scaled system",{"_19":607,"_25":608,"_31":6},[],{"_19":643,"_21":644,"_23":645,"_25":646,"_26":647,"_32":651,"_34":652},"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",[648,649],{"_19":29,"_25":57,"_31":6},{"_19":97,"_25":650,"_31":61},"- ILU factorization options","ILUFactorization",[],{"_19":654,"_21":655,"_23":656,"_25":657,"_26":658,"_32":662,"_34":663},"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.",[659,660],{"_19":29,"_25":57,"_31":6},{"_19":97,"_25":661,"_31":61},"- Factorization options","LUFactorization",[],{"_19":665,"_21":666,"_23":667,"_25":667,"_26":668,"_32":609,"_34":672},"slu.matrix.cooToCSC","slu.matrix.cooToCSC(coo)","Convert COO format to CSC format.",[669],{"_19":670,"_25":671,"_31":6},"coo","- COO sparse matrix",[],{"_19":674,"_21":675,"_23":676,"_25":676,"_26":677,"_32":33,"_34":679},"slu.matrix.cooToCSR","slu.matrix.cooToCSR(coo)","Convert COO format to CSR format.",[678],{"_19":670,"_25":671,"_31":6},[],{"_19":681,"_21":682,"_23":683,"_25":684,"_26":685,"_32":698,"_34":699},"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.",[686,689,692,695],{"_19":687,"_25":688,"_31":6},"data","- Matrix data",{"_19":690,"_25":691,"_31":6},"m","- Number of rows",{"_19":693,"_25":694,"_31":6},"n","- Number of columns",{"_19":696,"_25":697,"_31":61},"rowMajor","- If true, data is in row-major order (default: false)","DenseMatrix",[],{"_19":701,"_21":702,"_23":703,"_25":704,"_26":705,"_32":718,"_34":719},"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.",[706,707,708,711,714,716],{"_19":690,"_25":691,"_31":6},{"_19":693,"_25":694,"_31":6},{"_19":709,"_25":710,"_31":6},"rows","- Row indices for each nonzero",{"_19":712,"_25":713,"_31":6},"cols","- Column indices for each nonzero",{"_19":214,"_25":715,"_31":6},"- Nonzero values",{"_19":247,"_25":717,"_31":61},"- Data type (default: 'float64')","SparseMatrixCOO",[],{"_19":721,"_21":722,"_23":723,"_25":724,"_26":725,"_32":609,"_34":736},"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",[726,727,728,731,734,735],{"_19":690,"_25":691,"_31":6},{"_19":693,"_25":694,"_31":6},{"_19":729,"_25":730,"_31":6},"rowIndices","- Row index for each nonzero",{"_19":732,"_25":733,"_31":6},"colPointers","- Column pointers (length n+1)",{"_19":214,"_25":715,"_31":6},{"_19":247,"_25":717,"_31":61},[],{"_19":738,"_21":739,"_23":740,"_25":741,"_26":742,"_32":33,"_34":753},"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",[743,744,745,748,751,752],{"_19":690,"_25":691,"_31":6},{"_19":693,"_25":694,"_31":6},{"_19":746,"_25":747,"_31":6},"colIndices","- Column index for each nonzero",{"_19":749,"_25":750,"_31":6},"rowPointers","- Row pointers (length m+1)",{"_19":214,"_25":715,"_31":6},{"_19":247,"_25":717,"_31":61},[],{"_19":755,"_21":756,"_23":757,"_25":757,"_26":758,"_32":609,"_34":763},"slu.matrix.createSparseDiagonal","slu.matrix.createSparseDiagonal(diag, dtype?)","Create a sparse diagonal matrix in CSC format.",[759,762],{"_19":760,"_25":761,"_31":6},"diag","- Diagonal elements",{"_19":247,"_25":717,"_31":61},[],{"_19":765,"_21":766,"_23":767,"_25":767,"_26":768,"_32":609,"_34":772},"slu.matrix.createSparseIdentity","slu.matrix.createSparseIdentity(n, dtype?)","Create a sparse identity matrix in CSC format.",[769,771],{"_19":693,"_25":770,"_31":6},"- Size of the identity matrix",{"_19":247,"_25":717,"_31":61},[],{"_19":774,"_21":775,"_23":776,"_25":776,"_26":777,"_32":33,"_34":779},"slu.matrix.convertCSCtoCSR","slu.matrix.convertCSCtoCSR(A)","Convert a CSC matrix to CSR format.",[778],{"_19":29,"_25":57,"_31":6},[],{"_19":781,"_21":782,"_23":783,"_25":784,"_26":785,"_32":609,"_34":787},"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.",[786],{"_19":29,"_25":30,"_31":6},[],{"_19":789,"_21":790,"_23":791,"_25":791,"_26":792,"_32":802,"_34":803},"slu.matrix.denseToSparse","slu.matrix.denseToSparse(dense, format?, tolerance?)","Convert a dense matrix to sparse format.",[793,796,799],{"_19":794,"_25":795,"_31":6},"dense","- Dense matrix",{"_19":797,"_25":798,"_31":61},"format","- Output format ('csc' or 'csr')",{"_19":800,"_25":801,"_31":61},"tolerance","- Values with |v| < tolerance are treated as zero","SparseMatrix",[],{"_19":805,"_21":806,"_23":807,"_25":808,"_26":809,"_32":609,"_34":813},"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.",[810,811],{"_19":794,"_25":795,"_31":6},{"_19":800,"_25":812,"_31":61},"- Values with |v| < tolerance are treated as zero (default: 0)",[],{"_19":815,"_21":816,"_23":817,"_25":817,"_26":818,"_32":33,"_34":821},"slu.matrix.denseToSparseCSR","slu.matrix.denseToSparseCSR(dense, tolerance?)","Convert a dense matrix to sparse CSR format.",[819,820],{"_19":794,"_25":795,"_31":6},{"_19":800,"_25":812,"_31":61},[],{"_19":823,"_21":824,"_23":825,"_25":826,"_26":827,"_32":609,"_34":829},"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.",[828],{"_19":29,"_25":57,"_31":6},[],{"_19":831,"_21":832,"_23":833,"_25":834,"_26":835,"_32":698,"_34":841},"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.",[836,839],{"_19":837,"_25":838,"_31":6},"matrix","- Sparse matrix in any format",{"_19":696,"_25":840,"_31":61},"- If true, return row-major array (default: false, column-major)",[],{"_19":843,"_21":844,"_23":845,"_25":845,"_26":846,"_32":718,"_34":849},"slu.matrix.toCOO","slu.matrix.toCOO(matrix)","Convert any sparse matrix format to COO (coordinate) format.",[847],{"_19":837,"_25":848,"_31":6},"- Sparse matrix in any supported format",[],{"_19":851,"_21":852,"_23":853,"_25":854,"_26":855,"_32":609,"_34":857},"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.",[856],{"_19":837,"_25":848,"_31":6},[],{"_19":859,"_21":860,"_23":861,"_25":862,"_26":863,"_32":33,"_34":865},"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.",[864],{"_19":837,"_25":848,"_31":6},[],{"_19":867,"_21":868,"_23":869,"_25":869,"_26":870,"_32":802,"_34":873},"slu.matrix.copySparseMatrix","slu.matrix.copySparseMatrix(A)","Create a deep copy of a sparse matrix.",[871],{"_19":29,"_25":872,"_31":6},"- Sparse matrix to copy",[],{"_19":875,"_21":876,"_23":877,"_25":877,"_26":878,"_32":328,"_34":880},"slu.matrix.getDiagonal","slu.matrix.getDiagonal(A)","Get the diagonal elements of a sparse matrix.",[879],{"_19":29,"_25":546,"_31":6},[],{"_19":882,"_21":883,"_23":884,"_25":884,"_26":885,"_32":890,"_34":891},"slu.matrix.getMatrixNonzeros","slu.matrix.getMatrixNonzeros(A, maxEntries?)","Get information about the nonzero elements of a matrix.",[886,887],{"_19":29,"_25":546,"_31":6},{"_19":888,"_25":889,"_31":61},"maxEntries","- Maximum number of entries to list (default: all)","NonzeroInfo",[],{"_19":893,"_21":894,"_23":895,"_25":895,"_26":896,"_32":898,"_34":899},"slu.matrix.getMatrixStatistics","slu.matrix.getMatrixStatistics(A)","Compute statistics about a sparse matrix.",[897],{"_19":29,"_25":546,"_31":6},"MatrixStatistics",[],{"_19":901,"_21":902,"_23":903,"_25":904,"_26":905,"_32":907,"_34":908},"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).",[906],{"_19":29,"_25":546,"_31":6},"SparsityPattern",[],{"_19":910,"_21":911,"_23":912,"_25":913,"_26":914,"_32":918,"_34":919},"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.",[915,916],{"_19":29,"_25":57,"_31":6},{"_19":146,"_25":917,"_31":61},"- Column permutation (optional)","SupernodeStructure",[],{"_19":921,"_21":922,"_23":923,"_25":924,"_26":925,"_32":155,"_34":930},"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)",[926,928],{"_19":29,"_25":927,"_31":6},"- Sparse matrix (modified in-place)",{"_19":929,"_25":608,"_31":6},"scale",[],{"_19":932,"_21":933,"_23":934,"_25":935,"_26":936,"_32":155,"_34":939},"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",[937,938],{"_19":29,"_25":927,"_31":6},{"_19":929,"_25":605,"_31":6},[],{"_19":941,"_21":942,"_23":943,"_25":944,"_26":945,"_32":952,"_34":953},"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.",[946,948,950],{"_19":947,"_25":609,"_31":6},"_A",{"_19":949,"_25":662,"_31":6},"_lu",{"_19":951,"_25":136,"_31":61},"_tolerance","FactorizationCheckResult",[],{"_19":955,"_21":956,"_23":957,"_25":957,"_26":958,"_32":962,"_34":963},"slu.matrix.detectMatrixProperties","slu.matrix.detectMatrixProperties(A, tolerance?)","Detect various properties of a sparse matrix.",[959,960],{"_19":29,"_25":546,"_31":6},{"_19":800,"_25":961,"_31":61},"- Tolerance for numerical comparisons (default: 1e-14)","MatrixProperties",[],{"_19":965,"_21":966,"_23":967,"_25":968,"_26":969,"_32":298,"_34":973},"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).",[970,971],{"_19":29,"_25":546,"_31":6},{"_19":800,"_25":972,"_31":61},"- Tolerance for value comparison (default: 1e-14)",[],{"_19":975,"_21":976,"_23":977,"_25":978,"_26":979,"_32":298,"_34":981},"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.",[980],{"_19":29,"_25":546,"_31":6},[],{"_19":983,"_21":984,"_23":985,"_25":986,"_26":987,"_32":298,"_34":990},"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",[988,989],{"_19":29,"_25":546,"_31":6},{"_19":800,"_25":972,"_31":61},[],{"_19":992,"_21":993,"_23":994,"_25":995,"_26":996,"_32":999,"_34":1000},"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",[997],{"_19":29,"_25":998,"_31":6},"- Sparse matrix to validate","ValidationResult",[],{"_19":1002,"_21":1003,"_23":1004,"_25":1005,"_26":1006,"_32":1011,"_34":1012},"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)",[1007,1008],{"_19":29,"_25":57,"_31":6},{"_19":1009,"_25":1010,"_31":61},"strategy","- Permutation strategy","ColumnPermutationResult",[],{"_19":1014,"_21":1015,"_23":1016,"_25":1017,"_26":1018,"_32":1021,"_34":1022},"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.",[1019,1020],{"_19":29,"_25":57,"_31":6},{"_19":1009,"_25":1010,"_31":61},"RowPermutationResult",[],{"_19":1024,"_21":1025,"_23":1026,"_25":1027,"_26":1028,"_32":356,"_34":1031},"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.",[1029],{"_19":146,"_25":1030,"_31":6},"- Permutation array",[],{"_19":1033,"_21":1034,"_23":1035,"_25":1036,"_26":1037,"_32":609,"_34":1045},"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.",[1038,1039,1042],{"_19":29,"_25":57,"_31":6},{"_19":1040,"_25":1041,"_31":6},"rowPerm","- Row permutation (or null for identity)",{"_19":1043,"_25":1044,"_31":6},"colPerm","- Column permutation (or null for identity)",[],{"_19":1047,"_21":1048,"_23":1049,"_25":1050,"_26":1051,"_32":328,"_34":1055},"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.",[1052,1054],{"_19":94,"_25":1053,"_31":6},"- Input vector",{"_19":146,"_25":1030,"_31":6},[],{"_19":1057,"_21":1058,"_23":1059,"_25":1060,"_26":1061,"_32":328,"_34":1064},"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.",[1062,1063],{"_19":94,"_25":1053,"_31":6},{"_19":146,"_25":1030,"_31":6},[],{"_19":1066,"_21":1067,"_23":1068,"_25":1069,"_26":1070,"_32":1080,"_34":1081},"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.",[1071,1072,1075,1078],{"_19":29,"_25":57,"_31":6},{"_19":1073,"_25":1074,"_31":6},"B","- Right-hand side matrix (column-major, m x nrhs)",{"_19":1076,"_25":1077,"_31":6},"nrhs","- Number of right-hand sides (columns in B)",{"_19":97,"_25":1079,"_31":61},"- Solver options","BatchSolveResult",[],{"_19":1083,"_21":1084,"_23":1085,"_25":1086,"_26":1087,"_32":1093,"_34":1094},"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.",[1088,1090,1091],{"_19":71,"_25":1089,"_31":6},"- Pre-computed LU factorization from sparseLU()",{"_19":91,"_25":92,"_31":6},{"_19":97,"_25":1092,"_31":61},"- Solve options","ReusedFactorizationResult",[],{"_19":1096,"_21":1097,"_23":1098,"_25":1099,"_26":1100,"_32":1107,"_34":1108},"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",[1101,1102,1103,1106],{"_19":29,"_25":57,"_31":6},{"_19":91,"_25":92,"_31":6},{"_19":1104,"_25":1105,"_31":6},"deflationVectors","- Array of deflation vectors (columns of W)",{"_19":97,"_25":1079,"_31":61},"DeflationResult",[],{"_19":1110,"_21":1111,"_23":1112,"_25":1113,"_26":1114,"_32":1120,"_34":1121},"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`.",[1115,1117,1119],{"_19":29,"_25":1116,"_31":6},"- Sparse complex matrix in CSC format",{"_19":91,"_25":1118,"_31":6},"- Right-hand side vector (complex, interleaved)",{"_19":97,"_25":1079,"_31":61},"SolveResult",[],{"_19":1123,"_21":1124,"_23":1125,"_25":1126,"_26":1127,"_32":1120,"_34":1131},"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",[1128,1129,1130],{"_19":29,"_25":57,"_31":6},{"_19":91,"_25":92,"_31":6},{"_19":97,"_25":1079,"_31":61},[],{"_19":1133,"_21":1134,"_23":1135,"_25":1136,"_26":1137,"_32":1120,"_34":1141},"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.",[1138,1139,1140],{"_19":29,"_25":30,"_31":6},{"_19":91,"_25":92,"_31":6},{"_19":97,"_25":1079,"_31":61},[],{"_19":1143,"_21":1144,"_23":1145,"_25":1146,"_26":1147,"_32":1120,"_34":1151},"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.",[1148,1149,1150],{"_19":29,"_25":57,"_31":6},{"_19":91,"_25":92,"_31":6},{"_19":97,"_25":1079,"_31":61},[],{"_19":1153,"_21":1154,"_23":1155,"_25":1156,"_26":1157,"_32":1120,"_34":1162},"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",[1158,1159,1160],{"_19":29,"_25":57,"_31":6},{"_19":91,"_25":92,"_31":6},{"_19":97,"_25":1161,"_31":61},"- Expert solver options",[],{"_19":1164,"_21":1165,"_23":1166,"_25":1167,"_26":1168,"_32":1174,"_34":1175},"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.",[1169,1171,1173],{"_19":29,"_25":1170,"_31":6},"- Sparse matrix in CSC format (m x n, m >= n)",{"_19":91,"_25":1172,"_31":6},"- Right-hand side vector (length m)",{"_19":97,"_25":1079,"_31":61},"LeastSquaresResult",[],{"_19":1177,"_21":1178,"_23":1179,"_25":1180,"_26":1181,"_32":1188,"_34":1189},"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.",[1182,1183,1184,1185,1187],{"_19":29,"_25":87,"_31":6},{"_19":71,"_25":89,"_31":6},{"_19":91,"_25":92,"_31":6},{"_19":94,"_25":1186,"_31":6},"- Initial solution (from a previous solve)",{"_19":97,"_25":98,"_31":61},"RefinedSolveResult",[],{"_19":1191,"_21":1192,"_23":1193,"_25":1194,"_26":1195,"_32":1202,"_34":1203},"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.",[1196,1197,1200,1201],{"_19":29,"_25":57,"_31":6},{"_19":1198,"_25":1199,"_31":6},"shift","- Shift value σ",{"_19":91,"_25":92,"_31":6},{"_19":97,"_25":1079,"_31":61},"ShiftedSolveResult",[],{"_19":1205,"_21":1206,"_23":1207,"_25":1208,"_26":1209,"_32":1120,"_34":1215},"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.",[1210,1212,1214],{"_19":29,"_25":1211,"_31":6},"- Hermitian sparse matrix in CSC format",{"_19":91,"_25":1213,"_31":6},"- Right-hand side vector (complex, interleaved format)",{"_19":97,"_25":1079,"_31":61},[],{"_19":1217,"_21":1218,"_23":1219,"_25":1220,"_26":1221,"_32":1120,"_34":1226},"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).",[1222,1224,1225],{"_19":29,"_25":1223,"_31":6},"- Symmetric sparse matrix in CSC format (stored as triangle)",{"_19":91,"_25":92,"_31":6},{"_19":97,"_25":1079,"_31":61},[],{"_19":1228,"_21":1229,"_23":1230,"_25":1231,"_26":1232,"_32":1239,"_34":1240},"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).",[1233,1236,1237],{"_19":1234,"_25":1235,"_31":6},"T","- Sparse triangular matrix in CSC format",{"_19":91,"_25":92,"_31":6},{"_19":97,"_25":1238,"_31":61},"- Triangular solve options","TriangularSolveResult",[],{"_19":1242,"_21":1243,"_23":1244,"_25":1244,"_26":1245,"_32":1239,"_34":1250},"slu.solvers.solveTriangularCSR","slu.solvers.solveTriangularCSR(T, b, options?)","Solve a triangular system Tx = b where T is a sparse triangular CSR matrix.",[1246,1248,1249],{"_19":1234,"_25":1247,"_31":6},"- Sparse triangular matrix in CSR format",{"_19":91,"_25":92,"_31":6},{"_19":97,"_25":1238,"_31":61},[],{"_19":1252,"_21":1253,"_23":1254,"_25":1255,"_26":1256,"_32":1239,"_34":1261},"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.",[1257,1259,1260],{"_19":71,"_25":1258,"_31":6},"- LU factorization from sparseLU",{"_19":91,"_25":92,"_31":6},{"_19":97,"_25":1092,"_31":61},[],{"_19":1263,"_21":1264,"_23":1265,"_25":1266,"_26":1267,"_32":1239,"_34":1271},"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`.",[1268,1269,1270],{"_19":71,"_25":1258,"_31":6},{"_19":91,"_25":92,"_31":6},{"_19":97,"_25":1092,"_31":61},[],{"_19":1273,"_21":1274,"_23":1275,"_25":1276,"_26":1277,"_32":1239,"_34":1281},"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.",[1278,1279,1280],{"_19":71,"_25":1258,"_31":6},{"_19":91,"_25":92,"_31":6},{"_19":97,"_25":1092,"_31":61},[],{"_19":1283,"_21":1284,"_23":1285,"_25":1286,"_26":1287,"_32":1295,"_34":1296},"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)",[1288,1291,1293],{"_19":1289,"_25":1290,"_31":6},"type","- Type of test matrix to create",{"_19":693,"_25":1292,"_31":6},"- Matrix size (n x n)",{"_19":97,"_25":1294,"_31":61},"- Generation options","TestMatrixResult",[],{"_19":1298,"_21":1299,"_23":1300,"_25":1300,"_26":1301,"_32":1302,"_34":1303},"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}[]",[],{"_19":1305,"_21":1306,"_23":1307,"_25":1307,"_26":1308,"_32":136,"_34":1310},"slu.getNnz","slu.getNnz(matrix)","Get the number of nonzeros in a sparse matrix.",[1309],{"_19":837,"_25":802,"_31":6},[],{"_19":1312,"_21":1313,"_23":1314,"_25":1314,"_26":1315,"_32":280,"_34":1318},"slu.inferDataType","slu.inferDataType(arr)","Infer the data type from an array.",[1316],{"_19":376,"_25":1317,"_31":6},"RealArray | ComplexArray",[],{"_19":1320,"_21":1321,"_23":1322,"_25":1322,"_26":1323,"_32":1325,"_34":1326},"slu.isSparseMatrixCSC","slu.isSparseMatrixCSC(matrix)","Check if a sparse matrix is in CSC format.",[1324],{"_19":837,"_25":802,"_31":6},"matrix is SparseMatrixCSC",[],{"_19":1328,"_21":1329,"_23":1330,"_25":1330,"_26":1331,"_32":1333,"_34":1334},"slu.isSparseMatrixCSR","slu.isSparseMatrixCSR(matrix)","Check if a sparse matrix is in CSR format.",[1332],{"_19":837,"_25":802,"_31":6},"matrix is SparseMatrixCSR",[],"allPackages",[1337,2446,2804,3001,3610,4768,4969,5274,5655,9491,10238,16149,16365,17798,19896,20157,21198,37,22270],{"_38":1338,"_19":1339,"_25":1340,"_42":43,"_44":1341,"_48":1342},"core","Core Functions","Essential functions for array creation, mathematics, aggregation, and manipulation. Always available.","🔧",[1343,1368,1381,1395,1416,1436,1455,1468,1480,1506,1527,1561,1579,1591,1603,1616,1626,1639,1653,1668,1679,1690,1708,1721,1733,1745,1759,1773,1785,1796,1806,1829,1845,1858,1870,1882,1894,1915,1931,1958,1976,1987,1999,2010,2026,2040,2054,2071,2082,2093,2108,2124,2136,2148,2168,2180,2200,2219,2232,2246,2260,2273,2294,2312,2333,2346,2360,2378,2393,2406,2417,2428],{"_19":1344,"_21":1345,"_23":1346,"_25":1347,"_26":1348,"_32":1353,"_34":1354,"_1363":1364},"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.",[1349,1351],{"_19":690,"_25":1350},"Number of rows",{"_19":693,"_25":1352,"_31":61},"Number of columns","NDArray of zeros with the given shape",[1355,1360],{"_1356":1357,"_1358":1359},"code","zeros(3)","output","0 0 0\n0 0 0\n0 0 0",{"_1356":1361,"_1358":1362},"zeros(2, 4)","0 0 0 0\n0 0 0 0","seeAlso",[1365,1366,1367],"ones","eye","rand",{"_19":1365,"_21":1369,"_23":1370,"_25":1371,"_26":1372,"_32":1375,"_34":1376,"_1363":1380},"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.",[1373,1374],{"_19":690,"_25":1350},{"_19":693,"_25":1352,"_31":61},"NDArray of ones with the given shape",[1377],{"_1356":1378,"_1358":1379},"ones(2, 3)","1 1 1\n1 1 1",[1344,1366],{"_19":1366,"_21":1382,"_23":1383,"_25":1384,"_26":1385,"_32":1388,"_34":1389,"_1363":1393},"I = eye(n)","Identity matrix","Creates an n×n identity matrix with ones on the diagonal and zeros elsewhere.",[1386],{"_19":693,"_25":1387},"Size of the square matrix","n×n identity NDArray",[1390],{"_1356":1391,"_1358":1392},"eye(3)","1 0 0\n0 1 0\n0 0 1",[1344,1365,760,1394],"magic",{"_19":1394,"_21":1396,"_23":1397,"_25":1398,"_26":1399,"_32":1402,"_34":1403,"_1363":1413},"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.",[1400],{"_19":693,"_25":1401},"Size of the magic square (n ≥ 1)","n×n magic square NDArray",[1404,1407,1410],{"_1356":1405,"_1358":1406},"magic(3)","8 1 6\n3 5 7\n4 9 2",{"_1356":1408,"_1358":1409},"magic(4)","16 2 3 13\n 5 11 10 8\n 9 7 6 12\n 4 14 15 1",{"_1356":1411,"_1358":1412},"sum(magic(5))","65 65 65 65 65",[1366,1365,1344,1414,1415],"pascal","hilb",{"_19":1417,"_21":1418,"_23":1419,"_25":1420,"_26":1421,"_32":1429,"_34":1430,"_1363":1434},"linspace","v = linspace(a, b, n)","Generate linearly spaced vector","Returns a row vector of `n` evenly spaced points between `a` and `b` (inclusive).",[1422,1425,1427],{"_19":1423,"_25":1424},"a","Start value",{"_19":91,"_25":1426},"End value",{"_19":693,"_25":1428},"Number of points","1×n NDArray",[1431],{"_1356":1432,"_1358":1433},"linspace(0, 1, 5)","0 0.25 0.5 0.75 1",[1435,1344,1365],"logspace",{"_19":1435,"_21":1437,"_23":1438,"_25":1439,"_26":1440,"_32":1429,"_34":1447,"_1363":1454},"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.",[1441,1443,1445],{"_19":1423,"_25":1442},"Exponent of start value (10^a)",{"_19":91,"_25":1444},"Exponent of end value (10^b)",{"_19":693,"_25":1446,"_31":61},"Number of points (default: 50)",[1448,1451],{"_1356":1449,"_1358":1450},"logspace(0, 2, 5)","1 3.1623 10 31.623 100",{"_1356":1452,"_1358":1453},"logspace(-2, 0, 3)","0.01 0.1 1",[1417,1344,1365],{"_19":1367,"_21":1456,"_23":1457,"_25":1458,"_26":1459,"_32":1462,"_34":1463,"_1363":1466},"R = rand(n)\nR = rand(m, n)","Uniformly distributed random numbers","Creates an array of uniformly distributed random numbers in the interval (0, 1).",[1460,1461],{"_19":690,"_25":1350},{"_19":693,"_25":1352,"_31":61},"NDArray of random values in (0, 1)",[1464],{"_1356":1465},"rand(2, 3)",[1467,1344],"randn",{"_19":1467,"_21":1469,"_23":1470,"_25":1471,"_26":1472,"_32":1475,"_34":1476,"_1363":1479},"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).",[1473,1474],{"_19":690,"_25":1350},{"_19":693,"_25":1352,"_31":61},"NDArray of normally distributed random values",[1477],{"_1356":1478},"randn(2, 3)",[1367],{"_19":1481,"_21":1482,"_23":1483,"_25":1484,"_26":1485,"_32":1494,"_34":1495,"_1363":1503},"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.",[1486,1488,1491],{"_19":94,"_25":1487},"X-coordinate vector",{"_19":1489,"_25":1490,"_31":61},"y","Y-coordinate vector (defaults to x if omitted)",{"_19":1492,"_25":1493,"_31":61},"indexing","Indexing mode: 'xy' (default, MATLAB style) or 'ij' (NumPy matrix style)","Two NDArrays [X, Y] of coordinate matrices",[1496,1498,1500],{"_1356":1497},"[X, Y] = meshgrid(1:3, 1:2)",{"_1356":1499},"[X, Y] = meshgrid(-2:0.5:2)",{"_1356":1501,"_1358":1502},"[X, Y] = meshgrid(1:3, 1:5, 'ij')","% X is 3x5, Y is 3x5 (NumPy style)",[1504,1505,1417],"surf","mesh",{"_19":1507,"_21":1508,"_23":1509,"_25":1510,"_26":1511,"_32":1514,"_34":1515,"_1363":1525},"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.",[1512],{"_19":693,"_25":1513,"_31":61},"Grid size (default: 49). Returns an n×n matrix.","n×n NDArray of Z values, or [X, Y, Z] coordinate matrices",[1516,1519,1522],{"_1356":1517,"_1358":1518},"surf(peaks())","% 49×49 surface plot",{"_1356":1520,"_1358":1521},"Z = peaks(30)","% 30×30 matrix",{"_1356":1523,"_1358":1524},"[X, Y, Z] = peaks(25)","% Returns all coordinate matrices",[1504,1505,1481,1526],"gallery",{"_19":1526,"_21":1528,"_23":1529,"_25":1530,"_26":1531,"_32":1540,"_34":1541,"_1363":1557},"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'.",[1532,1535,1537],{"_19":1533,"_25":1534},"matname","Name of the test matrix type (string)",{"_19":693,"_25":1536,"_31":61},"Size or first parameter (depends on matrix type)",{"_19":1538,"_25":1539,"_31":61},"...","Additional parameters (depends on matrix type)","Test matrix of the specified type",[1542,1545,1548,1551,1554],{"_1356":1543,"_1358":1544},"gallery('hilb', 4)","4×4 Hilbert matrix",{"_1356":1546,"_1358":1547},"gallery('pascal', 5)","5×5 Pascal matrix",{"_1356":1549,"_1358":1550},"gallery('lehmer', 3)","1.0000 0.5000 0.3333\n0.5000 1.0000 0.6667\n0.3333 0.6667 1.0000",{"_1356":1552,"_1358":1553},"gallery('pei', 3, 2)","3×3 Pei matrix with alpha=2",{"_1356":1555,"_1358":1556},"gallery('kms', 4, 0.5)","4×4 KMS Toeplitz matrix with rho=0.5",[1415,1558,1414,1394,1559,1560],"invhilb","toeplitz","hankel",{"_19":1562,"_21":1563,"_23":1564,"_25":1565,"_26":1566,"_32":1570,"_34":1571,"_1363":1575},"sin","Y = sin(X)","Sine of argument in radians","Computes the sine of each element. Operates element-wise on arrays.",[1567],{"_19":1568,"_25":1569},"X","Input angle in radians (scalar or NDArray)","Sine values (same shape as input)",[1572],{"_1356":1573,"_1358":1574},"sin(pi/2)","1",[1576,1577,1578],"cos","tan","asin",{"_19":1576,"_21":1580,"_23":1581,"_25":1582,"_26":1583,"_32":1585,"_34":1586,"_1363":1589},"Y = cos(X)","Cosine of argument in radians","Computes the cosine of each element. Operates element-wise on arrays.",[1584],{"_19":1568,"_25":1569},"Cosine values (same shape as input)",[1587],{"_1356":1588,"_1358":1574},"cos(0)",[1562,1577,1590],"acos",{"_19":1577,"_21":1592,"_23":1593,"_25":1594,"_26":1595,"_32":1597,"_34":1598,"_1363":1601},"Y = tan(X)","Tangent of argument in radians","Computes the tangent of each element. Operates element-wise on arrays.",[1596],{"_19":1568,"_25":1569},"Tangent values (same shape as input)",[1599],{"_1356":1600,"_1358":1574},"tan(pi/4)",[1562,1576,1602],"atan",{"_19":1578,"_21":1604,"_23":1605,"_25":1606,"_26":1607,"_32":1610,"_34":1611,"_1363":1615},"Y = asin(X)","Inverse sine (arcsine)","Computes the inverse sine of each element. Result is in radians in the range [-pi/2, pi/2].",[1608],{"_19":1568,"_25":1609},"Input values in [-1, 1] (scalar or NDArray)","Angle in radians",[1612],{"_1356":1613,"_1358":1614},"asin(1)","1.5708",[1562,1590,1602],{"_19":1590,"_21":1617,"_23":1618,"_25":1619,"_26":1620,"_32":1610,"_34":1622,"_1363":1625},"Y = acos(X)","Inverse cosine (arccosine)","Computes the inverse cosine of each element. Result is in radians in the range [0, pi].",[1621],{"_19":1568,"_25":1609},[1623],{"_1356":1624,"_1358":1614},"acos(0)",[1576,1578,1602],{"_19":1602,"_21":1627,"_23":1628,"_25":1629,"_26":1630,"_32":1610,"_34":1633,"_1363":1637},"Y = atan(X)","Inverse tangent (arctangent)","Computes the inverse tangent of each element. Result is in radians in the range (-pi/2, pi/2).",[1631],{"_19":1568,"_25":1632},"Input value (scalar or NDArray)",[1634],{"_1356":1635,"_1358":1636},"atan(1)","0.7854",[1577,1638,1578],"atan2",{"_19":1638,"_21":1640,"_23":1641,"_25":1642,"_26":1643,"_32":1648,"_34":1649,"_1363":1652},"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.",[1644,1646],{"_19":1073,"_25":1645},"Y-coordinates (scalar or NDArray)",{"_19":29,"_25":1647},"X-coordinates (scalar or NDArray)","Angle in radians in (-pi, pi]",[1650],{"_1356":1651,"_1358":1636},"atan2(1, 1)",[1602,1562,1576],{"_19":1654,"_21":1655,"_23":1656,"_25":1657,"_26":1658,"_32":1660,"_34":1661,"_1363":1665},"sinh","Y = sinh(X)","Hyperbolic sine","Computes the hyperbolic sine of each element.",[1659],{"_19":1568,"_25":1632},"Hyperbolic sine values",[1662],{"_1356":1663,"_1358":1664},"sinh(0)","0",[1666,1667,1562],"cosh","tanh",{"_19":1666,"_21":1669,"_23":1670,"_25":1671,"_26":1672,"_32":1674,"_34":1675,"_1363":1678},"Y = cosh(X)","Hyperbolic cosine","Computes the hyperbolic cosine of each element.",[1673],{"_19":1568,"_25":1632},"Hyperbolic cosine values",[1676],{"_1356":1677,"_1358":1574},"cosh(0)",[1654,1667,1576],{"_19":1667,"_21":1680,"_23":1681,"_25":1682,"_26":1683,"_32":1685,"_34":1686,"_1363":1689},"Y = tanh(X)","Hyperbolic tangent","Computes the hyperbolic tangent of each element.",[1684],{"_19":1568,"_25":1632},"Hyperbolic tangent values",[1687],{"_1356":1688,"_1358":1664},"tanh(0)",[1654,1666,1577],{"_19":1691,"_21":1692,"_23":1693,"_25":1694,"_26":1695,"_32":1698,"_34":1699,"_1363":1705},"exp","Y = exp(X)","Exponential (e^x)","Computes e raised to the power of each element.",[1696],{"_19":1568,"_25":1697},"Exponent values (scalar or NDArray)","Exponential values",[1700,1702],{"_1356":1701,"_1358":1574},"exp(0)",{"_1356":1703,"_1358":1704},"exp(1)","2.7183",[1706,1707],"log","log10",{"_19":1706,"_21":1709,"_23":1710,"_25":1711,"_26":1712,"_32":1715,"_34":1716,"_1363":1719},"Y = log(X)","Natural logarithm","Computes the natural logarithm (base e) of each element.",[1713],{"_19":1568,"_25":1714},"Input values > 0 (scalar or NDArray)","Natural log values",[1717],{"_1356":1718,"_1358":1574},"log(exp(1))",[1691,1707,1720],"log2",{"_19":1707,"_21":1722,"_23":1723,"_25":1724,"_26":1725,"_32":1727,"_34":1728,"_1363":1732},"Y = log10(X)","Common logarithm (base 10)","Computes the base-10 logarithm of each element.",[1726],{"_19":1568,"_25":1714},"Base-10 log values",[1729],{"_1356":1730,"_1358":1731},"log10(100)","2",[1706,1720,1691],{"_19":1720,"_21":1734,"_23":1735,"_25":1736,"_26":1737,"_32":1739,"_34":1740,"_1363":1744},"Y = log2(X)","Base-2 logarithm","Computes the base-2 logarithm of each element.",[1738],{"_19":1568,"_25":1714},"Base-2 log values",[1741],{"_1356":1742,"_1358":1743},"log2(8)","3",[1706,1707,1691],{"_19":1746,"_21":1747,"_23":1748,"_25":1749,"_26":1750,"_32":1753,"_34":1754,"_1363":1757},"sqrt","Y = sqrt(X)","Square root","Computes the square root of each element.",[1751],{"_19":1568,"_25":1752},"Input values >= 0 (scalar or NDArray)","Square root values",[1755],{"_1356":1756,"_1358":1743},"sqrt(9)",[1758,1691],"abs",{"_19":1758,"_21":1760,"_23":1761,"_25":1762,"_26":1763,"_32":1765,"_34":1766,"_1363":1770},"Y = abs(X)","Absolute value","Computes the absolute value of each element.",[1764],{"_19":1568,"_25":1632},"Absolute values",[1767],{"_1356":1768,"_1358":1769},"abs(-5)","5",[1746,1771,1772],"floor","ceil",{"_19":1771,"_21":1774,"_23":1775,"_25":1776,"_26":1777,"_32":1779,"_34":1780,"_1363":1783},"Y = floor(X)","Round toward negative infinity","Rounds each element to the nearest integer toward negative infinity.",[1778],{"_19":1568,"_25":1632},"Rounded values",[1781],{"_1356":1782,"_1358":1743},"floor(3.7)",[1772,1784,1758],"round",{"_19":1772,"_21":1786,"_23":1787,"_25":1788,"_26":1789,"_32":1779,"_34":1791,"_1363":1795},"Y = ceil(X)","Round toward positive infinity","Rounds each element to the nearest integer toward positive infinity.",[1790],{"_19":1568,"_25":1632},[1792],{"_1356":1793,"_1358":1794},"ceil(3.2)","4",[1771,1784,1758],{"_19":1784,"_21":1797,"_23":1798,"_25":1799,"_26":1800,"_32":1779,"_34":1802,"_1363":1805},"Y = round(X)","Round to nearest integer","Rounds each element to the nearest integer.",[1801],{"_19":1568,"_25":1632},[1803],{"_1356":1804,"_1358":1794},"round(3.5)",[1771,1772],{"_19":1807,"_21":1808,"_23":1809,"_25":1810,"_26":1811,"_32":1817,"_34":1818,"_1363":1825},"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).",[1812,1814],{"_19":29,"_25":1813},"Input array (scalar or NDArray)",{"_19":1815,"_25":1816,"_31":61},"dim","Dimension to sum along (1-indexed)","Sum value (scalar or NDArray)",[1819,1822],{"_1356":1820,"_1358":1821},"sum([1 2 3])","6",{"_1356":1823,"_1358":1824},"A = [1 2; 3 4]; sum(A, 1)","4 6",[1826,1827,1828],"mean","min","max",{"_19":1826,"_21":1830,"_23":1831,"_25":1832,"_26":1833,"_32":1837,"_34":1838,"_1363":1842},"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.",[1834,1835],{"_19":29,"_25":1813},{"_19":1815,"_25":1836,"_31":61},"Dimension to average along (1-indexed)","Mean value (scalar or NDArray)",[1839],{"_1356":1840,"_1358":1841},"mean([1 2 3 4])","2.5",[1807,1843,1844],"std","var",{"_19":1843,"_21":1846,"_23":1847,"_25":1848,"_26":1849,"_32":1853,"_34":1854,"_1363":1857},"S = std(A)\nS = std(A, dim)","Standard deviation","Returns the standard deviation of the elements. With a dimension argument, computes along that dimension.",[1850,1851],{"_19":29,"_25":1813},{"_19":1815,"_25":1852,"_31":61},"Dimension (1-indexed)","Standard deviation (scalar or NDArray)",[1855],{"_1356":1856,"_1358":1731},"std([2 4 4 4 5 5 7 9])",[1844,1826],{"_19":1844,"_21":1859,"_23":1860,"_25":1861,"_26":1862,"_32":1865,"_34":1866,"_1363":1869},"V = var(A)\nV = var(A, dim)","Variance","Returns the variance of the elements. With a dimension argument, computes along that dimension.",[1863,1864],{"_19":29,"_25":1813},{"_19":1815,"_25":1852,"_31":61},"Variance (scalar or NDArray)",[1867],{"_1356":1868,"_1358":1794},"var([2 4 4 4 5 5 7 9])",[1843,1826],{"_19":1827,"_21":1871,"_23":1872,"_25":1873,"_26":1874,"_32":1877,"_34":1878,"_1363":1881},"M = min(A)\nM = min(A, dim)","Minimum value","Returns the smallest element. With a dimension argument, returns the minimum along that dimension.",[1875,1876],{"_19":29,"_25":1813},{"_19":1815,"_25":1852,"_31":61},"Minimum value (scalar or NDArray)",[1879],{"_1356":1880,"_1358":1574},"min([3 1 4 1 5])",[1828,1807],{"_19":1828,"_21":1883,"_23":1884,"_25":1885,"_26":1886,"_32":1889,"_34":1890,"_1363":1893},"M = max(A)\nM = max(A, dim)","Maximum value","Returns the largest element. With a dimension argument, returns the maximum along that dimension.",[1887,1888],{"_19":29,"_25":1813},{"_19":1815,"_25":1852,"_31":61},"Maximum value (scalar or NDArray)",[1891],{"_1356":1892,"_1358":1769},"max([3 1 4 1 5])",[1827,1807],{"_19":1895,"_21":1896,"_23":1897,"_25":1898,"_26":1899,"_32":1903,"_34":1904,"_1363":1912},"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.",[1900,1901],{"_19":29,"_25":1813},{"_19":1815,"_25":1902,"_31":61},"Dimension to operate along (1-indexed)","1 if any element is nonzero, 0 otherwise",[1905,1907,1909],{"_1356":1906,"_1358":1574},"any([0 0 1 0])",{"_1356":1908,"_1358":1664},"any([0 0 0])",{"_1356":1910,"_1358":1911},"A = [1 0; 0 0]; any(A, 1)","1 0",[1913,1914],"all","find",{"_19":1913,"_21":1916,"_23":1917,"_25":1918,"_26":1919,"_32":1922,"_34":1923,"_1363":1930},"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.",[1920,1921],{"_19":29,"_25":1813},{"_19":1815,"_25":1902,"_31":61},"1 if all elements are nonzero, 0 otherwise",[1924,1926,1928],{"_1356":1925,"_1358":1574},"all([1 2 3])",{"_1356":1927,"_1358":1664},"all([1 0 3])",{"_1356":1929,"_1358":1911},"A = [1 1; 1 0]; all(A, 1)",[1895,1914],{"_19":1914,"_21":1932,"_23":1933,"_25":1934,"_26":1935,"_32":1943,"_34":1944,"_1363":1957},"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.",[1936,1938,1940],{"_19":1568,"_25":1937},"Input array",{"_19":693,"_25":1939,"_31":61},"Number of indices to return",{"_19":1941,"_25":1942,"_31":61},"direction","'first' (default) or 'last' - which indices to return","Vector of indices (1-based)",[1945,1948,1951,1954],{"_1356":1946,"_1358":1947},"find([1 0 3 0 5])","1 3 5",{"_1356":1949,"_1358":1950},"find([1 0 3 0 5], 2)","1 3",{"_1356":1952,"_1358":1953},"find([1 0 3 0 5], 2, 'last')","3 5",{"_1356":1955,"_1358":1956},"A = [1 2 3 4 5]; find(A > 3)","4 5",[1895,1913],{"_19":217,"_21":1959,"_23":1960,"_25":1961,"_26":1962,"_32":1966,"_34":1967,"_1363":1973},"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.",[1963,1964],{"_19":29,"_25":1937},{"_19":1815,"_25":1965,"_31":61},"Dimension to query (1-indexed)","Size as NDArray or scalar",[1968,1971],{"_1356":1969,"_1358":1970},"A = zeros(3, 4); size(A)","3 4",{"_1356":1972,"_1358":1794},"size(A, 2)",[326,1974,1975],"numel","ndims",{"_19":326,"_21":1977,"_23":1978,"_25":1979,"_26":1980,"_32":1982,"_34":1983,"_1363":1986},"n = length(A)","Length of largest array dimension","Returns the length of the largest dimension of the array.",[1981],{"_19":29,"_25":1937},"Scalar length",[1984],{"_1356":1985,"_1358":1769},"length([1 2 3 4 5])",[217,1974],{"_19":1974,"_21":1988,"_23":1989,"_25":1990,"_26":1991,"_32":1993,"_34":1994,"_1363":1998},"n = numel(A)","Number of array elements","Returns the total number of elements in the array.",[1992],{"_19":29,"_25":1937},"Scalar count",[1995],{"_1356":1996,"_1358":1997},"A = zeros(3, 4); numel(A)","12",[217,326],{"_19":1975,"_21":2000,"_23":2001,"_25":2002,"_26":2003,"_32":2005,"_34":2006,"_1363":2009},"n = ndims(A)","Number of array dimensions","Returns the number of dimensions of the array.",[2004],{"_19":29,"_25":1937},"Scalar dimension count",[2007],{"_1356":2008,"_1358":1731},"A = zeros(3, 4); ndims(A)",[217,326],{"_19":2011,"_21":2012,"_23":2013,"_25":2014,"_26":2015,"_32":2019,"_34":2020,"_1363":2024},"reshape","B = reshape(A, m, n)","Reshape array","Reshapes array A into an m-by-n matrix. The number of elements must not change.",[2016,2017,2018],{"_19":29,"_25":1937},{"_19":690,"_25":1350},{"_19":693,"_25":1352},"Reshaped NDArray",[2021],{"_1356":2022,"_1358":2023},"reshape([1 2 3 4 5 6], 2, 3)","1 3 5\n2 4 6",[217,2025],"transpose",{"_19":2025,"_21":2027,"_23":2028,"_25":2029,"_26":2030,"_32":2033,"_34":2034,"_1363":2038},"B = transpose(A)\nB = A'","Transpose matrix","Transposes a matrix (swaps rows and columns).",[2031],{"_19":29,"_25":2032},"Input matrix","Transposed NDArray",[2035],{"_1356":2036,"_1358":2037},"A = [1 2; 3 4]; A'","1 3\n2 4",[2011,2039],"flip",{"_19":760,"_21":2041,"_23":2042,"_25":2043,"_26":2044,"_32":2048,"_34":2049,"_1363":2053},"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.",[2045],{"_19":2046,"_25":2047},"v/A","Input vector or matrix","Diagonal matrix or diagonal vector",[2050],{"_1356":2051,"_1358":2052},"diag([1 2 3])","1 0 0\n0 2 0\n0 0 3",[1366,1344],{"_19":2039,"_21":2055,"_23":2056,"_25":2057,"_26":2058,"_32":2062,"_34":2063,"_1363":2067},"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).",[2059,2060],{"_19":29,"_25":1937},{"_19":1815,"_25":2061,"_31":61},"Dimension to flip along","Flipped NDArray",[2064],{"_1356":2065,"_1358":2066},"flip([1 2 3])","3 2 1",[2068,2069,2070],"fliplr","flipud","rot90",{"_19":2068,"_21":2072,"_23":2073,"_25":2074,"_26":2075,"_32":2062,"_34":2077,"_1363":2081},"B = fliplr(A)","Flip array left to right","Flips a matrix left to right (reverses columns).",[2076],{"_19":29,"_25":2032},[2078],{"_1356":2079,"_1358":2080},"fliplr([1 2 3; 4 5 6])","3 2 1\n6 5 4",[2069,2039,2070],{"_19":2069,"_21":2083,"_23":2084,"_25":2085,"_26":2086,"_32":2062,"_34":2088,"_1363":2092},"B = flipud(A)","Flip array up to down","Flips a matrix up to down (reverses rows).",[2087],{"_19":29,"_25":2032},[2089],{"_1356":2090,"_1358":2091},"flipud([1 2; 3 4])","3 4\n1 2",[2068,2039,2070],{"_19":2070,"_21":2094,"_23":2095,"_25":2096,"_26":2097,"_32":2102,"_34":2103,"_1363":2107},"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.",[2098,2099],{"_19":29,"_25":2032},{"_19":2100,"_25":2101,"_31":61},"k","Number of 90° rotations (default: 1)","Rotated NDArray",[2104],{"_1356":2105,"_1358":2106},"rot90([1 2; 3 4])","2 4\n1 3",[2039,2025],{"_19":2109,"_21":2110,"_23":2111,"_25":2112,"_26":2113,"_32":2117,"_34":2118,"_1363":2122},"lower","s = lower(str)","Convert string to lowercase","Converts all uppercase characters in the string to lowercase.",[2114],{"_19":2115,"_25":2116},"str","Input string","Lowercase string",[2119],{"_1356":2120,"_1358":2121},"lower(\"Hello World\")","'hello world'",[2123],"upper",{"_19":2123,"_21":2125,"_23":2126,"_25":2127,"_26":2128,"_32":2130,"_34":2131,"_1363":2135},"s = upper(str)","Convert string to uppercase","Converts all lowercase characters in the string to uppercase.",[2129],{"_19":2115,"_25":2116},"Uppercase string",[2132],{"_1356":2133,"_1358":2134},"upper(\"Hello World\")","'HELLO WORLD'",[2109],{"_19":2137,"_21":2138,"_23":2139,"_25":2140,"_26":2141,"_32":2143,"_34":2144,"_1363":2147},"strlength","n = strlength(str)","Length of string","Returns the number of characters in the string.",[2142],{"_19":2115,"_25":2116},"Number of characters",[2145],{"_1356":2146,"_1358":1769},"strlength(\"hello\")",[326],{"_19":2149,"_21":2150,"_23":2151,"_25":2152,"_26":2153,"_32":2160,"_34":2161,"_1363":2166},"strcmp","tf = strcmp(s1, s2)","Compare strings","Returns 1 if the strings are identical, 0 otherwise.",[2154,2157],{"_19":2155,"_25":2156},"s1","First string",{"_19":2158,"_25":2159},"s2","Second string","1 if equal, 0 otherwise",[2162,2164],{"_1356":2163,"_1358":1574},"strcmp(\"abc\", \"abc\")",{"_1356":2165,"_1358":1664},"strcmp(\"abc\", \"def\")",[2167],"strcmpi",{"_19":2167,"_21":2169,"_23":2170,"_25":2171,"_26":2172,"_32":2175,"_34":2176,"_1363":2179},"tf = strcmpi(s1, s2)","Compare strings (case-insensitive)","Returns 1 if the strings are identical ignoring case, 0 otherwise.",[2173,2174],{"_19":2155,"_25":2156},{"_19":2158,"_25":2159},"1 if equal (ignoring case), 0 otherwise",[2177],{"_1356":2178,"_1358":1574},"strcmpi(\"Hello\", \"hello\")",[2149],{"_19":2181,"_21":2182,"_23":2183,"_25":2184,"_26":2185,"_32":2191,"_34":2192,"_1363":2196},"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.",[2186,2188],{"_19":2115,"_25":2187},"String to search in",{"_19":2189,"_25":2190},"pattern","Pattern to find","Array of starting indices",[2193],{"_1356":2194,"_1358":2195},"strfind(\"abcabc\", \"bc\")","[2, 5]",[2197,2198,2199],"contains","startsWith","endsWith",{"_19":2201,"_21":2202,"_23":2203,"_25":2204,"_26":2205,"_32":2213,"_34":2214,"_1363":2218},"strrep","s = strrep(str, old, new)","Replace substring","Replaces all occurrences of old with new in str.",[2206,2207,2210],{"_19":2115,"_25":2116},{"_19":2208,"_25":2209},"old","Substring to replace",{"_19":2211,"_25":2212},"new","Replacement string","String with replacements made",[2215],{"_1356":2216,"_1358":2217},"strrep(\"hello world\", \"world\", \"there\")","'hello there'",[2181],{"_19":2220,"_21":2221,"_23":2222,"_25":2223,"_26":2224,"_32":2226,"_34":2227,"_1363":2231},"strip","s = strip(str)","Remove leading and trailing whitespace","Removes leading and trailing whitespace characters from the string.",[2225],{"_19":2115,"_25":2116},"Trimmed string",[2228],{"_1356":2229,"_1358":2230},"strip(\" hello \")","'hello'",[],{"_19":2198,"_21":2233,"_23":2234,"_25":2235,"_26":2236,"_32":2241,"_34":2242,"_1363":2245},"tf = startsWith(str, prefix)","Check if string starts with prefix","Returns 1 if str starts with prefix, 0 otherwise.",[2237,2238],{"_19":2115,"_25":2116},{"_19":2239,"_25":2240},"prefix","Prefix to check","1 if starts with prefix, 0 otherwise",[2243],{"_1356":2244,"_1358":1574},"startsWith(\"hello\", \"hel\")",[2199,2197],{"_19":2199,"_21":2247,"_23":2248,"_25":2249,"_26":2250,"_32":2255,"_34":2256,"_1363":2259},"tf = endsWith(str, suffix)","Check if string ends with suffix","Returns 1 if str ends with suffix, 0 otherwise.",[2251,2252],{"_19":2115,"_25":2116},{"_19":2253,"_25":2254},"suffix","Suffix to check","1 if ends with suffix, 0 otherwise",[2257],{"_1356":2258,"_1358":1574},"endsWith(\"hello\", \"lo\")",[2198,2197],{"_19":2197,"_21":2261,"_23":2262,"_25":2263,"_26":2264,"_32":2268,"_34":2269,"_1363":2272},"tf = contains(str, pattern)","Check if string contains pattern","Returns 1 if str contains pattern, 0 otherwise.",[2265,2266],{"_19":2115,"_25":2116},{"_19":2189,"_25":2267},"Pattern to search for","1 if contains pattern, 0 otherwise",[2270],{"_1356":2271,"_1358":1574},"contains(\"hello world\", \"wor\")",[2198,2199,2181],{"_19":2274,"_21":2275,"_23":2276,"_25":2277,"_26":2278,"_32":2284,"_34":2285,"_1363":2292},"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).",[2279,2281],{"_19":797,"_25":2280},"Format string with conversion specifiers",{"_19":2282,"_25":2283},"A1, A2, ...","Values to format","Formatted string",[2286,2289],{"_1356":2287,"_1358":2288},"sprintf(\"x = %d\", 42)","'x = 42'",{"_1356":2290,"_1358":2291},"sprintf(\"pi = %.4f\", pi)","'pi = 3.1416'",[2293],"disp",{"_19":2295,"_21":2296,"_23":2297,"_25":2298,"_26":2299,"_32":2302,"_34":2303,"_1363":2310},"char","c = char(n)","Convert to character","Converts numeric code to character, or ensures input is a character array.",[2300],{"_19":693,"_25":2301},"Numeric ASCII/Unicode code or string","Character string",[2304,2307],{"_1356":2305,"_1358":2306},"char(65)","'A'",{"_1356":2308,"_1358":2309},"char([72 101 108 108 111])","'Hello'",[2311],"double",{"_19":2313,"_21":2314,"_23":2315,"_25":2316,"_26":2317,"_32":2323,"_34":2324,"_1363":2331},"num2str","s = num2str(A)\ns = num2str(A, precision)","Convert number to string","Converts numeric array to string representation.",[2318,2320],{"_19":29,"_25":2319},"Numeric value or array",{"_19":2321,"_25":2322,"_31":61},"precision","Number of significant digits","String representation of number",[2325,2328],{"_1356":2326,"_1358":2327},"num2str(3.14159)","'3.1416'",{"_1356":2329,"_1358":2330},"num2str(pi, 10)","'3.141592654'",[2332,2274],"str2num",{"_19":2332,"_21":2334,"_23":2335,"_25":2336,"_26":2337,"_32":2340,"_34":2341,"_1363":2345},"n = str2num(str)","Convert string to number","Converts string representation of number to numeric value.",[2338],{"_19":2115,"_25":2339},"String containing numeric value","Numeric value",[2342],{"_1356":2343,"_1358":2344},"str2num(\"3.14\")","3.14",[2313],{"_19":2347,"_21":2348,"_23":2349,"_25":2350,"_26":2351,"_32":2355,"_34":2356,"_1363":2359},"strcat","s = strcat(s1, s2, ...)","Concatenate strings","Concatenates strings horizontally.",[2352],{"_19":2353,"_25":2354},"s1, s2, ...","Strings to concatenate","Concatenated string",[2357],{"_1356":2358,"_1358":2121},"strcat(\"hello\", \" \", \"world\")",[],{"_19":2361,"_21":2362,"_23":2363,"_25":2364,"_26":2365,"_32":2372,"_34":2373,"_1363":2377},"strjoin","s = strjoin(strs, delimiter)","Join strings with delimiter","Joins an array of strings with the specified delimiter.",[2366,2369],{"_19":2367,"_25":2368},"strs","Cell array or string array",{"_19":2370,"_25":2371,"_31":61},"delimiter","Delimiter string (default: space)","Joined string",[2374],{"_1356":2375,"_1358":2376},"strjoin([\"a\", \"b\", \"c\"], \"-\")","'a-b-c'",[2347],{"_19":2379,"_21":2380,"_23":2381,"_25":2382,"_26":2383,"_32":2387,"_34":2388,"_1363":2392},"strsplit","parts = strsplit(str, delimiter)","Split string at delimiter","Splits a string at each occurrence of delimiter.",[2384,2385],{"_19":2115,"_25":2116},{"_19":2370,"_25":2386,"_31":61},"Delimiter string (default: whitespace)","Array of substrings",[2389],{"_1356":2390,"_1358":2391},"strsplit(\"a-b-c\", \"-\")","['a', 'b', 'c']",[2361],{"_19":2293,"_21":2394,"_23":2395,"_25":2396,"_26":2397,"_32":2400,"_34":2401,"_1363":2405},"disp(X)","Display value","Displays the value of a variable or expression without the variable name.",[2398],{"_19":1568,"_25":2399},"Value to display","The input value (also displayed as output)",[2402],{"_1356":2403,"_1358":2404},"disp('hello')","hello",[],{"_19":2407,"_21":2407,"_23":2408,"_25":2409,"_26":2410,"_32":155,"_34":2411,"_1363":2415},"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.",[],[2412],{"_1356":2413,"_1358":2414},"tic\nA = rand(100);\ntoc","Elapsed time is 0.012345 seconds.",[2416],"toc",{"_19":2416,"_21":2418,"_23":2419,"_25":2420,"_26":2421,"_32":2422,"_34":2423,"_1363":2427},"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)",[2424],{"_1356":2425,"_1358":2426},"tic\nfor i = 1:100\n rand(10);\nend\nt = toc","Elapsed time is 0.005123 seconds.\nt = 0.005123",[2407],{"_19":2429,"_21":2430,"_23":2431,"_25":2432,"_26":2433,"_32":2437,"_34":2438,"_1363":2445},"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.",[2434],{"_19":2435,"_25":2436},"expression","String containing M-Code to evaluate","Result of the evaluated expression",[2439,2442],{"_1356":2440,"_1358":2441},"eval('x = 5')","x = 5",{"_1356":2443,"_1358":2444},"Z = eval('magic(3)')","Z = [8 1 6; 3 5 7; 4 9 2]",[],{"_38":2447,"_19":2448,"_25":2449,"_42":43,"_44":2450,"_48":2451},"linalg","Linear Algebra","Matrix decompositions, solvers, products, norms, and other linear algebra operations.","📐",[2452,2471,2487,2498,2515,2530,2544,2556,2571,2585,2596,2610,2621,2640,2651,2669,2683,2695,2713,2729,2744,2758,2774,2791],{"_19":2453,"_21":2454,"_23":2455,"_25":2456,"_26":2457,"_32":2460,"_34":2461,"_1363":2467},"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.",[2458],{"_19":29,"_25":2459},"Square matrix (n×n)","Eigenvalue vector, or [V, D] decomposition",[2462,2465],{"_1356":2463,"_1358":2464},"eig([2 1; 1 2])","3\n1",{"_1356":2466},"[V,D] = eig([2 1; 1 2])",[2468,2469,2470],"svd","det","inv",{"_19":2472,"_21":2473,"_23":2474,"_25":2475,"_26":2476,"_32":2460,"_34":2479,"_1363":2485},"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.",[2477],{"_19":29,"_25":2478},"Symmetric/Hermitian matrix (n×n)",[2480,2483],{"_1356":2481,"_1358":2482},"A = [2 1; 1 2];\nD = eigh(A)","1\n3",{"_1356":2484},"[V, D] = eigh([2 1; 1 2])",[2453,2486,2468],"eigvalsh",{"_19":2486,"_21":2488,"_23":2489,"_25":2490,"_26":2491,"_32":2493,"_34":2494,"_1363":2497},"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.",[2492],{"_19":29,"_25":2478},"Vector of eigenvalues in ascending order",[2495],{"_1356":2496,"_1358":2482},"eigvalsh([2 1; 1 2])",[2472,2453],{"_19":2468,"_21":2499,"_23":2500,"_25":2501,"_26":2502,"_32":2505,"_34":2506,"_1363":2512},"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.",[2503],{"_19":29,"_25":2504},"Input matrix (m×n)","Singular value vector, or [U, S, V] decomposition",[2507,2510],{"_1356":2508,"_1358":2509},"svd([1 0; 0 2])","2\n1",{"_1356":2511},"[U,S,V] = svd([1 0; 0 2])",[2453,2513,2514],"rank","norm",{"_19":2516,"_21":2517,"_23":2518,"_25":2519,"_26":2520,"_32":2522,"_34":2523,"_1363":2528},"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).",[2521],{"_19":29,"_25":2504},"R matrix, or [Q, R] decomposition",[2524,2526],{"_1356":2525,"_1358":1392},"qr(eye(3))",{"_1356":2527},"[Q,R] = qr([1 2; 3 4])",[2468,2529,2453],"chol",{"_19":71,"_21":2531,"_23":2532,"_25":2533,"_26":2534,"_32":2536,"_34":2537,"_1363":2542},"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.",[2535],{"_19":29,"_25":2504},"Lower triangular factor L, or [L, U, P] decomposition",[2538,2540],{"_1356":2539},"[L,U,P] = lu([2 1; 4 3])",{"_1356":2541},"L = lu([1 2; 3 4])",[2516,2468,2529,2543],"linsolve",{"_19":2529,"_21":2545,"_23":2546,"_25":2547,"_26":2548,"_32":2551,"_34":2552,"_1363":2555},"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.",[2549],{"_19":29,"_25":2550},"Symmetric positive-definite matrix (n×n)","Upper-triangular Cholesky factor R",[2553],{"_1356":2554},"chol([4 2; 2 3])",[2516,2468,2470],{"_19":2469,"_21":2557,"_23":2558,"_25":2559,"_26":2560,"_32":2562,"_34":2563,"_1363":2569},"d = det(A)","Matrix determinant","Computes the determinant of a square matrix.",[2561],{"_19":29,"_25":2459},"Scalar determinant value",[2564,2567],{"_1356":2565,"_1358":2566},"det([1 2; 3 4])","-2",{"_1356":2568,"_1358":1574},"det(eye(3))",[2470,2513,2570],"trace",{"_19":2470,"_21":2572,"_23":2573,"_25":2574,"_26":2575,"_32":2578,"_34":2579,"_1363":2583},"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.",[2576],{"_19":29,"_25":2577},"Non-singular square matrix (n×n)","Inverse matrix (n×n)",[2580],{"_1356":2581,"_1358":2582},"inv([1 2; 3 4])","-2.0000 1.0000\n1.5000 -0.5000",[2469,2584,2543],"pinv",{"_19":2584,"_21":2586,"_23":2587,"_25":2588,"_26":2589,"_32":2591,"_34":2592,"_1363":2595},"B = pinv(A)","Moore-Penrose pseudo-inverse","Computes the pseudo-inverse of a matrix. Works for non-square and singular matrices.",[2590],{"_19":29,"_25":2504},"Pseudo-inverse matrix (n×m)",[2593],{"_1356":2594},"pinv([1 0; 0 0])",[2470,2543,2513],{"_19":2513,"_21":2597,"_23":2598,"_25":2599,"_26":2600,"_32":2602,"_34":2603,"_1363":2608},"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.",[2601],{"_19":29,"_25":2032},"Scalar rank",[2604,2606],{"_1356":2605,"_1358":1743},"rank(eye(3))",{"_1356":2607,"_1358":1574},"rank([1 2; 2 4])",[2468,2469,2609],"cond",{"_19":2570,"_21":2611,"_23":2612,"_25":2613,"_26":2614,"_32":2616,"_34":2617,"_1363":2620},"t = trace(A)","Sum of diagonal elements","Returns the sum of the elements on the main diagonal of a matrix.",[2615],{"_19":29,"_25":2032},"Scalar trace value",[2618],{"_1356":2619,"_1358":1794},"trace(eye(4))",[760,2469,2453],{"_19":2514,"_21":2622,"_23":2623,"_25":2624,"_26":2625,"_32":2630,"_34":2631,"_1363":2639},"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).",[2626,2627],{"_19":29,"_25":2047},{"_19":2628,"_25":2629,"_31":61},"p","Norm order or type: number (1, 2, Inf), or string ('fro', 'nuc')","Scalar norm value",[2632,2634,2637],{"_1356":2633,"_1358":1769},"norm([3 4])",{"_1356":2635,"_1358":2636},"norm([3 4], 1)","7",{"_1356":2638},"norm([1 2; 3 4], 'fro')",[2609,2513,2469],{"_19":2609,"_21":2641,"_23":2642,"_25":2643,"_26":2644,"_32":2646,"_34":2647,"_1363":2650},"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.",[2645],{"_19":29,"_25":2032},"Scalar condition number",[2648],{"_1356":2649,"_1358":1574},"cond(eye(3))",[2514,2513,2469],{"_19":2652,"_21":2653,"_23":2654,"_25":2655,"_26":2656,"_32":2661,"_34":2662,"_1363":2667},"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.",[2657,2659],{"_19":29,"_25":2658},"Coefficient matrix (m×n)",{"_19":91,"_25":2660},"Ordinate values (m×1) or (m×k)","Solution vector x, or [x, residuals, rank, s]",[2663,2665],{"_1356":2664},"A = [1 0; 1 1; 1 2]; b = [1; 2; 3];\nx = lstsq(A, b)",{"_1356":2666},"[x, res, rnk, s] = lstsq(A, b)",[2668,2584,2516],"mldivide",{"_19":2543,"_21":2670,"_23":2671,"_25":2672,"_26":2673,"_32":2678,"_34":2679,"_1363":2682},"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.",[2674,2676],{"_19":29,"_25":2675},"Coefficient matrix (n×n)",{"_19":91,"_25":2677},"Right-hand side vector or matrix","Solution vector or matrix x",[2680],{"_1356":2681},"A = [1 2; 3 4]; b = [5; 6]; linsolve(A, b)",[2668,2470,2469],{"_19":2668,"_21":2684,"_23":2685,"_25":2686,"_26":2687,"_32":2678,"_34":2691,"_1363":2694},"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.",[2688,2690],{"_19":29,"_25":2689},"Coefficient matrix",{"_19":91,"_25":2677},[2692],{"_1356":2693},"A = [1 2; 3 4]; b = [5; 6]; mldivide(A, b)",[2543,2470],{"_19":2696,"_21":2697,"_23":2698,"_25":2699,"_26":2700,"_32":2705,"_34":2706,"_1363":2709},"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.",[2701,2703],{"_19":29,"_25":2702},"First array (..., M, K)",{"_19":1073,"_25":2704},"Second array (..., K, N)","Matrix product (..., M, N)",[2707],{"_1356":2708},"matmul([1 2; 3 4], [5 6; 7 8])",[2710,2711,2712],"dot","kron","mpower",{"_19":2710,"_21":2714,"_23":2715,"_25":2716,"_26":2717,"_32":2722,"_34":2723,"_1363":2727},"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.",[2718,2720],{"_19":1423,"_25":2719},"First input array",{"_19":91,"_25":2721},"Second input array","Dot product result",[2724],{"_1356":2725,"_1358":2726},"dot([1 2 3], [4 5 6])","32",[2728,2711],"cross",{"_19":2728,"_21":2730,"_23":2731,"_25":2732,"_26":2733,"_32":2738,"_34":2739,"_1363":2743},"c = cross(a, b)","Cross product","Computes the cross product of two 3-element vectors.",[2734,2736],{"_19":1423,"_25":2735},"First 3-element vector",{"_19":91,"_25":2737},"Second 3-element vector","3-element cross product vector",[2740],{"_1356":2741,"_1358":2742},"cross([1 0 0], [0 1 0])","0 0 1",[2710,2711],{"_19":2711,"_21":2745,"_23":2746,"_25":2747,"_26":2748,"_32":2753,"_34":2754,"_1363":2757},"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.",[2749,2751],{"_19":29,"_25":2750},"First input matrix",{"_19":1073,"_25":2752},"Second input matrix","Kronecker product matrix",[2755],{"_1356":2756},"kron([1 0; 0 1], [1 2; 3 4])",[2710,2728],{"_19":2759,"_21":2760,"_23":2761,"_25":2762,"_26":2763,"_32":2768,"_34":2769,"_1363":2773},"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).",[2764,2766],{"_19":1423,"_25":2765},"First vector (m-element)",{"_19":91,"_25":2767},"Second vector (n-element)","Outer product matrix (m x n)",[2770],{"_1356":2771,"_1358":2772},"outer([1 2 3], [4 5])","4 5\n8 10\n12 15",[2710,2728,2711],{"_19":2775,"_21":2776,"_23":2777,"_25":2778,"_26":2779,"_32":2786,"_34":2787,"_1363":2790},"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).",[2780,2783],{"_19":2781,"_25":2782},"subscripts","Subscript string (e.g., \"ij,jk->ik\")",{"_19":2784,"_25":2785},"A,B,...","Input arrays","Result array according to subscripts",[2788],{"_1356":2789},"einsum('ij,jk->ik', A, B)",[2710,2696],{"_19":2712,"_21":2792,"_23":2793,"_25":2794,"_26":2795,"_32":2799,"_34":2800,"_1363":2803},"B = mpower(A, n)","Matrix power","Raises a square matrix to an integer power. Negative exponents compute the inverse raised to the absolute power.",[2796,2797],{"_19":29,"_25":2459},{"_19":693,"_25":2798},"Integer exponent","Matrix raised to power n",[2801],{"_1356":2802,"_1358":1392},"mpower(eye(3), 2)",[2470,2469],{"_38":2805,"_19":2806,"_25":2807,"_42":43,"_44":2808,"_48":2809},"fft","Fourier Analysis","Fast Fourier Transform, inverse transforms, frequency utilities, and window functions for spectral analysis.","〰️",[2810,2830,2847,2860,2872,2884,2896,2909,2921,2936,2954,2965,2976,2987],{"_19":2805,"_21":2811,"_23":2812,"_25":2813,"_26":2814,"_32":2819,"_34":2820,"_1363":2825},"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.",[2815,2817],{"_19":1568,"_25":2816},"Input signal (vector or array)",{"_19":693,"_25":2818,"_31":61},"Transform length (zero-pads or truncates)","Complex-valued frequency-domain representation",[2821,2823],{"_1356":2822},"fft([1 2 3 4])",{"_1356":2824},"fft([1 0 1 0], 8)",[2826,2827,2828,2829],"ifft","fft2","fftshift","fftfreq",{"_19":2826,"_21":2831,"_23":2832,"_25":2833,"_26":2834,"_32":2840,"_34":2841,"_1363":2844},"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.",[2835,2838],{"_19":2836,"_25":2837},"Y","Frequency-domain input",{"_19":693,"_25":2839,"_31":61},"Transform length","Time-domain signal",[2842],{"_1356":2843},"ifft(fft([1 2 3 4]))",[2805,2845,2846],"ifft2","ifftn",{"_19":2827,"_21":2848,"_23":2849,"_25":2850,"_26":2851,"_32":2854,"_34":2855,"_1363":2858},"Y = fft2(X)","2-D Fast Fourier Transform","Computes the two-dimensional discrete Fourier Transform. Useful for image processing and 2-D signal analysis.",[2852],{"_19":1568,"_25":2853},"Input 2-D array","2-D frequency-domain representation",[2856],{"_1356":2857},"fft2(eye(4))",[2845,2805,2859],"fftn",{"_19":2845,"_21":2861,"_23":2862,"_25":2863,"_26":2864,"_32":2867,"_34":2868,"_1363":2871},"x = ifft2(Y)","2-D inverse FFT","Computes the two-dimensional inverse discrete Fourier Transform.",[2865],{"_19":2836,"_25":2866},"Frequency-domain 2-D input","Spatial-domain 2-D signal",[2869],{"_1356":2870},"ifft2(fft2(eye(4)))",[2827,2826,2846],{"_19":2859,"_21":2873,"_23":2874,"_25":2875,"_26":2876,"_32":2879,"_34":2880,"_1363":2883},"Y = fftn(X)","N-dimensional FFT","Computes the N-dimensional discrete Fourier Transform over all axes of the input array.",[2877],{"_19":1568,"_25":2878},"Input N-D array","N-D frequency-domain representation",[2881],{"_1356":2882},"fftn(ones(4, 4))",[2846,2805,2827],{"_19":2846,"_21":2885,"_23":2886,"_25":2887,"_26":2888,"_32":2891,"_34":2892,"_1363":2895},"x = ifftn(Y)","N-dimensional inverse FFT","Computes the N-dimensional inverse discrete Fourier Transform.",[2889],{"_19":2836,"_25":2890},"Frequency-domain N-D input","Spatial-domain N-D signal",[2893],{"_1356":2894},"ifftn(fftn(ones(4, 4)))",[2859,2826,2845],{"_19":2828,"_21":2897,"_23":2898,"_25":2899,"_26":2900,"_32":2903,"_34":2904,"_1363":2907},"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.",[2901],{"_19":1568,"_25":2902},"Input array (typically output of fft)","Shifted array",[2905],{"_1356":2906},"fftshift(fft([1 2 3 4 5 6 7 8]))",[2908,2805,2829],"ifftshift",{"_19":2908,"_21":2910,"_23":2911,"_25":2912,"_26":2913,"_32":2916,"_34":2917,"_1363":2920},"Y = ifftshift(X)","Inverse of fftshift","Undoes the effect of `fftshift`. Shifts the zero-frequency component back to the beginning of the array.",[2914],{"_19":1568,"_25":2915},"Shifted input array","Unshifted array",[2918],{"_1356":2919},"ifftshift(fftshift([1 2 3 4]))",[2828,2805],{"_19":2829,"_21":2922,"_23":2923,"_25":2924,"_26":2925,"_32":2931,"_34":2932,"_1363":2935},"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`.",[2926,2928],{"_19":693,"_25":2927},"Window length (number of samples)",{"_19":2929,"_25":2930,"_31":61},"d","Sample spacing (default: 1.0)","Array of sample frequencies",[2933],{"_1356":2934},"fftfreq(8, 0.1)",[2805,2828],{"_19":2937,"_21":2938,"_23":2939,"_25":2940,"_26":2941,"_32":2945,"_34":2946,"_1363":2949},"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.",[2942],{"_19":2943,"_25":2944},"M","Number of points in the window","M-point Bartlett window vector",[2947],{"_1356":2948},"bartlett(8)",[2950,2951,2952,2953],"hamming","hanning","blackman","kaiser",{"_19":2952,"_21":2955,"_23":2956,"_25":2957,"_26":2958,"_32":2960,"_34":2961,"_1363":2964},"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.",[2959],{"_19":2943,"_25":2944},"M-point Blackman window vector",[2962],{"_1356":2963},"blackman(8)",[2950,2951,2937,2953],{"_19":2950,"_21":2966,"_23":2967,"_25":2968,"_26":2969,"_32":2971,"_34":2972,"_1363":2975},"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)).",[2970],{"_19":2943,"_25":2944},"M-point Hamming window vector",[2973],{"_1356":2974},"hamming(8)",[2951,2952,2937,2953],{"_19":2951,"_21":2977,"_23":2978,"_25":2979,"_26":2980,"_32":2982,"_34":2983,"_1363":2986},"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))).",[2981],{"_19":2943,"_25":2944},"M-point Hanning window vector",[2984],{"_1356":2985},"hanning(8)",[2950,2952,2937,2953],{"_19":2953,"_21":2988,"_23":2989,"_25":2990,"_26":2991,"_32":2996,"_34":2997,"_1363":3000},"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).",[2992,2993],{"_19":2943,"_25":2944},{"_19":2994,"_25":2995},"beta","Shape parameter controlling the trade-off","M-point Kaiser window vector",[2998],{"_1356":2999},"kaiser(8, 5)",[2950,2951,2952,2937],{"_38":3002,"_19":3003,"_25":3004,"_42":43,"_44":3005,"_48":3006},"plotting","Data Visualization","M-Code-style plotting functions for inline Chart.js visualizations.","📊",[3007,3027,3041,3052,3063,3078,3092,3116,3141,3179,3193,3204,3220,3231,3241,3253,3267,3283,3296,3309,3319,3333,3343,3356,3368,3379,3389,3398,3407,3419,3435,3448,3465,3485,3498,3508,3529,3554,3574,3595],{"_19":3008,"_21":3009,"_23":3010,"_25":3011,"_26":3012,"_32":3017,"_34":3018,"_1363":3021},"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.",[3013,3015],{"_19":94,"_25":3014,"_31":61},"X-axis data (NDArray or scalar)",{"_19":1489,"_25":3016},"Y-axis data (NDArray or scalar)","null (renders chart inline)",[3019],{"_1356":3020},"x = linspace(0, 2*pi, 50);\nplot(x, sin(x))",[3022,3023,3024,3025,3026],"scatter","bar","loglog","semilogx","semilogy",{"_19":3024,"_21":3028,"_23":3029,"_25":3030,"_26":3031,"_32":3034,"_34":3035,"_1363":3040},"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.",[3032,3033],{"_19":94,"_25":3014,"_31":61},{"_19":1489,"_25":3016},"Line handle",[3036,3038],{"_1356":3037},"x = 1:100;\ny = x.^2;\nloglog(x, y)",{"_1356":3039},"x = logspace(0, 3, 50);\nloglog(x, x.^(-1.5))",[3008,3025,3026],{"_19":3025,"_21":3042,"_23":3043,"_25":3044,"_26":3045,"_32":3034,"_34":3048,"_1363":3051},"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.",[3046,3047],{"_19":94,"_25":3014,"_31":61},{"_19":1489,"_25":3016},[3049],{"_1356":3050},"x = logspace(0, 3, 50);\nsemilogx(x, log10(x))",[3008,3024,3026],{"_19":3026,"_21":3053,"_23":3054,"_25":3055,"_26":3056,"_32":3034,"_34":3059,"_1363":3062},"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.",[3057,3058],{"_19":94,"_25":3014,"_31":61},{"_19":1489,"_25":3016},[3060],{"_1356":3061},"x = 1:10;\ny = 10.^x;\nsemilogy(x, y)",[3008,3024,3025],{"_19":3023,"_21":3064,"_23":3065,"_25":3066,"_26":3067,"_32":3017,"_34":3072,"_1363":3075},"bar(y)\nbar(x, y)","Bar chart","Creates a vertical bar chart.",[3068,3070],{"_19":94,"_25":3069,"_31":61},"Category positions or labels (NDArray)",{"_19":1489,"_25":3071},"Bar heights (NDArray)",[3073],{"_1356":3074},"bar([3 7 2 5])",[3008,3076,3077],"histogram","pie",{"_19":3022,"_21":3079,"_23":3080,"_25":3081,"_26":3082,"_32":3017,"_34":3087,"_1363":3090},"scatter(x, y)","Scatter plot","Creates a scatter plot of y versus x.",[3083,3085],{"_19":94,"_25":3084},"X-coordinates (NDArray)",{"_19":1489,"_25":3086},"Y-coordinates (NDArray)",[3088],{"_1356":3089},"scatter(rand(20, 1), rand(20, 1))",[3008,3023,3091],"spy",{"_19":3091,"_21":3093,"_23":3094,"_25":3095,"_26":3096,"_32":3017,"_34":3106,"_1363":3113},"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.",[3097,3100,3103],{"_19":3098,"_25":3099},"S","Input matrix (sparse or full)",{"_19":3101,"_25":3102,"_31":61},"linespec","Line specification for marker style (e.g., 'ro' for red circles)",{"_19":3104,"_25":3105,"_31":61},"markersize","Marker size in points (default: auto-scaled based on matrix size)",[3107,3109,3111],{"_1356":3108},"A = eye(10);\nspy(A)",{"_1356":3110},"B = rand(20, 20) > 0.8;\nspy(B)",{"_1356":3112},"spy(magic(10) > 50, 'ro', 8)",[3022,3114,1914,3115],"imagesc","nnz",{"_19":3117,"_21":3118,"_23":3119,"_25":3120,"_26":3121,"_32":3134,"_34":3135,"_1363":3140},"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).",[3122,3124,3126,3129,3132],{"_19":1568,"_25":3123,"_31":61},"Arrow base X-coordinates (matrix or vector)",{"_19":2836,"_25":3125,"_31":61},"Arrow base Y-coordinates (matrix or vector)",{"_19":3127,"_25":3128},"U","Arrow X-direction components (matrix or vector)",{"_19":3130,"_25":3131},"V","Arrow Y-direction components (matrix or vector)",{"_19":929,"_25":3133,"_31":61},"Arrow scaling factor (default: 1, 0 disables auto-scaling)","Graphics handle",[3136,3138],{"_1356":3137},"[X, Y] = meshgrid(1:5, 1:5);\nquiver(X, Y, ones(5), ones(5))",{"_1356":3139},"U = cos(linspace(0, 2*pi, 25));\nV = sin(linspace(0, 2*pi, 25));\nquiver(U, V)",[3008,3022,1481],{"_19":3142,"_21":3143,"_23":3144,"_25":3145,"_26":3146,"_32":3134,"_34":3169,"_1363":3176},"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].",[3147,3149,3151,3154,3157,3160,3163,3166],{"_19":1568,"_25":3148},"X-coordinates of polygon vertices (vector)",{"_19":2836,"_25":3150},"Y-coordinates of polygon vertices (vector)",{"_19":3152,"_25":3153,"_31":61},"C","Color specification: short name, long name, or RGB triplet",{"_19":3155,"_25":3156,"_31":61},"FaceColor","Fill color (Name-Value pair)",{"_19":3158,"_25":3159,"_31":61},"FaceAlpha","Fill transparency 0-1 (Name-Value pair)",{"_19":3161,"_25":3162,"_31":61},"EdgeColor","Edge color or 'none' (Name-Value pair)",{"_19":3164,"_25":3165,"_31":61},"LineWidth","Edge line width (Name-Value pair)",{"_19":3167,"_25":3168,"_31":61},"LineStyle","Edge line style: '-', '--', ':', '-.', 'none' (Name-Value pair)",[3170,3172,3174],{"_1356":3171},"fill([0 1 0.5], [0 0 1], 'r')",{"_1356":3173},"x = cos(linspace(0, 2*pi, 6));\ny = sin(linspace(0, 2*pi, 6));\nfill(x, y, 'b', 'FaceAlpha', 0.5)",{"_1356":3175},"fill([0 1 1 0], [0 0 1 1], [0.2 0.6 0.8], 'EdgeColor', 'none')",[3008,3177,3178],"patch","area",{"_19":3076,"_21":3180,"_23":3181,"_25":3182,"_26":3183,"_32":3017,"_34":3189,"_1363":3192},"histogram(data)\nhistogram(data, numBins)","Histogram","Creates a histogram of the data, auto-binned into the specified number of bins (default 10).",[3184,3186],{"_19":687,"_25":3185},"Input data (NDArray)",{"_19":3187,"_25":3188,"_31":61},"numBins","Number of bins (default: 10)",[3190],{"_1356":3191},"histogram(randn(100, 1))",[3023,3008],{"_19":3077,"_21":3194,"_23":3195,"_25":3196,"_26":3197,"_32":3017,"_34":3200,"_1363":3203},"pie(data)","Pie chart","Creates a pie chart from the data values.",[3198],{"_19":687,"_25":3199},"Slice values (NDArray)",[3201],{"_1356":3202},"pie([30 20 50])",[3023,3076],{"_19":3205,"_21":3206,"_23":3207,"_25":3208,"_26":3209,"_32":3212,"_34":3213,"_1363":3216},"title","title(str)","Add title to current chart","Sets the title of the most recently created chart.",[3210],{"_19":2115,"_25":3211},"Title string","null",[3214],{"_1356":3215},"plot([1 4 9 16]);\ntitle('Squares')",[3217,3218,3219],"xlabel","ylabel","legend",{"_19":3217,"_21":3221,"_23":3222,"_25":3223,"_26":3224,"_32":3212,"_34":3227,"_1363":3230},"xlabel(str)","Label x-axis","Sets the x-axis label of the most recently created chart.",[3225],{"_19":2115,"_25":3226},"Label string",[3228],{"_1356":3229},"xlabel('Time (s)')",[3218,3205],{"_19":3218,"_21":3232,"_23":3233,"_25":3234,"_26":3235,"_32":3212,"_34":3237,"_1363":3240},"ylabel(str)","Label y-axis","Sets the y-axis label of the most recently created chart.",[3236],{"_19":2115,"_25":3226},[3238],{"_1356":3239},"ylabel('Amplitude')",[3217,3205],{"_19":3219,"_21":3242,"_23":3243,"_25":3244,"_26":3245,"_32":3212,"_34":3249,"_1363":3252},"legend('label1', 'label2', ...)","Add legend to current chart","Adds a legend to the most recently created chart with the given labels.",[3246],{"_19":3247,"_25":3248},"labels","One or more string labels",[3250],{"_1356":3251},"legend('sin', 'cos')",[3205,3217,3218],{"_19":3254,"_21":3255,"_23":3256,"_25":3257,"_26":3258,"_32":3212,"_34":3261,"_1363":3264},"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.",[3259],{"_19":693,"_25":3260,"_31":61},"Figure number",[3262],{"_1356":3263},"plot([1 2 3]);\nfigure();\nplot([4 5 6])",[3008,3023,3022,3265,3266],"gcf","clf",{"_19":3268,"_21":3269,"_23":3270,"_25":3271,"_26":3272,"_32":3212,"_34":3277,"_1363":3280},"xlim","xlim([min max])","Set x-axis limits","Sets the minimum and maximum values for the x-axis of the current chart.",[3273,3275],{"_19":1827,"_25":3274},"Minimum x value",{"_19":1828,"_25":3276},"Maximum x value",[3278],{"_1356":3279},"plot([1 2 3 4]);\nxlim([0 5])",[3281,3282],"ylim","axis",{"_19":3281,"_21":3284,"_23":3285,"_25":3286,"_26":3287,"_32":3212,"_34":3292,"_1363":3295},"ylim([min max])","Set y-axis limits","Sets the minimum and maximum values for the y-axis of the current chart.",[3288,3290],{"_19":1827,"_25":3289},"Minimum y value",{"_19":1828,"_25":3291},"Maximum y value",[3293],{"_1356":3294},"plot([1 2 3 4]);\nylim([0 5])",[3268,3282],{"_19":3297,"_21":3298,"_23":3299,"_25":3300,"_26":3301,"_32":3212,"_34":3304,"_1363":3307},"xticks","xticks(values)","Set x-axis tick values","Sets custom tick mark positions on the x-axis.",[3302],{"_19":214,"_25":3303},"Vector of tick positions",[3305],{"_1356":3306},"plot([1 2 3 4]);\nxticks([1 2 3 4])",[3308,3268],"yticks",{"_19":3308,"_21":3310,"_23":3311,"_25":3312,"_26":3313,"_32":3212,"_34":3315,"_1363":3318},"yticks(values)","Set y-axis tick values","Sets custom tick mark positions on the y-axis.",[3314],{"_19":214,"_25":3303},[3316],{"_1356":3317},"bar([10 20 30]);\nyticks([0 10 20 30])",[3297,3281],{"_19":3320,"_21":3321,"_23":3322,"_25":3323,"_26":3324,"_32":3212,"_34":3328,"_1363":3331},"xtickangle","xtickangle(angle)","Rotate x-axis tick labels","Sets the rotation angle (in degrees) for x-axis tick labels.",[3325],{"_19":3326,"_25":3327},"angle","Rotation angle in degrees",[3329],{"_1356":3330},"bar([1 2 3]);\nxtickangle(45)",[3332,3297],"ytickangle",{"_19":3332,"_21":3334,"_23":3335,"_25":3336,"_26":3337,"_32":3212,"_34":3339,"_1363":3342},"ytickangle(angle)","Rotate y-axis tick labels","Sets the rotation angle (in degrees) for y-axis tick labels.",[3338],{"_19":3326,"_25":3327},[3340],{"_1356":3341},"bar([1 2 3]);\nytickangle(90)",[3320,3308],{"_19":3344,"_21":3345,"_23":3346,"_25":3347,"_26":3348,"_32":3212,"_34":3352,"_1363":3355},"grid","grid\ngrid('on')\ngrid('off')","Toggle grid lines","Controls the visibility of grid lines on the current chart.",[3349],{"_19":3350,"_25":3351,"_31":61},"state","'on' or 'off' (default: toggle)",[3353],{"_1356":3354},"plot([1 2 3]);\ngrid('on')",[3282,3268,3281],{"_19":3282,"_21":3357,"_23":3358,"_25":3359,"_26":3360,"_32":3212,"_34":3364,"_1363":3367},"axis([xmin xmax ymin ymax])","Set axis limits and scaling","Sets the limits for both x and y axes simultaneously.",[3361],{"_19":3362,"_25":3363},"limits","4-element vector [xmin xmax ymin ymax]",[3365],{"_1356":3366},"plot([1 2 3]);\naxis([0 4 0 4])",[3268,3281,3344],{"_19":3369,"_21":3370,"_23":3371,"_25":3372,"_26":3373,"_32":3212,"_34":3375,"_1363":3378},"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.",[3374],{"_19":3350,"_25":3351,"_31":61},[3376],{"_1356":3377},"plot([1 2 3]);\nhold('on');\nbar([2 3 4])",[3254,3008],{"_19":3265,"_21":3380,"_23":3381,"_25":3382,"_26":3383,"_32":3384,"_34":3385,"_1363":3387},"f = gcf","Get current figure","Returns the handle (ID) of the current figure.",[],"Figure ID number",[3386],{"_1356":3380},[3254,3388,3266],"gca",{"_19":3388,"_21":3390,"_23":3391,"_25":3392,"_26":3393,"_32":3394,"_34":3395,"_1363":3397},"ax = gca","Get current axes","Returns the handle (ID) of the current axes (same as gcf in this implementation).",[],"Axes ID number",[3396],{"_1356":3390},[3265,3254],{"_19":3266,"_21":3266,"_23":3399,"_25":3400,"_26":3401,"_32":3212,"_34":3402,"_1363":3405},"Clear current figure","Clears all charts from the current figure, resetting its state.",[],[3403],{"_1356":3404},"plot([1 2 3]);\nclf()",[3406,3254],"close",{"_19":3406,"_21":3408,"_23":3409,"_25":3410,"_26":3411,"_32":3212,"_34":3415,"_1363":3418},"close\nclose(fig)","Close figure","Closes the current figure or the specified figure by ID.",[3412],{"_19":3413,"_25":3414,"_31":61},"fig","Figure ID to close",[3416],{"_1356":3417},"close()",[3266,3254],{"_19":3420,"_21":3421,"_23":3422,"_25":3423,"_26":3424,"_32":3212,"_34":3431,"_1363":3434},"text","text(x, y, str)","Add text annotation","Adds a text annotation at the specified (x, y) coordinates in data units.",[3425,3427,3429],{"_19":94,"_25":3426},"X-coordinate",{"_19":1489,"_25":3428},"Y-coordinate",{"_19":2115,"_25":3430},"Text string",[3432],{"_1356":3433},"plot([1 2 3]);\ntext(2, 2.5, 'Peak')",[3205,3217,3218],{"_19":3436,"_21":3437,"_23":3438,"_25":3439,"_26":3440,"_32":3212,"_34":3444,"_1363":3447},"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.",[3441],{"_19":3442,"_25":3443},"side","'left' or 'right'",[3445],{"_1356":3446},"plot([1 2 3]);\nyyaxis('right');\nplot([10 20 30])",[3218,3281],{"_19":3449,"_21":3450,"_23":3451,"_25":3452,"_26":3453,"_32":3212,"_34":3461,"_1363":3464},"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).",[3454,3456,3458],{"_19":709,"_25":3455},"Number of rows in grid",{"_19":712,"_25":3457},"Number of columns in grid",{"_19":3459,"_25":3460},"index","1-based position in grid (row-major order)",[3462],{"_1356":3463},"subplot(2, 2, 1);\nplot([1 2 3]);\nsubplot(2, 2, 2);\nbar([4 5 6])",[3254,3008],{"_19":1505,"_21":3466,"_23":3467,"_25":3468,"_26":3469,"_32":3479,"_34":3480,"_1363":3483},"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.",[3470,3472,3474,3477],{"_19":1568,"_25":3471,"_31":61},"X-coordinate matrix (auto-generated if omitted)",{"_19":2836,"_25":3473,"_31":61},"Y-coordinate matrix (auto-generated if omitted)",{"_19":3475,"_25":3476},"Z","Height matrix (required)",{"_19":3152,"_25":3478,"_31":61},"Color data matrix (defaults to Z)","null (renders 3D chart inline)",[3481],{"_1356":3482},"[X, Y] = meshgrid(-2:0.2:2);\nZ = X .* exp(-X.^2 - Y.^2);\nmesh(X, Y, Z)",[1504,1481,3484],"zlabel",{"_19":1504,"_21":3486,"_23":3487,"_25":3488,"_26":3489,"_32":3479,"_34":3494,"_1363":3497},"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.",[3490,3491,3492,3493],{"_19":1568,"_25":3471,"_31":61},{"_19":2836,"_25":3473,"_31":61},{"_19":3475,"_25":3476},{"_19":3152,"_25":3478,"_31":61},[3495],{"_1356":3496},"[X, Y] = meshgrid(-2:0.2:2);\nZ = X .* exp(-X.^2 - Y.^2);\nsurf(X, Y, Z)",[1505,1481,3484],{"_19":3484,"_21":3499,"_23":3500,"_25":3501,"_26":3502,"_32":3212,"_34":3504,"_1363":3507},"zlabel(str)","Label z-axis","Sets the z-axis label of the most recently created 3D chart.",[3503],{"_19":2115,"_25":3226},[3505],{"_1356":3506},"[X, Y] = meshgrid(-2:0.2:2);\nZ = X .* exp(-X.^2 - Y.^2);\nsurf(X, Y, Z);\nzlabel('Height')",[3217,3218,3205,1505,1504],{"_19":3509,"_21":3510,"_23":3511,"_25":3512,"_26":3513,"_32":3520,"_34":3521,"_1363":3528},"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).",[3514,3517],{"_19":3515,"_25":3516,"_31":61},"az","Azimuth angle in degrees",{"_19":3518,"_25":3519,"_31":61},"el","Elevation angle in degrees","With no arguments, returns [az, el] of current view",[3522,3524,3526],{"_1356":3523},"[X, Y] = meshgrid(-2:0.2:2);\nZ = X .* exp(-X.^2 - Y.^2);\nsurf(X, Y, Z);\nview(45, 30)",{"_1356":3525},"[X, Y] = meshgrid(-2:0.2:2);\nZ = sin(X) .* cos(Y);\nsurf(X, Y, Z);\nview(2) % Top-down view",{"_1356":3527},"[X, Y] = meshgrid(-2:0.2:2);\nZ = X.^2 - Y.^2;\nmesh(X, Y, Z);\nview(3) % Default 3D view",[1505,1504,3484],{"_19":3114,"_21":3530,"_23":3531,"_25":3532,"_26":3533,"_32":3543,"_34":3544,"_1363":3551},"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.",[3534,3536,3538,3540],{"_19":94,"_25":3535,"_31":61},"X-axis coordinates for columns (2-element vector or full vector)",{"_19":1489,"_25":3537,"_31":61},"Y-axis coordinates for rows (2-element vector or full vector)",{"_19":3152,"_25":3539},"Data matrix to display",{"_19":3541,"_25":3542,"_31":61},"clims","Color limits [cmin cmax]","null (renders heatmap inline)",[3545,3547,3549],{"_1356":3546},"A = magic(5);\nimagesc(A)",{"_1356":3548},"A = peaks(50);\nimagesc(A)\ncolorbar",{"_1356":3550},"imagesc([0 10], [0 5], rand(10, 20))\ntitle('Random data')",[3552,3553,1505,1504],"colorbar","colormap",{"_19":3552,"_21":3555,"_23":3556,"_25":3557,"_26":3558,"_32":3562,"_34":3563,"_1363":3572},"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().",[3559],{"_19":3560,"_25":3561,"_31":61},"location","Location string: 'eastoutside' (default), 'westoutside', 'northoutside', 'southoutside', or 'off'","Colorbar handle (when assigned to variable)",[3564,3566,3568,3570],{"_1356":3565},"imagesc(peaks(30));\ncolorbar",{"_1356":3567},"surf(peaks(30));\ncolorbar('southoutside')",{"_1356":3569},"imagesc(rand(20));\nc = colorbar;\nset(c, 'Title', 'Values')",{"_1356":3571},"mesh(peaks);\ncolorbar('off')",[3114,3553,1505,1504,3573],"set",{"_19":3553,"_21":3575,"_23":3576,"_25":3577,"_26":3578,"_32":3584,"_34":3585,"_1363":3594},"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].",[3579,3581],{"_19":19,"_25":3580,"_31":61},"Colormap name: viridis (default), jet, hot, cool, gray, grayscale, parula, turbo, coolwarm, rainbow, bone, copper, spring, summer, autumn, winter",{"_19":3582,"_25":3583,"_31":61},"map","Mx3 matrix of RGB values (each in [0,1])","Mx3 RGB matrix (query mode) or null (set mode)",[3586,3588,3590,3592],{"_1356":3587},"imagesc(peaks(30));\ncolormap('jet');\ncolorbar",{"_1356":3589},"surf(peaks(25));\ncolormap('hot')",{"_1356":3591},"cmap = colormap % returns 256x3 matrix",{"_1356":3593},"colormap([0 0 1; 1 1 1; 1 0 0]) % custom blue-white-red",[3114,3552,1505,1504],{"_19":3596,"_21":3597,"_23":3598,"_25":3599,"_26":3600,"_32":3212,"_34":3604,"_1363":3609},"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.",[3601],{"_19":3602,"_25":3603},"mode","Shading mode: 'faceted' (default), 'flat', or 'interp'",[3605,3607],{"_1356":3606},"surf(peaks(30));\nshading interp",{"_1356":3608},"[X, Y] = meshgrid(-2:0.2:2);\nZ = X .* exp(-X.^2 - Y.^2);\nsurf(X, Y, Z);\nshading flat;\ncolorbar",[1504,1505,3553,3552],{"_38":3611,"_19":3612,"_25":3613,"_42":43,"_44":3614,"_48":3615},"poly","Polynomial Functions","Polynomial operations across power, Chebyshev, Legendre, Hermite, HermiteE, and Laguerre bases with fitting, evaluation, calculus, arithmetic, and conversion utilities.","∑",[3616,3636,3654,3669,3684,3700,3721,3735,3748,3761,3776,3790,3801,3812,3828,3843,3857,3869,3887,3902,3918,3929,3940,3953,3968,3978,3989,3998,4010,4023,4033,4041,4053,4065,4079,4094,4106,4116,4129,4138,4147,4156,4166,4177,4185,4193,4203,4213,4224,4239,4249,4259,4271,4280,4290,4299,4309,4320,4328,4336,4346,4356,4367,4380,4390,4400,4412,4421,4431,4440,4450,4461,4469,4477,4487,4497,4508,4523,4533,4543,4555,4564,4574,4583,4593,4604,4612,4620,4630,4640,4651,4661,4669,4677,4685,4693,4710,4723,4739,4755],{"_19":3617,"_21":3618,"_23":3619,"_25":3620,"_26":3621,"_32":3627,"_34":3628,"_1363":3632},"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 + ...",[3622,3624],{"_19":94,"_25":3623},"Point at which to evaluate",{"_19":3625,"_25":3626},"c","Coefficient array in ascending order [c0, c1, c2, ...]","Polynomial value at x",[3629],{"_1356":3630,"_1358":3631},"polyval(2, [1 2 3])","17",[3633,3634,3635],"polyfit","polyder","polyint",{"_19":3637,"_21":3638,"_23":3639,"_25":3640,"_26":3641,"_32":3648,"_34":3649,"_1363":3652},"polyval2d","z = polyval2d(x, y, c)","Evaluate 2-D power series polynomial","Evaluates a 2-D power series polynomial on x-y pairs.",[3642,3644,3646],{"_19":94,"_25":3643},"x coordinates",{"_19":1489,"_25":3645},"y coordinates",{"_19":3625,"_25":3647},"2-D coefficient array","Polynomial values at (x, y) pairs",[3650],{"_1356":3651},"polyval2d([1 2], [1 2], [1 0; 0 1])",[3617,3653],"polyval3d",{"_19":3653,"_21":3655,"_23":3656,"_25":3657,"_26":3658,"_32":3666,"_34":3667,"_1363":3668},"w = polyval3d(x, y, z, c)","Evaluate 3-D power series polynomial","Evaluates a 3-D power series polynomial on x-y-z triples.",[3659,3660,3661,3664],{"_19":94,"_25":3643},{"_19":1489,"_25":3645},{"_19":3662,"_25":3663},"z","z coordinates",{"_19":3625,"_25":3665},"3-D coefficient array","Polynomial values at (x, y, z) triples",[],[3617,3637],{"_19":3634,"_21":3670,"_23":3671,"_25":3672,"_26":3673,"_32":3678,"_34":3679,"_1363":3683},"dc = polyder(c)\ndc = polyder(c, m)","Power series derivative","Differentiates a power series polynomial m times. Default m = 1.",[3674,3676],{"_19":3625,"_25":3675},"Coefficient array in ascending order",{"_19":690,"_25":3677,"_31":61},"Number of derivatives (default: 1)","Differentiated coefficient array",[3680],{"_1356":3681,"_1358":3682},"polyder([1 2 3])","[2 6]",[3635,3617],{"_19":3635,"_21":3685,"_23":3686,"_25":3687,"_26":3688,"_32":3694,"_34":3695,"_1363":3699},"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].",[3689,3690,3692],{"_19":3625,"_25":3675},{"_19":690,"_25":3691,"_31":61},"Number of integrations (default: 1)",{"_19":2100,"_25":3693,"_31":61},"Integration constants (default: all zero)","Integrated coefficient array",[3696],{"_1356":3697,"_1358":3698},"polyint([2 6])","[0 2 3]",[3634,3617],{"_19":3701,"_21":3702,"_23":3703,"_25":3704,"_26":3705,"_32":3712,"_34":3713,"_1363":3717},"polymul","c = polymul(c1, c2)","Multiply two power series polynomials","Multiplies two power series coefficient arrays using convolution.",[3706,3709],{"_19":3707,"_25":3708},"c1","First coefficient array",{"_19":3710,"_25":3711},"c2","Second coefficient array","Product coefficient array",[3714],{"_1356":3715,"_1358":3716},"polymul([1 1], [1 1])","[1 2 1]",[3718,3719,3720],"polydiv","polyadd","polysub",{"_19":3718,"_21":3722,"_23":3723,"_25":3724,"_26":3725,"_32":3730,"_34":3731,"_1363":3734},"[q, r] = polydiv(c1, c2)","Divide two power series polynomials","Divides two power series coefficient arrays. Returns quotient and remainder.",[3726,3728],{"_19":3707,"_25":3727},"Dividend coefficient array",{"_19":3710,"_25":3729},"Divisor coefficient array","Quotient and remainder coefficient arrays",[3732],{"_1356":3733},"polydiv([1 2 1], [1 1])",[3701,3719,3720],{"_19":3719,"_21":3736,"_23":3737,"_25":3738,"_26":3739,"_32":3742,"_34":3743,"_1363":3747},"c = polyadd(c1, c2)","Add two power series polynomials","Adds two power series coefficient arrays.",[3740,3741],{"_19":3707,"_25":3708},{"_19":3710,"_25":3711},"Sum coefficient array",[3744],{"_1356":3745,"_1358":3746},"polyadd([1 2], [3 4])","[4 6]",[3720,3701,3718],{"_19":3720,"_21":3749,"_23":3750,"_25":3751,"_26":3752,"_32":3755,"_34":3756,"_1363":3760},"c = polysub(c1, c2)","Subtract two power series polynomials","Subtracts two power series coefficient arrays.",[3753,3754],{"_19":3707,"_25":3708},{"_19":3710,"_25":3711},"Difference coefficient array",[3757],{"_1356":3758,"_1358":3759},"polysub([3 4], [1 2])","[2 2]",[3719,3701,3718],{"_19":3762,"_21":3763,"_23":3764,"_25":3765,"_26":3766,"_32":3771,"_34":3772,"_1363":3775},"polypow","c = polypow(c, n)","Raise power series polynomial to a power","Raises a power series polynomial to a non-negative integer power.",[3767,3769],{"_19":3625,"_25":3768},"Coefficient array",{"_19":693,"_25":3770},"Non-negative integer power","Resulting coefficient array",[3773],{"_1356":3774,"_1358":3716},"polypow([1 1], 2)",[3701],{"_19":3777,"_21":3778,"_23":3779,"_25":3780,"_26":3781,"_32":3783,"_34":3784,"_1363":3787},"polyroots","r = polyroots(c)","Find power series polynomial roots","Finds roots of a power series polynomial using companion matrix eigenvalues.",[3782],{"_19":3625,"_25":3675},"Array of roots",[3785],{"_1356":3786},"polyroots([-1 0 1])",[3788,3789],"polyfromroots","polycompanion",{"_19":3788,"_21":3791,"_23":3792,"_25":3793,"_26":3794,"_32":3675,"_34":3797,"_1363":3800},"c = polyfromroots(r)","Construct power series from roots","Constructs a power series polynomial from its roots.",[3795],{"_19":3796,"_25":3783},"r",[3798],{"_1356":3799},"polyfromroots([1 -1])",[3777],{"_19":3789,"_21":3802,"_23":3803,"_25":3804,"_26":3805,"_32":3807,"_34":3808,"_1363":3811},"C = polycompanion(c)","Power series companion matrix","Generates the companion matrix for a power series polynomial.",[3806],{"_19":3625,"_25":3768},"Companion matrix",[3809],{"_1356":3810},"polycompanion([-1 0 1])",[3777],{"_19":3813,"_21":3814,"_23":3815,"_25":3816,"_26":3817,"_32":3823,"_34":3824,"_1363":3827},"polyvander","V = polyvander(x, deg)","Power series Vandermonde matrix","Generates a Vandermonde matrix of the given degree for the given sample points.",[3818,3820],{"_19":94,"_25":3819},"Sample points",{"_19":3821,"_25":3822},"deg","Degree of polynomial","Vandermonde matrix",[3825],{"_1356":3826},"polyvander([1 2 3], 2)",[3633],{"_19":3633,"_21":3829,"_23":3830,"_25":3831,"_26":3832,"_32":3675,"_34":3839,"_1363":3842},"c = polyfit(x, y, deg)","Least-squares power series fit","Fits a power series polynomial of the given degree to data using least squares.",[3833,3835,3837],{"_19":94,"_25":3834},"x values",{"_19":1489,"_25":3836},"y values",{"_19":3821,"_25":3838},"Degree of fitting polynomial",[3840],{"_1356":3841},"polyfit([0 1 2 3], [0 1 4 9], 2)",[3617,3813],{"_19":3844,"_21":3845,"_23":3846,"_25":3847,"_26":3848,"_32":3851,"_34":3852,"_1363":3856},"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].",[3849],{"_19":2628,"_25":3850},"Coefficient vector in descending order","Column vector of roots",[3853],{"_1356":3854,"_1358":3855},"roots([1 0 -1])","[1; -1]",[3611,3777],{"_19":3611,"_21":3858,"_23":3859,"_25":3860,"_26":3861,"_32":3850,"_34":3864,"_1363":3868},"p = poly(r)","Polynomial from roots (M-Code convention)","Constructs polynomial coefficients in descending order from a vector of roots.",[3862],{"_19":3796,"_25":3863},"Vector of roots",[3865],{"_1356":3866,"_1358":3867},"poly([1 -1])","[1 0 -1]",[3844,3788],{"_19":3870,"_21":3871,"_23":3872,"_25":3873,"_26":3874,"_32":3881,"_34":3882,"_1363":3885},"conv","w = conv(u, v)","Convolution / polynomial multiplication (M-Code convention)","Convolves two vectors, equivalent to polynomial multiplication with descending-order coefficients.",[3875,3878],{"_19":3876,"_25":3877},"u","First input vector (descending order)",{"_19":3879,"_25":3880},"v","Second input vector (descending order)","Convolution result (descending order)",[3883],{"_1356":3884,"_1358":3716},"conv([1 1], [1 1])",[3886,3701],"deconv",{"_19":3886,"_21":3888,"_23":3889,"_25":3890,"_26":3891,"_32":3896,"_34":3897,"_1363":3901},"[q, r] = deconv(b, a)","Deconvolution / polynomial division (M-Code convention)","Deconvolves two vectors, equivalent to polynomial long division with descending-order coefficients.",[3892,3894],{"_19":91,"_25":3893},"Dividend vector (descending order)",{"_19":1423,"_25":3895},"Divisor vector (descending order)","Quotient vector (descending order)",[3898],{"_1356":3899,"_1358":3900},"deconv([1 2 1], [1 1])","[1 1]",[3870,3718],{"_19":3903,"_21":3904,"_23":3905,"_25":3906,"_26":3907,"_32":3627,"_34":3911,"_1363":3914},"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 + ...",[3908,3909],{"_19":94,"_25":3623},{"_19":3625,"_25":3910},"Chebyshev coefficient array",[3912],{"_1356":3913},"chebval(0.5, [1 2 3])",[3915,3916,3917],"chebfit","chebder","chebint",{"_19":3919,"_21":3920,"_23":3921,"_25":3922,"_26":3923,"_32":3648,"_34":3927,"_1363":3928},"chebval2d","z = chebval2d(x, y, c)","Evaluate 2-D Chebyshev polynomial","Evaluates a 2-D Chebyshev polynomial on x-y pairs.",[3924,3925,3926],{"_19":94,"_25":3643},{"_19":1489,"_25":3645},{"_19":3625,"_25":3647},[],[3903],{"_19":3916,"_21":3930,"_23":3931,"_25":3932,"_26":3933,"_32":3678,"_34":3936,"_1363":3939},"dc = chebder(c)\ndc = chebder(c, m)","Chebyshev derivative","Differentiates a Chebyshev polynomial m times.",[3934,3935],{"_19":3625,"_25":3910},{"_19":690,"_25":3677,"_31":61},[3937],{"_1356":3938},"chebder([1 2 3])",[3917,3903],{"_19":3917,"_21":3941,"_23":3942,"_25":3943,"_26":3944,"_32":3694,"_34":3949,"_1363":3952},"ic = chebint(c)\nic = chebint(c, m)\nic = chebint(c, m, k)","Chebyshev integral","Integrates a Chebyshev polynomial m times with integration constants k.",[3945,3946,3947],{"_19":3625,"_25":3910},{"_19":690,"_25":3691,"_31":61},{"_19":2100,"_25":3948,"_31":61},"Integration constants",[3950],{"_1356":3951},"chebint([2 6])",[3916,3903],{"_19":3954,"_21":3955,"_23":3956,"_25":3957,"_26":3958,"_32":3712,"_34":3961,"_1363":3964},"chebmul","c = chebmul(c1, c2)","Multiply two Chebyshev polynomials","Multiplies two Chebyshev coefficient arrays.",[3959,3960],{"_19":3707,"_25":3708},{"_19":3710,"_25":3711},[3962],{"_1356":3963},"chebmul([1 1], [1 1])",[3965,3966,3967],"chebdiv","chebadd","chebsub",{"_19":3965,"_21":3969,"_23":3970,"_25":3971,"_26":3972,"_32":3975,"_34":3976,"_1363":3977},"[q, r] = chebdiv(c1, c2)","Divide two Chebyshev polynomials","Divides two Chebyshev coefficient arrays. Returns quotient and remainder.",[3973,3974],{"_19":3707,"_25":3727},{"_19":3710,"_25":3729},"Quotient and remainder",[],[3954],{"_19":3966,"_21":3979,"_23":3980,"_25":3981,"_26":3982,"_32":3742,"_34":3985,"_1363":3988},"c = chebadd(c1, c2)","Add two Chebyshev polynomials","Adds two Chebyshev coefficient arrays.",[3983,3984],{"_19":3707,"_25":3708},{"_19":3710,"_25":3711},[3986],{"_1356":3987},"chebadd([1 2], [3 4])",[3967,3954],{"_19":3967,"_21":3990,"_23":3991,"_25":3992,"_26":3993,"_32":3755,"_34":3996,"_1363":3997},"c = chebsub(c1, c2)","Subtract two Chebyshev polynomials","Subtracts two Chebyshev coefficient arrays.",[3994,3995],{"_19":3707,"_25":3708},{"_19":3710,"_25":3711},[],[3966,3954],{"_19":3999,"_21":4000,"_23":4001,"_25":4002,"_26":4003,"_32":3771,"_34":4006,"_1363":4009},"chebpow","c = chebpow(c, n)","Raise Chebyshev polynomial to a power","Raises a Chebyshev polynomial to a non-negative integer power.",[4004,4005],{"_19":3625,"_25":3768},{"_19":693,"_25":3770},[4007],{"_1356":4008},"chebpow([1 1], 2)",[3954],{"_19":4011,"_21":4012,"_23":4013,"_25":4014,"_26":4015,"_32":3783,"_34":4017,"_1363":4020},"chebroots","r = chebroots(c)","Find Chebyshev polynomial roots","Finds roots of a Chebyshev polynomial using companion matrix eigenvalues.",[4016],{"_19":3625,"_25":3910},[4018],{"_1356":4019},"chebroots([1 0 -1])",[4021,4022],"chebfromroots","chebcompanion",{"_19":4021,"_21":4024,"_23":4025,"_25":4026,"_26":4027,"_32":3910,"_34":4029,"_1363":4032},"c = chebfromroots(r)","Construct Chebyshev polynomial from roots","Constructs Chebyshev coefficient array from roots.",[4028],{"_19":3796,"_25":3783},[4030],{"_1356":4031},"chebfromroots([1 -1])",[4011],{"_19":4022,"_21":4034,"_23":4035,"_25":4036,"_26":4037,"_32":3807,"_34":4039,"_1363":4040},"C = chebcompanion(c)","Chebyshev companion matrix","Generates the companion matrix for a Chebyshev polynomial.",[4038],{"_19":3625,"_25":3910},[],[4011],{"_19":4042,"_21":4043,"_23":4044,"_25":4045,"_26":4046,"_32":3823,"_34":4049,"_1363":4052},"chebvander","V = chebvander(x, deg)","Chebyshev Vandermonde matrix","Generates a Chebyshev Vandermonde matrix for the given sample points and degree.",[4047,4048],{"_19":94,"_25":3819},{"_19":3821,"_25":3822},[4050],{"_1356":4051},"chebvander([0 0.5 1], 2)",[3915],{"_19":3915,"_21":4054,"_23":4055,"_25":4056,"_26":4057,"_32":3910,"_34":4061,"_1363":4064},"c = chebfit(x, y, deg)","Least-squares Chebyshev fit","Fits a Chebyshev polynomial of the given degree to data using least squares.",[4058,4059,4060],{"_19":94,"_25":3834},{"_19":1489,"_25":3836},{"_19":3821,"_25":3838},[4062],{"_1356":4063},"chebfit([0 0.5 1], [1 1.5 2], 1)",[3903,4042],{"_19":4066,"_21":4067,"_23":4068,"_25":4069,"_26":4070,"_32":4073,"_34":4074,"_1363":4077},"cheb2poly","p = cheb2poly(c)","Convert Chebyshev to power series","Converts Chebyshev coefficients to power series coefficients.",[4071],{"_19":3625,"_25":4072},"Chebyshev coefficients","Power series coefficients",[4075],{"_1356":4076},"cheb2poly([1 0 1])",[4078],"poly2cheb",{"_19":4080,"_21":4081,"_23":4082,"_25":4083,"_26":4084,"_32":3627,"_34":4088,"_1363":4091},"legval","y = legval(x, c)","Evaluate Legendre polynomial","Evaluates a Legendre polynomial at point x.",[4085,4086],{"_19":94,"_25":3623},{"_19":3625,"_25":4087},"Legendre coefficient array",[4089],{"_1356":4090},"legval(0.5, [1 2 3])",[4092,4093],"legfit","legder",{"_19":4093,"_21":4095,"_23":4096,"_25":4097,"_26":4098,"_32":3678,"_34":4101,"_1363":4104},"dc = legder(c)\ndc = legder(c, m)","Legendre derivative","Differentiates a Legendre polynomial m times.",[4099,4100],{"_19":3625,"_25":4087},{"_19":690,"_25":3677,"_31":61},[4102],{"_1356":4103},"legder([1 2 3])",[4105,4080],"legint",{"_19":4105,"_21":4107,"_23":4108,"_25":4109,"_26":4110,"_32":3694,"_34":4114,"_1363":4115},"ic = legint(c)\nic = legint(c, m)\nic = legint(c, m, k)","Legendre integral","Integrates a Legendre polynomial m times.",[4111,4112,4113],{"_19":3625,"_25":4087},{"_19":690,"_25":3691,"_31":61},{"_19":2100,"_25":3948,"_31":61},[],[4093,4080],{"_19":4117,"_21":4118,"_23":4119,"_25":4120,"_26":4121,"_32":3712,"_34":4124,"_1363":4125},"legmul","c = legmul(c1, c2)","Multiply two Legendre polynomials","Multiplies two Legendre coefficient arrays.",[4122,4123],{"_19":3707,"_25":3708},{"_19":3710,"_25":3711},[],[4126,4127,4128],"legdiv","legadd","legsub",{"_19":4126,"_21":4130,"_23":4131,"_25":4132,"_26":4133,"_32":3975,"_34":4136,"_1363":4137},"[q, r] = legdiv(c1, c2)","Divide two Legendre polynomials","Divides two Legendre coefficient arrays.",[4134,4135],{"_19":3707,"_25":3727},{"_19":3710,"_25":3729},[],[4117],{"_19":4127,"_21":4139,"_23":4140,"_25":4141,"_26":4142,"_32":3742,"_34":4145,"_1363":4146},"c = legadd(c1, c2)","Add two Legendre polynomials","Adds two Legendre coefficient arrays.",[4143,4144],{"_19":3707,"_25":3708},{"_19":3710,"_25":3711},[],[4128,4117],{"_19":4128,"_21":4148,"_23":4149,"_25":4150,"_26":4151,"_32":3755,"_34":4154,"_1363":4155},"c = legsub(c1, c2)","Subtract two Legendre polynomials","Subtracts two Legendre coefficient arrays.",[4152,4153],{"_19":3707,"_25":3708},{"_19":3710,"_25":3711},[],[4127,4117],{"_19":4157,"_21":4158,"_23":4159,"_25":4160,"_26":4161,"_32":3771,"_34":4164,"_1363":4165},"legpow","c = legpow(c, n)","Raise Legendre polynomial to a power","Raises a Legendre polynomial to a non-negative integer power.",[4162,4163],{"_19":3625,"_25":3768},{"_19":693,"_25":3770},[],[4117],{"_19":4167,"_21":4168,"_23":4169,"_25":4170,"_26":4171,"_32":3783,"_34":4173,"_1363":4174},"legroots","r = legroots(c)","Find Legendre polynomial roots","Finds roots of a Legendre polynomial.",[4172],{"_19":3625,"_25":4087},[],[4175,4176],"legfromroots","legcompanion",{"_19":4175,"_21":4178,"_23":4179,"_25":4180,"_26":4181,"_32":4087,"_34":4183,"_1363":4184},"c = legfromroots(r)","Construct Legendre polynomial from roots","Constructs Legendre coefficient array from roots.",[4182],{"_19":3796,"_25":3783},[],[4167],{"_19":4176,"_21":4186,"_23":4187,"_25":4188,"_26":4189,"_32":3807,"_34":4191,"_1363":4192},"C = legcompanion(c)","Legendre companion matrix","Generates the companion matrix for a Legendre polynomial.",[4190],{"_19":3625,"_25":4087},[],[4167],{"_19":4194,"_21":4195,"_23":4196,"_25":4197,"_26":4198,"_32":3823,"_34":4201,"_1363":4202},"legvander","V = legvander(x, deg)","Legendre Vandermonde matrix","Generates a Legendre Vandermonde matrix.",[4199,4200],{"_19":94,"_25":3819},{"_19":3821,"_25":3822},[],[4092],{"_19":4092,"_21":4204,"_23":4205,"_25":4206,"_26":4207,"_32":4087,"_34":4211,"_1363":4212},"c = legfit(x, y, deg)","Least-squares Legendre fit","Fits a Legendre polynomial of the given degree to data using least squares.",[4208,4209,4210],{"_19":94,"_25":3834},{"_19":1489,"_25":3836},{"_19":3821,"_25":3838},[],[4080,4194],{"_19":4214,"_21":4215,"_23":4216,"_25":4217,"_26":4218,"_32":4073,"_34":4221,"_1363":4222},"leg2poly","p = leg2poly(c)","Convert Legendre to power series","Converts Legendre coefficients to power series coefficients.",[4219],{"_19":3625,"_25":4220},"Legendre coefficients",[],[4223],"poly2leg",{"_19":4225,"_21":4226,"_23":4227,"_25":4228,"_26":4229,"_32":3627,"_34":4233,"_1363":4236},"hermval","y = hermval(x, c)","Evaluate Hermite polynomial","Evaluates a physicist's Hermite polynomial at point x.",[4230,4231],{"_19":94,"_25":3623},{"_19":3625,"_25":4232},"Hermite coefficient array",[4234],{"_1356":4235},"hermval(1, [1 2 3])",[4237,4238],"hermfit","hermder",{"_19":4238,"_21":4240,"_23":4241,"_25":4242,"_26":4243,"_32":3678,"_34":4246,"_1363":4247},"dc = hermder(c)\ndc = hermder(c, m)","Hermite derivative","Differentiates a Hermite polynomial m times.",[4244,4245],{"_19":3625,"_25":4232},{"_19":690,"_25":3677,"_31":61},[],[4248,4225],"hermint",{"_19":4248,"_21":4250,"_23":4251,"_25":4252,"_26":4253,"_32":3694,"_34":4257,"_1363":4258},"ic = hermint(c)\nic = hermint(c, m)\nic = hermint(c, m, k)","Hermite integral","Integrates a Hermite polynomial m times.",[4254,4255,4256],{"_19":3625,"_25":4232},{"_19":690,"_25":3691,"_31":61},{"_19":2100,"_25":3948,"_31":61},[],[4238,4225],{"_19":4260,"_21":4261,"_23":4262,"_25":4263,"_26":4264,"_32":3712,"_34":4267,"_1363":4268},"hermmul","c = hermmul(c1, c2)","Multiply two Hermite polynomials","Multiplies two Hermite coefficient arrays.",[4265,4266],{"_19":3707,"_25":3708},{"_19":3710,"_25":3711},[],[4269,4270],"hermdiv","hermadd",{"_19":4269,"_21":4272,"_23":4273,"_25":4274,"_26":4275,"_32":3975,"_34":4278,"_1363":4279},"[q, r] = hermdiv(c1, c2)","Divide two Hermite polynomials","Divides two Hermite coefficient arrays.",[4276,4277],{"_19":3707,"_25":3727},{"_19":3710,"_25":3729},[],[4260],{"_19":4270,"_21":4281,"_23":4282,"_25":4283,"_26":4284,"_32":3742,"_34":4287,"_1363":4288},"c = hermadd(c1, c2)","Add two Hermite polynomials","Adds two Hermite coefficient arrays.",[4285,4286],{"_19":3707,"_25":3708},{"_19":3710,"_25":3711},[],[4289,4260],"hermsub",{"_19":4289,"_21":4291,"_23":4292,"_25":4293,"_26":4294,"_32":3755,"_34":4297,"_1363":4298},"c = hermsub(c1, c2)","Subtract two Hermite polynomials","Subtracts two Hermite coefficient arrays.",[4295,4296],{"_19":3707,"_25":3708},{"_19":3710,"_25":3711},[],[4270,4260],{"_19":4300,"_21":4301,"_23":4302,"_25":4303,"_26":4304,"_32":3771,"_34":4307,"_1363":4308},"hermpow","c = hermpow(c, n)","Raise Hermite polynomial to a power","Raises a Hermite polynomial to a non-negative integer power.",[4305,4306],{"_19":3625,"_25":3768},{"_19":693,"_25":3770},[],[4260],{"_19":4310,"_21":4311,"_23":4312,"_25":4313,"_26":4314,"_32":3783,"_34":4316,"_1363":4317},"hermroots","r = hermroots(c)","Find Hermite polynomial roots","Finds roots of a Hermite polynomial.",[4315],{"_19":3625,"_25":4232},[],[4318,4319],"hermfromroots","hermcompanion",{"_19":4318,"_21":4321,"_23":4322,"_25":4323,"_26":4324,"_32":4232,"_34":4326,"_1363":4327},"c = hermfromroots(r)","Construct Hermite polynomial from roots","Constructs Hermite coefficient array from roots.",[4325],{"_19":3796,"_25":3783},[],[4310],{"_19":4319,"_21":4329,"_23":4330,"_25":4331,"_26":4332,"_32":3807,"_34":4334,"_1363":4335},"C = hermcompanion(c)","Hermite companion matrix","Generates the companion matrix for a Hermite polynomial.",[4333],{"_19":3625,"_25":4232},[],[4310],{"_19":4337,"_21":4338,"_23":4339,"_25":4340,"_26":4341,"_32":3823,"_34":4344,"_1363":4345},"hermvander","V = hermvander(x, deg)","Hermite Vandermonde matrix","Generates a Hermite Vandermonde matrix.",[4342,4343],{"_19":94,"_25":3819},{"_19":3821,"_25":3822},[],[4237],{"_19":4237,"_21":4347,"_23":4348,"_25":4349,"_26":4350,"_32":4232,"_34":4354,"_1363":4355},"c = hermfit(x, y, deg)","Least-squares Hermite fit","Fits a Hermite polynomial of the given degree to data using least squares.",[4351,4352,4353],{"_19":94,"_25":3834},{"_19":1489,"_25":3836},{"_19":3821,"_25":3838},[],[4225,4337],{"_19":4357,"_21":4358,"_23":4359,"_25":4360,"_26":4361,"_32":4073,"_34":4364,"_1363":4365},"herm2poly","p = herm2poly(c)","Convert Hermite to power series","Converts Hermite coefficients to power series coefficients.",[4362],{"_19":3625,"_25":4363},"Hermite coefficients",[],[4366],"poly2herm",{"_19":4368,"_21":4369,"_23":4370,"_25":4371,"_26":4372,"_32":3627,"_34":4376,"_1363":4377},"hermeval","y = hermeval(x, c)","Evaluate probabilist's Hermite polynomial","Evaluates a probabilist's Hermite (HermiteE) polynomial at point x.",[4373,4374],{"_19":94,"_25":3623},{"_19":3625,"_25":4375},"HermiteE coefficient array",[],[4378,4379],"hermefit","hermeder",{"_19":4379,"_21":4381,"_23":4382,"_25":4383,"_26":4384,"_32":3678,"_34":4387,"_1363":4388},"dc = hermeder(c)\ndc = hermeder(c, m)","HermiteE derivative","Differentiates a HermiteE polynomial m times.",[4385,4386],{"_19":3625,"_25":4375},{"_19":690,"_25":3677,"_31":61},[],[4389,4368],"hermeint",{"_19":4389,"_21":4391,"_23":4392,"_25":4393,"_26":4394,"_32":3694,"_34":4398,"_1363":4399},"ic = hermeint(c)\nic = hermeint(c, m)\nic = hermeint(c, m, k)","HermiteE integral","Integrates a HermiteE polynomial m times.",[4395,4396,4397],{"_19":3625,"_25":4375},{"_19":690,"_25":3691,"_31":61},{"_19":2100,"_25":3948,"_31":61},[],[4379,4368],{"_19":4401,"_21":4402,"_23":4403,"_25":4404,"_26":4405,"_32":3712,"_34":4408,"_1363":4409},"hermemul","c = hermemul(c1, c2)","Multiply two HermiteE polynomials","Multiplies two HermiteE coefficient arrays.",[4406,4407],{"_19":3707,"_25":3708},{"_19":3710,"_25":3711},[],[4410,4411],"hermediv","hermeadd",{"_19":4410,"_21":4413,"_23":4414,"_25":4415,"_26":4416,"_32":3975,"_34":4419,"_1363":4420},"[q, r] = hermediv(c1, c2)","Divide two HermiteE polynomials","Divides two HermiteE coefficient arrays.",[4417,4418],{"_19":3707,"_25":3727},{"_19":3710,"_25":3729},[],[4401],{"_19":4411,"_21":4422,"_23":4423,"_25":4424,"_26":4425,"_32":3742,"_34":4428,"_1363":4429},"c = hermeadd(c1, c2)","Add two HermiteE polynomials","Adds two HermiteE coefficient arrays.",[4426,4427],{"_19":3707,"_25":3708},{"_19":3710,"_25":3711},[],[4430,4401],"hermesub",{"_19":4430,"_21":4432,"_23":4433,"_25":4434,"_26":4435,"_32":3755,"_34":4438,"_1363":4439},"c = hermesub(c1, c2)","Subtract two HermiteE polynomials","Subtracts two HermiteE coefficient arrays.",[4436,4437],{"_19":3707,"_25":3708},{"_19":3710,"_25":3711},[],[4411,4401],{"_19":4441,"_21":4442,"_23":4443,"_25":4444,"_26":4445,"_32":3771,"_34":4448,"_1363":4449},"hermepow","c = hermepow(c, n)","Raise HermiteE polynomial to a power","Raises a HermiteE polynomial to a non-negative integer power.",[4446,4447],{"_19":3625,"_25":3768},{"_19":693,"_25":3770},[],[4401],{"_19":4451,"_21":4452,"_23":4453,"_25":4454,"_26":4455,"_32":3783,"_34":4457,"_1363":4458},"hermeroots","r = hermeroots(c)","Find HermiteE polynomial roots","Finds roots of a HermiteE polynomial.",[4456],{"_19":3625,"_25":4375},[],[4459,4460],"hermefromroots","hermecompanion",{"_19":4459,"_21":4462,"_23":4463,"_25":4464,"_26":4465,"_32":4375,"_34":4467,"_1363":4468},"c = hermefromroots(r)","Construct HermiteE polynomial from roots","Constructs HermiteE coefficient array from roots.",[4466],{"_19":3796,"_25":3783},[],[4451],{"_19":4460,"_21":4470,"_23":4471,"_25":4472,"_26":4473,"_32":3807,"_34":4475,"_1363":4476},"C = hermecompanion(c)","HermiteE companion matrix","Generates the companion matrix for a HermiteE polynomial.",[4474],{"_19":3625,"_25":4375},[],[4451],{"_19":4478,"_21":4479,"_23":4480,"_25":4481,"_26":4482,"_32":3823,"_34":4485,"_1363":4486},"hermevander","V = hermevander(x, deg)","HermiteE Vandermonde matrix","Generates a HermiteE Vandermonde matrix.",[4483,4484],{"_19":94,"_25":3819},{"_19":3821,"_25":3822},[],[4378],{"_19":4378,"_21":4488,"_23":4489,"_25":4490,"_26":4491,"_32":4375,"_34":4495,"_1363":4496},"c = hermefit(x, y, deg)","Least-squares HermiteE fit","Fits a HermiteE polynomial of the given degree to data using least squares.",[4492,4493,4494],{"_19":94,"_25":3834},{"_19":1489,"_25":3836},{"_19":3821,"_25":3838},[],[4368,4478],{"_19":4498,"_21":4499,"_23":4500,"_25":4501,"_26":4502,"_32":4073,"_34":4505,"_1363":4506},"herme2poly","p = herme2poly(c)","Convert HermiteE to power series","Converts HermiteE coefficients to power series coefficients.",[4503],{"_19":3625,"_25":4504},"HermiteE coefficients",[],[4507],"poly2herme",{"_19":4509,"_21":4510,"_23":4511,"_25":4512,"_26":4513,"_32":3627,"_34":4517,"_1363":4520},"lagval","y = lagval(x, c)","Evaluate Laguerre polynomial","Evaluates a Laguerre polynomial at point x.",[4514,4515],{"_19":94,"_25":3623},{"_19":3625,"_25":4516},"Laguerre coefficient array",[4518],{"_1356":4519},"lagval(1, [1 2 3])",[4521,4522],"lagfit","lagder",{"_19":4522,"_21":4524,"_23":4525,"_25":4526,"_26":4527,"_32":3678,"_34":4530,"_1363":4531},"dc = lagder(c)\ndc = lagder(c, m)","Laguerre derivative","Differentiates a Laguerre polynomial m times.",[4528,4529],{"_19":3625,"_25":4516},{"_19":690,"_25":3677,"_31":61},[],[4532,4509],"lagint",{"_19":4532,"_21":4534,"_23":4535,"_25":4536,"_26":4537,"_32":3694,"_34":4541,"_1363":4542},"ic = lagint(c)\nic = lagint(c, m)\nic = lagint(c, m, k)","Laguerre integral","Integrates a Laguerre polynomial m times.",[4538,4539,4540],{"_19":3625,"_25":4516},{"_19":690,"_25":3691,"_31":61},{"_19":2100,"_25":3948,"_31":61},[],[4522,4509],{"_19":4544,"_21":4545,"_23":4546,"_25":4547,"_26":4548,"_32":3712,"_34":4551,"_1363":4552},"lagmul","c = lagmul(c1, c2)","Multiply two Laguerre polynomials","Multiplies two Laguerre coefficient arrays.",[4549,4550],{"_19":3707,"_25":3708},{"_19":3710,"_25":3711},[],[4553,4554],"lagdiv","lagadd",{"_19":4553,"_21":4556,"_23":4557,"_25":4558,"_26":4559,"_32":3975,"_34":4562,"_1363":4563},"[q, r] = lagdiv(c1, c2)","Divide two Laguerre polynomials","Divides two Laguerre coefficient arrays.",[4560,4561],{"_19":3707,"_25":3727},{"_19":3710,"_25":3729},[],[4544],{"_19":4554,"_21":4565,"_23":4566,"_25":4567,"_26":4568,"_32":3742,"_34":4571,"_1363":4572},"c = lagadd(c1, c2)","Add two Laguerre polynomials","Adds two Laguerre coefficient arrays.",[4569,4570],{"_19":3707,"_25":3708},{"_19":3710,"_25":3711},[],[4573,4544],"lagsub",{"_19":4573,"_21":4575,"_23":4576,"_25":4577,"_26":4578,"_32":3755,"_34":4581,"_1363":4582},"c = lagsub(c1, c2)","Subtract two Laguerre polynomials","Subtracts two Laguerre coefficient arrays.",[4579,4580],{"_19":3707,"_25":3708},{"_19":3710,"_25":3711},[],[4554,4544],{"_19":4584,"_21":4585,"_23":4586,"_25":4587,"_26":4588,"_32":3771,"_34":4591,"_1363":4592},"lagpow","c = lagpow(c, n)","Raise Laguerre polynomial to a power","Raises a Laguerre polynomial to a non-negative integer power.",[4589,4590],{"_19":3625,"_25":3768},{"_19":693,"_25":3770},[],[4544],{"_19":4594,"_21":4595,"_23":4596,"_25":4597,"_26":4598,"_32":3783,"_34":4600,"_1363":4601},"lagroots","r = lagroots(c)","Find Laguerre polynomial roots","Finds roots of a Laguerre polynomial.",[4599],{"_19":3625,"_25":4516},[],[4602,4603],"lagfromroots","lagcompanion",{"_19":4602,"_21":4605,"_23":4606,"_25":4607,"_26":4608,"_32":4516,"_34":4610,"_1363":4611},"c = lagfromroots(r)","Construct Laguerre polynomial from roots","Constructs Laguerre coefficient array from roots.",[4609],{"_19":3796,"_25":3783},[],[4594],{"_19":4603,"_21":4613,"_23":4614,"_25":4615,"_26":4616,"_32":3807,"_34":4618,"_1363":4619},"C = lagcompanion(c)","Laguerre companion matrix","Generates the companion matrix for a Laguerre polynomial.",[4617],{"_19":3625,"_25":4516},[],[4594],{"_19":4621,"_21":4622,"_23":4623,"_25":4624,"_26":4625,"_32":3823,"_34":4628,"_1363":4629},"lagvander","V = lagvander(x, deg)","Laguerre Vandermonde matrix","Generates a Laguerre Vandermonde matrix.",[4626,4627],{"_19":94,"_25":3819},{"_19":3821,"_25":3822},[],[4521],{"_19":4521,"_21":4631,"_23":4632,"_25":4633,"_26":4634,"_32":4516,"_34":4638,"_1363":4639},"c = lagfit(x, y, deg)","Least-squares Laguerre fit","Fits a Laguerre polynomial of the given degree to data using least squares.",[4635,4636,4637],{"_19":94,"_25":3834},{"_19":1489,"_25":3836},{"_19":3821,"_25":3838},[],[4509,4621],{"_19":4641,"_21":4642,"_23":4643,"_25":4644,"_26":4645,"_32":4073,"_34":4648,"_1363":4649},"lag2poly","p = lag2poly(c)","Convert Laguerre to power series","Converts Laguerre coefficients to power series coefficients.",[4646],{"_19":3625,"_25":4647},"Laguerre coefficients",[],[4650],"poly2lag",{"_19":4078,"_21":4652,"_23":4653,"_25":4654,"_26":4655,"_32":4072,"_34":4657,"_1363":4660},"cc = poly2cheb(c)","Convert power series to Chebyshev","Converts power series coefficients to Chebyshev coefficients.",[4656],{"_19":3625,"_25":4073},[4658],{"_1356":4659},"poly2cheb([1 0 1])",[4066],{"_19":4223,"_21":4662,"_23":4663,"_25":4664,"_26":4665,"_32":4220,"_34":4667,"_1363":4668},"lc = poly2leg(c)","Convert power series to Legendre","Converts power series coefficients to Legendre coefficients.",[4666],{"_19":3625,"_25":4073},[],[4214],{"_19":4366,"_21":4670,"_23":4671,"_25":4672,"_26":4673,"_32":4363,"_34":4675,"_1363":4676},"hc = poly2herm(c)","Convert power series to Hermite","Converts power series coefficients to Hermite coefficients.",[4674],{"_19":3625,"_25":4073},[],[4357],{"_19":4507,"_21":4678,"_23":4679,"_25":4680,"_26":4681,"_32":4504,"_34":4683,"_1363":4684},"hc = poly2herme(c)","Convert power series to HermiteE","Converts power series coefficients to HermiteE coefficients.",[4682],{"_19":3625,"_25":4073},[],[4498],{"_19":4650,"_21":4686,"_23":4687,"_25":4688,"_26":4689,"_32":4647,"_34":4691,"_1363":4692},"lc = poly2lag(c)","Convert power series to Laguerre","Converts power series coefficients to Laguerre coefficients.",[4690],{"_19":3625,"_25":4073},[],[4641],{"_19":4694,"_21":4695,"_23":4696,"_25":4697,"_26":4698,"_32":4703,"_34":4704,"_1363":4708},"trimcoef","ct = trimcoef(c)\nct = trimcoef(c, tol)","Remove small trailing coefficients","Removes trailing elements with absolute value less than or equal to tol.",[4699,4700],{"_19":3625,"_25":3768},{"_19":4701,"_25":4702,"_31":61},"tol","Tolerance (default: 0)","Trimmed coefficient array",[4705],{"_1356":4706,"_1358":4707},"trimcoef([1 2 3 0 0])","[1 2 3]",[4709],"trimseq",{"_19":4709,"_21":4711,"_23":4712,"_25":4713,"_26":4714,"_32":4717,"_34":4718,"_1363":4722},"ct = trimseq(c)","Remove trailing zeros","Removes trailing zeros from a coefficient sequence.",[4715],{"_19":3625,"_25":4716},"Coefficient sequence","Trimmed sequence",[4719],{"_1356":4720,"_1358":4721},"trimseq([1 2 0 0])","[1 2]",[4694],{"_19":4724,"_21":4725,"_23":4726,"_25":4727,"_26":4728,"_32":4731,"_34":4732,"_1363":4736},"getdomain","d = getdomain(x)","Get domain from data points","Returns the minimum and maximum of the data as the domain [min, max].",[4729],{"_19":94,"_25":4730},"Data points","[min, max] domain",[4733],{"_1356":4734,"_1358":4735},"getdomain([1 2 3 4 5])","[1 5]",[4737,4738],"mapdomain","mapparms",{"_19":4737,"_21":4740,"_23":4741,"_25":4742,"_26":4743,"_32":4750,"_34":4751,"_1363":4754},"y = mapdomain(x, old, new)","Map values between domains","Maps x from the old domain to the new domain using a linear transformation.",[4744,4746,4748],{"_19":94,"_25":4745},"Values to map",{"_19":2208,"_25":4747},"Original domain [min, max]",{"_19":2211,"_25":4749},"Target domain [min, max]","Mapped values",[4752],{"_1356":4753,"_1358":1664},"mapdomain(0.5, [0 1], [-1 1])",[4738,4724],{"_19":4738,"_21":4756,"_23":4757,"_25":4758,"_26":4759,"_32":4762,"_34":4763,"_1363":4767},"[off, scl] = mapparms(old, new)","Get linear mapping parameters","Returns [offset, scale] such that new = offset + scale * old.",[4760,4761],{"_19":2208,"_25":4747},{"_19":2211,"_25":4749},"[offset, scale]",[4764],{"_1356":4765,"_1358":4766},"mapparms([0 1], [-1 1])","[-1 2]",[4737,4724],{"_38":4769,"_19":4770,"_25":4771,"_42":43,"_44":4772,"_48":4773},"symbolic","Symbolic Mathematics","MATLAB-compatible symbolic mathematics functions for creating symbolic variables, solving equations, expanding expressions, and more. Powered by SymEngine via symngwasm.","🔣",[4774,4799,4817,4836,4856,4873,4888,4914,4935,4956],{"_19":4775,"_21":4776,"_23":4777,"_25":4778,"_26":4779,"_32":4783,"_34":4784,"_1363":4795},"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.",[4780],{"_19":4781,"_25":4782},"s","Variable name (string) or numeric value to convert","Symbolic variable or expression",[4785,4787,4789,4792],{"_1356":4786,"_1358":94},"x = sym('x')",{"_1356":4788,"_1358":94},"sym x",{"_1356":4790,"_1358":4791},"f = sym('x^2 + 2*x + 1')","x^2 + 2*x + 1",{"_1356":4793,"_1358":4794},"half = sym(1/2)","1/2",[4796,4797,4798],"syms","solve","expand",{"_19":4796,"_21":4800,"_23":4801,"_25":4802,"_26":4803,"_32":4807,"_34":4808,"_1363":4815},"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.",[4804],{"_19":4805,"_25":4806},"vars","Variable names (space-separated for command syntax, or multiple string arguments)","Creates variables in workspace (no return value)",[4809,4812],{"_1356":4810,"_1358":4811},"syms x y z","% Creates x, y, z as symbolic variables",{"_1356":4813,"_1358":4814},"syms('a', 'b')","% Creates a, b as symbolic variables",[4775,4797,4816],"subs",{"_19":4797,"_21":4818,"_23":4819,"_25":4820,"_26":4821,"_32":4827,"_34":4828,"_1363":4835},"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).",[4822,4825],{"_19":4823,"_25":4824},"eqn","Symbolic equation or expression (assumed = 0)",{"_19":1844,"_25":4826,"_31":61},"Variable to solve for","Array of symbolic solutions",[4829,4832],{"_1356":4830,"_1358":4831},"syms x; solve(x^2 - 1, x)","[-1, 1]",{"_1356":4833,"_1358":4834},"syms x; solve(x^2 + x - 6, x)","[-3, 2]",[4775,4796,4798,4816],{"_19":4816,"_21":4837,"_23":4838,"_25":4839,"_26":4840,"_32":4848,"_34":4849,"_1363":4855},"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.",[4841,4844,4846],{"_19":4842,"_25":4843},"f","Symbolic expression",{"_19":2208,"_25":4845},"Symbol or expression to replace",{"_19":2211,"_25":4847},"Replacement value or expression","Expression with substitution applied",[4850,4852],{"_1356":4851,"_1358":1769},"syms x; subs(x^2 + 1, x, 2)",{"_1356":4853,"_1358":4854},"syms x y; subs(x + y, x, y^2)","y^2 + y",[4775,4797,4798],{"_19":4798,"_21":4857,"_23":4858,"_25":4859,"_26":4860,"_32":4863,"_34":4864,"_1363":4870},"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",[4861],{"_19":4842,"_25":4862},"Symbolic expression to expand","Expanded expression",[4865,4867],{"_1356":4866,"_1358":4791},"syms x; expand((x + 1)^2)",{"_1356":4868,"_1358":4869},"syms x y; expand((x + y)*(x - y))","x^2 - y^2",[4775,4871,4872],"simplify","factor",{"_19":4871,"_21":4874,"_23":4875,"_25":4876,"_26":4877,"_32":4880,"_34":4881,"_1363":4886},"g = simplify(f)","Simplify symbolic expression","Simplifies a symbolic expression using various algebraic rules. Combines like terms, cancels common factors, and applies trigonometric identities.",[4878],{"_19":4842,"_25":4879},"Symbolic expression to simplify","Simplified expression",[4882,4884],{"_1356":4883,"_1358":94},"syms x; simplify(x^2/x)",{"_1356":4885,"_1358":1574},"syms x; simplify(sin(x)^2 + cos(x)^2)",[4798,4872,4887],"collect",{"_19":4889,"_21":4890,"_23":4891,"_25":4892,"_26":4893,"_32":4900,"_34":4901,"_1363":4911},"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.",[4894,4896,4898],{"_19":4842,"_25":4895},"Symbolic expression to differentiate",{"_19":94,"_25":4897},"Variable to differentiate with respect to",{"_19":693,"_25":4899,"_31":61},"Order of derivative (default: 1)","Derivative expression",[4902,4905,4908],{"_1356":4903,"_1358":4904},"syms x; diff(x^3, x)","3*x^2",{"_1356":4906,"_1358":4907},"syms x; diff(sin(x), x)","cos(x)",{"_1356":4909,"_1358":4910},"syms x; diff(x^3, x, 2)","6*x",[4912,4913,4775],"int","taylor",{"_19":4913,"_21":4915,"_23":4916,"_25":4917,"_26":4918,"_32":4926,"_34":4927,"_1363":4934},"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.",[4919,4920,4922,4924],{"_19":4842,"_25":4862},{"_19":94,"_25":4921},"Expansion variable",{"_19":1423,"_25":4923,"_31":61},"Expansion point (default: 0)",{"_19":693,"_25":4925,"_31":61},"Number of terms (default: 6)","Taylor polynomial",[4928,4931],{"_1356":4929,"_1358":4930},"syms x; taylor(exp(x), x, 0, 4)","1 + x + x^2/2 + x^3/6",{"_1356":4932,"_1358":4933},"syms x; taylor(sin(x), x)","x - x^3/6 + x^5/120",[4889,4798,4775],{"_19":4936,"_21":4937,"_23":4938,"_25":4939,"_26":4940,"_32":4946,"_34":4947,"_1363":4954},"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",[4941,4943],{"_19":94,"_25":4942},"Symbolic variable",{"_19":4944,"_25":4945},"prop","Property to assume (e.g., 'positive', 'real', 'integer')","Nothing (modifies variable in place)",[4948,4951],{"_1356":4949,"_1358":4950},"syms x; assume(x, 'positive')","% x is now assumed positive",{"_1356":4952,"_1358":4953},"assume x real","% x is now assumed real",[4955,4775,4796],"assumptions",{"_19":4955,"_21":4957,"_23":4958,"_25":4959,"_26":4960,"_32":4963,"_34":4964,"_1363":4968},"a = assumptions(x)","Get assumptions on symbolic variable","Returns the current assumptions on a symbolic variable as a string.",[4961],{"_19":94,"_25":4962},"Symbolic variable to query","String describing assumptions",[4965],{"_1356":4966,"_1358":4967},"syms x; assume(x, 'positive'); assumptions(x)","'positive'",[4936,4775,4796],{"_38":4970,"_19":4971,"_25":4972,"_42":43,"_44":4973,"_46":4970,"_48":4974},"vtk","3D Visualization (VTK)","Advanced 3D visualization functions powered by VTK.js for volumetric data, FEM meshes, and scientific visualization.","🧊",[4975,4998,5021,5042,5063,5087,5106,5129,5147,5163,5174,5186,5197,5206,5215,5228,5241,5257],{"_19":4976,"_21":4977,"_23":4978,"_25":4979,"_26":4980,"_32":4990,"_34":4991,"_1363":4994},"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.",[4981,4984,4987],{"_19":4982,"_25":4983},"points","Nx3 matrix of point coordinates",{"_19":4985,"_25":4986},"polys","Polygon connectivity array (VTK format: [npts, p1, p2, ...])",{"_19":4988,"_25":4989,"_31":61},"scalars","Per-point scalar values for coloring","null (renders VTK visualization inline)",[4992],{"_1356":4993},"% 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)",[4995,4996,4997],"vtk.volume","vtk.femgrid","vtk.sphere",{"_19":4995,"_21":4999,"_23":5000,"_25":5001,"_26":5002,"_32":5014,"_34":5015,"_1363":5018},"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.",[5003,5005,5008,5011],{"_19":687,"_25":5004},"Flat array of scalar values (nx*ny*nz elements)",{"_19":5006,"_25":5007},"dims","3-element vector [nx, ny, nz] specifying grid dimensions",{"_19":5009,"_25":5010,"_31":61},"spacing","3-element vector [dx, dy, dz] for voxel spacing (default: [1,1,1])",{"_19":5012,"_25":5013,"_31":61},"origin","3-element vector [x0, y0, z0] for grid origin (default: [0,0,0])","null (renders VTK volume inline)",[5016],{"_1356":5017},"% 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))",[5019,5020,4976],"vtk.isosurface","vtk.slice",{"_19":5019,"_21":5022,"_23":5023,"_25":5024,"_26":5025,"_32":5037,"_34":5038,"_1363":5041},"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.",[5026,5028,5030,5032,5034],{"_19":687,"_25":5027},"Flat array of scalar values",{"_19":5006,"_25":5029},"3-element vector [nx, ny, nz]",{"_19":5009,"_25":5031,"_31":61},"Voxel spacing (default: [1,1,1])",{"_19":5012,"_25":5033,"_31":61},"Grid origin (default: [0,0,0])",{"_19":5035,"_25":5036},"isovalue","Scalar value for the isosurface","null (renders isosurface inline)",[5039],{"_1356":5040},"% 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",[4995,4976],{"_19":4996,"_21":5043,"_23":5044,"_25":5045,"_26":5046,"_32":5058,"_34":5059,"_1363":5062},"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).",[5047,5050,5053,5056],{"_19":5048,"_25":5049},"nodes","Nx3 matrix of node coordinates",{"_19":5051,"_25":5052},"elements","Cell connectivity in VTK format [npts, n1, n2, ...]",{"_19":5054,"_25":5055},"elementTypes","Array of VTK cell type codes for each element",{"_19":4988,"_25":5057,"_31":61},"Per-node or per-cell scalar field (e.g., stress, temperature)","null (renders FEM mesh inline)",[5060],{"_1356":5061},"% 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)",[4976,4995],{"_19":4997,"_21":5064,"_23":5065,"_25":5066,"_26":5067,"_32":5077,"_34":5078,"_1363":5083},"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.",[5068,5071,5074],{"_19":5069,"_25":5070,"_31":61},"radius","Sphere radius (default: 1)",{"_19":5072,"_25":5073,"_31":61},"center","3-element vector [x, y, z] for center (default: [0,0,0])",{"_19":5075,"_25":5076,"_31":61},"resolution","Number of phi/theta divisions (default: 32)","null (renders sphere inline)",[5079,5081],{"_1356":5080},"vtk.sphere() % unit sphere at origin",{"_1356":5082},"vtk.sphere(2, [1 0 0], 64) % radius 2, centered at (1,0,0), high resolution",[5084,5085,5086],"vtk.cone","vtk.cube","vtk.cylinder",{"_19":5084,"_21":5088,"_23":5089,"_25":5090,"_26":5091,"_32":5099,"_34":5100,"_1363":5105},"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.",[5092,5095,5097],{"_19":5093,"_25":5094,"_31":61},"height","Cone height (default: 1)",{"_19":5069,"_25":5096,"_31":61},"Base radius (default: 0.5)",{"_19":5072,"_25":5098,"_31":61},"3-element center position (default: [0,0,0])","null (renders cone inline)",[5101,5103],{"_1356":5102},"vtk.cone()",{"_1356":5104},"vtk.cone(2, 1, [0 0 1])",[4997,5085,5086],{"_19":5085,"_21":5107,"_23":5108,"_25":5109,"_26":5110,"_32":5122,"_34":5123,"_1363":5128},"vtk.cube()\nvtk.cube(size)\nvtk.cube(xLen, yLen, zLen)","Create cube/box geometry","Creates a VTK cube (box) source with specified dimensions.",[5111,5113,5116,5119],{"_19":217,"_25":5112,"_31":61},"Uniform size for all dimensions (default: 1)",{"_19":5114,"_25":5115,"_31":61},"xLen","X dimension length",{"_19":5117,"_25":5118,"_31":61},"yLen","Y dimension length",{"_19":5120,"_25":5121,"_31":61},"zLen","Z dimension length","null (renders cube inline)",[5124,5126],{"_1356":5125},"vtk.cube()",{"_1356":5127},"vtk.cube(2, 1, 0.5) % rectangular box",[4997,5084,5086],{"_19":5086,"_21":5130,"_23":5131,"_25":5132,"_26":5133,"_32":5140,"_34":5141,"_1363":5146},"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.",[5134,5136,5138],{"_19":5093,"_25":5135,"_31":61},"Cylinder height (default: 1)",{"_19":5069,"_25":5137,"_31":61},"Cylinder radius (default: 0.5)",{"_19":5075,"_25":5139,"_31":61},"Number of facets around circumference (default: 32)","null (renders cylinder inline)",[5142,5144],{"_1356":5143},"vtk.cylinder()",{"_1356":5145},"vtk.cylinder(3, 0.5, 64)",[4997,5084,5085],{"_19":5148,"_21":5149,"_23":5150,"_25":5151,"_26":5152,"_32":3212,"_34":5155,"_1363":5160},"vtk.colormap","vtk.colormap('name')","Set VTK colormap","Sets the colormap for subsequent VTK visualizations. Available colormaps: 'viridis', 'rainbow', 'coolwarm', 'grayscale', 'jet', 'hot'.",[5153],{"_19":19,"_25":5154},"Colormap name",[5156,5158],{"_1356":5157},"vtk.colormap('coolwarm')",{"_1356":5159},"vtk.colormap('viridis'); vtk.volume(data, dims)",[5161,5162],"vtk.opacity","vtk.edges",{"_19":5161,"_21":5164,"_23":5165,"_25":5166,"_26":5167,"_32":3212,"_34":5170,"_1363":5173},"vtk.opacity(value)","Set VTK opacity","Sets the opacity (0-1) for subsequent VTK visualizations.",[5168],{"_19":417,"_25":5169},"Opacity value between 0 (transparent) and 1 (opaque)",[5171],{"_1356":5172},"vtk.opacity(0.7)",[5148,5162],{"_19":5162,"_21":5175,"_23":5176,"_25":5177,"_26":5178,"_32":3212,"_34":5181,"_1363":5184},"vtk.edges('on')\nvtk.edges('off')","Toggle edge visibility","Enables or disables edge rendering for surface meshes. Useful for FEM visualization.",[5179],{"_19":3350,"_25":5180},"'on' or 'off'",[5182],{"_1356":5183},"vtk.edges('on')",[5148,5185],"vtk.wireframe",{"_19":5185,"_21":5187,"_23":5188,"_25":5189,"_26":5190,"_32":3212,"_34":5191,"_1363":5194},"vtk.wireframe()","Set wireframe rendering","Sets the rendering mode to wireframe for subsequent VTK visualizations.",[],[5192],{"_1356":5193},"vtk.wireframe(); vtk.sphere()",[5195,5196,5162],"vtk.surface","vtk.points",{"_19":5195,"_21":5198,"_23":5199,"_25":5200,"_26":5201,"_32":3212,"_34":5202,"_1363":5205},"vtk.surface()","Set surface rendering","Sets the rendering mode to filled surface for subsequent VTK visualizations (default mode).",[],[5203],{"_1356":5204},"vtk.surface(); vtk.sphere()",[5185,5196],{"_19":5196,"_21":5207,"_23":5208,"_25":5209,"_26":5210,"_32":3212,"_34":5211,"_1363":5214},"vtk.points()","Set point rendering","Sets the rendering mode to points only for subsequent VTK visualizations.",[],[5212],{"_1356":5213},"vtk.points(); vtk.sphere()",[5185,5195],{"_19":5216,"_21":5217,"_23":5218,"_25":5219,"_26":5220,"_32":4990,"_34":5223,"_1363":5226},"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.",[5221],{"_19":1505,"_25":5222},"MFEM Mesh object (from mfem.mesh.makeCartesian2D, etc.)",[5224],{"_1356":5225},"mesh = mfem.mesh.makeCartesian2D(10, 10, 'TRIANGLE', true, 1.0, 1.0)\nvtk.edges('on')\nvtk.mesh(mesh)",[5227,4996,5148],"vtk.gridfunction",{"_19":5229,"_21":5230,"_23":5231,"_25":5232,"_26":5233,"_32":5236,"_34":5237,"_1363":5240},"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.",[5234],{"_19":1505,"_25":5235},"MFEM Mesh object","Struct with fields: x, y, z (NDArrays) and numVertices (number)",[5238],{"_1356":5239},"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",[5216,5227],{"_19":5227,"_21":5242,"_23":5243,"_25":5244,"_26":5245,"_32":4990,"_34":5251,"_1363":5256},"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.",[5246,5248],{"_19":1505,"_25":5247},"MFEM Mesh object (the mesh on which the GridFunction is defined)",{"_19":5249,"_25":5250},"gf","MFEM GridFunction object containing the finite element solution",[5252,5254],{"_1356":5253},"vtk.colormap('viridis')\nvtk.gridfunction(mesh, solution)",{"_1356":5255},"vtk.colormap('coolwarm')\nvtk.edges('on')\nvtk.gridfunction(mesh, x)",[5216,5148,5162],{"_19":5258,"_21":5259,"_23":5260,"_25":5261,"_26":5262,"_32":5269,"_34":5270,"_1363":5273},"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).",[5263,5264,5266],{"_19":1505,"_25":5235},{"_19":3876,"_25":5265},"Vector GridFunction containing displacement [ux, uy, uz] per node",{"_19":5267,"_25":5268,"_31":61},"scaleFactor","Deformation amplification factor (default: 1)","null (renders deformed mesh inline)",[5271],{"_1356":5272},"vtk.colormap('coolwarm')\nvtk.displacement(mesh, u, 100) % amplify by 100x",[5227,5216],{"_38":5275,"_19":5276,"_25":5277,"_42":43,"_44":5278,"_48":5279},"sparse","Sparse Matrices","Sparse matrix creation, manipulation, and iterative solvers for large-scale linear systems.","🔳",[5280,5308,5320,5337,5350,5362,5379,5395,5409,5423,5438,5449,5461,5472,5484,5499,5514,5539,5553,5567,5583,5599,5612,5629,5643],{"_19":5275,"_21":5281,"_23":5282,"_25":5283,"_26":5284,"_32":5295,"_34":5296,"_1363":5303},"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.",[5285,5288,5291,5293,5294],{"_19":5286,"_25":5287},"A/i","Dense matrix, or row index vector (1-based)",{"_19":5289,"_25":5290,"_31":61},"j/n","Column index vector (1-based), or number of columns",{"_19":3879,"_25":5292,"_31":61},"Values vector",{"_19":690,"_25":1350,"_31":61},{"_19":693,"_25":1352,"_31":61},"Sparse matrix (CSR format)",[5297,5299,5301],{"_1356":5298},"S = sparse(eye(5))",{"_1356":5300},"S = sparse([1 2 3], [1 2 3], [10 20 30], 3, 3)",{"_1356":5302},"S = sparse(5, 5) % empty 5x5 sparse",[5304,5305,5306,5307],"speye","sprand","full","issparse",{"_19":5304,"_21":5309,"_23":5310,"_25":5311,"_26":5312,"_32":5310,"_34":5316,"_1363":5319},"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.",[5313,5315],{"_19":690,"_25":5314},"Size (or number of rows)",{"_19":693,"_25":1352,"_31":61},[5317],{"_1356":5318},"I = speye(100)",[5275,1366,5305],{"_19":5305,"_21":5321,"_23":5322,"_25":5323,"_26":5324,"_32":5330,"_34":5331,"_1363":5334},"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).",[5325,5326,5327],{"_19":690,"_25":1350},{"_19":693,"_25":1352},{"_19":5328,"_25":5329},"density","Approximate density (0 to 1)","Sparse random matrix",[5332],{"_1356":5333},"S = sprand(100, 100, 0.05)",[5335,5336,5275],"sprandn","sprandsym",{"_19":5335,"_21":5338,"_23":5339,"_25":5340,"_26":5341,"_32":5345,"_34":5346,"_1363":5349},"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.",[5342,5343,5344],{"_19":690,"_25":1350},{"_19":693,"_25":1352},{"_19":5328,"_25":5329},"Sparse random matrix with normal distribution",[5347],{"_1356":5348},"S = sprandn(100, 100, 0.05)",[5305,5336,5275],{"_19":5336,"_21":5351,"_23":5352,"_25":5353,"_26":5354,"_32":5352,"_34":5358,"_1363":5361},"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.",[5355,5357],{"_19":693,"_25":5356},"Matrix size",{"_19":5328,"_25":5329},[5359],{"_1356":5360},"S = sprandsym(50, 0.1)",[5305,5335],{"_19":5363,"_21":5364,"_23":5365,"_25":5366,"_26":5367,"_32":5374,"_34":5375,"_1363":5378},"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.",[5368,5370,5372,5373],{"_19":1073,"_25":5369},"Matrix whose columns are the diagonals",{"_19":2929,"_25":5371},"Vector of diagonal positions (0 = main, positive = above, negative = below)",{"_19":690,"_25":1350},{"_19":693,"_25":1352},"Sparse matrix with specified diagonals",[5376],{"_1356":5377},"e = ones(5,1);\nS = spdiags([-e 2*e -e], [-1 0 1], 5, 5)",[5275,5304,760],{"_19":5380,"_21":5381,"_23":5382,"_25":5383,"_26":5384,"_32":5390,"_34":5391,"_1363":5394},"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).",[5385,5386,5387],{"_19":690,"_25":1350},{"_19":693,"_25":1352},{"_19":5388,"_25":5389},"nz","Number of nonzero elements to allocate (hint)","Empty sparse matrix",[5392],{"_1356":5393},"S = spalloc(10, 10, 50)",[5275,5304],{"_19":5396,"_21":5397,"_23":5398,"_25":5399,"_26":5400,"_32":5404,"_34":5405,"_1363":5408},"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].",[5401],{"_19":5402,"_25":5403},"D","Dense matrix with columns [i, j, v]","Sparse matrix",[5406],{"_1356":5407},"D = [1 1 10; 2 2 20; 3 3 30];\nS = spconvert(D)",[5275,1914],{"_19":5307,"_21":5410,"_23":5411,"_25":5412,"_26":5413,"_32":5416,"_34":5417,"_1363":5422},"tf = issparse(S)","Determine if matrix is sparse","Returns true (1) if S is a sparse matrix, false (0) otherwise.",[5414],{"_19":3098,"_25":5415},"Input value to test","Logical 1 or 0",[5418,5420],{"_1356":5419,"_1358":1574},"issparse(speye(5))",{"_1356":5421,"_1358":1664},"issparse(eye(5))",[5275,5306],{"_19":3115,"_21":5424,"_23":5425,"_25":5426,"_26":5427,"_32":5430,"_34":5431,"_1363":5435},"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.",[5428],{"_19":3098,"_25":5429},"Sparse or full matrix","Number of nonzeros",[5432],{"_1356":5433,"_1358":5434},"nnz(speye(100))","100",[5436,5437,5307],"nonzeros","nzmax",{"_19":5436,"_21":5439,"_23":5440,"_25":5441,"_26":5442,"_32":5444,"_34":5445,"_1363":5448},"v = nonzeros(S)","Nonzero matrix elements","Returns a column vector of the nonzero elements in sparse matrix S.",[5443],{"_19":3098,"_25":5404},"Column vector of nonzero values",[5446],{"_1356":5447},"nonzeros(sparse([1 0; 0 2]))",[3115,1914,5437],{"_19":5437,"_21":5450,"_23":5451,"_25":5452,"_26":5453,"_32":5455,"_34":5456,"_1363":5460},"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.",[5454],{"_19":3098,"_25":5404},"Allocated storage size",[5457],{"_1356":5458,"_1358":5459},"nzmax(speye(10))","10",[3115,5436],{"_19":5306,"_21":5462,"_23":5463,"_25":5464,"_26":5465,"_32":5467,"_34":5468,"_1363":5471},"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.",[5466],{"_19":3098,"_25":5429},"Full (dense) matrix",[5469],{"_1356":5470},"full(speye(3))",[5275,5307,3091],{"_19":5473,"_21":5474,"_23":5475,"_25":5476,"_26":5477,"_32":5479,"_34":5480,"_1363":5483},"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.",[5478],{"_19":3098,"_25":5404},"Sparse matrix with ones at nonzero positions",[5481],{"_1356":5482},"full(spones(sparse([1 0; 0 5])))",[3115,5436,5275],{"_19":5485,"_21":5486,"_23":5487,"_25":5488,"_26":5489,"_32":5494,"_34":5495,"_1363":5498},"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.",[5490,5493],{"_19":5491,"_25":5492},"func","Function handle to apply (e.g., @sqrt, @exp)",{"_19":3098,"_25":5404},"Sparse matrix with function applied to nonzeros",[5496],{"_1356":5497},"full(spfun(@sqrt, sparse([4 0; 0 9])))",[5473,5436],{"_19":5500,"_21":5501,"_23":5502,"_25":5503,"_26":5504,"_32":5510,"_34":5511,"_1363":5513},"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.",[5505,5508],{"_19":5506,"_25":5507,"_31":61},"key","Parameter name",{"_19":417,"_25":5509,"_31":61},"Parameter value","Current parameter values, or null",[5512],{"_1356":5500},[5275],{"_19":5515,"_21":5516,"_23":5517,"_25":5518,"_26":5519,"_32":5532,"_34":5533,"_1363":5536},"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.",[5520,5522,5524,5527,5529],{"_19":29,"_25":5521},"Sparse coefficient matrix (n x n)",{"_19":91,"_25":5523},"Right-hand side vector",{"_19":5525,"_25":5526,"_31":61},"restart","Restart parameter (default 20)",{"_19":4701,"_25":5528,"_31":61},"Convergence tolerance (default 1e-6)",{"_19":5530,"_25":5531,"_31":61},"maxit","Maximum iterations","Solution vector x, or [x, flag, relres, iter]",[5534],{"_1356":5535},"A = speye(3); b = [1;2;3];\nx = gmres(A, b)",[5537,5538,5275],"bicgstab","pcg",{"_19":5537,"_21":5540,"_23":5541,"_25":5542,"_26":5543,"_32":5532,"_34":5549,"_1363":5552},"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.",[5544,5546,5547,5548],{"_19":29,"_25":5545},"Sparse coefficient matrix",{"_19":91,"_25":5523},{"_19":4701,"_25":5528,"_31":61},{"_19":5530,"_25":5531,"_31":61},[5550],{"_1356":5551},"x = bicgstab(A, b)",[5515,5538],{"_19":5538,"_21":5554,"_23":5555,"_25":5556,"_26":5557,"_32":5532,"_34":5563,"_1363":5566},"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.",[5558,5560,5561,5562],{"_19":29,"_25":5559},"Symmetric positive definite sparse matrix",{"_19":91,"_25":5523},{"_19":4701,"_25":5528,"_31":61},{"_19":5530,"_25":5531,"_31":61},[5564],{"_1356":5565},"x = pcg(A, b)",[5515,5537],{"_19":5568,"_21":5569,"_23":5570,"_25":5571,"_26":5572,"_32":5578,"_34":5579,"_1363":5582},"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.",[5573,5575,5576,5577],{"_19":29,"_25":5574},"Sparse matrix (possibly non-square)",{"_19":91,"_25":5523},{"_19":4701,"_25":5528,"_31":61},{"_19":5530,"_25":5531,"_31":61},"Solution vector x, or [x, flag]",[5580],{"_1356":5581},"x = lsqr(A, b)",[5538,5515],{"_19":5584,"_21":5585,"_23":5586,"_25":5587,"_26":5588,"_32":5593,"_34":5594,"_1363":5597},"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.",[5589,5591],{"_19":29,"_25":5590},"Sparse matrix or LinearOperator",{"_19":2100,"_25":5592,"_31":61},"Number of eigenvalues (default 6)","Eigenvalues vector, or [V, D] decomposition",[5595],{"_1356":5596},"d = eigs(speye(10), 3)",[2453,5598],"svds",{"_19":5598,"_21":5600,"_23":5601,"_25":5602,"_26":5603,"_32":5607,"_34":5608,"_1363":5611},"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.",[5604,5605],{"_19":29,"_25":5404},{"_19":2100,"_25":5606,"_31":61},"Number of singular values (default 6)","Singular values vector, or [U, S, V] decomposition",[5609],{"_1356":5610},"s = svds(A, 3)",[2468,5584],{"_19":5613,"_21":5614,"_23":5615,"_25":5616,"_26":5617,"_32":5623,"_34":5624,"_1363":5627},"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.",[5618,5620],{"_19":29,"_25":5619},"Sparse square matrix",{"_19":5621,"_25":5622,"_31":61},"setup","Options struct with type and droptol","[L, U] incomplete factors",[5625],{"_1356":5626},"[L, U] = ilu(speye(5))",[5628,5538,5515],"ichol",{"_19":5628,"_21":5630,"_23":5631,"_25":5632,"_26":5633,"_32":5638,"_34":5639,"_1363":5642},"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.",[5634,5635],{"_19":29,"_25":5559},{"_19":5636,"_25":5637,"_31":61},"opts","Options struct","Lower triangular incomplete factor L",[5640],{"_1356":5641},"L = ichol(speye(5))",[5613,5538],{"_19":5644,"_21":5645,"_23":5646,"_25":5647,"_26":5648,"_32":5650,"_34":5651,"_1363":5654},"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.",[5649],{"_19":29,"_25":5404},"Structural rank (integer)",[5652],{"_1356":5653,"_1358":1769},"sprank(speye(5))",[3115,5275],{"_38":5656,"_19":5657,"_25":5658,"_42":43,"_44":5659,"_46":5660,"_48":5661},"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",[5662,5675,5689,5698,5714,5732,5746,5755,5764,5776,5783,5792,5801,5810,5820,5828,5838,5855,5865,5872,5885,5893,5905,5915,5927,5936,5944,5952,5961,5970,5981,6000,6017,6032,6043,6055,6064,6076,6091,6102,6115,6125,6134,6147,6156,6168,6177,6185,6194,6203,6215,6224,6235,6244,6253,6266,6277,6286,6295,6304,6313,6325,6336,6346,6355,6368,6379,6392,6403,6414,6423,6433,6442,6452,6463,6472,6480,6488,6497,6505,6513,6521,6529,6539,6551,6562,6570,6577,6585,6594,6601,6610,6618,6626,6633,6641,6649,6659,6668,6676,6684,6692,6701,6711,6719,6732,6742,6754,6766,6778,6788,6796,6804,6812,6824,6831,6847,6858,6869,6880,6890,6900,6910,6923,6933,6942,6953,6964,6974,6982,6992,7004,7019,7029,7041,7050,7064,7076,7086,7097,7107,7117,7126,7137,7152,7170,7181,7192,7205,7217,7229,7239,7250,7261,7271,7282,7291,7299,7307,7320,7333,7342,7355,7364,7376,7385,7394,7404,7413,7421,7433,7441,7449,7457,7465,7476,7482,7489,7495,7501,7508,7514,7520,7527,7534,7541,7547,7553,7560,7569,7580,7589,7598,7606,7613,7623,7632,7642,7651,7664,7671,7686,7693,7702,7710,7723,7733,7743,7751,7764,7774,7781,7788,7795,7802,7817,7827,7834,7840,7847,7859,7870,7880,7890,7904,7913,7923,7932,7939,7946,7954,7961,7972,7978,7986,7993,8001,8008,8019,8026,8033,8040,8050,8059,8065,8075,8082,8088,8094,8101,8108,8115,8122,8128,8134,8141,8153,8161,8169,8176,8188,8199,8208,8217,8226,8235,8244,8253,8262,8271,8284,8293,8302,8309,8321,8332,8344,8356,8376,8394,8406,8419,8430,8440,8451,8460,8471,8484,8495,8506,8519,8527,8542,8555,8564,8572,8580,8588,8597,8605,8616,8628,8636,8643,8653,8664,8675,8687,8695,8705,8714,8725,8735,8747,8754,8764,8773,8780,8787,8794,8801,8808,8815,8822,8829,8836,8843,8850,8857,8864,8874,8881,8888,8895,8904,8911,8918,8925,8932,8939,8946,8953,8960,8967,8974,8981,8989,8998,9005,9017,9025,9036,9044,9054,9064,9071,9078,9085,9094,9101,9108,9115,9122,9129,9138,9146,9153,9160,9168,9176,9184,9191,9198,9204,9211,9217,9223,9230,9239,9247,9256,9262,9269,9275,9281,9292,9300,9311,9327,9337,9350,9361,9370,9376,9383,9390,9397,9404,9411,9417,9425,9435,9444,9451,9458,9471,9481],{"_19":5663,"_21":5664,"_23":5665,"_25":5666,"_26":5667,"_32":155,"_34":5674},"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",[5668,5671],{"_19":5669,"_25":5670,"_31":6},"blf","- BilinearForm instance",{"_19":5672,"_25":5673,"_31":61},"coeff","- Optional scalar coefficient",[],{"_19":5676,"_21":5677,"_23":5678,"_25":5679,"_26":5680,"_32":155,"_34":5688},"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",[5681,5682,5685],{"_19":5669,"_25":5670,"_31":6},{"_19":5683,"_25":5684,"_31":6},"velocity","- Vector coefficient for velocity field",{"_19":5686,"_25":5687,"_31":61},"alpha","- Scaling factor (defaults to 1.0)",[],{"_19":5690,"_21":5691,"_23":5692,"_25":5693,"_26":5694,"_32":155,"_34":5697},"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",[5695,5696],{"_19":5669,"_25":5670,"_31":6},{"_19":5672,"_25":5673,"_31":61},[],{"_19":5699,"_21":5700,"_23":5701,"_25":5702,"_26":5703,"_32":155,"_34":5713},"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.",[5704,5705,5707,5710],{"_19":5669,"_25":5670,"_31":6},{"_19":5672,"_25":5706,"_31":6},"- Diffusion coefficient (optional)",{"_19":5708,"_25":5709,"_31":6},"sigma","- Symmetry parameter (-1 = SIPG, 0 = IIPG, 1 = NIPG)",{"_19":5711,"_25":5712,"_31":6},"kappa","- Penalty parameter (typically 10 * p^2 / h)",[],{"_19":5715,"_21":5716,"_23":5717,"_25":5718,"_26":5719,"_32":155,"_34":5731},"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.",[5720,5721,5724,5727,5729],{"_19":5669,"_25":5670,"_31":6},{"_19":5722,"_25":5723,"_31":6},"lambda","- Lamé first parameter",{"_19":5725,"_25":5726,"_31":6},"mu","- Shear modulus",{"_19":5686,"_25":5728,"_31":61},"- Symmetry parameter (default: -1.0 for symmetric form)",{"_19":5711,"_25":5730,"_31":61},"- Penalty parameter for stability",[],{"_19":5733,"_21":5734,"_23":5735,"_25":5736,"_26":5737,"_32":155,"_34":5745},"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.",[5738,5739,5741,5743],{"_19":5669,"_25":5670,"_31":6},{"_19":5672,"_25":5740,"_31":61},"- Optional coefficient (VectorCoefficient)",{"_19":5686,"_25":5742,"_31":61},"- Upwinding parameter (default: 0)",{"_19":2994,"_25":5744,"_31":61},"- Penalty parameter (default: 0)",[],{"_19":5747,"_21":5748,"_23":5749,"_25":5750,"_26":5751,"_32":155,"_34":5754},"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",[5752,5753],{"_19":5669,"_25":5670,"_31":6},{"_19":5672,"_25":5673,"_31":61},[],{"_19":5756,"_21":5757,"_23":5758,"_25":5759,"_26":5760,"_32":155,"_34":5763},"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",[5761,5762],{"_19":5669,"_25":5670,"_31":6},{"_19":5672,"_25":5673,"_31":61},[],{"_19":5765,"_21":5766,"_23":5767,"_25":5768,"_26":5769,"_32":155,"_34":5775},"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",[5770,5771,5773],{"_19":5669,"_25":5670,"_31":6},{"_19":5722,"_25":5772,"_31":6},"- Lamé first parameter (scalar coefficient)",{"_19":5725,"_25":5774,"_31":6},"- Shear modulus / Lamé second parameter (scalar coefficient)",[],{"_19":5777,"_21":5778,"_23":5779,"_25":5779,"_26":5780,"_32":155,"_34":5782},"mfem.bilinearForms.addGradientIntegrator","mfem.bilinearForms.addGradientIntegrator(blf)","Add a gradient integrator to the bilinear form.",[5781],{"_19":5669,"_25":5670,"_31":6},[],{"_19":5784,"_21":5785,"_23":5786,"_25":5787,"_26":5788,"_32":155,"_34":5791},"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",[5789,5790],{"_19":5669,"_25":5670,"_31":6},{"_19":5672,"_25":5673,"_31":61},[],{"_19":5793,"_21":5794,"_23":5795,"_25":5796,"_26":5797,"_32":155,"_34":5800},"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.",[5798,5799],{"_19":5669,"_25":5670,"_31":6},{"_19":5672,"_25":5673,"_31":61},[],{"_19":5802,"_21":5803,"_23":5804,"_25":5805,"_26":5806,"_32":155,"_34":5809},"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",[5807,5808],{"_19":5669,"_25":5670,"_31":6},{"_19":5672,"_25":5673,"_31":61},[],{"_19":5811,"_21":5812,"_23":5813,"_25":5813,"_26":5814,"_32":155,"_34":5819},"mfem.bilinearForms.assemble","mfem.bilinearForms.assemble(blf, skipZeros?)","Assemble bilinear form into sparse matrix.",[5815,5816],{"_19":5669,"_25":5670,"_31":6},{"_19":5817,"_25":5818,"_31":61},"skipZeros","- If true, skip storing zeros in the matrix (default: true)",[],{"_19":5821,"_21":5822,"_23":5823,"_25":5824,"_26":5825,"_32":155,"_34":5827},"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.",[5826],{"_19":5669,"_25":5670,"_31":6},[],{"_19":5829,"_21":5830,"_23":5831,"_25":5831,"_26":5832,"_32":5836,"_34":5837},"mfem.bilinearForms.create","mfem.bilinearForms.create(fespace)","Create a bilinear form on a finite element space.",[5833],{"_19":5834,"_25":5835,"_31":6},"fespace","- FiniteElementSpace instance","Promise",[],{"_19":5839,"_21":5840,"_23":5841,"_25":5842,"_26":5843,"_32":155,"_34":5854},"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.",[5844,5845,5848,5851],{"_19":5669,"_25":5670,"_31":6},{"_19":5846,"_25":5847,"_31":6},"essentialDofs","- Essential DOF indices",{"_19":5849,"_25":5850,"_31":6},"sol","- Solution vector with boundary values",{"_19":5852,"_25":5853,"_31":6},"rhs","- Right-hand side vector (modified in place)",[],{"_19":5856,"_21":5857,"_23":5858,"_25":5859,"_26":5860,"_32":802,"_34":5864},"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.",[5861,5863],{"_19":5669,"_25":5862,"_31":6},"- BilinearForm instance (must be assembled first)",{"_19":5846,"_25":5847,"_31":6},[],{"_19":5866,"_21":5867,"_23":5868,"_25":5868,"_26":5869,"_32":802,"_34":5871},"mfem.bilinearForms.getMatrix","mfem.bilinearForms.getMatrix(blf)","Get assembled sparse matrix from a bilinear form.",[5870],{"_19":5669,"_25":5862,"_31":6},[],{"_19":5873,"_21":5874,"_23":5875,"_25":5875,"_26":5876,"_32":5883,"_34":5884},"mfem.bilinearForms.createMixed","mfem.bilinearForms.createMixed(trialFES, testFES)","Create a mixed bilinear form on trial and test spaces.",[5877,5880],{"_19":5878,"_25":5879,"_31":6},"trialFES","- Trial FiniteElementSpace",{"_19":5881,"_25":5882,"_31":6},"testFES","- Test FiniteElementSpace","Promise",[],{"_19":5886,"_21":5887,"_23":5888,"_25":5888,"_26":5889,"_32":5836,"_34":5892},"mfem.bilinearForms.BilinearForm.create","mfem.bilinearForms.BilinearForm.create(fespace)","Creates a new bilinear form on the specified finite element space.",[5890],{"_19":5834,"_25":5891,"_31":6},"- The finite element space",[],{"_19":5894,"_21":5895,"_23":5896,"_25":5896,"_26":5897,"_32":5883,"_34":5904},"mfem.bilinearForms.MixedBilinearForm.create","mfem.bilinearForms.MixedBilinearForm.create(trialFespace, testFespace)","Creates a new mixed bilinear form.",[5898,5901],{"_19":5899,"_25":5900,"_31":6},"trialFespace","- The trial finite element space",{"_19":5902,"_25":5903,"_31":6},"testFespace","- The test finite element space",[],{"_19":5906,"_21":5907,"_23":5908,"_25":5908,"_26":5909,"_32":5913,"_34":5914},"mfem.block.BlockMatrix.createSquare","mfem.block.BlockMatrix.createSquare(offsets)","Create a square BlockMatrix with the same offsets for rows and columns.",[5910],{"_19":5911,"_25":5912,"_31":6},"offsets","- Block offsets array (used for both rows and columns)","Promise",[],{"_19":5916,"_21":5917,"_23":5918,"_25":5918,"_26":5919,"_32":5913,"_34":5926},"mfem.block.BlockMatrix.create","mfem.block.BlockMatrix.create(rowOffsets, colOffsets)","Create a rectangular BlockMatrix with different row and column offsets.",[5920,5923],{"_19":5921,"_25":5922,"_31":6},"rowOffsets","- Row block offsets array",{"_19":5924,"_25":5925,"_31":6},"colOffsets","- Column block offsets array",[],{"_19":5928,"_21":5929,"_23":5930,"_25":5931,"_26":5932,"_32":5913,"_34":5935},"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.",[5933],{"_19":307,"_25":5934,"_31":6},"- WASM pointer to an existing MFEM BlockMatrix",[],{"_19":5937,"_21":5938,"_23":5939,"_25":5939,"_26":5940,"_32":5942,"_34":5943},"mfem.block.BlockOperator.createSquare","mfem.block.BlockOperator.createSquare(offsets)","Create a square BlockOperator with the same offsets for rows and columns.",[5941],{"_19":5911,"_25":5912,"_31":6},"Promise",[],{"_19":5945,"_21":5946,"_23":5947,"_25":5947,"_26":5948,"_32":5942,"_34":5951},"mfem.block.BlockOperator.create","mfem.block.BlockOperator.create(rowOffsets, colOffsets)","Create a rectangular BlockOperator with different row and column offsets.",[5949,5950],{"_19":5921,"_25":5922,"_31":6},{"_19":5924,"_25":5925,"_31":6},[],{"_19":5953,"_21":5954,"_23":5955,"_25":5956,"_26":5957,"_32":5942,"_34":5960},"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.",[5958],{"_19":307,"_25":5959,"_31":6},"- WASM pointer to an existing MFEM BlockOperator",[],{"_19":5962,"_21":5963,"_23":5964,"_25":5964,"_26":5965,"_32":5968,"_34":5969},"mfem.block.BlockVector.create","mfem.block.BlockVector.create(offsets)","Create a new BlockVector with the specified block offsets.",[5966],{"_19":5911,"_25":5967,"_31":6},"- Array where offsets[i+1] - offsets[i] defines block i size","Promise",[],{"_19":5971,"_21":5972,"_23":5973,"_25":5974,"_26":5975,"_32":5968,"_34":5980},"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.",[5976,5978],{"_19":307,"_25":5977,"_31":6},"- WASM pointer to an existing MFEM BlockVector",{"_19":5911,"_25":5979,"_31":6},"- Block offsets array",[],{"_19":5982,"_21":5983,"_23":5984,"_25":5984,"_26":5985,"_32":5998,"_34":5999},"mfem.boundaryConditions.addBoundaryRobinIntegrator","mfem.boundaryConditions.addBoundaryRobinIntegrator(blf, lf, alpha, g, bdrAttrs)","Add Robin boundary condition integrator (legacy name)",[5986,5988,5991,5993,5995],{"_19":5669,"_25":5987,"_31":6},"BilinearForm",{"_19":5989,"_25":5990,"_31":6},"lf","LinearForm",{"_19":5686,"_25":5992,"_31":6},"number | CoefficientLike_15",{"_19":5994,"_25":5992,"_31":6},"g",{"_19":5996,"_25":5997,"_31":6},"bdrAttrs","number[]","Promise",[],{"_19":6001,"_21":6002,"_23":6003,"_25":6004,"_26":6005,"_32":5998,"_34":6016},"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.",[6006,6008,6010,6012,6014],{"_19":6007,"_25":5670,"_31":6},"bf",{"_19":5989,"_25":6009,"_31":6},"- LinearForm instance",{"_19":5686,"_25":6011,"_31":6},"- Coefficient for u term (scalar value or CoefficientLike)",{"_19":5994,"_25":6013,"_31":6},"- RHS coefficient g (scalar value or CoefficientLike)",{"_19":5996,"_25":6015,"_31":6},"- Array of boundary attributes where Robin BC applies",[],{"_19":6018,"_21":6019,"_23":6020,"_25":6021,"_26":6022,"_32":155,"_34":6031},"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.",[6023,6025,6027,6029],{"_19":5669,"_25":6024,"_31":6},"- BilinearForm instance (system matrix)",{"_19":5846,"_25":6026,"_31":6},"- Array of essential DOF indices",{"_19":94,"_25":6028,"_31":6},"- GridFunction with Dirichlet values set",{"_19":91,"_25":6030,"_31":6},"- LinearForm (RHS) to modify",[],{"_19":6033,"_21":6034,"_23":6035,"_25":6036,"_26":6037,"_32":356,"_34":6042},"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.",[6038,6040],{"_19":1505,"_25":6039,"_31":6},"- Mesh instance",{"_19":5996,"_25":6041,"_31":6},"- Array of boundary attribute numbers to mark (1-based)",[],{"_19":6044,"_21":6045,"_23":6046,"_25":6047,"_26":6048,"_32":155,"_34":6054},"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.",[6049,6050,6051],{"_19":5669,"_25":5670,"_31":6},{"_19":5846,"_25":6026,"_31":6},{"_19":6052,"_25":6053,"_31":61},"diagPolicy","- Diagonal policy (default: DIAG_ONE)",[],{"_19":6056,"_21":6057,"_23":6058,"_25":6058,"_26":6059,"_32":5997,"_34":6063},"mfem.boundaryConditions.getEssentialTrueDofs","mfem.boundaryConditions.getEssentialTrueDofs(fespace, bdrAttrs)","Get essential true DOF indices for given boundary attributes.",[6060,6061],{"_19":5834,"_25":5835,"_31":6},{"_19":5996,"_25":6062,"_31":6},"- Array of boundary attribute numbers",[],{"_19":6065,"_21":6066,"_23":6067,"_25":6068,"_26":6069,"_32":6074,"_34":6075},"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.",[6070,6072],{"_19":5834,"_25":6071,"_31":6},"- FiniteElementSpace (typically on a periodic mesh)",{"_19":97,"_25":6073,"_31":6},"- Configuration including translation vectors and tolerance","Promise",[],{"_19":6077,"_21":6078,"_23":6079,"_25":6080,"_26":6081,"_32":6089,"_34":6090},"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.",[6082,6084,6087],{"_19":1505,"_25":6083,"_31":6},"- Original mesh",{"_19":6085,"_25":6086,"_31":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]]`",{"_19":4701,"_25":6088,"_31":61},"- Tolerance for vertex matching (relative to mesh diameter).\r\n Default is 1e-8.","Promise",[],{"_19":6092,"_21":6093,"_23":6094,"_25":6094,"_26":6095,"_32":6098,"_34":6101},"mfem.boundaryConditions.makePeriodic","mfem.boundaryConditions.makePeriodic(_fespace, _mesh)","Create periodic finite element space (legacy name).",[6096,6099],{"_19":6097,"_25":6098,"_31":6},"_fespace","unknown",{"_19":6100,"_25":6098,"_31":6},"_mesh",[],{"_19":6103,"_21":6104,"_23":6105,"_25":6106,"_26":6107,"_32":6113,"_34":6114},"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.",[6108,6110,6112],{"_19":1505,"_25":6109,"_31":6},"- Mesh to analyze",{"_19":6085,"_25":6111,"_31":6},"- Array of translation vectors defining periodicity",{"_19":4701,"_25":6088,"_31":61},"Promise",[],{"_19":6116,"_21":6117,"_23":6118,"_25":6118,"_26":6119,"_32":155,"_34":6124},"mfem.boundaryConditions.makePeriodicVertices","mfem.boundaryConditions.makePeriodicVertices(_mesh, _v2v)","Set periodic vertex mapping on mesh (legacy name).",[6120,6121],{"_19":6100,"_25":6098,"_31":6},{"_19":6122,"_25":6123,"_31":6},"_v2v","number[][]",[],{"_19":6126,"_21":6127,"_23":6128,"_25":6128,"_26":6129,"_32":6132,"_34":6133},"mfem.coefficients.constant","mfem.coefficients.constant(value)","Create a constant scalar coefficient.",[6130],{"_19":417,"_25":6131,"_31":6},"- Constant value","Promise",[],{"_19":6135,"_21":6136,"_23":6137,"_25":6137,"_26":6138,"_32":6145,"_34":6146},"mfem.coefficients.crossProduct","mfem.coefficients.crossProduct(v1, v2)","Create a cross product coefficient from two vector coefficients.",[6139,6142],{"_19":6140,"_25":6141,"_31":6},"v1","- First vector coefficient (must be 3D)",{"_19":6143,"_25":6144,"_31":6},"v2","- Second vector coefficient (must be 3D)","Promise",[],{"_19":6148,"_21":6149,"_23":6150,"_25":6150,"_26":6151,"_32":6154,"_34":6155},"mfem.coefficients.curl","mfem.coefficients.curl(gf)","Create a curl vector coefficient from a vector GridFunction.",[6152],{"_19":5249,"_25":6153,"_31":6},"- Vector GridFunction instance","Promise",[],{"_19":6157,"_21":6158,"_23":6159,"_25":6159,"_26":6160,"_32":6166,"_34":6167},"mfem.coefficients.delta","mfem.coefficients.delta(center, weight?)","Create a Dirac delta coefficient (point source).",[6161,6163],{"_19":5072,"_25":6162,"_31":6},"- Center point of the delta function",{"_19":6164,"_25":6165,"_31":61},"weight","- Weight (scale) of the delta function (defaults to 1.0)","Promise",[],{"_19":6169,"_21":6170,"_23":6171,"_25":6171,"_26":6172,"_32":6175,"_34":6176},"mfem.coefficients.diagonal","mfem.coefficients.diagonal(values)","Create a diagonal matrix coefficient from an array of values.",[6173],{"_19":214,"_25":6174,"_31":6},"- Array of diagonal values","Promise",[],{"_19":6178,"_21":6179,"_23":6180,"_25":6180,"_26":6181,"_32":6183,"_34":6184},"mfem.coefficients.divergence","mfem.coefficients.divergence(gf)","Create a divergence scalar coefficient from a vector GridFunction.",[6182],{"_19":5249,"_25":6153,"_31":6},"Promise",[],{"_19":6186,"_21":6187,"_23":6188,"_25":6188,"_26":6189,"_32":6192,"_34":6193},"mfem.coefficients.functionCoefficient","mfem.coefficients.functionCoefficient(fn)","Create a coefficient from a JavaScript function.",[6190],{"_19":404,"_25":6191,"_31":6},"- Function (x, y, z) => number","Promise",[],{"_19":6195,"_21":6196,"_23":6197,"_25":6197,"_26":6198,"_32":6201,"_34":6202},"mfem.coefficients.gradient","mfem.coefficients.gradient(gf)","Create a gradient vector coefficient from a scalar GridFunction.",[6199],{"_19":5249,"_25":6200,"_31":6},"- Scalar GridFunction instance","Promise",[],{"_19":6204,"_21":6205,"_23":6206,"_25":6206,"_26":6207,"_32":6213,"_34":6214},"mfem.coefficients.gridFunctionCoefficient","mfem.coefficients.gridFunctionCoefficient(gf, component?)","Create a coefficient from a GridFunction.",[6208,6210],{"_19":5249,"_25":6209,"_31":6},"- GridFunction instance",{"_19":6211,"_25":6212,"_31":61},"component","- Component to use (1-based, for vector GridFunctions)","Promise",[],{"_19":6216,"_21":6217,"_23":6218,"_25":6218,"_26":6219,"_32":6222,"_34":6223},"mfem.coefficients.identity","mfem.coefficients.identity(dim)","Create an identity matrix coefficient.",[6220],{"_19":1815,"_25":6221,"_31":6},"- Dimension of the identity matrix","Promise",[],{"_19":6225,"_21":6226,"_23":6227,"_25":6227,"_26":6228,"_32":6233,"_34":6234},"mfem.coefficients.innerProduct","mfem.coefficients.innerProduct(v1, v2)","Create an inner product coefficient from two vector coefficients.",[6229,6231],{"_19":6140,"_25":6230,"_31":6},"- First vector coefficient",{"_19":6143,"_25":6232,"_31":6},"- Second vector coefficient","Promise",[],{"_19":6236,"_21":6237,"_23":6238,"_25":6238,"_26":6239,"_32":6242,"_34":6243},"mfem.coefficients.inverse","mfem.coefficients.inverse(m)","Create an inverse of a matrix coefficient.",[6240],{"_19":690,"_25":6241,"_31":6},"- Matrix coefficient to invert","Promise",[],{"_19":6245,"_21":6246,"_23":6247,"_25":6247,"_26":6248,"_32":6251,"_34":6252},"mfem.coefficients.matrixConstant","mfem.coefficients.matrixConstant(values)","Create a constant matrix coefficient.",[6249],{"_19":214,"_25":6250,"_31":6},"- 2D array of values (row-major)","Promise",[],{"_19":6254,"_21":6255,"_23":6256,"_25":6256,"_26":6257,"_32":6264,"_34":6265},"mfem.coefficients.matrixFunction","mfem.coefficients.matrixFunction(fn, height, width?)","Create a matrix coefficient from a JavaScript function.",[6258,6260,6261],{"_19":404,"_25":6259,"_31":6},"- Function (x, y, z) => number[][]",{"_19":5093,"_25":691,"_31":6},{"_19":6262,"_25":6263,"_31":61},"width","- Number of columns (defaults to height)","Promise",[],{"_19":6267,"_21":6268,"_23":6269,"_25":6269,"_26":6270,"_32":6275,"_34":6276},"mfem.coefficients.matrixProduct","mfem.coefficients.matrixProduct(a, b)","Create a matrix product coefficient from two matrix coefficients.",[6271,6273],{"_19":1423,"_25":6272,"_31":6},"- First matrix coefficient",{"_19":91,"_25":6274,"_31":6},"- Second matrix coefficient","Promise",[],{"_19":6278,"_21":6279,"_23":6280,"_25":6280,"_26":6281,"_32":6284,"_34":6285},"mfem.coefficients.normalizedVector","mfem.coefficients.normalizedVector(v)","Create a normalized vector coefficient from a vector coefficient.",[6282],{"_19":3879,"_25":6283,"_31":6},"- Vector coefficient to normalize","Promise",[],{"_19":6287,"_21":6288,"_23":6289,"_25":6289,"_26":6290,"_32":6293,"_34":6294},"mfem.coefficients.outerProduct","mfem.coefficients.outerProduct(a, b)","Create an outer product coefficient from two vector coefficients.",[6291,6292],{"_19":1423,"_25":6230,"_31":6},{"_19":91,"_25":6232,"_31":6},"Promise",[],{"_19":6296,"_21":6297,"_23":6298,"_25":6298,"_26":6299,"_32":6302,"_34":6303},"mfem.coefficients.piecewiseConstant","mfem.coefficients.piecewiseConstant(values)","Create a piecewise constant coefficient by element attribute.",[6300],{"_19":214,"_25":6301,"_31":6},"- Map of attribute number (1-based) to value","Promise",[],{"_19":6305,"_21":6306,"_23":6307,"_25":6307,"_26":6308,"_32":6311,"_34":6312},"mfem.coefficients.position","mfem.coefficients.position(dim?)","Create a position vector coefficient that returns the spatial position x.",[6309],{"_19":1815,"_25":6310,"_31":61},"- Spatial dimension (1, 2, or 3). Defaults to 3.","Promise",[],{"_19":6314,"_21":6315,"_23":6316,"_25":6316,"_26":6317,"_32":6323,"_34":6324},"mfem.coefficients.power","mfem.coefficients.power(c, exponent)","Create a power of a coefficient.",[6318,6320],{"_19":3625,"_25":6319,"_31":6},"- Base coefficient",{"_19":6321,"_25":6322,"_31":6},"exponent","- Exponent value","Promise",[],{"_19":6326,"_21":6327,"_23":6328,"_25":6328,"_26":6329,"_32":6334,"_34":6335},"mfem.coefficients.product","mfem.coefficients.product(c1, c2)","Create a product of two coefficients.",[6330,6332],{"_19":3707,"_25":6331,"_31":6},"- First coefficient",{"_19":3710,"_25":6333,"_31":6},"- Second coefficient","Promise",[],{"_19":6337,"_21":6338,"_23":6339,"_25":6339,"_26":6340,"_32":6344,"_34":6345},"mfem.coefficients.quadratureFunctionCoefficient","mfem.coefficients.quadratureFunctionCoefficient(qf)","Create a coefficient from a scalar quadrature function.",[6341],{"_19":6342,"_25":6343,"_31":6},"qf","- The quadrature function (vdim=1)","Promise",[],{"_19":6347,"_21":6348,"_23":6349,"_25":6349,"_26":6350,"_32":6353,"_34":6354},"mfem.coefficients.vectorQuadratureFunctionCoefficient","mfem.coefficients.vectorQuadratureFunctionCoefficient(qf)","Create a vector coefficient from a quadrature function.",[6351],{"_19":6342,"_25":6352,"_31":6},"- The quadrature function","Promise",[],{"_19":6356,"_21":6357,"_23":6358,"_25":6358,"_26":6359,"_32":6366,"_34":6367},"mfem.coefficients.restricted","mfem.coefficients.restricted(baseCoeff, attributes)","Create a restricted coefficient from a base coefficient.",[6360,6363],{"_19":6361,"_25":6362,"_31":6},"baseCoeff","- The base coefficient to restrict",{"_19":6364,"_25":6365,"_31":6},"attributes","- Array of mesh attributes where the coefficient is active (1-based)","Promise",[],{"_19":6369,"_21":6370,"_23":6371,"_25":6371,"_26":6372,"_32":6377,"_34":6378},"mfem.coefficients.scalarVectorProduct","mfem.coefficients.scalarVectorProduct(s, v)","Create a scalar-vector product coefficient.",[6373,6375],{"_19":4781,"_25":6374,"_31":6},"- Scalar coefficient",{"_19":3879,"_25":6376,"_31":6},"- Vector coefficient","Promise",[],{"_19":6380,"_21":6381,"_23":6382,"_25":6382,"_26":6383,"_32":6390,"_34":6391},"mfem.coefficients.sum","mfem.coefficients.sum(c1, c2, alpha?, beta?)","Create a sum of two coefficients.",[6384,6385,6386,6388],{"_19":3707,"_25":6331,"_31":6},{"_19":3710,"_25":6333,"_31":6},{"_19":5686,"_25":6387,"_31":61},"- Scale factor for c1 (default 1.0)",{"_19":2994,"_25":6389,"_31":61},"- Scale factor for c2 (default 1.0)","Promise",[],{"_19":6393,"_21":6394,"_23":6395,"_25":6395,"_26":6396,"_32":6401,"_34":6402},"mfem.coefficients.symmetric","mfem.coefficients.symmetric(fn, dim)","Create a symmetric matrix coefficient from a JavaScript function.",[6397,6399],{"_19":404,"_25":6398,"_31":6},"- Function (position: number[]) => number[][]",{"_19":1815,"_25":6400,"_31":6},"- Dimension of the symmetric matrix","Promise",[],{"_19":6404,"_21":6405,"_23":6406,"_25":6406,"_26":6407,"_32":6412,"_34":6413},"mfem.coefficients.transformed","mfem.coefficients.transformed(coeff, fn)","Create a transformed coefficient that applies a function to another coefficient.",[6408,6410],{"_19":5672,"_25":6409,"_31":6},"- Source coefficient to transform",{"_19":404,"_25":6411,"_31":6},"- Transformation function (value) => transformedValue","Promise",[],{"_19":6415,"_21":6416,"_23":6417,"_25":6417,"_26":6418,"_32":6421,"_34":6422},"mfem.coefficients.transpose","mfem.coefficients.transpose(m)","Create a transpose of a matrix coefficient.",[6419],{"_19":690,"_25":6420,"_31":6},"- Matrix coefficient to transpose","Promise",[],{"_19":6424,"_21":6425,"_23":6426,"_25":6426,"_26":6427,"_32":6431,"_34":6432},"mfem.coefficients.vectorArray","mfem.coefficients.vectorArray(coeffs)","Create a vector coefficient from an array of scalar coefficients.",[6428],{"_19":6429,"_25":6430,"_31":6},"coeffs","- Array of scalar coefficients for each component","Promise",[],{"_19":6434,"_21":6435,"_23":6436,"_25":6436,"_26":6437,"_32":6440,"_34":6441},"mfem.coefficients.vectorConstant","mfem.coefficients.vectorConstant(values)","Create a constant vector coefficient.",[6438],{"_19":214,"_25":6439,"_31":6},"- Array of constant values","Promise",[],{"_19":6443,"_21":6444,"_23":6445,"_25":6445,"_26":6446,"_32":6450,"_34":6451},"mfem.coefficients.vectorDelta","mfem.coefficients.vectorDelta(center, direction)","Create a vector Dirac delta coefficient (directional point source).",[6447,6448],{"_19":5072,"_25":6162,"_31":6},{"_19":1941,"_25":6449,"_31":6},"- Direction vector of the source","Promise",[],{"_19":6453,"_21":6454,"_23":6455,"_25":6455,"_26":6456,"_32":6461,"_34":6462},"mfem.coefficients.vectorFunction","mfem.coefficients.vectorFunction(fn, dim?)","Create a vector coefficient from a JavaScript function.",[6457,6459],{"_19":404,"_25":6458,"_31":6},"- Function (x, y, z) => number[]",{"_19":1815,"_25":6460,"_31":61},"- Output vector dimension (defaults to 3)","Promise",[],{"_19":6464,"_21":6465,"_23":6466,"_25":6466,"_26":6467,"_32":6470,"_34":6471},"mfem.coefficients.vectorRotProduct","mfem.coefficients.vectorRotProduct(a, b)","Create a 2D cross product (rotation product) of two vector coefficients.",[6468,6469],{"_19":1423,"_25":6230,"_31":6},{"_19":91,"_25":6232,"_31":6},"Promise",[],{"_19":6473,"_21":6474,"_23":6475,"_25":6475,"_26":6476,"_32":6132,"_34":6479},"mfem.coefficients.ConstantCoefficient.create","mfem.coefficients.ConstantCoefficient.create(value)","Creates a new constant coefficient with the specified value.",[6477],{"_19":417,"_25":6478,"_31":6},"- The constant value",[],{"_19":6481,"_21":6482,"_23":6483,"_25":6483,"_26":6484,"_32":6154,"_34":6487},"mfem.coefficients.CurlCoefficient.create","mfem.coefficients.CurlCoefficient.create(gf)","Creates a new curl coefficient from a vector GridFunction.",[6485],{"_19":5249,"_25":6486,"_31":6},"- The vector GridFunction whose curl to compute",[],{"_19":6489,"_21":6490,"_23":6491,"_25":6491,"_26":6492,"_32":6166,"_34":6496},"mfem.coefficients.DeltaCoefficient.create","mfem.coefficients.DeltaCoefficient.create(center, weight?)","Creates a new delta coefficient (point source).",[6493,6495],{"_19":5072,"_25":6494,"_31":6},"- Center point of the delta function [x] or [x, y] or [x, y, z]",{"_19":6164,"_25":6165,"_31":61},[],{"_19":6498,"_21":6499,"_23":6500,"_25":6500,"_26":6501,"_32":6175,"_34":6504},"mfem.coefficients.DiagonalMatrixCoefficient.create","mfem.coefficients.DiagonalMatrixCoefficient.create(values)","Creates a new diagonal matrix coefficient.",[6502],{"_19":214,"_25":6503,"_31":6},"- Array of diagonal values. The length determines the matrix dimension.",[],{"_19":6506,"_21":6507,"_23":6508,"_25":6508,"_26":6509,"_32":6183,"_34":6512},"mfem.coefficients.DivergenceCoefficient.create","mfem.coefficients.DivergenceCoefficient.create(gf)","Creates a new divergence coefficient from a vector GridFunction.",[6510],{"_19":5249,"_25":6511,"_31":6},"- The vector GridFunction whose divergence to compute",[],{"_19":6514,"_21":6515,"_23":6516,"_25":6516,"_26":6517,"_32":6192,"_34":6520},"mfem.coefficients.FunctionCoefficient.create","mfem.coefficients.FunctionCoefficient.create(fn)","Creates a new function coefficient with the specified evaluation function.",[6518],{"_19":404,"_25":6519,"_31":6},"- Function that takes (x, y, z) coordinates and returns a scalar value",[],{"_19":6522,"_21":6523,"_23":6524,"_25":6524,"_26":6525,"_32":6201,"_34":6528},"mfem.coefficients.GradientCoefficient.create","mfem.coefficients.GradientCoefficient.create(gf)","Creates a new gradient coefficient from a scalar GridFunction.",[6526],{"_19":5249,"_25":6527,"_31":6},"- The scalar GridFunction whose gradient to compute",[],{"_19":6530,"_21":6531,"_23":6532,"_25":6532,"_26":6533,"_32":6213,"_34":6538},"mfem.coefficients.GridFunctionCoefficient.create","mfem.coefficients.GridFunctionCoefficient.create(gf, component?)","Creates a new GridFunction coefficient.",[6534,6536],{"_19":5249,"_25":6535,"_31":6},"- The GridFunction to evaluate",{"_19":6211,"_25":6537,"_31":61},"- Component to use for vector GridFunctions (1-based, default 1)",[],{"_19":6540,"_21":6541,"_23":6542,"_25":6542,"_26":6543,"_32":6251,"_34":6550},"mfem.coefficients.MatrixConstantCoefficient.create","mfem.coefficients.MatrixConstantCoefficient.create(values, height?, width?)","Creates a new constant matrix coefficient with the specified values.",[6544,6546,6548],{"_19":214,"_25":6545,"_31":6},"- 2D array of values (row-major) or 1D array with explicit dimensions",{"_19":5093,"_25":6547,"_31":61},"- Number of rows (required if values is 1D array)",{"_19":6262,"_25":6549,"_31":61},"- Number of columns (required if values is 1D array)",[],{"_19":6552,"_21":6553,"_23":6554,"_25":6554,"_26":6555,"_32":6264,"_34":6561},"mfem.coefficients.MatrixFunctionCoefficient.create","mfem.coefficients.MatrixFunctionCoefficient.create(fn, height, width?)","Creates a new matrix function coefficient.",[6556,6558,6559],{"_19":404,"_25":6557,"_31":6},"- Function that takes (x, y, z) and returns a 2D array",{"_19":5093,"_25":691,"_31":6},{"_19":6262,"_25":6560,"_31":61},"- Number of columns (defaults to height for square matrices)",[],{"_19":6563,"_21":6564,"_23":6565,"_25":6565,"_26":6566,"_32":6275,"_34":6569},"mfem.coefficients.MatrixProductCoefficient.create","mfem.coefficients.MatrixProductCoefficient.create(a, b)","Creates a new matrix product coefficient: A * B",[6567,6568],{"_19":1423,"_25":6272,"_31":6},{"_19":91,"_25":6274,"_31":6},[],{"_19":6571,"_21":6572,"_23":6573,"_25":6573,"_26":6574,"_32":6284,"_34":6576},"mfem.coefficients.NormalizedVectorCoefficient.create","mfem.coefficients.NormalizedVectorCoefficient.create(v)","Creates a new normalized vector coefficient: v / ||v||",[6575],{"_19":3879,"_25":6283,"_31":6},[],{"_19":6578,"_21":6579,"_23":6580,"_25":6580,"_26":6581,"_32":6302,"_34":6584},"mfem.coefficients.PWConstCoefficient.create","mfem.coefficients.PWConstCoefficient.create(values)","Creates a new piecewise constant coefficient.",[6582],{"_19":214,"_25":6583,"_31":6},"- Array of values for each attribute (index i corresponds to attribute i+1)",[],{"_19":6586,"_21":6587,"_23":6588,"_25":6588,"_26":6589,"_32":6302,"_34":6593},"mfem.coefficients.PWConstCoefficient.createFromMap","mfem.coefficients.PWConstCoefficient.createFromMap(attrValues)","Creates a new piecewise constant coefficient from a Map.",[6590],{"_19":6591,"_25":6592,"_31":6},"attrValues","- Map of attribute numbers (1-based) to values",[],{"_19":6595,"_21":6596,"_23":6597,"_25":6597,"_26":6598,"_32":6311,"_34":6600},"mfem.coefficients.PositionVectorCoefficient.create","mfem.coefficients.PositionVectorCoefficient.create(dim?)","Creates a new position vector coefficient.",[6599],{"_19":1815,"_25":6310,"_31":61},[],{"_19":6602,"_21":6603,"_23":6604,"_25":6604,"_26":6605,"_32":6323,"_34":6609},"mfem.coefficients.PowerCoefficient.create","mfem.coefficients.PowerCoefficient.create(c, exponent)","Creates a new power coefficient: c^p",[6606,6607],{"_19":3625,"_25":6319,"_31":6},{"_19":6321,"_25":6608,"_31":6},"- Power exponent",[],{"_19":6611,"_21":6612,"_23":6613,"_25":6613,"_26":6614,"_32":6334,"_34":6617},"mfem.coefficients.ProductCoefficient.create","mfem.coefficients.ProductCoefficient.create(c1, c2)","Creates a new product coefficient: c1 * c2",[6615,6616],{"_19":3707,"_25":6331,"_31":6},{"_19":3710,"_25":6333,"_31":6},[],{"_19":6619,"_21":6620,"_23":6621,"_25":6621,"_26":6622,"_32":6344,"_34":6625},"mfem.coefficients.QuadratureFunctionCoefficient.create","mfem.coefficients.QuadratureFunctionCoefficient.create(qf)","Creates a new coefficient from a scalar quadrature function.",[6623],{"_19":6342,"_25":6624,"_31":6},"- The quadrature function (must have vdim=1)",[],{"_19":6627,"_21":6628,"_23":6629,"_25":6629,"_26":6630,"_32":6353,"_34":6632},"mfem.coefficients.VectorQuadratureFunctionCoefficient.create","mfem.coefficients.VectorQuadratureFunctionCoefficient.create(qf)","Creates a new vector coefficient from a quadrature function.",[6631],{"_19":6342,"_25":6352,"_31":6},[],{"_19":6634,"_21":6635,"_23":6636,"_25":6636,"_26":6637,"_32":6366,"_34":6640},"mfem.coefficients.RestrictedCoefficient.create","mfem.coefficients.RestrictedCoefficient.create(baseCoeff, attributes)","Creates a new restricted coefficient.",[6638,6639],{"_19":6361,"_25":6362,"_31":6},{"_19":6364,"_25":6365,"_31":6},[],{"_19":6642,"_21":6643,"_23":6644,"_25":6644,"_26":6645,"_32":6377,"_34":6648},"mfem.coefficients.ScalarVectorProductCoefficient.create","mfem.coefficients.ScalarVectorProductCoefficient.create(s, v)","Creates a new scalar-vector product coefficient: s * v",[6646,6647],{"_19":4781,"_25":6374,"_31":6},{"_19":3879,"_25":6376,"_31":6},[],{"_19":6650,"_21":6651,"_23":6652,"_25":6652,"_26":6653,"_32":6390,"_34":6658},"mfem.coefficients.SumCoefficient.create","mfem.coefficients.SumCoefficient.create(c1, c2, alpha?, beta?)","Creates a new sum coefficient: alpha * c1 + beta * c2",[6654,6655,6656,6657],{"_19":3707,"_25":6331,"_31":6},{"_19":3710,"_25":6333,"_31":6},{"_19":5686,"_25":6387,"_31":61},{"_19":2994,"_25":6389,"_31":61},[],{"_19":6660,"_21":6661,"_23":6662,"_25":6662,"_26":6663,"_32":6401,"_34":6667},"mfem.coefficients.SymmetricMatrixCoefficient.create","mfem.coefficients.SymmetricMatrixCoefficient.create(fn, dim)","Creates a new symmetric matrix function coefficient.",[6664,6666],{"_19":404,"_25":6665,"_31":6},"- Function that takes position [x, y, z] and returns a symmetric 2D array",{"_19":1815,"_25":6400,"_31":6},[],{"_19":6669,"_21":6670,"_23":6671,"_25":6671,"_26":6672,"_32":6412,"_34":6675},"mfem.coefficients.TransformedCoefficient.create","mfem.coefficients.TransformedCoefficient.create(coeff, fn)","Creates a new transformed coefficient: F(Q)",[6673,6674],{"_19":5672,"_25":6409,"_31":6},{"_19":404,"_25":6411,"_31":6},[],{"_19":6677,"_21":6678,"_23":6679,"_25":6679,"_26":6680,"_32":6431,"_34":6683},"mfem.coefficients.VectorArrayCoefficient.create","mfem.coefficients.VectorArrayCoefficient.create(dim)","Creates a new vector array coefficient of the specified dimension.",[6681],{"_19":1815,"_25":6682,"_31":6},"- Vector dimension",[],{"_19":6685,"_21":6686,"_23":6687,"_25":6687,"_26":6688,"_32":6440,"_34":6691},"mfem.coefficients.VectorConstantCoefficient.create","mfem.coefficients.VectorConstantCoefficient.create(values)","Creates a new constant vector coefficient with the specified values.",[6689],{"_19":214,"_25":6690,"_31":6},"- Array of constant values for each component",[],{"_19":6693,"_21":6694,"_23":6695,"_25":6695,"_26":6696,"_32":6450,"_34":6700},"mfem.coefficients.VectorDeltaCoefficient.create","mfem.coefficients.VectorDeltaCoefficient.create(center, direction)","Creates a new vector delta coefficient (directional point source).",[6697,6698],{"_19":5072,"_25":6494,"_31":6},{"_19":1941,"_25":6699,"_31":6},"- Direction vector of the source (must match spatial dimension)",[],{"_19":6702,"_21":6703,"_23":6704,"_25":6704,"_26":6705,"_32":6461,"_34":6710},"mfem.coefficients.VectorFunctionCoefficient.create","mfem.coefficients.VectorFunctionCoefficient.create(fn, dim)","Creates a new vector function coefficient.",[6706,6708],{"_19":404,"_25":6707,"_31":6},"- Function that takes (x, y, z) and returns a vector",{"_19":1815,"_25":6709,"_31":6},"- Output vector dimension",[],{"_19":6712,"_21":6713,"_23":6714,"_25":6714,"_26":6715,"_32":6470,"_34":6

slu.matrix.getTransposeCSR

Syntax

Description

Parameters

Returns