[{"_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,"_35":36,"_6061":6062},"function",{"_19":20,"_21":22,"_23":24,"_25":24,"_26":27,"_32":30,"_33":34},"name","np.arctan","signature","np.arctan(x)","summary","Trigonometric inverse tangent, element-wise.","description","params",[28],{"_19":29,"_25":30,"_31":6},"x","NDArray","optional","returns","examples",[],"package",{"_37":38,"_19":39,"_25":40,"_41":42,"_43":44,"_45":46,"_47":48},"id","np-generated","Numerical Arrays (NumPy)","NumPy-inspired numerical array library for WebAssembly.","tier","free","icon","🔢","namespace","np","functions",[49,64,92,110,126,142,160,172,182,200,214,227,240,252,263,275,287,298,305,315,330,345,359,368,381,396,409,424,431,438,445,18,452,460,467,479,489,502,515,522,537,548,559,568,583,592,600,614,624,633,641,649,657,670,681,688,695,708,718,733,745,756,765,778,786,795,803,811,819,828,838,851,860,872,884,894,909,916,923,933,943,951,961,970,992,1001,1016,1031,1039,1050,1057,1065,1075,1087,1097,1114,1126,1140,1155,1164,1174,1181,1191,1203,1212,1223,1235,1246,1256,1264,1278,1285,1293,1310,1324,1335,1342,1349,1356,1373,1395,1406,1416,1430,1441,1452,1465,1472,1484,1492,1500,1510,1522,1531,1543,1558,1570,1584,1592,1604,1613,1622,1630,1638,1646,1653,1661,1669,1677,1687,1695,1707,1714,1723,1735,1745,1755,1763,1775,1789,1797,1804,1811,1820,1831,1841,1848,1857,1871,1886,1900,1912,1924,1934,1949,1958,1965,1972,1981,1989,1997,2006,2013,2021,2029,2037,2045,2066,2080,2089,2097,2107,2119,2130,2141,2153,2163,2182,2197,2213,2224,2232,2243,2253,2270,2279,2289,2296,2303,2316,2324,2332,2340,2348,2359,2366,2375,2382,2390,2398,2405,2413,2420,2428,2436,2450,2457,2467,2475,2484,2491,2499,2507,2515,2527,2534,2544,2552,2561,2568,2576,2584,2592,2601,2614,2632,2651,2663,2679,2688,2696,2704,2713,2722,2733,2745,2755,2764,2775,2783,2796,2810,2817,2826,2839,2859,2872,2879,2886,2899,2909,2919,2926,2933,2940,2953,2961,2968,2975,2983,2990,3001,3008,3015,3022,3032,3039,3046,3054,3061,3068,3074,3082,3089,3096,3104,3111,3120,3127,3134,3142,3154,3162,3170,3176,3185,3194,3205,3214,3221,3229,3236,3244,3252,3264,3271,3281,3289,3298,3305,3313,3321,3329,3338,3349,3357,3364,3372,3379,3387,3395,3407,3414,3424,3432,3441,3448,3456,3464,3472,3480,3488,3498,3511,3517,3529,3540,3550,3558,3567,3574,3581,3588,3595,3603,3611,3619,3626,3634,3642,3657,3664,3674,3687,3703,3712,3726,3737,3750,3760,3772,3781,3792,3802,3810,3822,3832,3841,3851,3860,3868,3876,3889,3898,3906,3922,3933,3942,3953,3963,3974,3987,3997,4006,4023,4036,4049,4063,4076,4089,4098,4107,4115,4122,4132,4140,4149,4157,4166,4174,4181,4193,4201,4215,4230,4240,4252,4262,4272,4289,4298,4313,4323,4332,4339,4346,4353,4360,4370,4377,4385,4395,4407,4414,4424,4433,4444,4451,4459,4468,4477,4489,4497,4509,4516,4524,4535,4548,4559,4572,4586,4596,4606,4618,4625,4634,4648,4655,4662,4672,4678,4684,4691,4702,4710,4720,4731,4741,4755,4765,4778,4785,4793,4805,4811,4822,4833,4841,4853,4863,4872,4883,4897,4905,4915,4922,4931,4943,4954,4963,4975,4982,4991,4999,5005,5018,5030,5040,5049,5061,5069,5083,5093,5101,5111,5119,5129,5136,5143,5150,5158,5165,5178,5187,5197,5207,5215,5223,5234,5241,5248,5257,5267,5279,5293,5300,5308,5315,5324,5335,5345,5355,5364,5373,5383,5391,5400,5409,5420,5430,5438,5446,5459,5473,5481,5495,5502,5510,5521,5533,5540,5551,5558,5570,5580,5590,5597,5604,5617,5629,5642,5652,5662,5670,5686,5696,5706,5716,5727,5737,5747,5756,5766,5775,5784,5791,5799,5808,5817,5825,5833,5841,5849,5856,5871,5880,5891,5907,5914,5929,5942,5951,5962,5972,5984,5996,6004,6012,6025,6037,6045,6052],{"_19":50,"_21":51,"_23":52,"_25":53,"_26":54,"_32":62,"_33":63},"np.testing.assert_","np.testing.assert_(val, msg?)","Assert a condition is true.\r","Assert a condition is true.\r\n\r\nUnlike the built-in assert, this works in optimized mode\r\nand provides a consistent interface.",[55,58],{"_19":56,"_25":57,"_31":6},"val","- Value to test for truthiness",{"_19":59,"_25":60,"_31":61},"msg","- Message to display on failure",true,"void",[],{"_19":65,"_21":66,"_23":67,"_25":68,"_26":69,"_32":62,"_33":91},"np.testing.assert_allclose","np.testing.assert_allclose(actual, desired, rtol?, atol?, equal_nan?, err_msg?, _verbose?)","Assert that two arrays are element-wise equal within tolerance.\r","Assert that two arrays are element-wise equal within tolerance.\r\n\r\nThe comparison is:\r\n |actual - desired| <= atol + rtol * |desired|\r\n\r\nThis is the recommended assertion for floating-point comparisons.",[70,73,76,79,82,85,88],{"_19":71,"_25":72,"_31":6},"actual","- Actual array",{"_19":74,"_25":75,"_31":6},"desired","- Expected array",{"_19":77,"_25":78,"_31":61},"rtol","- Relative tolerance (default: 1e-7)",{"_19":80,"_25":81,"_31":61},"atol","- Absolute tolerance (default: 0)",{"_19":83,"_25":84,"_31":61},"equal_nan","- If true, NaN == NaN (default: true)",{"_19":86,"_25":87,"_31":61},"err_msg","- Custom error message",{"_19":89,"_25":90,"_31":61},"_verbose","boolean",[],{"_19":93,"_21":94,"_23":95,"_25":96,"_26":97,"_32":62,"_33":109},"np.testing.assert_almost_equal","np.testing.assert_almost_equal(actual, desired, decimal?, err_msg?, verbose?)","Assert that two values are equal up to specified decimal places.\r","Assert that two values are equal up to specified decimal places.\r\n\r\nComparison: |actual - desired| < 10^(-decimal)\r\n\r\nFor more control over tolerances, use assert_allclose instead.",[98,100,102,105,106],{"_19":71,"_25":99,"_31":6},"- Actual value or array",{"_19":74,"_25":101,"_31":6},"- Expected value or array",{"_19":103,"_25":104,"_31":61},"decimal","- Number of decimal places (default: 7)",{"_19":86,"_25":87,"_31":61},{"_19":107,"_25":108,"_31":61},"verbose","- Show detailed output",[],{"_19":111,"_21":112,"_23":113,"_25":114,"_26":115,"_32":62,"_33":125},"np.testing.assert_approx_equal","np.testing.assert_approx_equal(actual, desired, significant?, err_msg?, verbose?)","Assert values are equal to specified significant figures.\r","Assert values are equal to specified significant figures.\r\n\r\nThe comparison is relative to the scale of the expected value.",[116,118,120,123,124],{"_19":71,"_25":117,"_31":6},"- Actual value",{"_19":74,"_25":119,"_31":6},"- Expected value",{"_19":121,"_25":122,"_31":61},"significant","- Number of significant figures (default: 7)",{"_19":86,"_25":87,"_31":61},{"_19":107,"_25":108,"_31":61},[],{"_19":127,"_21":128,"_23":129,"_25":130,"_26":131,"_32":62,"_33":141},"np.testing.assert_array_almost_equal","np.testing.assert_array_almost_equal(x, y, decimal?, err_msg?, verbose?)","Assert arrays are element-wise equal up to decimal places.\r","Assert arrays are element-wise equal up to decimal places.\r\n\r\nCombination of assert_array_equal and assert_almost_equal.\r\nFirst checks shapes, then element values.",[132,134,137,139,140],{"_19":29,"_25":133,"_31":6},"- First array",{"_19":135,"_25":136,"_31":6},"y","- Second array",{"_19":103,"_25":138,"_31":61},"- Number of decimal places (default: 6)",{"_19":86,"_25":87,"_31":61},{"_19":107,"_25":108,"_31":61},[],{"_19":143,"_21":144,"_23":145,"_25":146,"_26":147,"_32":62,"_33":159},"np.testing.assert_array_compare","np.testing.assert_array_compare(comparison, x, y, header?, precision?)","Assert arrays satisfy a custom comparison.\r","Assert arrays satisfy a custom comparison.\r\n\r\nLow-level function for building custom assertions.",[148,151,152,153,156],{"_19":149,"_25":150,"_31":6},"comparison","- Comparison function (a, b) => boolean",{"_19":29,"_25":133,"_31":6},{"_19":135,"_25":136,"_31":6},{"_19":154,"_25":155,"_31":61},"header","- Error message header",{"_19":157,"_25":158,"_31":61},"precision","- Decimal places for display",[],{"_19":161,"_21":162,"_23":163,"_25":164,"_26":165,"_32":62,"_33":171},"np.testing.assert_array_equal","np.testing.assert_array_equal(x, y, err_msg?, verbose?)","Assert that two arrays are element-wise equal.\r","Assert that two arrays are element-wise equal.\r\n\r\nCompares shape and all elements. For floating-point arrays,\r\nuse assert_allclose for tolerance-based comparison.",[166,167,168,169],{"_19":29,"_25":133,"_31":6},{"_19":135,"_25":136,"_31":6},{"_19":86,"_25":87,"_31":61},{"_19":107,"_25":170,"_31":61},"- Show detailed output on failure",[],{"_19":173,"_21":174,"_23":175,"_25":175,"_26":176,"_32":62,"_33":181},"np.testing.assert_array_less","np.testing.assert_array_less(x, y, err_msg?, verbose?)","Assert that all elements of x are strictly less than those of y.",[177,178,179,180],{"_19":29,"_25":133,"_31":6},{"_19":135,"_25":136,"_31":6},{"_19":86,"_25":87,"_31":61},{"_19":107,"_25":108,"_31":61},[],{"_19":183,"_21":184,"_23":185,"_25":186,"_26":187,"_32":198,"_33":199},"np.testing.assert_array_max_ulp","np.testing.assert_array_max_ulp(a, b, maxulp?, dtype?)","Assert arrays differ by at most `maxulp` ULPs.\r","Assert arrays differ by at most `maxulp` ULPs.\r\n\r\nULP = Unit in the Last Place (floating-point precision unit).\r\nThis is the most precise way to compare floating-point numbers.",[188,190,192,195],{"_19":189,"_25":133,"_31":6},"a",{"_19":191,"_25":136,"_31":6},"b",{"_19":193,"_25":194,"_31":61},"maxulp","- Maximum ULP difference allowed (default: 1)",{"_19":196,"_25":197,"_31":61},"dtype","- Data type for comparison","number",[],{"_19":201,"_21":202,"_23":203,"_25":204,"_26":205,"_32":62,"_33":213},"np.testing.assert_equal","np.testing.assert_equal(actual, desired, err_msg?, verbose?)","Assert that two objects are equal.\r","Assert that two objects are equal.\r\n\r\nHandles comparison of:\r\n- Scalars (number, string, boolean)\r\n- Arrays (JavaScript arrays, nested arrays)\r\n- NDArrays (element-wise comparison)\r\n- Objects (deep equality)\r\n\r\nSpecial cases:\r\n- NaN == NaN is treated as True for testing purposes\r\n- Infinity values are compared correctly",[206,208,209,211],{"_19":71,"_25":207,"_31":6},"- Actual value obtained",{"_19":74,"_25":119,"_31":6},{"_19":86,"_25":210,"_31":61},"- Custom error message prefix",{"_19":107,"_25":212,"_31":61},"- If true, show detailed diff (default: true)",[],{"_19":215,"_21":216,"_23":217,"_25":217,"_26":218,"_32":225,"_33":226},"np.testing.assert_no_warnings","np.testing.assert_no_warnings(func, args)","Assert that a function emits no warnings.",[219,222],{"_19":220,"_25":221,"_31":6},"func","- Function to call",{"_19":223,"_25":224,"_31":6},"args","- Arguments to pass to function","unknown",[],{"_19":228,"_21":229,"_23":230,"_25":230,"_26":231,"_32":62,"_33":239},"np.testing.assert_raises","np.testing.assert_raises(exception_class, callable, args)","Assert that a callable raises the specified exception.",[232,235,237],{"_19":233,"_25":234,"_31":6},"exception_class","- Expected exception type",{"_19":236,"_25":221,"_31":6},"callable",{"_19":223,"_25":238,"_31":6},"- Arguments to pass to callable",[],{"_19":241,"_21":242,"_23":243,"_25":243,"_26":244,"_32":62,"_33":251},"np.testing.assert_raises_regex","np.testing.assert_raises_regex(exception_class, expected_regexp, callable, args)","Assert exception is raised with matching message.",[245,246,249,250],{"_19":233,"_25":234,"_31":6},{"_19":247,"_25":248,"_31":6},"expected_regexp","- Regex pattern for message",{"_19":236,"_25":221,"_31":6},{"_19":223,"_25":238,"_31":6},[],{"_19":253,"_21":254,"_23":255,"_25":256,"_26":257,"_32":62,"_33":262},"np.testing.assert_string_equal","np.testing.assert_string_equal(actual, desired)","Assert that two strings are equal.\r","Assert that two strings are equal.\r\n\r\nProvides clear diff output for multi-line strings.",[258,260],{"_19":71,"_25":259,"_31":6},"- Actual string",{"_19":74,"_25":261,"_31":6},"- Expected string",[],{"_19":264,"_21":265,"_23":266,"_25":267,"_26":268,"_32":225,"_33":274},"np.testing.assert_warns","np.testing.assert_warns(warning_class, callable, args)","Assert that a function emits a warning.\r","Assert that a function emits a warning.\r\n\r\nNote: JavaScript doesn't have built-in warnings.\r\nThis integrates with a custom warning system if available.",[269,272,273],{"_19":270,"_25":271,"_31":6},"warning_class","- Expected warning type",{"_19":236,"_25":221,"_31":6},{"_19":223,"_25":238,"_31":6},[],{"_19":276,"_21":277,"_23":278,"_25":278,"_26":279,"_32":198,"_33":286},"np.testing.measure","np.testing.measure(code, times?)","Measure execution time of a code block.",[280,283],{"_19":281,"_25":282,"_31":6},"code","- Function to benchmark",{"_19":284,"_25":285,"_31":61},"times","- Number of iterations (default: 1)",[],{"_19":288,"_21":289,"_23":290,"_25":290,"_26":291,"_32":62,"_33":297},"np.testing.print_assert_equal","np.testing.print_assert_equal(test_string, actual, desired)","Print comparison result for debugging.",[292,295,296],{"_19":293,"_25":294,"_31":6},"test_string","- Description of test",{"_19":71,"_25":117,"_31":6},{"_19":74,"_25":119,"_31":6},[],{"_19":299,"_21":300,"_23":301,"_25":301,"_26":302,"_32":30,"_33":304},"np.absolute","np.absolute(x)","Calculate the absolute value element-wise.",[303],{"_19":29,"_25":30,"_31":6},[],{"_19":306,"_21":307,"_23":308,"_25":308,"_26":309,"_32":30,"_33":314},"np.add","np.add(x1, x2)","Add arguments element-wise.",[310,312],{"_19":311,"_25":30,"_31":6},"x1",{"_19":313,"_25":30,"_31":6},"x2",[],{"_19":316,"_21":317,"_23":318,"_25":318,"_26":319,"_32":328,"_33":329},"np.all","np.all(a, axis?, keepdims?)","Test whether all array elements along a given axis evaluate to True.",[320,322,325],{"_19":189,"_25":321,"_31":6},"- Input array",{"_19":323,"_25":324,"_31":61},"axis","- Axis along which to test (undefined for entire array)",{"_19":326,"_25":327,"_31":61},"keepdims","- If true, keep reduced axis as size-1 dimension","Promise",[],{"_19":331,"_21":332,"_23":333,"_25":333,"_26":334,"_32":343,"_33":344},"np.allclose","np.allclose(a, b, rtol?, atol?, equal_nan?)","Returns True if two arrays are element-wise equal within a tolerance.",[335,336,337,339,341],{"_19":189,"_25":133,"_31":6},{"_19":191,"_25":136,"_31":6},{"_19":77,"_25":338,"_31":61},"- Relative tolerance (default 1e-5)",{"_19":80,"_25":340,"_31":61},"- Absolute tolerance (default 1e-8)",{"_19":83,"_25":342,"_31":61},"- Whether to compare NaN's as equal (default false)","Promise",[],{"_19":346,"_21":347,"_23":348,"_25":349,"_26":350,"_32":357,"_33":358},"np.angle","np.angle(z, deg?)","Return the angle of the complex argument.\r","Return the angle of the complex argument.\r\n\r\nThe angle is computed as the counterclockwise angle from the positive\r\nreal axis, using `arctan2(imag, real)`.",[351,354],{"_19":352,"_25":353,"_31":6},"z","- A complex number or array of complex numbers",{"_19":355,"_25":356,"_31":61},"deg","- Return angle in degrees if true, radians if false (default)","Promise",[],{"_19":360,"_21":361,"_23":362,"_25":362,"_26":363,"_32":328,"_33":367},"np.any","np.any(a, axis?, keepdims?)","Test whether any array element along a given axis evaluates to True.",[364,365,366],{"_19":189,"_25":321,"_31":6},{"_19":323,"_25":324,"_31":61},{"_19":326,"_25":327,"_31":61},[],{"_19":369,"_21":370,"_23":371,"_25":371,"_26":372,"_32":30,"_33":380},"np.append","np.append(arr, values, axis?)","Append values to the end of an array.",[373,375,378],{"_19":374,"_25":321,"_31":6},"arr",{"_19":376,"_25":377,"_31":6},"values","- Values to append",{"_19":323,"_25":379,"_31":61},"- Axis along which to append (default: flatten both)",[],{"_19":382,"_21":383,"_23":384,"_25":385,"_26":386,"_32":357,"_33":395},"np.applyAlongAxis","np.applyAlongAxis(func1d, axis, arr, args)","Apply a function to 1-D slices along the given axis.\r","Apply a function to 1-D slices along the given axis.\r\n\r\nExecute `func1d(a, ...args)` where `func1d` operates on 1-D arrays\r\nand `a` is a 1-D slice of `arr` along `axis`.",[387,390,392,393],{"_19":388,"_25":389,"_31":6},"func1d","- Function that accepts a 1-D array and returns a scalar or 1-D array",{"_19":323,"_25":391,"_31":6},"- Axis along which to apply `func1d`",{"_19":374,"_25":321,"_31":6},{"_19":223,"_25":394,"_31":6},"- Additional arguments to pass to `func1d`",[],{"_19":397,"_21":398,"_23":399,"_25":400,"_26":401,"_32":357,"_33":408},"np.applyOverAxes","np.applyOverAxes(func, arr, axes)","Apply a function repeatedly over multiple axes.\r","Apply a function repeatedly over multiple axes.\r\n\r\n`func` is called as `func(a, axis)` where `a` is the current array\r\nand `axis` is the current axis being processed. The result should\r\nhave the same number of dimensions as the input, or one less if\r\nthe function reduces along the axis (in which case `expandDims` is\r\nautomatically called to maintain dimensionality).",[402,404,405],{"_19":220,"_25":403,"_31":6},"- Function to apply, signature: (a, axis) => NDArray",{"_19":374,"_25":321,"_31":6},{"_19":406,"_25":407,"_31":6},"axes","- Axes over which to apply func",[],{"_19":410,"_21":411,"_23":412,"_25":412,"_26":413,"_32":357,"_33":423},"np.arange","np.arange(start, end?, step?)","Create an NDArray with evenly spaced values within a given interval.",[414,417,420],{"_19":415,"_25":416,"_31":6},"start","- Start value (or end if end is not provided)",{"_19":418,"_25":419,"_31":61},"end","- End value (exclusive)",{"_19":421,"_25":422,"_31":61},"step","- Step between values (default: 1)",[],{"_19":425,"_21":426,"_23":427,"_25":427,"_26":428,"_32":30,"_33":430},"np.arccos","np.arccos(x)","Trigonometric inverse cosine, element-wise.",[429],{"_19":29,"_25":30,"_31":6},[],{"_19":432,"_21":433,"_23":434,"_25":434,"_26":435,"_32":30,"_33":437},"np.arccosh","np.arccosh(x)","Inverse hyperbolic cosine, element-wise.",[436],{"_19":29,"_25":30,"_31":6},[],{"_19":439,"_21":440,"_23":441,"_25":441,"_26":442,"_32":30,"_33":444},"np.arcsin","np.arcsin(x)","Inverse sine, element-wise.",[443],{"_19":29,"_25":30,"_31":6},[],{"_19":446,"_21":447,"_23":448,"_25":448,"_26":449,"_32":30,"_33":451},"np.arcsinh","np.arcsinh(x)","Inverse hyperbolic sine element-wise.",[450],{"_19":29,"_25":30,"_31":6},[],{"_19":453,"_21":454,"_23":455,"_25":455,"_26":456,"_32":30,"_33":459},"np.arctan2","np.arctan2(x1, x2)","Element-wise arc tangent of x1/x2 choosing the quadrant correctly.",[457,458],{"_19":311,"_25":30,"_31":6},{"_19":313,"_25":30,"_31":6},[],{"_19":461,"_21":462,"_23":463,"_25":463,"_26":464,"_32":30,"_33":466},"np.arctanh","np.arctanh(x)","Inverse hyperbolic tangent element-wise.",[465],{"_19":29,"_25":30,"_31":6},[],{"_19":468,"_21":469,"_23":470,"_25":470,"_26":471,"_32":477,"_33":478},"np.argmax","np.argmax(a, axis?, keepdims?)","Returns the indices of the maximum values along an axis.",[472,473,475],{"_19":189,"_25":321,"_31":6},{"_19":323,"_25":474,"_31":61},"- Axis along which to find argmax. null finds argmax of flattened array.",{"_19":326,"_25":476,"_31":61},"- If true, reduced axes are left with size 1","Promise",[],{"_19":480,"_21":481,"_23":482,"_25":482,"_26":483,"_32":477,"_33":488},"np.argmin","np.argmin(a, axis?, keepdims?)","Returns the indices of the minimum values along an axis.",[484,485,487],{"_19":189,"_25":321,"_31":6},{"_19":323,"_25":486,"_31":61},"- Axis along which to find argmin. null finds argmin of flattened array.",{"_19":326,"_25":476,"_31":61},[],{"_19":490,"_21":491,"_23":492,"_25":492,"_26":493,"_32":357,"_33":501},"np.argpartition","np.argpartition(a, kth, axis?)","Returns the indices that would partition an array.",[494,496,499],{"_19":189,"_25":495,"_31":6},"- Array to partition",{"_19":497,"_25":498,"_31":6},"kth","- Index to partition around",{"_19":323,"_25":500,"_31":61},"- Axis along which to partition (default: -1)",[],{"_19":503,"_21":504,"_23":505,"_25":505,"_26":506,"_32":357,"_33":514},"np.argsort","np.argsort(a, axis?, kind?)","Returns the indices that would sort an array.",[507,509,511],{"_19":189,"_25":508,"_31":6},"- Array to sort",{"_19":323,"_25":510,"_31":61},"- Axis along which to sort. null flattens the array.\r\n Default is -1 (last axis).",{"_19":512,"_25":513,"_31":61},"kind","- Sorting algorithm",[],{"_19":516,"_21":517,"_23":518,"_25":518,"_26":519,"_32":357,"_33":521},"np.argwhere","np.argwhere(arr)","Find the indices of array elements that are non-zero, grouped by element.",[520],{"_19":374,"_25":321,"_31":6},[],{"_19":523,"_21":524,"_23":525,"_25":525,"_26":526,"_32":357,"_33":536},"np.array","np.array(data, shape?, options?)","Create an NDArray from a nested array or flat array with shape.",[527,530,533],{"_19":528,"_25":529,"_31":6},"data","- Nested array or flat array of numbers",{"_19":531,"_25":532,"_31":61},"shape","- Optional shape (inferred from nested structure if not provided)",{"_19":534,"_25":535,"_31":61},"options","- Optional configuration (dtype)",[],{"_19":538,"_21":539,"_23":540,"_25":540,"_26":541,"_32":546,"_33":547},"np.array2string","np.array2string(arr, options?)","Return a string representation of an array.",[542,544],{"_19":374,"_25":543,"_31":6},"- Array to convert",{"_19":534,"_25":545,"_31":61},"- Override print options","string",[],{"_19":549,"_21":550,"_23":551,"_25":551,"_26":552,"_32":343,"_33":558},"np.array_equal","np.array_equal(a1, a2, equal_nan?)","True if two arrays have the same shape and elements, False otherwise.",[553,555,557],{"_19":554,"_25":133,"_31":6},"a1",{"_19":556,"_25":136,"_31":6},"a2",{"_19":83,"_25":342,"_31":61},[],{"_19":560,"_21":561,"_23":562,"_25":563,"_26":564,"_32":343,"_33":567},"np.array_equiv","np.array_equiv(a1, a2)","Returns True if input arrays are shape consistent and all elements equal.\r","Returns True if input arrays are shape consistent and all elements equal.\r\n\r\nShape consistent means they are either the same shape, or one input array\r\ncan be broadcast to create the same shape as the other one.",[565,566],{"_19":554,"_25":133,"_31":6},{"_19":556,"_25":136,"_31":6},[],{"_19":569,"_21":570,"_23":571,"_25":572,"_26":573,"_32":581,"_33":582},"np.array_split","np.array_split(arr, indices_or_sections, axis?)","Split an array into multiple sub-arrays as views.\r","Split an array into multiple sub-arrays as views.\r\nAllows unequal division (unlike split).",[574,576,579],{"_19":374,"_25":575,"_31":6},"- Array to split",{"_19":577,"_25":578,"_31":6},"indices_or_sections","- Number of sections or split indices",{"_19":323,"_25":580,"_31":61},"- Axis along which to split (default: 0)","NDArray[]",[],{"_19":584,"_21":585,"_23":586,"_25":586,"_26":587,"_32":546,"_33":591},"np.arrayRepr","np.arrayRepr(arr, options?)","Return the string representation of an array (with dtype info).",[588,590],{"_19":374,"_25":589,"_31":6},"- Array to represent",{"_19":534,"_25":545,"_31":61},[],{"_19":593,"_21":594,"_23":595,"_25":595,"_26":596,"_32":546,"_33":599},"np.arrayStr","np.arrayStr(arr, options?)","Return a string representation of an array (no dtype).",[597,598],{"_19":374,"_25":589,"_31":6},{"_19":534,"_25":545,"_31":61},[],{"_19":601,"_21":602,"_23":603,"_25":604,"_26":605,"_32":612,"_33":613},"np.as_series","np.as_series(alist, trim?)","Convert input to a list of 1D coefficient arrays.\r","Convert input to a list of 1D coefficient arrays.\r\n\r\nThis is used to normalize multiple coefficient array inputs for\r\noperations that work with several polynomials.",[606,609],{"_19":607,"_25":608,"_31":6},"alist","- List of array-like coefficient sequences",{"_19":610,"_25":611,"_31":61},"trim","- If true, remove trailing zeros (default: true)","number[][]",[],{"_19":615,"_21":616,"_23":617,"_25":618,"_26":619,"_32":357,"_33":623},"np.asanyarray","np.asanyarray(a, options?)","Convert the input to an array, passing through ndarrays unchanged.\r","Convert the input to an array, passing through ndarrays unchanged.\r\n\r\nIn NumPy, this preserves subclasses of ndarray. In numwasm, there are\r\nno subclasses, so this behaves identically to asarray.",[620,622],{"_19":189,"_25":621,"_31":6},"- Input data",{"_19":534,"_25":535,"_31":61},[],{"_19":625,"_21":626,"_23":627,"_25":627,"_26":628,"_32":357,"_33":632},"np.asarray","np.asarray(a, dtype?)","Convert the input to an array.",[629,630],{"_19":189,"_25":621,"_31":6},{"_19":196,"_25":631,"_31":61},"- Optional data type",[],{"_19":634,"_21":635,"_23":636,"_25":636,"_26":637,"_32":357,"_33":640},"np.asarray_chkfinite","np.asarray_chkfinite(a, options?)","Convert the input to an array, checking for NaNs or Infs.",[638,639],{"_19":189,"_25":621,"_31":6},{"_19":534,"_25":535,"_31":61},[],{"_19":642,"_21":643,"_23":644,"_25":644,"_26":645,"_32":357,"_33":648},"np.ascontiguousarray","np.ascontiguousarray(a, options?)","Return a contiguous array (ndim >= 1) in memory (C order).",[646,647],{"_19":189,"_25":621,"_31":6},{"_19":534,"_25":535,"_31":61},[],{"_19":650,"_21":651,"_23":652,"_25":652,"_26":653,"_32":357,"_33":656},"np.asfortranarray","np.asfortranarray(a, options?)","Return a contiguous array (ndim >= 1) in memory (Fortran order).",[654,655],{"_19":189,"_25":621,"_31":6},{"_19":534,"_25":535,"_31":61},[],{"_19":658,"_21":659,"_23":660,"_25":661,"_26":662,"_32":30,"_33":669},"np.astype","np.astype(a, dtype, copy?)","Cast an array to a specified type.\r","Cast an array to a specified type.\r\n\r\nThis is the top-level function version of NDArray.astype().",[663,664,666],{"_19":189,"_25":321,"_31":6},{"_19":196,"_25":665,"_31":6},"- Target data type",{"_19":667,"_25":668,"_31":61},"copy","- If true, always return a copy. Default false.",[],{"_19":671,"_21":672,"_23":673,"_25":674,"_26":675,"_32":679,"_33":680},"np.atleast_1d","np.atleast_1d(arrs)","Convert inputs to arrays with at least one dimension.\r","Convert inputs to arrays with at least one dimension.\r\nScalar inputs are converted to 1D arrays. Higher-dimensional inputs are unchanged.",[676],{"_19":677,"_25":678,"_31":6},"arrs","- Input arrays","NDArray | NDArray[]",[],{"_19":682,"_21":683,"_23":684,"_25":684,"_26":685,"_32":679,"_33":687},"np.atleast_2d","np.atleast_2d(arrs)","View inputs as arrays with at least two dimensions.",[686],{"_19":677,"_25":678,"_31":6},[],{"_19":689,"_21":690,"_23":691,"_25":691,"_26":692,"_32":679,"_33":694},"np.atleast_3d","np.atleast_3d(arrs)","View inputs as arrays with at least three dimensions.",[693],{"_19":677,"_25":678,"_31":6},[],{"_19":696,"_21":697,"_23":698,"_25":698,"_26":699,"_32":477,"_33":707},"np.average","np.average(a, axis?, weights?, keepdims?)","Compute the weighted average along the specified axis.",[700,701,703,706],{"_19":189,"_25":321,"_31":6},{"_19":323,"_25":702,"_31":61},"- Axis along which to compute average. null computes average of all elements.",{"_19":704,"_25":705,"_31":61},"weights","- Array of weights for each value. If null, all weights are equal to 1.",{"_19":326,"_25":476,"_31":61},[],{"_19":709,"_21":710,"_23":711,"_25":712,"_26":713,"_32":357,"_33":717},"np.bartlett","np.bartlett(M)","Return the Bartlett window.\r","Return the Bartlett window.\r\n\r\nThe Bartlett window is very similar to a triangular window, except\r\nthat the end points are at zero. Also known as the triangular or\r\nFejér window.\r\n\r\nFormula:\r\n w(n) = 1 + n/(M-1) for n <= 0\r\n w(n) = 1 - n/(M-1) for n > 0",[714],{"_19":715,"_25":716,"_31":6},"M","- Number of points in the output window. If zero or less,\r\n an empty array is returned.",[],{"_19":719,"_21":720,"_23":721,"_25":721,"_26":722,"_32":546,"_33":732},"np.baseRepr","np.baseRepr(num, base?, padding?)","Return a string representation of a number in the given base.",[723,726,729],{"_19":724,"_25":725,"_31":6},"num","- Integer to convert",{"_19":727,"_25":728,"_31":61},"base","- Number base (2-36)",{"_19":730,"_25":731,"_31":61},"padding","- Minimum number of digits",[],{"_19":734,"_21":735,"_23":736,"_25":736,"_26":737,"_32":743,"_33":744},"np.baseReprArray","np.baseReprArray(arr, base?, padding?)","Convert an array of numbers to base-N representations.",[738,740,741],{"_19":374,"_25":739,"_31":6},"- Array of integers",{"_19":727,"_25":728,"_31":61},{"_19":730,"_25":742,"_31":61},"- Minimum digits per number","string[]",[],{"_19":746,"_21":747,"_23":748,"_25":749,"_26":750,"_32":546,"_33":755},"np.binaryRepr","np.binaryRepr(num, width?)","Base Conversion Functions\r","Base Conversion Functions\r\n\r\nFunctions for converting numbers to binary and arbitrary base representations.\r\n\r\nReference: numpy/_core/numeric.py (binary_repr, base_repr)",[751,752],{"_19":724,"_25":725,"_31":6},{"_19":753,"_25":754,"_31":61},"width","- Fixed width for two's complement representation",[],{"_19":757,"_21":758,"_23":759,"_25":759,"_26":760,"_32":743,"_33":764},"np.binaryReprArray","np.binaryReprArray(arr, width?)","Convert an array of numbers to binary representations.",[761,762],{"_19":374,"_25":739,"_31":6},{"_19":753,"_25":763,"_31":61},"- Fixed width for all representations",[],{"_19":766,"_21":767,"_23":768,"_25":768,"_26":769,"_32":357,"_33":777},"np.bincount","np.bincount(x, weights?, minlength?)","Count number of occurrences of each value in array of non-negative ints.",[770,772,774],{"_19":29,"_25":771,"_31":6},"- Input array of non-negative integers",{"_19":704,"_25":773,"_31":61},"- Weights, array of the same shape as x (optional)",{"_19":775,"_25":776,"_31":61},"minlength","- Minimum number of bins for the output array (default: 0)",[],{"_19":779,"_21":780,"_23":781,"_25":781,"_26":782,"_32":30,"_33":785},"np.bitwise_and","np.bitwise_and(x1, x2)","Compute the bit-wise AND of two arrays element-wise.",[783,784],{"_19":311,"_25":30,"_31":6},{"_19":313,"_25":30,"_31":6},[],{"_19":787,"_21":788,"_23":789,"_25":790,"_26":791,"_32":30,"_33":794},"np.bitwise_count","np.bitwise_count(x)","Computes the number of 1-bits in the absolute value of x.\r","Computes the number of 1-bits in the absolute value of x.\r\nAlso known as popcount or population count.\r\nInput array must be integers.",[792],{"_19":29,"_25":793,"_31":6},"- Input array of integers",[],{"_19":796,"_21":797,"_23":798,"_25":798,"_26":799,"_32":30,"_33":802},"np.bitwise_or","np.bitwise_or(x1, x2)","Compute the bit-wise OR of two arrays element-wise.",[800,801],{"_19":311,"_25":30,"_31":6},{"_19":313,"_25":30,"_31":6},[],{"_19":804,"_21":805,"_23":806,"_25":806,"_26":807,"_32":30,"_33":810},"np.bitwise_xor","np.bitwise_xor(x1, x2)","Compute the bit-wise XOR of two arrays element-wise.",[808,809],{"_19":311,"_25":30,"_31":6},{"_19":313,"_25":30,"_31":6},[],{"_19":812,"_21":813,"_23":814,"_25":815,"_26":816,"_32":357,"_33":818},"np.blackman","np.blackman(M)","Return the Blackman window.\r","Return the Blackman window.\r\n\r\nThe Blackman window is a taper formed by using the first three\r\nterms of a summation of cosines. It was designed to have close to\r\nthe minimal leakage possible.\r\n\r\nFormula: w(n) = 0.42 + 0.5*cos(π*n/(M-1)) + 0.08*cos(2π*n/(M-1))",[817],{"_19":715,"_25":716,"_31":6},[],{"_19":820,"_21":821,"_23":822,"_25":822,"_26":823,"_32":30,"_33":827},"np.block","np.block(arrays)","Assemble an nd-array from nested lists of blocks.",[824],{"_19":825,"_25":826,"_31":6},"arrays","- Nested list of arrays (1D list for hstack, 2D for block assembly)",[],{"_19":829,"_21":830,"_23":831,"_25":832,"_26":833,"_32":836,"_33":837},"np.broadcastArrays","np.broadcastArrays(arrays)","Broadcast any number of arrays against each other.\r","Broadcast any number of arrays against each other.\r\n\r\nReturns views of the arrays with the same shape. All returned arrays\r\nshare data with their originals.",[834],{"_19":825,"_25":835,"_31":6},"- Arrays to broadcast together","Promise",[],{"_19":839,"_21":840,"_23":841,"_25":841,"_26":842,"_32":849,"_33":850},"np.broadcastShapes","np.broadcastShapes(shape1, shape2)","Compute the broadcast shape for two shapes.",[843,846],{"_19":844,"_25":845,"_31":6},"shape1","- First shape",{"_19":847,"_25":848,"_31":6},"shape2","- Second shape","Promise",[],{"_19":852,"_21":853,"_23":854,"_25":854,"_26":855,"_32":849,"_33":859},"np.broadcastShapesMulti","np.broadcastShapesMulti(shapes)","Compute the broadcast shape for multiple shapes.",[856],{"_19":857,"_25":858,"_31":6},"shapes","- Array of shapes",[],{"_19":861,"_21":862,"_23":863,"_25":864,"_26":865,"_32":357,"_33":871},"np.broadcastTo","np.broadcastTo(arr, targetShape)","Broadcast an array to a target shape.\r","Broadcast an array to a target shape.\r\n\r\nReturns a view of the array with the target shape. The view shares\r\ndata with the original array but has zero strides for broadcast dimensions.",[866,868],{"_19":374,"_25":867,"_31":6},"- Array to broadcast",{"_19":869,"_25":870,"_31":6},"targetShape","- Target shape",[],{"_19":873,"_21":874,"_23":875,"_25":875,"_26":876,"_32":882,"_33":883},"np.buildIndexSpecs","np.buildIndexSpecs(indices, shape)","Build IndexSpec array from parsed indices for C interop.",[877,880],{"_19":878,"_25":879,"_31":6},"indices","- Expanded index elements (no ellipsis)",{"_19":531,"_25":881,"_31":6},"- Shape of the array being indexed","IndexSpec[]",[],{"_19":885,"_21":886,"_23":887,"_25":887,"_26":888,"_32":892,"_33":893},"np.bytes","np.bytes(length)","Return random bytes.",[889],{"_19":890,"_25":891,"_31":6},"length","- Number of random bytes to generate","Uint8Array",[],{"_19":895,"_21":896,"_23":897,"_25":897,"_26":898,"_32":90,"_33":908},"np.can_cast","np.can_cast(from, to, casting?)","Returns true if cast between data types can occur according to the casting rule.",[899,902,905],{"_19":900,"_25":901,"_31":6},"from","- Data type to cast from",{"_19":903,"_25":904,"_31":6},"to","- Data type to cast to",{"_19":906,"_25":907,"_31":61},"casting","- Controls what kind of data casting may occur:\r\n- 'no': No casting allowed\r\n- 'equiv': Only byte-order changes allowed\r\n- 'safe': Only casts that can preserve values allowed\r\n- 'same_kind': Only safe casts or casts within a kind allowed\r\n- 'unsafe': Any data conversions allowed",[],{"_19":910,"_21":911,"_23":912,"_25":912,"_26":913,"_32":30,"_33":915},"np.cbrt","np.cbrt(x)","Return the cube-root of an array, element-wise.",[914],{"_19":29,"_25":30,"_31":6},[],{"_19":917,"_21":918,"_23":919,"_25":919,"_26":920,"_32":30,"_33":922},"np.ceil","np.ceil(x)","Return the ceiling of the input, element-wise.",[921],{"_19":29,"_25":30,"_31":6},[],{"_19":924,"_21":925,"_23":926,"_25":926,"_26":927,"_32":931,"_33":932},"np.cheb2poly","np.cheb2poly(c)","Convert Chebyshev coefficients to power series.",[928],{"_19":929,"_25":930,"_31":6},"c","- Chebyshev coefficients","number[]",[],{"_19":934,"_21":935,"_23":936,"_25":936,"_26":937,"_32":931,"_33":942},"np.chebadd","np.chebadd(c1, c2)","Add two Chebyshev polynomials.",[938,940],{"_19":939,"_25":931,"_31":6},"c1",{"_19":941,"_25":931,"_31":6},"c2",[],{"_19":944,"_21":945,"_23":946,"_25":946,"_26":947,"_32":612,"_33":950},"np.chebcompanion","np.chebcompanion(c)","Generate Chebyshev companion matrix.",[948],{"_19":929,"_25":949,"_31":6},"- Coefficient array",[],{"_19":952,"_21":953,"_23":954,"_25":954,"_26":955,"_32":931,"_33":960},"np.chebder","np.chebder(c, m?)","Chebyshev derivative.",[956,957],{"_19":929,"_25":949,"_31":6},{"_19":958,"_25":959,"_31":61},"m","- Number of derivatives (default: 1)",[],{"_19":962,"_21":963,"_23":964,"_25":964,"_26":965,"_32":968,"_33":969},"np.chebdiv","np.chebdiv(c1, c2)","Divide two Chebyshev polynomials.",[966,967],{"_19":939,"_25":931,"_31":6},{"_19":941,"_25":931,"_31":6},"[number[], number[]]",[],{"_19":971,"_21":972,"_23":973,"_25":973,"_26":974,"_32":990,"_33":991},"np.chebfit","np.chebfit(x, y, deg, rcond?, full?, w?)","Chebyshev least squares fit.",[975,977,979,981,984,987],{"_19":29,"_25":976,"_31":6},"- x values",{"_19":135,"_25":978,"_31":6},"- y values",{"_19":355,"_25":980,"_31":6},"- Degree of fitting polynomial",{"_19":982,"_25":983,"_31":61},"rcond","- Cutoff for small singular values",{"_19":985,"_25":986,"_31":61},"full","- If true, return extra info",{"_19":988,"_25":989,"_31":61},"w","- Weights","Promise",[],{"_19":993,"_21":994,"_23":995,"_25":995,"_26":996,"_32":931,"_33":1000},"np.chebfromroots","np.chebfromroots(roots)","Construct Chebyshev polynomial from roots.",[997],{"_19":998,"_25":999,"_31":6},"roots","- Array of roots",[],{"_19":1002,"_21":1003,"_23":1004,"_25":1004,"_26":1005,"_32":931,"_33":1015},"np.chebint","np.chebint(c, m?, k?, lbnd?)","Chebyshev integral.",[1006,1007,1009,1012],{"_19":929,"_25":949,"_31":6},{"_19":958,"_25":1008,"_31":61},"- Number of integrals (default: 1)",{"_19":1010,"_25":1011,"_31":61},"k","- Integration constants (default: all zero)",{"_19":1013,"_25":1014,"_31":61},"lbnd","- Lower bound (default: 0)",[],{"_19":1017,"_21":1018,"_23":1019,"_25":1020,"_26":1021,"_32":1029,"_33":1030},"np.chebinterpolate","np.chebinterpolate(func, deg, domain?)","Interpolate a function using Chebyshev polynomials.\r","Interpolate a function using Chebyshev polynomials.\r\n\r\nUses Chebyshev nodes for optimal interpolation on [-1, 1].",[1022,1024,1026],{"_19":220,"_25":1023,"_31":6},"- Function to interpolate",{"_19":355,"_25":1025,"_31":6},"- Degree of interpolating polynomial",{"_19":1027,"_25":1028,"_31":61},"domain","- Domain for interpolation (default: [-1, 1])","Promise",[],{"_19":1032,"_21":1033,"_23":1034,"_25":1034,"_26":1035,"_32":931,"_33":1038},"np.chebmul","np.chebmul(c1, c2)","Multiply two Chebyshev polynomials.",[1036,1037],{"_19":939,"_25":931,"_31":6},{"_19":941,"_25":931,"_31":6},[],{"_19":1040,"_21":1041,"_23":1042,"_25":1042,"_26":1043,"_32":931,"_33":1049},"np.chebpow","np.chebpow(c, pow, maxpower?)","Raise Chebyshev polynomial to a power.",[1044,1045,1047],{"_19":929,"_25":931,"_31":6},{"_19":1046,"_25":198,"_31":6},"pow",{"_19":1048,"_25":198,"_31":61},"maxpower",[],{"_19":1051,"_21":1052,"_23":1053,"_25":1053,"_26":1054,"_32":1029,"_33":1056},"np.chebroots","np.chebroots(c)","Find Chebyshev polynomial roots.",[1055],{"_19":929,"_25":949,"_31":6},[],{"_19":1058,"_21":1059,"_23":1060,"_25":1060,"_26":1061,"_32":931,"_33":1064},"np.chebsub","np.chebsub(c1, c2)","Subtract two Chebyshev polynomials.",[1062,1063],{"_19":939,"_25":931,"_31":6},{"_19":941,"_25":931,"_31":6},[],{"_19":1066,"_21":1067,"_23":1068,"_25":1068,"_26":1069,"_32":198,"_33":1074},"np.chebval","np.chebval(x, c)","Evaluate Chebyshev polynomial using Clenshaw's algorithm.",[1070,1072],{"_19":29,"_25":1071,"_31":6},"- Point at which to evaluate",{"_19":929,"_25":1073,"_31":6},"- Coefficient array [c0, c1, c2, ...] for c0*T_0 + c1*T_1 + c2*T_2 + ...",[],{"_19":1076,"_21":1077,"_23":1078,"_25":1078,"_26":1079,"_32":931,"_33":1086},"np.chebval2d","np.chebval2d(x, y, c)","Evaluate 2D Chebyshev polynomial.",[1080,1082,1084],{"_19":29,"_25":1081,"_31":6},"- x coordinates",{"_19":135,"_25":1083,"_31":6},"- y coordinates",{"_19":929,"_25":1085,"_31":6},"- 2D coefficient array",[],{"_19":1088,"_21":1089,"_23":1090,"_25":1090,"_26":1091,"_32":612,"_33":1096},"np.chebvander","np.chebvander(x, deg)","Chebyshev Vandermonde matrix.",[1092,1094],{"_19":29,"_25":1093,"_31":6},"- Sample points",{"_19":355,"_25":1095,"_31":6},"- Degree of polynomial",[],{"_19":1098,"_21":1099,"_23":1100,"_25":1100,"_26":1101,"_32":477,"_33":1113},"np.choice","np.choice(a, size?, replace?, p?)","Generates a random sample from a given array or range.",[1102,1104,1107,1110],{"_19":189,"_25":1103,"_31":6},"- If an array, a random sample is generated from its elements.\r\n If an int, the random sample is generated from arange(a).",{"_19":1105,"_25":1106,"_31":61},"size","- Output shape. If null (default), a single value is returned.",{"_19":1108,"_25":1109,"_31":61},"replace","- Whether the sample is with or without replacement. Default is true.",{"_19":1111,"_25":1112,"_31":61},"p","- Probabilities associated with each entry in a. If not given, the sample\r\n assumes a uniform distribution over all entries.",[],{"_19":1115,"_21":1116,"_23":1117,"_25":1118,"_26":1119,"_32":357,"_33":1125},"np.cholesky","np.cholesky(a, upper?)","Cholesky decomposition.\r","Cholesky decomposition.\r\n\r\nReturns the Cholesky factor of a Hermitian positive-definite matrix.",[1120,1122],{"_19":189,"_25":1121,"_31":6},"- Hermitian positive-definite matrix (N x N)",{"_19":1123,"_25":1124,"_31":61},"upper","- If true, return upper triangular U (a = U^H @ U),\r\n otherwise return lower triangular L (a = L @ L^H)",[],{"_19":1127,"_21":1128,"_23":1129,"_25":1129,"_26":1130,"_32":357,"_33":1139},"np.choose","np.choose(indices, choices, mode?)","Construct an array from an index array and a set of arrays to choose from.",[1131,1133,1136],{"_19":878,"_25":1132,"_31":6},"- Array of indices into choices",{"_19":1134,"_25":1135,"_31":6},"choices","- Array of choice arrays",{"_19":1137,"_25":1138,"_31":61},"mode","- How to handle out-of-bounds indices (default: 'raise')",[],{"_19":1141,"_21":1142,"_23":1143,"_25":1144,"_26":1145,"_32":357,"_33":1154},"np.clip","np.clip(a, a_min, a_max)","Clip (limit) the values in an array.\r","Clip (limit) the values in an array.\r\n\r\nGiven an interval, values outside the interval are clipped to the interval edges.\r\nFor example, if an interval of [0, 1] is specified, values smaller than 0\r\nbecome 0, and values larger than 1 become 1.",[1146,1148,1151],{"_19":189,"_25":1147,"_31":6},"- Array containing elements to clip",{"_19":1149,"_25":1150,"_31":6},"a_min","- Minimum value. If null, clipping is not performed on the lower interval edge.",{"_19":1152,"_25":1153,"_31":6},"a_max","- Maximum value. If null, clipping is not performed on the upper interval edge.",[],{"_19":1156,"_21":1157,"_23":1158,"_25":1158,"_26":1159,"_32":30,"_33":1163},"np.column_stack","np.column_stack(tup)","Stack 1-D arrays as columns into a 2-D array.",[1160],{"_19":1161,"_25":1162,"_31":6},"tup","- Sequence of 1-D or 2-D arrays",[],{"_19":1165,"_21":1166,"_23":1167,"_25":1167,"_26":1168,"_32":1172,"_33":1173},"np.common_type","np.common_type(dtypes)","Determine common type following standard coercion rules.",[1169],{"_19":1170,"_25":1171,"_31":6},"dtypes","DType[]","DType",[],{"_19":1175,"_21":1176,"_23":1177,"_25":1177,"_26":1178,"_32":1172,"_33":1180},"np.commonType","np.commonType(dtypes)","Get common type for multiple dtypes.",[1179],{"_19":1170,"_25":1171,"_31":6},[],{"_19":1182,"_21":1183,"_23":1184,"_25":1184,"_26":1185,"_32":30,"_33":1190},"np.compare_chararrays","np.compare_chararrays(x1, x2)","Compare two string arrays element-wise.",[1186,1188],{"_19":311,"_25":1187,"_31":6},"- First string array",{"_19":313,"_25":1189,"_31":6},"- Second string array",[],{"_19":1192,"_21":1193,"_23":1194,"_25":1194,"_26":1195,"_32":357,"_33":1202},"np.compress","np.compress(condition, arr, axis?)","Return selected slices of an array along given axis.",[1196,1199,1200],{"_19":1197,"_25":1198,"_31":6},"condition","- Boolean 1D array selecting which slices to keep",{"_19":374,"_25":321,"_31":6},{"_19":323,"_25":1201,"_31":61},"- Axis along which to select (default: 0)",[],{"_19":1204,"_21":1205,"_23":1206,"_25":1207,"_26":1208,"_32":849,"_33":1211},"np.computeBroadcastStrides","np.computeBroadcastStrides(arr, targetShape)","Compute the strides needed to broadcast an array to a target shape.\r","Compute the strides needed to broadcast an array to a target shape.\r\nThis is mainly for internal use.",[1209,1210],{"_19":374,"_25":867,"_31":6},{"_19":869,"_25":870,"_31":6},[],{"_19":1213,"_21":1214,"_23":1215,"_25":1215,"_26":1216,"_32":931,"_33":1222},"np.computeResultShape","np.computeResultShape(specs, shape)","Compute the result shape from index specifications.",[1217,1220],{"_19":1218,"_25":1219,"_31":6},"specs","- Array of IndexSpec",{"_19":531,"_25":1221,"_31":6},"- Original array shape",[],{"_19":1224,"_21":1225,"_23":1226,"_25":1226,"_26":1227,"_32":30,"_33":1234},"np.concatenate","np.concatenate(arrays, axis?, dtype?)","Join a sequence of arrays along an existing axis.",[1228,1230,1232],{"_19":825,"_25":1229,"_31":6},"- Sequence of arrays to concatenate",{"_19":323,"_25":1231,"_31":61},"- The axis along which to concatenate (default: 0)",{"_19":196,"_25":1233,"_31":61},"- Optional dtype for the output array",[],{"_19":1236,"_21":1237,"_23":1238,"_25":1238,"_26":1239,"_32":1244,"_33":1245},"np.cond","np.cond(x, p?)","Compute the condition number of a matrix.",[1240,1242],{"_19":29,"_25":1241,"_31":6},"- Matrix",{"_19":1111,"_25":1243,"_31":61},"- Norm order (default: 2, using SVD)","Promise",[],{"_19":1247,"_21":1248,"_23":1249,"_25":1250,"_26":1251,"_32":62,"_33":1255},"np.configureWasm","np.configureWasm(config)","Configure WASM loading before initialization.\r","Configure WASM loading before initialization.\r\nMust be called before loadWasmModule() for custom URLs.",[1252],{"_19":1253,"_25":1254,"_31":6},"config","WasmLoadConfig",[],{"_19":1257,"_21":1258,"_23":1259,"_25":1260,"_26":1261,"_32":30,"_33":1263},"np.conjugate","np.conjugate(x)","Return the complex conjugate, element-wise.\r","Return the complex conjugate, element-wise.\r\n\r\nThe complex conjugate of a complex number is obtained by changing\r\nthe sign of its imaginary part.\r\n\r\nFor non-complex arrays, returns a copy of the input.",[1262],{"_19":29,"_25":321,"_31":6},[],{"_19":1265,"_21":1266,"_23":1267,"_25":1268,"_26":1269,"_32":357,"_33":1277},"np.convolve","np.convolve(a, v, mode?)","Returns the discrete, linear convolution of two one-dimensional sequences.\r","Returns the discrete, linear convolution of two one-dimensional sequences.\r\n\r\nThe convolution product is only given for points where the signals overlap completely.\r\nValues outside the signal boundary have no effect.",[1270,1272,1275],{"_19":189,"_25":1271,"_31":6},"- First one-dimensional input array",{"_19":1273,"_25":1274,"_31":6},"v","- Second one-dimensional input array",{"_19":1137,"_25":1276,"_31":61},"- 'full', 'same', or 'valid':\r\n- 'full': Output is the full discrete linear convolution (default)\r\n- 'same': Output is the same size as a, centered with respect to the 'full' output\r\n- 'valid': Output consists only of those elements that do not rely on zero-padding",[],{"_19":1279,"_21":1280,"_23":1281,"_25":1281,"_26":1282,"_32":357,"_33":1284},"np.copy","np.copy(a)","Return a copy of an array.",[1283],{"_19":189,"_25":321,"_31":6},[],{"_19":1286,"_21":1287,"_23":1288,"_25":1288,"_26":1289,"_32":30,"_33":1292},"np.copysign","np.copysign(x1, x2)","Change the sign of x1 to that of x2, element-wise.",[1290,1291],{"_19":311,"_25":30,"_31":6},{"_19":313,"_25":30,"_31":6},[],{"_19":1294,"_21":1295,"_23":1296,"_25":1296,"_26":1297,"_32":62,"_33":1309},"np.copyto","np.copyto(dst, src, _casting?, where?)","Copy values from one array to another, broadcasting as necessary.",[1298,1301,1304,1306],{"_19":1299,"_25":1300,"_31":6},"dst","- Destination array",{"_19":1302,"_25":1303,"_31":6},"src","- Source array",{"_19":1305,"_25":546,"_31":61},"_casting",{"_19":1307,"_25":1308,"_31":61},"where","- Optional boolean mask array",[],{"_19":1311,"_21":1312,"_23":1313,"_25":1314,"_26":1315,"_32":357,"_33":1323},"np.corrcoef","np.corrcoef(x, y?, rowvar?)","Return Pearson product-moment correlation coefficients.\r","Return Pearson product-moment correlation coefficients.\r\n\r\nThe correlation coefficient matrix of the variables.",[1316,1318,1320],{"_19":29,"_25":1317,"_31":6},"- A 1-D or 2-D array containing multiple variables and observations",{"_19":135,"_25":1319,"_31":61},"- An additional set of variables and observations. Has the same shape as x.",{"_19":1321,"_25":1322,"_31":61},"rowvar","- If true, each row represents a variable, with observations in columns.\r\n If false, the relationship is transposed.",[],{"_19":1325,"_21":1326,"_23":1327,"_25":1328,"_26":1329,"_32":357,"_33":1334},"np.correlate","np.correlate(a, v, mode?)","Cross-correlation of two 1-dimensional sequences.\r","Cross-correlation of two 1-dimensional sequences.\r\n\r\nThis function computes the correlation as generally understood in signal processing texts:\r\nc_k = sum_n a_{n+k} * conj(v_n)",[1330,1331,1332],{"_19":189,"_25":1271,"_31":6},{"_19":1273,"_25":1274,"_31":6},{"_19":1137,"_25":1333,"_31":61},"- 'full', 'same', or 'valid':\r\n- 'full': Output is the full discrete linear correlation (default)\r\n- 'same': Output is the same size as a, centered with respect to the 'full' output\r\n- 'valid': Output consists only of those elements that do not rely on zero-padding",[],{"_19":1336,"_21":1337,"_23":1338,"_25":1338,"_26":1339,"_32":30,"_33":1341},"np.cos","np.cos(x)","Cosine element-wise.",[1340],{"_19":29,"_25":30,"_31":6},[],{"_19":1343,"_21":1344,"_23":1345,"_25":1345,"_26":1346,"_32":30,"_33":1348},"np.cosh","np.cosh(x)","Hyperbolic cosine, element-wise.",[1347],{"_19":29,"_25":30,"_31":6},[],{"_19":1350,"_21":1351,"_23":1352,"_25":1352,"_26":1353,"_32":1244,"_33":1355},"np.countNonzero","np.countNonzero(arr)","Count the number of nonzero elements in an array.",[1354],{"_19":374,"_25":321,"_31":6},[],{"_19":1357,"_21":1358,"_23":1359,"_25":1360,"_26":1361,"_32":357,"_33":1372},"np.cov","np.cov(m, y?, rowvar?, bias?, ddof?)","Estimate a covariance matrix.\r","Estimate a covariance matrix.\r\n\r\nCovariance indicates the level to which two variables vary together.",[1362,1363,1365,1366,1369],{"_19":958,"_25":1317,"_31":6},{"_19":135,"_25":1364,"_31":61},"- An additional set of variables and observations. Has the same shape as m.",{"_19":1321,"_25":1322,"_31":61},{"_19":1367,"_25":1368,"_31":61},"bias","- If false (default), normalization is by (N-1). If true, normalization is by N.",{"_19":1370,"_25":1371,"_31":61},"ddof","- If not null, this overrides the bias setting. ddof=1 gives unbiased estimate,\r\n ddof=0 gives biased estimate.",[],{"_19":1374,"_21":1375,"_23":1376,"_25":1377,"_26":1378,"_32":357,"_33":1394},"np.cross","np.cross(a, b, axisa?, axisb?, axisc?, axis?)","Return the cross product of two (arrays of) vectors.\r","Return the cross product of two (arrays of) vectors.\r\n\r\nThe cross product of a and b in R^3 is a vector perpendicular to both\r\na and b. The vectors are defined by the last axis by default.",[1379,1381,1383,1386,1389,1392],{"_19":189,"_25":1380,"_31":6},"- First vector(s)",{"_19":191,"_25":1382,"_31":6},"- Second vector(s)",{"_19":1384,"_25":1385,"_31":61},"axisa","- Axis of a that defines the vector(s) (default: -1)",{"_19":1387,"_25":1388,"_31":61},"axisb","- Axis of b that defines the vector(s) (default: -1)",{"_19":1390,"_25":1391,"_31":61},"axisc","- Axis of c that contains the cross product vectors (default: -1)",{"_19":323,"_25":1393,"_31":61},"- If specified, overrides axisa, axisb, and axisc",[],{"_19":1396,"_21":1397,"_23":1398,"_25":1398,"_26":1399,"_32":357,"_33":1405},"np.cumprod","np.cumprod(a, axis?, dtype?)","Return the cumulative product of elements along a given axis.",[1400,1401,1403],{"_19":189,"_25":321,"_31":6},{"_19":323,"_25":1402,"_31":61},"- Axis along which to compute cumprod. null = flatten first",{"_19":196,"_25":1404,"_31":61},"- Type of output array (default: promotes integers to float64)",[],{"_19":1407,"_21":1408,"_23":1409,"_25":1409,"_26":1410,"_32":357,"_33":1415},"np.cumsum","np.cumsum(a, axis?, dtype?)","Return the cumulative sum of the elements along a given axis.",[1411,1412,1414],{"_19":189,"_25":321,"_31":6},{"_19":323,"_25":1413,"_31":61},"- Axis along which to compute cumsum. null = flatten first",{"_19":196,"_25":1404,"_31":61},[],{"_19":1417,"_21":1418,"_23":1419,"_25":1420,"_26":1421,"_32":357,"_33":1429},"np.cumulative_prod","np.cumulative_prod(x, axis?, dtype?, _include_initial?)","Return the cumulative product of array elements.\r","Return the cumulative product of array elements.\r\n\r\nNumPy 2.0 alias for cumprod with include_initial support.",[1422,1423,1425,1427],{"_19":29,"_25":321,"_31":6},{"_19":323,"_25":1424,"_31":61},"- Axis along which to compute. Default: 0",{"_19":196,"_25":1426,"_31":61},"- Type of output array",{"_19":1428,"_25":90,"_31":61},"_include_initial",[],{"_19":1431,"_21":1432,"_23":1433,"_25":1434,"_26":1435,"_32":357,"_33":1440},"np.cumulative_sum","np.cumulative_sum(x, axis?, dtype?, _include_initial?)","Return the cumulative sum of array elements.\r","Return the cumulative sum of array elements.\r\n\r\nNumPy 2.0 alias for cumsum with include_initial support.",[1436,1437,1438,1439],{"_19":29,"_25":321,"_31":6},{"_19":323,"_25":1424,"_31":61},{"_19":196,"_25":1426,"_31":61},{"_19":1428,"_25":90,"_31":61},[],{"_19":1442,"_21":1443,"_23":1444,"_25":1444,"_26":1445,"_32":30,"_33":1451},"np.decode","np.decode(a, encoding?)","Decode bytes to strings using specified encoding.",[1446,1448],{"_19":189,"_25":1447,"_31":6},"- Array of byte arrays (Uint8Arrays)",{"_19":1449,"_25":1450,"_31":61},"encoding","- Character encoding (default 'utf-8')",[],{"_19":1453,"_21":1454,"_23":1455,"_25":1456,"_26":1457,"_32":1463,"_33":1464},"np.default_rng","np.default_rng(seed?, options?)","Construct a new Generator with the given BitGenerator.\r","Construct a new Generator with the given BitGenerator.\r\n\r\nIf seed is:\r\n- null/undefined: Use OS entropy\r\n- number/bigint: Create SeedSequence from the integer\r\n- array: Create SeedSequence from the array\r\n- SeedSequence: Use directly\r\n- BitGenerator: Use directly",[1458,1461],{"_19":1459,"_25":1460,"_31":61},"seed","- Seed value or BitGenerator",{"_19":534,"_25":1462,"_31":61},"- Options object with optional bitGenerator name","Generator_2",[],{"_19":1466,"_21":1467,"_23":1468,"_25":1468,"_26":1469,"_32":30,"_33":1471},"np.degrees","np.degrees(x)","Convert angles from radians to degrees.",[1470],{"_19":29,"_25":30,"_31":6},[],{"_19":1473,"_21":1474,"_23":1475,"_25":1475,"_26":1476,"_32":357,"_33":1483},"np.deleteArr","np.deleteArr(arr, obj, axis?)","Return a new array with sub-arrays along an axis deleted.",[1477,1478,1481],{"_19":374,"_25":321,"_31":6},{"_19":1479,"_25":1480,"_31":6},"obj","- Index or indices to delete",{"_19":323,"_25":1482,"_31":61},"- Axis along which to delete (default: flatten first)",[],{"_19":1485,"_21":1486,"_23":1487,"_25":1487,"_26":1488,"_32":1172,"_33":1491},"np.descrToDtype","np.descrToDtype(descr)","Parse NPY descriptor string to DType.",[1489],{"_19":1490,"_25":546,"_31":6},"descr",[],{"_19":1493,"_21":1494,"_23":1495,"_25":1495,"_26":1496,"_32":1244,"_33":1499},"np.det","np.det(a)","Compute the determinant of an array.",[1497],{"_19":189,"_25":1498,"_31":6},"- Square matrix (N x N)",[],{"_19":1501,"_21":1502,"_23":1503,"_25":1503,"_26":1504,"_32":357,"_33":1509},"np.diag","np.diag(v, k?)","Extract a diagonal or construct a diagonal array.",[1505,1507],{"_19":1273,"_25":1506,"_31":6},"- Input array (1D to create diagonal matrix, 2D to extract diagonal)",{"_19":1010,"_25":1508,"_31":61},"- Diagonal offset (default: 0)",[],{"_19":1511,"_21":1512,"_23":1513,"_25":1513,"_26":1514,"_32":836,"_33":1521},"np.diag_indices","np.diag_indices(n, ndim?)","Return the indices to access the main diagonal of an array.",[1515,1518],{"_19":1516,"_25":1517,"_31":6},"n","- Size of the array (along each dimension)",{"_19":1519,"_25":1520,"_31":61},"ndim","- Number of dimensions (default: 2)",[],{"_19":1523,"_21":1524,"_23":1525,"_25":1526,"_26":1527,"_32":836,"_33":1530},"np.diag_indices_from","np.diag_indices_from(arr)","Return the indices to access the main diagonal of an array.\r","Return the indices to access the main diagonal of an array.\r\n\r\nThis returns a tuple of arrays, one for each dimension of a,\r\nsuitable for accessing the diagonal of an array.",[1528],{"_19":374,"_25":1529,"_31":6},"- Array of which to get diagonal indices",[],{"_19":1532,"_21":1533,"_23":1534,"_25":1534,"_26":1535,"_32":357,"_33":1542},"np.diagflat","np.diagflat(v, k?, options?)","Create a 2D array with the flattened input as a diagonal.",[1536,1538,1540],{"_19":1273,"_25":1537,"_31":6},"- Input array, which will be flattened",{"_19":1010,"_25":1539,"_31":61},"- Diagonal to set (default: 0, main diagonal)",{"_19":534,"_25":1541,"_31":61},"NDArrayOptions",[],{"_19":1544,"_21":1545,"_23":1546,"_25":1546,"_26":1547,"_32":357,"_33":1557},"np.diagonal","np.diagonal(arr, offset?, axis1?, axis2?)","Return specified diagonals from a 2D array.",[1548,1550,1553,1555],{"_19":374,"_25":1549,"_31":6},"- Input array (must be 2D)",{"_19":1551,"_25":1552,"_31":61},"offset","- Offset from main diagonal (default: 0)",{"_19":1554,"_25":198,"_31":61},"axis1",{"_19":1556,"_25":198,"_31":61},"axis2",[],{"_19":1559,"_21":1560,"_23":1561,"_25":1562,"_26":1563,"_32":357,"_33":1569},"np.diff","np.diff(a, n?, axis?)","Calculate the n-th discrete difference along the given axis.\r","Calculate the n-th discrete difference along the given axis.\r\n\r\nThe first difference is given by out[i] = a[i+1] - a[i] along the given axis,\r\nhigher differences are calculated by using diff recursively.",[1564,1565,1567],{"_19":189,"_25":321,"_31":6},{"_19":1516,"_25":1566,"_31":61},"- The number of times values are differenced. If zero, the input is returned as-is.",{"_19":323,"_25":1568,"_31":61},"- The axis along which the difference is taken, default is the last axis.",[],{"_19":1571,"_21":1572,"_23":1573,"_25":1573,"_26":1574,"_32":357,"_33":1583},"np.digitize","np.digitize(x, bins, right?)","Return the indices of the bins to which each value in input array belongs.",[1575,1577,1580],{"_19":29,"_25":1576,"_31":6},"- Input array to be binned",{"_19":1578,"_25":1579,"_31":6},"bins","- Array of bins. Must be 1-dimensional and monotonic.",{"_19":1581,"_25":1582,"_31":61},"right","- If true, bins[i-1] < x <= bins[i]. If false (default), bins[i-1] <= x < bins[i].",[],{"_19":1585,"_21":1586,"_23":1587,"_25":1587,"_26":1588,"_32":30,"_33":1591},"np.divide","np.divide(x1, x2)","Divide arguments element-wise (true division).",[1589,1590],{"_19":311,"_25":30,"_31":6},{"_19":313,"_25":30,"_31":6},[],{"_19":1593,"_21":1594,"_23":1595,"_25":1596,"_26":1597,"_32":1602,"_33":1603},"np.divmod","np.divmod(x1, x2)","Return element-wise quotient and remainder simultaneously.\r","Return element-wise quotient and remainder simultaneously.\r\nEquivalent to (floor_divide(x1, x2), remainder(x1, x2)), but\r\nreturns both in one call.",[1598,1600],{"_19":311,"_25":1599,"_31":6},"- Dividend array",{"_19":313,"_25":1601,"_31":6},"- Divisor array","[NDArray, NDArray]",[],{"_19":1605,"_21":1606,"_23":1607,"_25":1608,"_26":1609,"_32":357,"_33":1612},"np.dot","np.dot(a, b)","Dot product of two arrays.\r","Dot product of two arrays.\r\n\r\nFor 1-D arrays: inner product of vectors.\r\nFor 2-D arrays: matrix multiplication.",[1610,1611],{"_19":189,"_25":133,"_31":6},{"_19":191,"_25":136,"_31":6},[],{"_19":1614,"_21":1615,"_23":1616,"_25":1616,"_26":1617,"_32":581,"_33":1621},"np.dsplit","np.dsplit(arr, indices_or_sections)","Split array into multiple sub-arrays along the 3rd axis (depth).",[1618,1620],{"_19":374,"_25":1619,"_31":6},"- Array with at least 3 dimensions",{"_19":577,"_25":578,"_31":6},[],{"_19":1623,"_21":1624,"_23":1625,"_25":1625,"_26":1626,"_32":30,"_33":1629},"np.dstack","np.dstack(tup)","Stack arrays in sequence along the third axis (depth-wise).",[1627],{"_19":1161,"_25":1628,"_31":6},"- Sequence of arrays",[],{"_19":1631,"_21":1632,"_23":1633,"_25":1634,"_26":1635,"_32":198,"_33":1637},"np.dtypeAlignment","np.dtypeAlignment(dtype)","Get natural alignment for a dtype (for C struct compatibility).\r","Get natural alignment for a dtype (for C struct compatibility).\r\nMost types align to their size, capped at 8 bytes.",[1636],{"_19":196,"_25":1172,"_31":6},[],{"_19":1639,"_21":1640,"_23":1641,"_25":1641,"_26":1642,"_32":1172,"_33":1645},"np.dtypeFromString","np.dtypeFromString(name)","Convert string dtype name to DType enum.",[1643],{"_19":19,"_25":1644,"_31":6},"- String name (e.g., 'float64', 'int32')",[],{"_19":1647,"_21":1648,"_23":1649,"_25":1649,"_26":1650,"_32":198,"_33":1652},"np.dtypeSize","np.dtypeSize(dtype)","Get the size of a dtype in bytes.",[1651],{"_19":196,"_25":1172,"_31":6},[],{"_19":1654,"_21":1655,"_23":1656,"_25":1657,"_26":1658,"_32":546,"_33":1660},"np.dtypeToDescr","np.dtypeToDescr(dtype)","Convert DType to NPY descriptor string.\r","Convert DType to NPY descriptor string.\r\n\r\nFormat: \r\n- Endian: '<' (little), '>' (big), '|' (not applicable)\r\n- Type: 'b' (bool), 'i' (int), 'u' (uint), 'f' (float), 'c' (complex)\r\n- Size: bytes (1, 2, 4, 8, 16)",[1659],{"_19":196,"_25":1172,"_31":6},[],{"_19":1662,"_21":1663,"_23":1664,"_25":1664,"_26":1665,"_32":546,"_33":1668},"np.dtypeToString","np.dtypeToString(dtype)","Get dtype string name.",[1666],{"_19":196,"_25":1667,"_31":6},"- DType enum value",[],{"_19":1670,"_21":1671,"_23":1672,"_25":1672,"_26":1673,"_32":1675,"_33":1676},"np.dtypeToTypedArrayConstructor","np.dtypeToTypedArrayConstructor(dtype)","Get the TypedArray constructor for a given dtype.",[1674],{"_19":196,"_25":1667,"_31":6},"Float32ArrayConstructor | Float64ArrayConstructor | Int32ArrayConstructor | Int16ArrayConstructor | Int8ArrayConstructor | Uint32ArrayConstructor | Uint16ArrayConstructor | Uint8ArrayConstructor | BigInt64ArrayConstructor | BigUint64ArrayConstructor",[],{"_19":1678,"_21":1679,"_23":1680,"_25":1681,"_26":1682,"_32":357,"_33":1686},"np.ediff1d","np.ediff1d(arr, options?)","Compute the differences between consecutive elements of an array.\r","Compute the differences between consecutive elements of an array.\r\n\r\nThis is implemented in TypeScript as it's straightforward and doesn't\r\nrequire WASM for performance.",[1683,1684],{"_19":374,"_25":321,"_31":6},{"_19":534,"_25":1685,"_31":61},"- Configuration options",[],{"_19":1688,"_21":1689,"_23":1690,"_25":1690,"_26":1691,"_32":1693,"_33":1694},"np.eig","np.eig(a)","Compute eigenvalues and right eigenvectors of a general matrix.",[1692],{"_19":189,"_25":1498,"_31":6},"Promise",[],{"_19":1696,"_21":1697,"_23":1698,"_25":1699,"_26":1700,"_32":1693,"_33":1706},"np.eigh","np.eigh(a, _UPLO?)","Compute eigenvalues and eigenvectors of a Hermitian/symmetric matrix.\r","Compute eigenvalues and eigenvectors of a Hermitian/symmetric matrix.\r\n\r\nEigenvalues are always real and returned in ascending order.",[1701,1703],{"_19":189,"_25":1702,"_31":6},"- Hermitian/symmetric matrix (N x N)",{"_19":1704,"_25":1705,"_31":61},"_UPLO","\"L\" | \"U\"",[],{"_19":1708,"_21":1709,"_23":1710,"_25":1710,"_26":1711,"_32":357,"_33":1713},"np.eigvals","np.eigvals(a)","Compute eigenvalues only.",[1712],{"_19":189,"_25":30,"_31":6},[],{"_19":1715,"_21":1716,"_23":1717,"_25":1717,"_26":1718,"_32":357,"_33":1722},"np.eigvalsh","np.eigvalsh(a, UPLO?)","Compute eigenvalues of a Hermitian/symmetric matrix.",[1719,1720],{"_19":189,"_25":30,"_31":6},{"_19":1721,"_25":1705,"_31":61},"UPLO",[],{"_19":1724,"_21":1725,"_23":1726,"_25":1727,"_26":1728,"_32":357,"_33":1734},"np.einsum","np.einsum(subscripts, operands)","Evaluates the Einstein summation convention on the operands.\r","Evaluates the Einstein summation convention on the operands.\r\n\r\nUsing the Einstein summation convention, many common multi-dimensional,\r\nlinear algebraic array operations can be represented in a simple fashion.",[1729,1732],{"_19":1730,"_25":1731,"_31":6},"subscripts","- Subscripts string in format \"ij,jk->ik\"",{"_19":1733,"_25":678,"_31":6},"operands",[],{"_19":1736,"_21":1737,"_23":1738,"_25":1738,"_26":1739,"_32":1743,"_33":1744},"np.einsum_path","np.einsum_path(subscripts, operands)","Evaluates the lowest cost contraction order for an einsum expression.",[1740,1742],{"_19":1730,"_25":1741,"_31":6},"- Subscripts string",{"_19":1733,"_25":678,"_31":6},"[number[][], string]",[],{"_19":1746,"_21":1747,"_23":1748,"_25":1749,"_26":1750,"_32":357,"_33":1754},"np.empty","np.empty(shape, options?)","Create a new NDArray without initializing values.\r","Create a new NDArray without initializing values.\r\nFaster than zeros() but contains arbitrary values.",[1751,1753],{"_19":531,"_25":1752,"_31":6},"- Array dimensions",{"_19":534,"_25":535,"_31":61},[],{"_19":1756,"_21":1757,"_23":1758,"_25":1758,"_26":1759,"_32":357,"_33":1762},"np.empty_like","np.empty_like(a)","Create an uninitialized array with the same shape and type as a given array.",[1760],{"_19":189,"_25":1761,"_31":6},"- Reference array",[],{"_19":1764,"_21":1765,"_23":1766,"_25":1767,"_26":1768,"_32":1773,"_33":1774},"np.encode","np.encode(a, _encoding?)","Encode strings to bytes using specified encoding.\r","Encode strings to bytes using specified encoding.\r\nReturns an array of Uint8Arrays (one per string element).",[1769,1771],{"_19":189,"_25":1770,"_31":6},"- Input string array",{"_19":1772,"_25":546,"_31":61},"_encoding","Uint8Array[]",[],{"_19":1776,"_21":1777,"_23":1778,"_25":1778,"_26":1779,"_32":30,"_33":1788},"np.endswith","np.endswith(a, suffix, start?, end?)","Return true for each element if the string ends with suffix.",[1780,1781,1784,1786],{"_19":189,"_25":1770,"_31":6},{"_19":1782,"_25":1783,"_31":6},"suffix","- Suffix to check",{"_19":415,"_25":1785,"_31":61},"- Start position (default 0)",{"_19":418,"_25":1787,"_31":61},"- End position (default string length)",[],{"_19":1790,"_21":1791,"_23":1792,"_25":1792,"_26":1793,"_32":30,"_33":1796},"np.equal","np.equal(x1, x2)","Return (x1 == x2) element-wise.",[1794,1795],{"_19":311,"_25":30,"_31":6},{"_19":313,"_25":30,"_31":6},[],{"_19":1798,"_21":1799,"_23":1800,"_25":1800,"_26":1801,"_32":30,"_33":1803},"np.exp","np.exp(x)","Calculate the exponential of all elements in the input array.",[1802],{"_19":29,"_25":30,"_31":6},[],{"_19":1805,"_21":1806,"_23":1807,"_25":1807,"_26":1808,"_32":30,"_33":1810},"np.exp2","np.exp2(x)","Calculate 2**x for all elements in the array.",[1809],{"_19":29,"_25":30,"_31":6},[],{"_19":1812,"_21":1813,"_23":1814,"_25":1814,"_26":1815,"_32":30,"_33":1819},"np.expand_dims","np.expand_dims(a, axis)","Expand the shape of an array by inserting a new axis.",[1816,1817],{"_19":189,"_25":321,"_31":6},{"_19":323,"_25":1818,"_31":6},"- Position in the expanded axes where the new axis is placed",[],{"_19":1821,"_21":1822,"_23":1823,"_25":1823,"_26":1824,"_32":1829,"_33":1830},"np.expandEllipsis","np.expandEllipsis(indices, ndim)","Expand ellipsis and validate index dimensions.",[1825,1827],{"_19":878,"_25":1826,"_31":6},"- Array of index elements (may contain ellipsis)",{"_19":1519,"_25":1828,"_31":6},"- Number of dimensions in the array being indexed","IndexElement[]",[],{"_19":1832,"_21":1833,"_23":1834,"_25":1834,"_26":1835,"_32":30,"_33":1840},"np.expandtabs","np.expandtabs(a, tabsize?)","Return element-wise copy with tabs expanded to spaces.",[1836,1837],{"_19":189,"_25":1770,"_31":6},{"_19":1838,"_25":1839,"_31":61},"tabsize","- Tab stop spacing (default 8)",[],{"_19":1842,"_21":1843,"_23":1844,"_25":1844,"_26":1845,"_32":30,"_33":1847},"np.expm1","np.expm1(x)","Calculate exp(x) - 1 for all elements in the array.",[1846],{"_19":29,"_25":30,"_31":6},[],{"_19":1849,"_21":1850,"_23":1851,"_25":1851,"_26":1852,"_32":357,"_33":1856},"np.extract","np.extract(condition, arr)","Return elements of an array that satisfy some condition.",[1853,1855],{"_19":1197,"_25":1854,"_31":6},"- Boolean array, same shape as arr",{"_19":374,"_25":321,"_31":6},[],{"_19":1858,"_21":1859,"_23":1860,"_25":1860,"_26":1861,"_32":357,"_33":1870},"np.eye","np.eye(N, M?, k?, options?)","Create a 2D array with ones on the diagonal and zeros elsewhere.",[1862,1865,1867,1869],{"_19":1863,"_25":1864,"_31":6},"N","- Number of rows",{"_19":715,"_25":1866,"_31":61},"- Number of columns (default: N)",{"_19":1010,"_25":1868,"_31":61},"- Diagonal offset (default: 0, main diagonal)",{"_19":534,"_25":535,"_31":61},[],{"_19":1872,"_21":1873,"_23":1874,"_25":1874,"_26":1875,"_32":30,"_33":1885},"np.fft","np.fft(a, n?, axis?, norm?)","Compute the one-dimensional discrete Fourier Transform.",[1876,1878,1880,1882],{"_19":189,"_25":1877,"_31":6},"- Input array (can be complex or real)",{"_19":1516,"_25":1879,"_31":61},"- Length of the transformed axis. If n < a.shape[axis], input is truncated.\r\n If n > a.shape[axis], input is zero-padded. Default: a.shape[axis]",{"_19":323,"_25":1881,"_31":61},"- Axis over which to compute the FFT. Default: -1 (last axis)",{"_19":1883,"_25":1884,"_31":61},"norm","- Normalization mode: \"backward\", \"ortho\", or \"forward\"",[],{"_19":1887,"_21":1888,"_23":1889,"_25":1889,"_26":1890,"_32":30,"_33":1899},"np.fft2","np.fft2(a, s?, axes?, norm?)","Compute the 2-dimensional discrete Fourier Transform.",[1891,1892,1895,1897],{"_19":189,"_25":321,"_31":6},{"_19":1893,"_25":1894,"_31":61},"s","- Shape (length of each axis) of the output. Default: shape of a",{"_19":406,"_25":1896,"_31":61},"- Axes over which to compute the FFT. Default: (-2, -1)",{"_19":1883,"_25":1898,"_31":61},"- Normalization mode",[],{"_19":1901,"_21":1902,"_23":1903,"_25":1904,"_26":1905,"_32":357,"_33":1911},"np.fftfreq","np.fftfreq(n, d?)","Return the Discrete Fourier Transform sample frequencies.\r","Return the Discrete Fourier Transform sample frequencies.\r\n\r\nReturns an array of length n with the sample frequencies:\r\nf = [0, 1, ..., n/2-1, -n/2, ..., -1] / (d*n) if n is even\r\nf = [0, 1, ..., (n-1)/2, -(n-1)/2, ..., -1] / (d*n) if n is odd",[1906,1908],{"_19":1516,"_25":1907,"_31":6},"- Window length",{"_19":1909,"_25":1910,"_31":61},"d","- Sample spacing (default: 1.0)",[],{"_19":1913,"_21":1914,"_23":1915,"_25":1915,"_26":1916,"_32":30,"_33":1923},"np.fftn","np.fftn(a, s?, axes?, norm?)","Compute the N-dimensional discrete Fourier Transform.",[1917,1918,1920,1922],{"_19":189,"_25":321,"_31":6},{"_19":1893,"_25":1919,"_31":61},"- Shape of the output along transformed axes",{"_19":406,"_25":1921,"_31":61},"- Axes over which to compute the FFT. Default: all axes",{"_19":1883,"_25":1898,"_31":61},[],{"_19":1925,"_21":1926,"_23":1927,"_25":1928,"_26":1929,"_32":30,"_33":1933},"np.fftshift","np.fftshift(x, axes?)","Shift the zero-frequency component to the center of the spectrum.\r","Shift the zero-frequency component to the center of the spectrum.\r\n\r\nThis function swaps half-spaces for all axes listed (or all axes by default).",[1930,1931],{"_19":29,"_25":321,"_31":6},{"_19":406,"_25":1932,"_31":61},"- Axes over which to shift. Default: all axes",[],{"_19":1935,"_21":1936,"_23":1937,"_25":1938,"_26":1939,"_32":1947,"_33":1948},"np.fill_diagonal","np.fill_diagonal(a, val, wrap?)","Fill the main diagonal of the given array of any dimensionality.\r","Fill the main diagonal of the given array of any dimensionality.\r\n\r\nFor an array a with a.ndim >= 2, the diagonal is the list of\r\nlocations with indices a[i, i, ..., i] all identical. This function\r\nmodifies the input array in-place, it does not return a value.",[1940,1942,1944],{"_19":189,"_25":1941,"_31":6},"- Array to fill (modified in-place). Must be at least 2-D.",{"_19":56,"_25":1943,"_31":6},"- Value to write on the diagonal",{"_19":1945,"_25":1946,"_31":61},"wrap","- For tall matrices, whether to \"wrap\" after filling the main diagonal","Promise",[],{"_19":1950,"_21":1951,"_23":1952,"_25":1952,"_26":1953,"_32":743,"_33":1957},"np.find_duplicate","np.find_duplicate(list)","Find duplicate elements in a list.",[1954],{"_19":1955,"_25":1956,"_31":6},"list","- Array of strings to check",[],{"_19":1959,"_21":1960,"_23":1961,"_25":1961,"_26":1962,"_32":357,"_33":1964},"np.flatnonzero","np.flatnonzero(arr)","Return flat indices of nonzero elements.",[1963],{"_19":374,"_25":321,"_31":6},[],{"_19":1966,"_21":1967,"_23":1968,"_25":1968,"_26":1969,"_32":30,"_33":1971},"np.flatten","np.flatten(a)","Return a copy of the array collapsed into one dimension.",[1970],{"_19":189,"_25":321,"_31":6},[],{"_19":1973,"_21":1974,"_23":1975,"_25":1975,"_26":1976,"_32":30,"_33":1980},"np.flip","np.flip(arr, axis?)","Reverse the order of elements in an array along the given axis.",[1977,1978],{"_19":374,"_25":321,"_31":6},{"_19":323,"_25":1979,"_31":61},"- Axis or axes along which to flip. Default is to flip all axes.",[],{"_19":1982,"_21":1983,"_23":1984,"_25":1984,"_26":1985,"_32":30,"_33":1988},"np.fliplr","np.fliplr(arr)","Reverse the order of elements along axis 1 (left/right).",[1986],{"_19":374,"_25":1987,"_31":6},"- Input array with at least 2 dimensions",[],{"_19":1990,"_21":1991,"_23":1992,"_25":1992,"_26":1993,"_32":30,"_33":1996},"np.flipud","np.flipud(arr)","Reverse the order of elements along axis 0 (up/down).",[1994],{"_19":374,"_25":1995,"_31":6},"- Input array with at least 1 dimension",[],{"_19":1998,"_21":1999,"_23":2000,"_25":2001,"_26":2002,"_32":30,"_33":2005},"np.float_power","np.float_power(x1, x2)","First array elements raised to powers from second array, element-wise.\r","First array elements raised to powers from second array, element-wise.\r\nUnlike power, float_power always returns float64 output.\r\nIn numwasm, this is equivalent to power since we use float64 by default.",[2003,2004],{"_19":311,"_25":30,"_31":6},{"_19":313,"_25":30,"_31":6},[],{"_19":2007,"_21":2008,"_23":2009,"_25":2009,"_26":2010,"_32":30,"_33":2012},"np.floor","np.floor(x)","Return the floor of the input, element-wise.",[2011],{"_19":29,"_25":30,"_31":6},[],{"_19":2014,"_21":2015,"_23":2016,"_25":2016,"_26":2017,"_32":30,"_33":2020},"np.floor_divide","np.floor_divide(x1, x2)","Return the largest integer smaller or equal to the division of the inputs.",[2018,2019],{"_19":311,"_25":30,"_31":6},{"_19":313,"_25":30,"_31":6},[],{"_19":2022,"_21":2023,"_23":2024,"_25":2024,"_26":2025,"_32":30,"_33":2028},"np.fmax","np.fmax(x1, x2)","Element-wise maximum (ignores NaN).",[2026,2027],{"_19":311,"_25":30,"_31":6},{"_19":313,"_25":30,"_31":6},[],{"_19":2030,"_21":2031,"_23":2032,"_25":2032,"_26":2033,"_32":30,"_33":2036},"np.fmin","np.fmin(x1, x2)","Element-wise minimum (ignores NaN).",[2034,2035],{"_19":311,"_25":30,"_31":6},{"_19":313,"_25":30,"_31":6},[],{"_19":2038,"_21":2039,"_23":2040,"_25":2040,"_26":2041,"_32":30,"_33":2044},"np.fmod","np.fmod(x1, x2)","Returns element-wise remainder of floor_divide (C-style modulo).",[2042,2043],{"_19":311,"_25":30,"_31":6},{"_19":313,"_25":30,"_31":6},[],{"_19":2046,"_21":2047,"_23":2048,"_25":2048,"_26":2049,"_32":546,"_33":2065},"np.formatFloatPositional","np.formatFloatPositional(value, precision?, _unique?, fractional?, trim?, sign?, padLeft?, padRight?)","Format a float in positional notation.",[2050,2052,2053,2055,2057,2059,2061,2063],{"_19":2051,"_25":198,"_31":6},"value",{"_19":157,"_25":198,"_31":61},{"_19":2054,"_25":90,"_31":61},"_unique",{"_19":2056,"_25":90,"_31":61},"fractional",{"_19":610,"_25":2058,"_31":61},"\"k\" | \".\" | \"0\" | \"-\"",{"_19":2060,"_25":90,"_31":61},"sign",{"_19":2062,"_25":198,"_31":61},"padLeft",{"_19":2064,"_25":198,"_31":61},"padRight",[],{"_19":2067,"_21":2068,"_23":2069,"_25":2069,"_26":2070,"_32":546,"_33":2079},"np.formatFloatScientific","np.formatFloatScientific(value, precision?, _unique?, trim?, sign?, padLeft?, expDigits?)","Format a float in scientific notation.",[2071,2072,2073,2074,2075,2076,2077],{"_19":2051,"_25":198,"_31":6},{"_19":157,"_25":198,"_31":61},{"_19":2054,"_25":90,"_31":61},{"_19":610,"_25":2058,"_31":61},{"_19":2060,"_25":90,"_31":61},{"_19":2062,"_25":198,"_31":61},{"_19":2078,"_25":198,"_31":61},"expDigits",[],{"_19":2081,"_21":2082,"_23":2083,"_25":2083,"_26":2084,"_32":546,"_33":2088},"np.formatValue","np.formatValue(value, fmt)","Format a number according to printf-style format string.",[2085,2086],{"_19":2051,"_25":198,"_31":6},{"_19":2087,"_25":546,"_31":6},"fmt",[],{"_19":2090,"_21":2091,"_23":2092,"_25":2093,"_26":2094,"_32":1602,"_33":2096},"np.frexp","np.frexp(x)","Decompose the elements of x into mantissa and twos exponent.\r","Decompose the elements of x into mantissa and twos exponent.\r\nReturns (mantissa, exponent), where x = mantissa * 2^exponent.\r\nThe mantissa lies in the open-closed interval (-1, 1) for float64,\r\nand the twos exponent is a signed integer.",[2095],{"_19":29,"_25":321,"_31":6},[],{"_19":2098,"_21":2099,"_23":2100,"_25":2100,"_26":2101,"_32":198,"_33":2106},"np.fromBaseRepr","np.fromBaseRepr(str, base?)","Convert a base-N string to a number.",[2102,2105],{"_19":2103,"_25":2104,"_31":6},"str","- String representation",{"_19":727,"_25":728,"_31":61},[],{"_19":2108,"_21":2109,"_23":2110,"_25":2110,"_26":2111,"_32":198,"_33":2118},"np.fromBinaryRepr","np.fromBinaryRepr(binary, twosComplement?, width?)","Convert a binary string to a number.",[2112,2115,2117],{"_19":2113,"_25":2114,"_31":6},"binary","- Binary string (optionally with '0b' prefix)",{"_19":2116,"_25":90,"_31":61},"twosComplement",{"_19":753,"_25":198,"_31":61},[],{"_19":2120,"_21":2121,"_23":2122,"_25":2122,"_26":2123,"_32":357,"_33":2129},"np.frombuffer","np.frombuffer(buffer, options?)","Interpret a buffer as a 1-dimensional array.",[2124,2127],{"_19":2125,"_25":2126,"_31":6},"buffer","- Buffer containing array data",{"_19":534,"_25":2128,"_31":61},"- Interpretation options",[],{"_19":2131,"_21":2132,"_23":2133,"_25":2133,"_26":2134,"_32":357,"_33":2140},"np.fromfile","np.fromfile(file, options?)","Construct an array from data in a binary file.",[2135,2138],{"_19":2136,"_25":2137,"_31":6},"file","- File source (path, File object, URL, or ArrayBuffer)",{"_19":534,"_25":2139,"_31":61},"- Reading options",[],{"_19":2142,"_21":2143,"_23":2144,"_25":2145,"_26":2146,"_32":357,"_33":2152},"np.fromfunction","np.fromfunction(func, shape, options?)","Construct an array by executing a function over each coordinate.\r","Construct an array by executing a function over each coordinate.\r\n\r\nThe resulting array has a value `fn(x, y, ...)` at coordinate `(x, y, ...)`.",[2147,2149,2151],{"_19":220,"_25":2148,"_31":6},"- Function to execute on each coordinate (receives indices as arguments)",{"_19":531,"_25":2150,"_31":6},"- Shape of the output array",{"_19":534,"_25":535,"_31":61},[],{"_19":2154,"_21":2155,"_23":2156,"_25":2156,"_26":2157,"_32":357,"_33":2162},"np.fromiter","np.fromiter(iter, options?)","Create a 1D array from an iterable object.",[2158,2161],{"_19":2159,"_25":2160,"_31":6},"iter","- Iterable yielding numbers",{"_19":534,"_25":535,"_31":61},[],{"_19":2164,"_21":2165,"_23":2166,"_25":2167,"_26":2168,"_32":2180,"_33":2181},"np.frompyfunc","np.frompyfunc(func, nin, nout, identity?)","Create a ufunc-like wrapper from a JavaScript function.\r","Create a ufunc-like wrapper from a JavaScript function.\r\n\r\nTakes an arbitrary JavaScript function and returns a ufunc-like object\r\nthat can apply the function element-wise to arrays with broadcasting.",[2169,2171,2174,2177],{"_19":220,"_25":2170,"_31":6},"- A JavaScript function that operates on scalars",{"_19":2172,"_25":2173,"_31":6},"nin","- The number of input arguments",{"_19":2175,"_25":2176,"_31":6},"nout","- The number of objects returned by func",{"_19":2178,"_25":2179,"_31":61},"identity","- Optional identity value for reduction operations","UfuncLike",[],{"_19":2183,"_21":2184,"_23":2185,"_25":2185,"_26":2186,"_32":357,"_33":2196},"np.fromregex","np.fromregex(file, regexp, dtype?, options?)","Construct an array from a text file using regular expression parsing.",[2187,2189,2192,2194],{"_19":2136,"_25":2188,"_31":6},"- File source",{"_19":2190,"_25":2191,"_31":6},"regexp","- Regular expression with groups to extract",{"_19":196,"_25":2193,"_31":61},"- Output data type",{"_19":534,"_25":2195,"_31":61},"- Additional options",[],{"_19":2198,"_21":2199,"_23":2200,"_25":2201,"_26":2202,"_32":357,"_33":2212},"np.fromstring","np.fromstring(string, sep?, count?, options?)","Create a 1D array from text data in a string.\r","Create a 1D array from text data in a string.\r\n\r\nA simple way to quickly create 1D arrays from raw text. The string\r\nis parsed using a separator character.",[2203,2205,2208,2211],{"_19":546,"_25":2204,"_31":6},"- String containing the data",{"_19":2206,"_25":2207,"_31":61},"sep","- Separator between data items. If empty string, treats the\r\n string as binary data with each character representing a byte.",{"_19":2209,"_25":2210,"_31":61},"count","- Number of items to read. Default is -1 (read all).",{"_19":534,"_25":535,"_31":61},[],{"_19":2214,"_21":2215,"_23":2216,"_25":2216,"_26":2217,"_32":357,"_33":2223},"np.full","np.full(shape, fillValue, options?)","Create a new NDArray filled with a constant value.",[2218,2219,2222],{"_19":531,"_25":1752,"_31":6},{"_19":2220,"_25":2221,"_31":6},"fillValue","- Value to fill with",{"_19":534,"_25":535,"_31":61},[],{"_19":2225,"_21":2226,"_23":2227,"_25":2227,"_26":2228,"_32":357,"_33":2231},"np.full_like","np.full_like(a, fillValue)","Create an array filled with a value, with the same shape and type as a given array.",[2229,2230],{"_19":189,"_25":1761,"_31":6},{"_19":2220,"_25":2221,"_31":6},[],{"_19":2233,"_21":2234,"_23":2235,"_25":2236,"_26":2237,"_32":30,"_33":2242},"np.gcd","np.gcd(x1, x2)","Returns the greatest common divisor of |x1| and |x2|.\r","Returns the greatest common divisor of |x1| and |x2|.\r\nInput arrays must be integers.",[2238,2240],{"_19":311,"_25":2239,"_31":6},"- First array of integers",{"_19":313,"_25":2241,"_31":6},"- Second array of integers",[],{"_19":2244,"_21":2245,"_23":2246,"_25":2247,"_26":2248,"_32":357,"_33":2252},"np.genfromtxt","np.genfromtxt(file, options?)","Load data from a text file with handling for missing values.\r","Load data from a text file with handling for missing values.\r\nMore sophisticated than loadtxt, supports missing value replacement.",[2249,2250],{"_19":2136,"_25":2188,"_31":6},{"_19":534,"_25":2251,"_31":61},"- Parsing options",[],{"_19":2254,"_21":2255,"_23":2256,"_25":2256,"_26":2257,"_32":357,"_33":2269},"np.geomspace","np.geomspace(start, stop, num?, endpoint?, options?)","Create an NDArray with numbers spaced evenly on a geometric scale.",[2258,2260,2263,2265,2268],{"_19":415,"_25":2259,"_31":6},"- Start value (must be non-zero)",{"_19":2261,"_25":2262,"_31":6},"stop","- End value (must be non-zero)",{"_19":724,"_25":2264,"_31":61},"- Number of samples (default: 50)",{"_19":2266,"_25":2267,"_31":61},"endpoint","- Include stop value (default: true)",{"_19":534,"_25":535,"_31":61},[],{"_19":2271,"_21":2272,"_23":2273,"_25":2273,"_26":2274,"_32":2277,"_33":2278},"np.getBitGenerator","np.getBitGenerator(name)","Get a BitGenerator class by name.",[2275],{"_19":19,"_25":2276,"_31":6},"- Name of the BitGenerator (case-insensitive)","new (seed?: number | bigint | number[] | SeedSequence | null) => BitGenerator",[],{"_19":2280,"_21":2281,"_23":2282,"_25":2283,"_26":2284,"_32":2287,"_33":2288},"np.getdomain","np.getdomain(x)","Get the domain appropriate for given data points.\r","Get the domain appropriate for given data points.\r\n\r\nReturns the minimum and maximum of the data as the domain.",[2285],{"_19":29,"_25":2286,"_31":6},"- Data points","[number, number]",[],{"_19":2290,"_21":2291,"_23":2292,"_25":2292,"_26":2293,"_32":2294,"_33":2295},"np.getPrintoptions","np.getPrintoptions()","Get current print options.",[],"Required",[],{"_19":2297,"_21":2298,"_23":2299,"_25":2299,"_26":2300,"_32":2301,"_33":2302},"np.getWasmModule","np.getWasmModule()","Get the loaded WASM module synchronously.",[],"WasmModule",[],{"_19":2304,"_21":2305,"_23":2306,"_25":2307,"_26":2308,"_32":2314,"_33":2315},"np.gradient","np.gradient(f, args)","Return the gradient of an N-dimensional array.\r","Return the gradient of an N-dimensional array.\r\n\r\nThe gradient is computed using second order accurate central differences\r\nin the interior points and first order accurate one-sides (forward or backwards)\r\ndifferences at the boundaries.",[2309,2312],{"_19":2310,"_25":2311,"_31":6},"f","- An N-dimensional array containing samples of a scalar function",{"_19":223,"_25":2313,"_31":6},"(number | number[] | NDArray | {\r\n axis?: number | number[];\r\n edge_order?: number;\r\n})[]","Promise",[],{"_19":2317,"_21":2318,"_23":2319,"_25":2319,"_26":2320,"_32":30,"_33":2323},"np.greater","np.greater(x1, x2)","Return (x1 > x2) element-wise.",[2321,2322],{"_19":311,"_25":30,"_31":6},{"_19":313,"_25":30,"_31":6},[],{"_19":2325,"_21":2326,"_23":2327,"_25":2327,"_26":2328,"_32":30,"_33":2331},"np.greater_equal","np.greater_equal(x1, x2)","Return (x1 >= x2) element-wise.",[2329,2330],{"_19":311,"_25":30,"_31":6},{"_19":313,"_25":30,"_31":6},[],{"_19":2333,"_21":2334,"_23":2335,"_25":2336,"_26":2337,"_32":357,"_33":2339},"np.hamming","np.hamming(M)","Return the Hamming window.\r","Return the Hamming window.\r\n\r\nThe Hamming window is a taper formed by using a weighted cosine,\r\nsimilar to Hanning but with raised endpoints to reduce the first\r\nside lobe.\r\n\r\nFormula: w(n) = 0.54 + 0.46*cos(π*n/(M-1))",[2338],{"_19":715,"_25":716,"_31":6},[],{"_19":2341,"_21":2342,"_23":2343,"_25":2344,"_26":2345,"_32":357,"_33":2347},"np.hanning","np.hanning(M)","Return the Hanning window (also known as Hann window).\r","Return the Hanning window (also known as Hann window).\r\n\r\nThe Hanning window is a taper formed by using a weighted cosine.\r\nNamed for Julius von Hann.\r\n\r\nFormula: w(n) = 0.5 + 0.5*cos(π*n/(M-1))",[2346],{"_19":715,"_25":716,"_31":6},[],{"_19":2349,"_21":2350,"_23":2351,"_25":2352,"_26":2353,"_32":30,"_33":2358},"np.heaviside","np.heaviside(x1, x2)","Compute the Heaviside step function.\r","Compute the Heaviside step function.\r\n\r\nH(x) = 0 if x < 0\r\nH(x) = h0 if x == 0\r\nH(x) = 1 if x > 0",[2354,2356],{"_19":311,"_25":2355,"_31":6},"- Input values",{"_19":313,"_25":2357,"_31":6},"- Value of the function at x1 == 0 (h0)",[],{"_19":2360,"_21":2361,"_23":2362,"_25":2362,"_26":2363,"_32":931,"_33":2365},"np.herm2poly","np.herm2poly(c)","Convert Hermite coefficients to power series.",[2364],{"_19":929,"_25":931,"_31":6},[],{"_19":2367,"_21":2368,"_23":2369,"_25":2370,"_26":2371,"_32":931,"_33":2374},"np.hermadd","np.hermadd(c1, c2)","hermadd","",[2372,2373],{"_19":939,"_25":931,"_31":6},{"_19":941,"_25":931,"_31":6},[],{"_19":2376,"_21":2377,"_23":2378,"_25":2370,"_26":2379,"_32":612,"_33":2381},"np.hermcompanion","np.hermcompanion(c)","hermcompanion",[2380],{"_19":929,"_25":931,"_31":6},[],{"_19":2383,"_21":2384,"_23":2385,"_25":2370,"_26":2386,"_32":931,"_33":2389},"np.hermder","np.hermder(c, m?)","hermder",[2387,2388],{"_19":929,"_25":931,"_31":6},{"_19":958,"_25":198,"_31":61},[],{"_19":2391,"_21":2392,"_23":2393,"_25":2370,"_26":2394,"_32":968,"_33":2397},"np.hermdiv","np.hermdiv(c1, c2)","hermdiv",[2395,2396],{"_19":939,"_25":931,"_31":6},{"_19":941,"_25":931,"_31":6},[],{"_19":2399,"_21":2400,"_23":2401,"_25":2401,"_26":2402,"_32":931,"_33":2404},"np.herme2poly","np.herme2poly(c)","Convert HermiteE coefficients to power series.",[2403],{"_19":929,"_25":931,"_31":6},[],{"_19":2406,"_21":2407,"_23":2408,"_25":2370,"_26":2409,"_32":931,"_33":2412},"np.hermeadd","np.hermeadd(c1, c2)","hermeadd",[2410,2411],{"_19":939,"_25":931,"_31":6},{"_19":941,"_25":931,"_31":6},[],{"_19":2414,"_21":2415,"_23":2416,"_25":2370,"_26":2417,"_32":612,"_33":2419},"np.hermecompanion","np.hermecompanion(c)","hermecompanion",[2418],{"_19":929,"_25":931,"_31":6},[],{"_19":2421,"_21":2422,"_23":2423,"_25":2370,"_26":2424,"_32":931,"_33":2427},"np.hermeder","np.hermeder(c, m?)","hermeder",[2425,2426],{"_19":929,"_25":931,"_31":6},{"_19":958,"_25":198,"_31":61},[],{"_19":2429,"_21":2430,"_23":2431,"_25":2370,"_26":2432,"_32":968,"_33":2435},"np.hermediv","np.hermediv(c1, c2)","hermediv",[2433,2434],{"_19":939,"_25":931,"_31":6},{"_19":941,"_25":931,"_31":6},[],{"_19":2437,"_21":2438,"_23":2439,"_25":2370,"_26":2440,"_32":990,"_33":2449},"np.hermefit","np.hermefit(x, y, deg, rcond?, full?, w?)","hermefit",[2441,2442,2443,2444,2446,2447],{"_19":29,"_25":931,"_31":6},{"_19":135,"_25":931,"_31":6},{"_19":355,"_25":198,"_31":6},{"_19":982,"_25":2445,"_31":61},"number | null",{"_19":985,"_25":90,"_31":61},{"_19":988,"_25":2448,"_31":61},"number[] | null",[],{"_19":2451,"_21":2452,"_23":2453,"_25":2370,"_26":2454,"_32":931,"_33":2456},"np.hermefromroots","np.hermefromroots(roots)","hermefromroots",[2455],{"_19":998,"_25":931,"_31":6},[],{"_19":2458,"_21":2459,"_23":2460,"_25":2370,"_26":2461,"_32":931,"_33":2466},"np.hermeint","np.hermeint(c, m?, k?, lbnd?)","hermeint",[2462,2463,2464,2465],{"_19":929,"_25":931,"_31":6},{"_19":958,"_25":198,"_31":61},{"_19":1010,"_25":931,"_31":61},{"_19":1013,"_25":198,"_31":61},[],{"_19":2468,"_21":2469,"_23":2470,"_25":2370,"_26":2471,"_32":931,"_33":2474},"np.hermemul","np.hermemul(c1, c2)","hermemul",[2472,2473],{"_19":939,"_25":931,"_31":6},{"_19":941,"_25":931,"_31":6},[],{"_19":2476,"_21":2477,"_23":2478,"_25":2370,"_26":2479,"_32":931,"_33":2483},"np.hermepow","np.hermepow(c, pow, maxpower?)","hermepow",[2480,2481,2482],{"_19":929,"_25":931,"_31":6},{"_19":1046,"_25":198,"_31":6},{"_19":1048,"_25":198,"_31":61},[],{"_19":2485,"_21":2486,"_23":2487,"_25":2370,"_26":2488,"_32":1029,"_33":2490},"np.hermeroots","np.hermeroots(c)","hermeroots",[2489],{"_19":929,"_25":931,"_31":6},[],{"_19":2492,"_21":2493,"_23":2494,"_25":2370,"_26":2495,"_32":931,"_33":2498},"np.hermesub","np.hermesub(c1, c2)","hermesub",[2496,2497],{"_19":939,"_25":931,"_31":6},{"_19":941,"_25":931,"_31":6},[],{"_19":2500,"_21":2501,"_23":2502,"_25":2502,"_26":2503,"_32":198,"_33":2506},"np.hermeval","np.hermeval(x, c)","Evaluate HermiteE polynomial.",[2504,2505],{"_19":29,"_25":198,"_31":6},{"_19":929,"_25":931,"_31":6},[],{"_19":2508,"_21":2509,"_23":2510,"_25":2370,"_26":2511,"_32":612,"_33":2514},"np.hermevander","np.hermevander(x, deg)","hermevander",[2512,2513],{"_19":29,"_25":931,"_31":6},{"_19":355,"_25":198,"_31":6},[],{"_19":2516,"_21":2517,"_23":2518,"_25":2370,"_26":2519,"_32":990,"_33":2526},"np.hermfit","np.hermfit(x, y, deg, rcond?, full?, w?)","hermfit",[2520,2521,2522,2523,2524,2525],{"_19":29,"_25":931,"_31":6},{"_19":135,"_25":931,"_31":6},{"_19":355,"_25":198,"_31":6},{"_19":982,"_25":2445,"_31":61},{"_19":985,"_25":90,"_31":61},{"_19":988,"_25":2448,"_31":61},[],{"_19":2528,"_21":2529,"_23":2530,"_25":2370,"_26":2531,"_32":931,"_33":2533},"np.hermfromroots","np.hermfromroots(roots)","hermfromroots",[2532],{"_19":998,"_25":931,"_31":6},[],{"_19":2535,"_21":2536,"_23":2537,"_25":2370,"_26":2538,"_32":931,"_33":2543},"np.hermint","np.hermint(c, m?, k?, lbnd?)","hermint",[2539,2540,2541,2542],{"_19":929,"_25":931,"_31":6},{"_19":958,"_25":198,"_31":61},{"_19":1010,"_25":931,"_31":61},{"_19":1013,"_25":198,"_31":61},[],{"_19":2545,"_21":2546,"_23":2547,"_25":2370,"_26":2548,"_32":931,"_33":2551},"np.hermmul","np.hermmul(c1, c2)","hermmul",[2549,2550],{"_19":939,"_25":931,"_31":6},{"_19":941,"_25":931,"_31":6},[],{"_19":2553,"_21":2554,"_23":2555,"_25":2370,"_26":2556,"_32":931,"_33":2560},"np.hermpow","np.hermpow(c, pow, maxpower?)","hermpow",[2557,2558,2559],{"_19":929,"_25":931,"_31":6},{"_19":1046,"_25":198,"_31":6},{"_19":1048,"_25":198,"_31":61},[],{"_19":2562,"_21":2563,"_23":2564,"_25":2370,"_26":2565,"_32":1029,"_33":2567},"np.hermroots","np.hermroots(c)","hermroots",[2566],{"_19":929,"_25":931,"_31":6},[],{"_19":2569,"_21":2570,"_23":2571,"_25":2370,"_26":2572,"_32":931,"_33":2575},"np.hermsub","np.hermsub(c1, c2)","hermsub",[2573,2574],{"_19":939,"_25":931,"_31":6},{"_19":941,"_25":931,"_31":6},[],{"_19":2577,"_21":2578,"_23":2579,"_25":2579,"_26":2580,"_32":198,"_33":2583},"np.hermval","np.hermval(x, c)","Evaluate Hermite polynomial.",[2581,2582],{"_19":29,"_25":198,"_31":6},{"_19":929,"_25":931,"_31":6},[],{"_19":2585,"_21":2586,"_23":2587,"_25":2370,"_26":2588,"_32":612,"_33":2591},"np.hermvander","np.hermvander(x, deg)","hermvander",[2589,2590],{"_19":29,"_25":931,"_31":6},{"_19":355,"_25":198,"_31":6},[],{"_19":2593,"_21":2594,"_23":2595,"_25":2595,"_26":2596,"_32":546,"_33":2600},"np.hexRepr","np.hexRepr(num, width?)","Return the hexadecimal representation of a number.",[2597,2598],{"_19":724,"_25":725,"_31":6},{"_19":753,"_25":2599,"_31":61},"- Minimum number of hex digits",[],{"_19":2602,"_21":2603,"_23":2604,"_25":2604,"_26":2605,"_32":30,"_33":2613},"np.hfft","np.hfft(a, n?, axis?, norm?)","Compute the FFT of a signal that has Hermitian symmetry (real spectrum).",[2606,2608,2610,2612],{"_19":189,"_25":2607,"_31":6},"- Input array with Hermitian symmetry",{"_19":1516,"_25":2609,"_31":61},"- Length of the transformed axis",{"_19":323,"_25":2611,"_31":61},"- Axis over which to compute the FFT. Default: -1",{"_19":1883,"_25":1898,"_31":61},[],{"_19":2615,"_21":2616,"_23":2617,"_25":2617,"_26":2618,"_32":2630,"_33":2631},"np.histogram","np.histogram(a, bins?, range?, density?, weights?)","Compute the histogram of a dataset.",[2619,2620,2622,2625,2628],{"_19":189,"_25":621,"_31":6},{"_19":1578,"_25":2621,"_31":61},"- Number of bins, method string, or explicit bin edges (default: 10)",{"_19":2623,"_25":2624,"_31":61},"range","- Lower and upper range of bins",{"_19":2626,"_25":2627,"_31":61},"density","- If true, return probability density instead of counts (default: false)",{"_19":704,"_25":2629,"_31":61},"- Weights for each data point","Promise",[],{"_19":2633,"_21":2634,"_23":2635,"_25":2635,"_26":2636,"_32":2649,"_33":2650},"np.histogram2d","np.histogram2d(x, y, bins?, range?, density?, weights?)","Compute the bi-dimensional histogram of two data samples.",[2637,2639,2641,2643,2645,2647],{"_19":29,"_25":2638,"_31":6},"- Array of x coordinates",{"_19":135,"_25":2640,"_31":6},"- Array of y coordinates",{"_19":1578,"_25":2642,"_31":61},"- Number of bins or [nx, ny] or [xedges, yedges] (default: 10)",{"_19":2623,"_25":2644,"_31":61},"- [[xmin, xmax], [ymin, ymax]]",{"_19":2626,"_25":2646,"_31":61},"- If true, return probability density (default: false)",{"_19":704,"_25":2648,"_31":61},"- Weights for each sample","Promise",[],{"_19":2652,"_21":2653,"_23":2654,"_25":2654,"_26":2655,"_32":357,"_33":2662},"np.histogram_bin_edges","np.histogram_bin_edges(a, bins?, range?, weights?)","Compute histogram bin edges.",[2656,2657,2659,2660],{"_19":189,"_25":621,"_31":6},{"_19":1578,"_25":2658,"_31":61},"- Number of bins, bin method string, or explicit bin edges (default: 'auto')",{"_19":2623,"_25":2624,"_31":61},{"_19":704,"_25":2661,"_31":61},"- Weights (used for some bin estimation methods)",[],{"_19":2664,"_21":2665,"_23":2666,"_25":2666,"_26":2667,"_32":2677,"_33":2678},"np.histogramdd","np.histogramdd(sample, bins?, range?, density?, weights?)","Compute the multidimensional histogram of some data.",[2668,2671,2673,2675,2676],{"_19":2669,"_25":2670,"_31":6},"sample","- Data to histogram (shape: [N, D] for N samples in D dimensions,\r\n or 1D array for single dimension)",{"_19":1578,"_25":2672,"_31":61},"- Number of bins per dimension or list of bin edges (default: 10)",{"_19":2623,"_25":2674,"_31":61},"- Ranges for each dimension [[min, max], ...]",{"_19":2626,"_25":2646,"_31":61},{"_19":704,"_25":2648,"_31":61},"Promise",[],{"_19":2680,"_21":2681,"_23":2682,"_25":2682,"_26":2683,"_32":581,"_33":2687},"np.hsplit","np.hsplit(arr, indices_or_sections)","Split an array into multiple sub-arrays horizontally (column-wise).",[2684,2686],{"_19":374,"_25":2685,"_31":6},"- Array",{"_19":577,"_25":578,"_31":6},[],{"_19":2689,"_21":2690,"_23":2691,"_25":2692,"_26":2693,"_32":30,"_33":2695},"np.hstack","np.hstack(tup)","Stack arrays in sequence horizontally (column-wise).\r","Stack arrays in sequence horizontally (column-wise).\r\nFor 1-D arrays, concatenates along axis 0.\r\nFor 2-D+ arrays, concatenates along axis 1.",[2694],{"_19":1161,"_25":1628,"_31":6},[],{"_19":2697,"_21":2698,"_23":2699,"_25":2699,"_26":2700,"_32":30,"_33":2703},"np.hypot","np.hypot(x1, x2)","Given the \"legs\" of a right triangle, return its hypotenuse.",[2701,2702],{"_19":311,"_25":30,"_31":6},{"_19":313,"_25":30,"_31":6},[],{"_19":2705,"_21":2706,"_23":2707,"_25":2708,"_26":2709,"_32":357,"_33":2712},"np.i0","np.i0(x)","Modified Bessel function of the first kind, order 0.\r","Modified Bessel function of the first kind, order 0.\r\n\r\nUsually denoted I₀. This implementation uses Chebyshev polynomial\r\napproximations from the Cephes library, partitioning the domain\r\ninto [0, 8] and (8, ∞).",[2710],{"_19":29,"_25":2711,"_31":6},"- Input array, number, or array of numbers",[],{"_19":2714,"_21":2715,"_23":2716,"_25":2716,"_26":2717,"_32":357,"_33":2721},"np.identity","np.identity(n, options?)","Create a square identity matrix.",[2718,2720],{"_19":1516,"_25":2719,"_31":6},"- Size of the matrix",{"_19":534,"_25":535,"_31":61},[],{"_19":2723,"_21":2724,"_23":2725,"_25":2725,"_26":2726,"_32":30,"_33":2732},"np.ifft","np.ifft(a, n?, axis?, norm?)","Compute the one-dimensional inverse discrete Fourier Transform.",[2727,2728,2729,2731],{"_19":189,"_25":321,"_31":6},{"_19":1516,"_25":2609,"_31":61},{"_19":323,"_25":2730,"_31":61},"- Axis over which to compute the inverse FFT. Default: -1",{"_19":1883,"_25":1898,"_31":61},[],{"_19":2734,"_21":2735,"_23":2736,"_25":2736,"_26":2737,"_32":30,"_33":2744},"np.ifft2","np.ifft2(a, s?, axes?, norm?)","Compute the 2-dimensional inverse discrete Fourier Transform.",[2738,2739,2741,2742],{"_19":189,"_25":30,"_31":6},{"_19":1893,"_25":2740,"_31":61},"[number, number] | null",{"_19":406,"_25":2287,"_31":61},{"_19":1883,"_25":2743,"_31":61},"FFTNorm",[],{"_19":2746,"_21":2747,"_23":2748,"_25":2748,"_26":2749,"_32":30,"_33":2754},"np.ifftn","np.ifftn(a, s?, axes?, norm?)","Compute the N-dimensional inverse discrete Fourier Transform.",[2750,2751,2752,2753],{"_19":189,"_25":30,"_31":6},{"_19":1893,"_25":2448,"_31":61},{"_19":406,"_25":2448,"_31":61},{"_19":1883,"_25":2743,"_31":61},[],{"_19":2756,"_21":2757,"_23":2758,"_25":2759,"_26":2760,"_32":30,"_33":2763},"np.ifftshift","np.ifftshift(x, axes?)","The inverse of fftshift.\r","The inverse of fftshift.\r\n\r\nUndoes the effect of fftshift.",[2761,2762],{"_19":29,"_25":321,"_31":6},{"_19":406,"_25":1932,"_31":61},[],{"_19":2765,"_21":2766,"_23":2767,"_25":2767,"_26":2768,"_32":30,"_33":2774},"np.ihfft","np.ihfft(a, n?, axis?, norm?)","Compute the inverse FFT of a signal that has Hermitian symmetry.",[2769,2771,2772,2773],{"_19":189,"_25":2770,"_31":6},"- Input array (real-valued)",{"_19":1516,"_25":2609,"_31":61},{"_19":323,"_25":2730,"_31":61},{"_19":1883,"_25":1898,"_31":61},[],{"_19":2776,"_21":2777,"_23":2778,"_25":2779,"_26":2780,"_32":30,"_33":2782},"np.imag","np.imag(val)","Return the imaginary part of the complex argument.\r","Return the imaginary part of the complex argument.\r\n\r\nFor non-complex arrays, returns an array of zeros with the same shape.",[2781],{"_19":56,"_25":321,"_31":6},[],{"_19":2784,"_21":2785,"_23":2786,"_25":2786,"_26":2787,"_32":357,"_33":2795},"np.in1d","np.in1d(ar1, ar2, options?)","Test whether each element of ar1 is also present in ar2 (flat version).",[2788,2791,2794],{"_19":2789,"_25":2790,"_31":6},"ar1","- Input array (will be flattened)",{"_19":2792,"_25":2793,"_31":6},"ar2","- Values to test against",{"_19":534,"_25":1685,"_31":61},[],{"_19":2797,"_21":2798,"_23":2799,"_25":2799,"_26":2800,"_32":2314,"_33":2809},"np.indices","np.indices(dimensions, dtype?, sparse?)","Return an array representing the indices of a grid.",[2801,2804,2806],{"_19":2802,"_25":2803,"_31":6},"dimensions","- The shape of the grid",{"_19":196,"_25":2805,"_31":61},"- Data type of the result (default: Int32)",{"_19":2807,"_25":2808,"_31":61},"sparse","- Return sparse representation (default: false)",[],{"_19":2811,"_21":2812,"_23":2813,"_25":2814,"_26":2815,"_32":1947,"_33":2816},"np.initRandom","np.initRandom()","Initialize the random module.\r","Initialize the random module.\r\n\r\nThis must be called before using any random functions.\r\nIt loads the WASM module and sets up the default generator.",[],[],{"_19":2818,"_21":2819,"_23":2820,"_25":2821,"_26":2822,"_32":357,"_33":2825},"np.inner","np.inner(a, b)","Inner product of two arrays.\r","Inner product of two arrays.\r\nFor 1-D arrays: dot product.\r\nFor N-D arrays: sum product over last axes.",[2823,2824],{"_19":189,"_25":30,"_31":6},{"_19":191,"_25":30,"_31":6},[],{"_19":2827,"_21":2828,"_23":2829,"_25":2829,"_26":2830,"_32":30,"_33":2838},"np.insert","np.insert(arr, obj, values, axis?)","Insert values along the given axis before the given indices.",[2831,2832,2834,2836],{"_19":374,"_25":321,"_31":6},{"_19":1479,"_25":2833,"_31":6},"- Index or indices before which values are inserted",{"_19":376,"_25":2835,"_31":6},"- Values to insert",{"_19":323,"_25":2837,"_31":61},"- Axis along which to insert (default: flatten first)",[],{"_19":2840,"_21":2841,"_23":2842,"_25":2843,"_26":2844,"_32":477,"_33":2858},"np.interp","np.interp(x, xp, fp, left?, right?)","One-dimensional linear interpolation for monotonically increasing sample points.\r","One-dimensional linear interpolation for monotonically increasing sample points.\r\n\r\nReturns the one-dimensional piecewise linear interpolant to a function with\r\ngiven discrete data points (xp, fp), evaluated at x.",[2845,2847,2850,2853,2856],{"_19":29,"_25":2846,"_31":6},"- The x-coordinates at which to evaluate the interpolated values",{"_19":2848,"_25":2849,"_31":6},"xp","- The x-coordinates of the data points, must be increasing",{"_19":2851,"_25":2852,"_31":6},"fp","- The y-coordinates of the data points, same length as xp",{"_19":2854,"_25":2855,"_31":61},"left","- Value to return for x < xp[0], default is fp[0]",{"_19":1581,"_25":2857,"_31":61},"- Value to return for x > xp[-1], default is fp[-1]",[],{"_19":2860,"_21":2861,"_23":2862,"_25":2863,"_26":2864,"_32":2870,"_33":2871},"np.intersect1d","np.intersect1d(ar1, ar2, options?)","Find the intersection of two arrays.\r","Find the intersection of two arrays.\r\n\r\nReturns the sorted unique values that are in both input arrays.",[2865,2867,2869],{"_19":2789,"_25":2866,"_31":6},"- First input array",{"_19":2792,"_25":2868,"_31":6},"- Second input array",{"_19":534,"_25":1685,"_31":61},"Promise",[],{"_19":2873,"_21":2874,"_23":2875,"_25":2875,"_26":2876,"_32":357,"_33":2878},"np.inv","np.inv(a)","Compute the (multiplicative) inverse of a matrix.",[2877],{"_19":189,"_25":1498,"_31":6},[],{"_19":2880,"_21":2881,"_23":2882,"_25":2882,"_26":2883,"_32":30,"_33":2885},"np.invert","np.invert(x)","Compute bit-wise inversion, element-wise.",[2884],{"_19":29,"_25":30,"_31":6},[],{"_19":2887,"_21":2888,"_23":2889,"_25":2890,"_26":2891,"_32":30,"_33":2898},"np.irfft","np.irfft(a, n?, axis?, norm?)","Compute the inverse of the one-dimensional discrete Fourier Transform for real input.\r","Compute the inverse of the one-dimensional discrete Fourier Transform for real input.\r\n\r\nThis function computes the inverse of the one-dimensional n-point DFT of\r\nHermitian-symmetric input (from rfft). The input should have shape (..., n//2 + 1).",[2892,2894,2896,2897],{"_19":189,"_25":2893,"_31":6},"- Input array (complex, Hermitian-symmetric)",{"_19":1516,"_25":2895,"_31":61},"- Length of the output. If n is not given, it is determined from the\r\n input shape: n = 2 * (a.shape[axis] - 1)",{"_19":323,"_25":2730,"_31":61},{"_19":1883,"_25":1898,"_31":61},[],{"_19":2900,"_21":2901,"_23":2902,"_25":2902,"_26":2903,"_32":30,"_33":2908},"np.irfft2","np.irfft2(a, s?, axes?, norm?)","Compute the inverse of the 2-dimensional FFT of real input.",[2904,2905,2906,2907],{"_19":189,"_25":30,"_31":6},{"_19":1893,"_25":2740,"_31":61},{"_19":406,"_25":2287,"_31":61},{"_19":1883,"_25":2743,"_31":61},[],{"_19":2910,"_21":2911,"_23":2912,"_25":2912,"_26":2913,"_32":30,"_33":2918},"np.irfftn","np.irfftn(a, s?, axes?, norm?)","Compute the inverse of the N-dimensional FFT of real input.",[2914,2915,2916,2917],{"_19":189,"_25":30,"_31":6},{"_19":1893,"_25":2448,"_31":61},{"_19":406,"_25":2448,"_31":61},{"_19":1883,"_25":2743,"_31":61},[],{"_19":2920,"_21":2921,"_23":2922,"_25":2922,"_26":2923,"_32":30,"_33":2925},"np.isalnum","np.isalnum(a)","Return true for each element if all characters are alphanumeric.",[2924],{"_19":189,"_25":1770,"_31":6},[],{"_19":2927,"_21":2928,"_23":2929,"_25":2929,"_26":2930,"_32":30,"_33":2932},"np.isalpha","np.isalpha(a)","Return true for each element if all characters are alphabetic.",[2931],{"_19":189,"_25":1770,"_31":6},[],{"_19":2934,"_21":2935,"_23":2936,"_25":2936,"_26":2937,"_32":90,"_33":2939},"np.isBoolDType","np.isBoolDType(dtype)","Check if dtype is boolean.",[2938],{"_19":196,"_25":1172,"_31":6},[],{"_19":2941,"_21":2942,"_23":2943,"_25":2944,"_26":2945,"_32":357,"_33":2952},"np.isclose","np.isclose(a, b, rtol?, atol?, equal_nan?)","Returns a boolean array where two arrays are element-wise equal within tolerance.\r","Returns a boolean array where two arrays are element-wise equal within tolerance.\r\n\r\nFormula: |a - b| <= (atol + rtol * |b|)",[2946,2947,2949,2950,2951],{"_19":189,"_25":133,"_31":6},{"_19":191,"_25":2948,"_31":6},"- Second array (reference)",{"_19":77,"_25":338,"_31":61},{"_19":80,"_25":340,"_31":61},{"_19":83,"_25":342,"_31":61},[],{"_19":2954,"_21":2955,"_23":2956,"_25":2957,"_26":2958,"_32":357,"_33":2960},"np.iscomplex","np.iscomplex(x)","Returns a bool array where True if input element is complex (imaginary part != 0).\r","Returns a bool array where True if input element is complex (imaginary part != 0).\r\nFor non-complex dtype arrays, returns all False.",[2959],{"_19":29,"_25":321,"_31":6},[],{"_19":2962,"_21":2963,"_23":2964,"_25":2964,"_26":2965,"_32":90,"_33":2967},"np.isComplexDType","np.isComplexDType(dtype)","Check if dtype is a complex type.",[2966],{"_19":196,"_25":1172,"_31":6},[],{"_19":2969,"_21":2970,"_23":2971,"_25":2971,"_26":2972,"_32":90,"_33":2974},"np.iscomplexobj","np.iscomplexobj(x)","Check if the array has a complex dtype.",[2973],{"_19":29,"_25":321,"_31":6},[],{"_19":2976,"_21":2977,"_23":2978,"_25":2979,"_26":2980,"_32":30,"_33":2982},"np.isdecimal","np.isdecimal(a)","Return true for each element if all characters are decimal.\r","Return true for each element if all characters are decimal.\r\nDecimal characters are those in Unicode category \"Nd\".",[2981],{"_19":189,"_25":1770,"_31":6},[],{"_19":2984,"_21":2985,"_23":2986,"_25":2986,"_26":2987,"_32":30,"_33":2989},"np.isdigit","np.isdigit(a)","Return true for each element if all characters are digits (0-9).",[2988],{"_19":189,"_25":1770,"_31":6},[],{"_19":2991,"_21":2992,"_23":2993,"_25":2994,"_26":2995,"_32":90,"_33":3000},"np.isdtype","np.isdtype(dtype, kind)","Returns a boolean indicating whether the provided dtype is of the specified kind.\r","Returns a boolean indicating whether the provided dtype is of the specified kind.\r\n\r\nThis is the NumPy 2.0 version of issubdtype, with a more explicit API.",[2996,2998],{"_19":196,"_25":2997,"_31":6},"- The dtype to check",{"_19":512,"_25":2999,"_31":6},"- The dtype kind to check against",[],{"_19":3002,"_21":3003,"_23":3004,"_25":3004,"_26":3005,"_32":357,"_33":3007},"np.isfinite","np.isfinite(x)","Test element-wise for finiteness (not infinity and not NaN).",[3006],{"_19":29,"_25":321,"_31":6},[],{"_19":3009,"_21":3010,"_23":3011,"_25":3011,"_26":3012,"_32":90,"_33":3014},"np.isFloatDType","np.isFloatDType(dtype)","Check if dtype is a floating point type.",[3013],{"_19":196,"_25":1172,"_31":6},[],{"_19":3016,"_21":3017,"_23":3018,"_25":3018,"_26":3019,"_32":90,"_33":3021},"np.isfortran","np.isfortran(a)","Check if the array is Fortran contiguous but not C contiguous.",[3020],{"_19":189,"_25":321,"_31":6},[],{"_19":3023,"_21":3024,"_23":3025,"_25":3026,"_26":3027,"_32":357,"_33":3031},"np.isin","np.isin(ar1, ar2, options?)","Test whether each element of ar1 is also present in ar2.\r","Test whether each element of ar1 is also present in ar2.\r\n\r\nReturns a boolean array of the same shape as ar1.",[3028,3029,3030],{"_19":2789,"_25":321,"_31":6},{"_19":2792,"_25":2793,"_31":6},{"_19":534,"_25":1685,"_31":61},[],{"_19":3033,"_21":3034,"_23":3035,"_25":3035,"_26":3036,"_32":357,"_33":3038},"np.isinf","np.isinf(x)","Test element-wise for positive or negative infinity.",[3037],{"_19":29,"_25":321,"_31":6},[],{"_19":3040,"_21":3041,"_23":3042,"_25":3042,"_26":3043,"_32":90,"_33":3045},"np.isIntegerDType","np.isIntegerDType(dtype)","Check if dtype is an integer type (signed or unsigned).",[3044],{"_19":196,"_25":1172,"_31":6},[],{"_19":3047,"_21":3048,"_23":3049,"_25":3050,"_26":3051,"_32":30,"_33":3053},"np.islower","np.islower(a)","Return true for each element if all cased characters are lowercase\r","Return true for each element if all cased characters are lowercase\r\nand there is at least one cased character.",[3052],{"_19":189,"_25":1770,"_31":6},[],{"_19":3055,"_21":3056,"_23":3057,"_25":3057,"_26":3058,"_32":357,"_33":3060},"np.isnan","np.isnan(x)","Test element-wise for NaN.",[3059],{"_19":29,"_25":321,"_31":6},[],{"_19":3062,"_21":3063,"_23":3064,"_25":3064,"_26":3065,"_32":357,"_33":3067},"np.isneginf","np.isneginf(x)","Test element-wise for negative infinity.",[3066],{"_19":29,"_25":321,"_31":6},[],{"_19":3069,"_21":3070,"_23":3071,"_25":3071,"_26":3072,"_32":90,"_33":3073},"np.isNode","np.isNode()","Check if running in Node.js environment.",[],[],{"_19":3075,"_21":3076,"_23":3077,"_25":3078,"_26":3079,"_32":30,"_33":3081},"np.isnumeric","np.isnumeric(a)","Return true for each element if all characters are numeric.\r","Return true for each element if all characters are numeric.\r\nNumeric characters include digit characters and characters\r\nthat have the Unicode numeric value property (subscripts, fractions, etc.).",[3080],{"_19":189,"_25":1770,"_31":6},[],{"_19":3083,"_21":3084,"_23":3085,"_25":3085,"_26":3086,"_32":90,"_33":3088},"np.isNumericDType","np.isNumericDType(dtype)","Check if dtype is numeric (not bool).",[3087],{"_19":196,"_25":1172,"_31":6},[],{"_19":3090,"_21":3091,"_23":3092,"_25":3092,"_26":3093,"_32":357,"_33":3095},"np.isposinf","np.isposinf(x)","Test element-wise for positive infinity.",[3094],{"_19":29,"_25":321,"_31":6},[],{"_19":3097,"_21":3098,"_23":3099,"_25":3100,"_26":3101,"_32":357,"_33":3103},"np.isreal","np.isreal(x)","Returns a bool array where True if input element is real (imaginary part == 0).\r","Returns a bool array where True if input element is real (imaginary part == 0).\r\nFor non-complex dtype arrays, returns all True.",[3102],{"_19":29,"_25":321,"_31":6},[],{"_19":3105,"_21":3106,"_23":3107,"_25":3107,"_26":3108,"_32":90,"_33":3110},"np.isrealobj","np.isrealobj(x)","Check if the array has a non-complex dtype.",[3109],{"_19":29,"_25":321,"_31":6},[],{"_19":3112,"_21":3113,"_23":3114,"_25":3114,"_26":3115,"_32":90,"_33":3119},"np.isscalar","np.isscalar(element)","Check if an element is a scalar type.",[3116],{"_19":3117,"_25":3118,"_31":6},"element","- Value to check",[],{"_19":3121,"_21":3122,"_23":3123,"_25":3123,"_26":3124,"_32":90,"_33":3126},"np.isSignedDType","np.isSignedDType(dtype)","Check if dtype is a signed type.",[3125],{"_19":196,"_25":1172,"_31":6},[],{"_19":3128,"_21":3129,"_23":3130,"_25":3130,"_26":3131,"_32":30,"_33":3133},"np.isspace","np.isspace(a)","Return true for each element if all characters are whitespace.",[3132],{"_19":189,"_25":1770,"_31":6},[],{"_19":3135,"_21":3136,"_23":3137,"_25":3137,"_26":3138,"_32":3140,"_33":3141},"np.isStructuredDType","np.isStructuredDType(dtype)","Type guard for structured dtypes.",[3139],{"_19":196,"_25":225,"_31":6},"dtype is StructuredDType",[],{"_19":3143,"_21":3144,"_23":3145,"_25":3145,"_26":3146,"_32":90,"_33":3153},"np.issubdtype","np.issubdtype(arg1, arg2)","Return true if first argument is a typecode lower/equal in type hierarchy.",[3147,3150],{"_19":3148,"_25":3149,"_31":6},"arg1","- dtype to check",{"_19":3151,"_25":3152,"_31":6},"arg2","- dtype category or abstract type to compare against",[],{"_19":3155,"_21":3156,"_23":3157,"_25":3158,"_26":3159,"_32":30,"_33":3161},"np.istitle","np.istitle(a)","Return true for each element if the string is titlecased.\r","Return true for each element if the string is titlecased.\r\nA string is titlecased if uppercase characters follow uncased\r\ncharacters and lowercase characters follow cased characters.",[3160],{"_19":189,"_25":1770,"_31":6},[],{"_19":3163,"_21":3164,"_23":3165,"_25":3166,"_26":3167,"_32":30,"_33":3169},"np.isupper","np.isupper(a)","Return true for each element if all cased characters are uppercase\r","Return true for each element if all cased characters are uppercase\r\nand there is at least one cased character.",[3168],{"_19":189,"_25":1770,"_31":6},[],{"_19":3171,"_21":3172,"_23":3173,"_25":3173,"_26":3174,"_32":90,"_33":3175},"np.isWasmLoaded","np.isWasmLoaded()","Check if the WASM module has been loaded.",[],[],{"_19":3177,"_21":3178,"_23":3179,"_25":3180,"_26":3181,"_32":90,"_33":3184},"np.iterable","np.iterable(y)","Check whether the object is iterable.\r","Check whether the object is iterable.\r\n\r\nThis function returns True if the object is iterable, i.e., if it has\r\na Symbol.iterator method. Strings are considered iterable in JavaScript,\r\nbut this function returns false for strings to match NumPy behavior.",[3182],{"_19":135,"_25":3183,"_31":6},"- Object to check",[],{"_19":3186,"_21":3187,"_23":3188,"_25":3189,"_26":3190,"_32":836,"_33":3193},"np.ix_","np.ix_(args)","Construct an open mesh from multiple sequences.\r","Construct an open mesh from multiple sequences.\r\nThis function takes N 1-D sequences and returns N outputs with N dimensions each,\r\nsuch that the shape in the ith dimension is the length of the ith input.",[3191],{"_19":223,"_25":3192,"_31":6},"- 1-D sequences (arrays or NDArrays)",[],{"_19":3195,"_21":3196,"_23":3197,"_25":3198,"_26":3199,"_32":357,"_33":3204},"np.kaiser","np.kaiser(M, beta)","Return the Kaiser window.\r","Return the Kaiser window.\r\n\r\nThe Kaiser window is a taper formed by using a Bessel function.\r\nIt provides a good approximation to the Digital Prolate Spheroidal\r\nSequence (DPSS/Slepian window).\r\n\r\nFormula: w(n) = I₀(β * sqrt(1 - (2n/(M-1))²)) / I₀(β)\r\n\r\nThe beta parameter controls the window shape:\r\n- β = 0: Rectangular window\r\n- β ≈ 5: Similar to Hamming\r\n- β ≈ 6: Similar to Hanning\r\n- β ≈ 8.6: Similar to Blackman\r\n- β = 14: Good starting point for most applications",[3200,3201],{"_19":715,"_25":716,"_31":6},{"_19":3202,"_25":3203,"_31":6},"beta","- Shape parameter for the window. Larger values produce\r\n narrower main lobe with lower side lobes.",[],{"_19":3206,"_21":3207,"_23":3208,"_25":3209,"_26":3210,"_32":357,"_33":3213},"np.kron","np.kron(a, b)","Kronecker product of two arrays.\r","Kronecker product of two arrays.\r\n\r\nComputes the Kronecker product, a composite array made of blocks of the\r\nsecond array scaled by the first.",[3211,3212],{"_19":189,"_25":133,"_31":6},{"_19":191,"_25":136,"_31":6},[],{"_19":3215,"_21":3216,"_23":3217,"_25":3217,"_26":3218,"_32":931,"_33":3220},"np.lag2poly","np.lag2poly(c)","Convert Laguerre coefficients to power series.",[3219],{"_19":929,"_25":931,"_31":6},[],{"_19":3222,"_21":3223,"_23":3224,"_25":2370,"_26":3225,"_32":931,"_33":3228},"np.lagadd","np.lagadd(c1, c2)","lagadd",[3226,3227],{"_19":939,"_25":931,"_31":6},{"_19":941,"_25":931,"_31":6},[],{"_19":3230,"_21":3231,"_23":3232,"_25":2370,"_26":3233,"_32":612,"_33":3235},"np.lagcompanion","np.lagcompanion(c)","lagcompanion",[3234],{"_19":929,"_25":931,"_31":6},[],{"_19":3237,"_21":3238,"_23":3239,"_25":2370,"_26":3240,"_32":931,"_33":3243},"np.lagder","np.lagder(c, m?)","lagder",[3241,3242],{"_19":929,"_25":931,"_31":6},{"_19":958,"_25":198,"_31":61},[],{"_19":3245,"_21":3246,"_23":3247,"_25":2370,"_26":3248,"_32":968,"_33":3251},"np.lagdiv","np.lagdiv(c1, c2)","lagdiv",[3249,3250],{"_19":939,"_25":931,"_31":6},{"_19":941,"_25":931,"_31":6},[],{"_19":3253,"_21":3254,"_23":3255,"_25":2370,"_26":3256,"_32":990,"_33":3263},"np.lagfit","np.lagfit(x, y, deg, rcond?, full?, w?)","lagfit",[3257,3258,3259,3260,3261,3262],{"_19":29,"_25":931,"_31":6},{"_19":135,"_25":931,"_31":6},{"_19":355,"_25":198,"_31":6},{"_19":982,"_25":2445,"_31":61},{"_19":985,"_25":90,"_31":61},{"_19":988,"_25":2448,"_31":61},[],{"_19":3265,"_21":3266,"_23":3267,"_25":2370,"_26":3268,"_32":931,"_33":3270},"np.lagfromroots","np.lagfromroots(roots)","lagfromroots",[3269],{"_19":998,"_25":931,"_31":6},[],{"_19":3272,"_21":3273,"_23":3274,"_25":2370,"_26":3275,"_32":931,"_33":3280},"np.lagint","np.lagint(c, m?, k?, lbnd?)","lagint",[3276,3277,3278,3279],{"_19":929,"_25":931,"_31":6},{"_19":958,"_25":198,"_31":61},{"_19":1010,"_25":931,"_31":61},{"_19":1013,"_25":198,"_31":61},[],{"_19":3282,"_21":3283,"_23":3284,"_25":2370,"_26":3285,"_32":931,"_33":3288},"np.lagmul","np.lagmul(c1, c2)","lagmul",[3286,3287],{"_19":939,"_25":931,"_31":6},{"_19":941,"_25":931,"_31":6},[],{"_19":3290,"_21":3291,"_23":3292,"_25":2370,"_26":3293,"_32":931,"_33":3297},"np.lagpow","np.lagpow(c, pow, maxpower?)","lagpow",[3294,3295,3296],{"_19":929,"_25":931,"_31":6},{"_19":1046,"_25":198,"_31":6},{"_19":1048,"_25":198,"_31":61},[],{"_19":3299,"_21":3300,"_23":3301,"_25":2370,"_26":3302,"_32":1029,"_33":3304},"np.lagroots","np.lagroots(c)","lagroots",[3303],{"_19":929,"_25":931,"_31":6},[],{"_19":3306,"_21":3307,"_23":3308,"_25":2370,"_26":3309,"_32":931,"_33":3312},"np.lagsub","np.lagsub(c1, c2)","lagsub",[3310,3311],{"_19":939,"_25":931,"_31":6},{"_19":941,"_25":931,"_31":6},[],{"_19":3314,"_21":3315,"_23":3316,"_25":3316,"_26":3317,"_32":198,"_33":3320},"np.lagval","np.lagval(x, c)","Evaluate Laguerre polynomial.",[3318,3319],{"_19":29,"_25":198,"_31":6},{"_19":929,"_25":931,"_31":6},[],{"_19":3322,"_21":3323,"_23":3324,"_25":2370,"_26":3325,"_32":612,"_33":3328},"np.lagvander","np.lagvander(x, deg)","lagvander",[3326,3327],{"_19":29,"_25":931,"_31":6},{"_19":355,"_25":198,"_31":6},[],{"_19":3330,"_21":3331,"_23":3332,"_25":3333,"_26":3334,"_32":30,"_33":3337},"np.lcm","np.lcm(x1, x2)","Returns the lowest common multiple of |x1| and |x2|.\r","Returns the lowest common multiple of |x1| and |x2|.\r\nInput arrays must be integers.",[3335,3336],{"_19":311,"_25":2239,"_31":6},{"_19":313,"_25":2241,"_31":6},[],{"_19":3339,"_21":3340,"_23":3341,"_25":3342,"_26":3343,"_32":30,"_33":3348},"np.ldexp","np.ldexp(x1, x2)","Returns x1 * 2^x2, element-wise.\r","Returns x1 * 2^x2, element-wise.\r\n\r\nThe mantissas x1 and twos exponents x2 are used to construct\r\nfloating point numbers x = x1 * 2^x2.",[3344,3346],{"_19":311,"_25":3345,"_31":6},"- Array of multipliers (mantissas)",{"_19":313,"_25":3347,"_31":6},"- Array of twos exponents",[],{"_19":3350,"_21":3351,"_23":3352,"_25":3352,"_26":3353,"_32":30,"_33":3356},"np.left_shift","np.left_shift(x1, x2)","Shift the bits of an integer to the left.",[3354,3355],{"_19":311,"_25":30,"_31":6},{"_19":313,"_25":30,"_31":6},[],{"_19":3358,"_21":3359,"_23":3360,"_25":3360,"_26":3361,"_32":931,"_33":3363},"np.leg2poly","np.leg2poly(c)","Convert Legendre coefficients to power series.",[3362],{"_19":929,"_25":931,"_31":6},[],{"_19":3365,"_21":3366,"_23":3367,"_25":3367,"_26":3368,"_32":931,"_33":3371},"np.legadd","np.legadd(c1, c2)","Add two Legendre polynomials.",[3369,3370],{"_19":939,"_25":931,"_31":6},{"_19":941,"_25":931,"_31":6},[],{"_19":3373,"_21":3374,"_23":3375,"_25":3375,"_26":3376,"_32":612,"_33":3378},"np.legcompanion","np.legcompanion(c)","Generate Legendre companion matrix.",[3377],{"_19":929,"_25":931,"_31":6},[],{"_19":3380,"_21":3381,"_23":3382,"_25":3382,"_26":3383,"_32":931,"_33":3386},"np.legder","np.legder(c, m?)","Legendre derivative.",[3384,3385],{"_19":929,"_25":931,"_31":6},{"_19":958,"_25":198,"_31":61},[],{"_19":3388,"_21":3389,"_23":3390,"_25":3390,"_26":3391,"_32":968,"_33":3394},"np.legdiv","np.legdiv(c1, c2)","Divide two Legendre polynomials.",[3392,3393],{"_19":939,"_25":931,"_31":6},{"_19":941,"_25":931,"_31":6},[],{"_19":3396,"_21":3397,"_23":3398,"_25":3398,"_26":3399,"_32":990,"_33":3406},"np.legfit","np.legfit(x, y, deg, rcond?, full?, w?)","Legendre least squares fit.",[3400,3401,3402,3403,3404,3405],{"_19":29,"_25":931,"_31":6},{"_19":135,"_25":931,"_31":6},{"_19":355,"_25":198,"_31":6},{"_19":982,"_25":2445,"_31":61},{"_19":985,"_25":90,"_31":61},{"_19":988,"_25":2448,"_31":61},[],{"_19":3408,"_21":3409,"_23":3410,"_25":3410,"_26":3411,"_32":931,"_33":3413},"np.legfromroots","np.legfromroots(roots)","Construct Legendre polynomial from roots.",[3412],{"_19":998,"_25":931,"_31":6},[],{"_19":3415,"_21":3416,"_23":3417,"_25":3417,"_26":3418,"_32":931,"_33":3423},"np.legint","np.legint(c, m?, k?, lbnd?)","Legendre integral.",[3419,3420,3421,3422],{"_19":929,"_25":931,"_31":6},{"_19":958,"_25":198,"_31":61},{"_19":1010,"_25":931,"_31":61},{"_19":1013,"_25":198,"_31":61},[],{"_19":3425,"_21":3426,"_23":3427,"_25":3427,"_26":3428,"_32":931,"_33":3431},"np.legmul","np.legmul(c1, c2)","Multiply two Legendre polynomials.",[3429,3430],{"_19":939,"_25":931,"_31":6},{"_19":941,"_25":931,"_31":6},[],{"_19":3433,"_21":3434,"_23":3435,"_25":3435,"_26":3436,"_32":931,"_33":3440},"np.legpow","np.legpow(c, pow, maxpower?)","Raise Legendre polynomial to a power.",[3437,3438,3439],{"_19":929,"_25":931,"_31":6},{"_19":1046,"_25":198,"_31":6},{"_19":1048,"_25":198,"_31":61},[],{"_19":3442,"_21":3443,"_23":3444,"_25":3444,"_26":3445,"_32":1029,"_33":3447},"np.legroots","np.legroots(c)","Find Legendre polynomial roots.",[3446],{"_19":929,"_25":931,"_31":6},[],{"_19":3449,"_21":3450,"_23":3451,"_25":3451,"_26":3452,"_32":931,"_33":3455},"np.legsub","np.legsub(c1, c2)","Subtract two Legendre polynomials.",[3453,3454],{"_19":939,"_25":931,"_31":6},{"_19":941,"_25":931,"_31":6},[],{"_19":3457,"_21":3458,"_23":3459,"_25":3459,"_26":3460,"_32":198,"_33":3463},"np.legval","np.legval(x, c)","Evaluate Legendre polynomial using Clenshaw-like algorithm.",[3461,3462],{"_19":29,"_25":1071,"_31":6},{"_19":929,"_25":949,"_31":6},[],{"_19":3465,"_21":3466,"_23":3467,"_25":3467,"_26":3468,"_32":612,"_33":3471},"np.legvander","np.legvander(x, deg)","Legendre Vandermonde matrix.",[3469,3470],{"_19":29,"_25":931,"_31":6},{"_19":355,"_25":198,"_31":6},[],{"_19":3473,"_21":3474,"_23":3475,"_25":3475,"_26":3476,"_32":30,"_33":3479},"np.less","np.less(x1, x2)","Return (x1 < x2) element-wise.",[3477,3478],{"_19":311,"_25":30,"_31":6},{"_19":313,"_25":30,"_31":6},[],{"_19":3481,"_21":3482,"_23":3483,"_25":3483,"_26":3484,"_32":30,"_33":3487},"np.less_equal","np.less_equal(x1, x2)","Return (x1 <= x2) element-wise.",[3485,3486],{"_19":311,"_25":30,"_31":6},{"_19":313,"_25":30,"_31":6},[],{"_19":3489,"_21":3490,"_23":3491,"_25":3492,"_26":3493,"_32":357,"_33":3497},"np.lexsort","np.lexsort(keys)","Perform an indirect stable sort using a sequence of keys.\r","Perform an indirect stable sort using a sequence of keys.\r\n\r\nGiven multiple sorting keys, lexsort returns an array of integer indices\r\nthat describes the sort order by multiple columns. The last key in the\r\nsequence is used for the primary sort order, the second-to-last key for\r\nthe secondary sort order, and so on.",[3494],{"_19":3495,"_25":3496,"_31":6},"keys","- Array of keys to sort by. Each key should be 1-D with the same length.\r\n The last key is the primary sort key.",[],{"_19":3499,"_21":3500,"_23":3501,"_25":3501,"_26":3502,"_32":357,"_33":3510},"np.linspace","np.linspace(start, stop, num?, endpoint?, options?)","Create an NDArray with evenly spaced numbers over a specified interval.",[3503,3505,3507,3508,3509],{"_19":415,"_25":3504,"_31":6},"- Start value",{"_19":2261,"_25":3506,"_31":6},"- End value",{"_19":724,"_25":2264,"_31":61},{"_19":2266,"_25":2267,"_31":61},{"_19":534,"_25":535,"_31":61},[],{"_19":3512,"_21":3513,"_23":3514,"_25":3514,"_26":3515,"_32":743,"_33":3516},"np.listBitGenerators","np.listBitGenerators()","List available BitGenerator names.",[],[],{"_19":3518,"_21":3519,"_23":3520,"_25":3520,"_26":3521,"_32":30,"_33":3528},"np.ljust","np.ljust(a, width, fillchar?)","Return element-wise left-justified string of given width.",[3522,3523,3525],{"_19":189,"_25":1770,"_31":6},{"_19":753,"_25":3524,"_31":6},"- Total width of output string",{"_19":3526,"_25":3527,"_31":61},"fillchar","- Padding character (default space)",[],{"_19":3530,"_21":3531,"_23":3532,"_25":3532,"_26":3533,"_32":357,"_33":3539},"np.load","np.load(file, _options?)","Load an array from a NPY file.",[3534,3536],{"_19":2136,"_25":3535,"_31":6},"- File path (Node.js), File object (browser), ArrayBuffer, or URL",{"_19":3537,"_25":3538,"_31":61},"_options","LoadOptions",[],{"_19":3541,"_21":3542,"_23":3543,"_25":3544,"_26":3545,"_32":357,"_33":3549},"np.loadtxt","np.loadtxt(file, options?)","Load data from a text file.\r","Load data from a text file.\r\n\r\nEach row in the text file must have the same number of values.",[3546,3548],{"_19":2136,"_25":3547,"_31":6},"- File source (path, File object, or URL)",{"_19":534,"_25":2251,"_31":61},[],{"_19":3551,"_21":3552,"_23":3553,"_25":3554,"_26":3555,"_32":3556,"_33":3557},"np.loadWasmModule","np.loadWasmModule()","Load the WASM module asynchronously.\r","Load the WASM module asynchronously.\r\n\r\nThis function is idempotent - calling it multiple times will return\r\nthe same module instance. The module is loaded lazily on first call.",[],"Promise",[],{"_19":3559,"_21":3560,"_23":3561,"_25":3562,"_26":3563,"_32":3565,"_33":3566},"np.loadz","np.loadz(file)","Load arrays from a `.npz` file.\r","Load arrays from a `.npz` file.\r\n\r\nReturns an object with array names as keys and NDArrays as values.\r\nThe `files` property contains the list of array names.",[3564],{"_19":2136,"_25":3535,"_31":6},"Promise",[],{"_19":3568,"_21":3569,"_23":3570,"_25":3570,"_26":3571,"_32":30,"_33":3573},"np.log","np.log(x)","Natural logarithm, element-wise.",[3572],{"_19":29,"_25":30,"_31":6},[],{"_19":3575,"_21":3576,"_23":3577,"_25":3577,"_26":3578,"_32":30,"_33":3580},"np.log10","np.log10(x)","Base-10 logarithm, element-wise.",[3579],{"_19":29,"_25":30,"_31":6},[],{"_19":3582,"_21":3583,"_23":3584,"_25":3584,"_26":3585,"_32":30,"_33":3587},"np.log1p","np.log1p(x)","Return the natural logarithm of one plus the input array, element-wise.",[3586],{"_19":29,"_25":30,"_31":6},[],{"_19":3589,"_21":3590,"_23":3591,"_25":3591,"_26":3592,"_32":30,"_33":3594},"np.log2","np.log2(x)","Base-2 logarithm of x.",[3593],{"_19":29,"_25":30,"_31":6},[],{"_19":3596,"_21":3597,"_23":3598,"_25":3598,"_26":3599,"_32":30,"_33":3602},"np.logaddexp","np.logaddexp(x1, x2)","Compute the logarithm of the sum of exponentials of the inputs.",[3600,3601],{"_19":311,"_25":30,"_31":6},{"_19":313,"_25":30,"_31":6},[],{"_19":3604,"_21":3605,"_23":3606,"_25":3606,"_26":3607,"_32":30,"_33":3610},"np.logaddexp2","np.logaddexp2(x1, x2)","Compute log(2**x1 + 2**x2).",[3608,3609],{"_19":311,"_25":30,"_31":6},{"_19":313,"_25":30,"_31":6},[],{"_19":3612,"_21":3613,"_23":3614,"_25":3614,"_26":3615,"_32":30,"_33":3618},"np.logical_and","np.logical_and(x1, x2)","Compute the truth value of x1 AND x2 element-wise.",[3616,3617],{"_19":311,"_25":30,"_31":6},{"_19":313,"_25":30,"_31":6},[],{"_19":3620,"_21":3621,"_23":3622,"_25":3622,"_26":3623,"_32":30,"_33":3625},"np.logical_not","np.logical_not(x)","Compute the truth value of NOT x element-wise.",[3624],{"_19":29,"_25":30,"_31":6},[],{"_19":3627,"_21":3628,"_23":3629,"_25":3629,"_26":3630,"_32":30,"_33":3633},"np.logical_or","np.logical_or(x1, x2)","Compute the truth value of x1 OR x2 element-wise.",[3631,3632],{"_19":311,"_25":30,"_31":6},{"_19":313,"_25":30,"_31":6},[],{"_19":3635,"_21":3636,"_23":3637,"_25":3637,"_26":3638,"_32":30,"_33":3641},"np.logical_xor","np.logical_xor(x1, x2)","Compute the truth value of x1 XOR x2, element-wise.",[3639,3640],{"_19":311,"_25":30,"_31":6},{"_19":313,"_25":30,"_31":6},[],{"_19":3643,"_21":3644,"_23":3645,"_25":3645,"_26":3646,"_32":357,"_33":3656},"np.logspace","np.logspace(start, stop, num?, endpoint?, base?, options?)","Create an NDArray with numbers spaced evenly on a log scale.",[3647,3649,3651,3652,3653,3655],{"_19":415,"_25":3648,"_31":6},"- Start value (power of base)",{"_19":2261,"_25":3650,"_31":6},"- End value (power of base)",{"_19":724,"_25":2264,"_31":61},{"_19":2266,"_25":2267,"_31":61},{"_19":727,"_25":3654,"_31":61},"- Base of the log scale (default: 10)",{"_19":534,"_25":535,"_31":61},[],{"_19":3658,"_21":3659,"_23":3660,"_25":3660,"_26":3661,"_32":30,"_33":3663},"np.lower","np.lower(a)","Return element-wise copy with uppercase characters converted to lowercase.",[3662],{"_19":189,"_25":1770,"_31":6},[],{"_19":3665,"_21":3666,"_23":3667,"_25":3667,"_26":3668,"_32":30,"_33":3673},"np.lstrip","np.lstrip(a, chars?)","Return element-wise copy with leading characters removed.",[3669,3670],{"_19":189,"_25":1770,"_31":6},{"_19":3671,"_25":3672,"_31":61},"chars","- Characters to remove (default: whitespace)",[],{"_19":3675,"_21":3676,"_23":3677,"_25":3678,"_26":3679,"_32":3685,"_33":3686},"np.lstsq","np.lstsq(a, b, rcond?)","Return the least-squares solution to a linear matrix equation.\r","Return the least-squares solution to a linear matrix equation.\r\n\r\nComputes the vector x that approximately solves the equation a @ x = b.",[3680,3682,3684],{"_19":189,"_25":3681,"_31":6},"- Coefficient matrix (M x N)",{"_19":191,"_25":3683,"_31":6},"- Ordinate values (M,) or (M x K)",{"_19":982,"_25":983,"_31":61},"Promise",[],{"_19":3688,"_21":3689,"_23":3690,"_25":3691,"_26":3692,"_32":3701,"_33":3702},"np.mapdomain","np.mapdomain(x, old, new_)","Map x from old domain to new domain.\r","Map x from old domain to new domain.\r\n\r\nThe mapping is: new = off + scl * old\r\nwhere off and scl are computed from the domains.",[3693,3695,3698],{"_19":29,"_25":3694,"_31":6},"- Values to map (number, array, or NDArray)",{"_19":3696,"_25":3697,"_31":6},"old","- Original domain [min, max]",{"_19":3699,"_25":3700,"_31":6},"new_","- Target domain [min, max]","number[] | number",[],{"_19":3704,"_21":3705,"_23":3706,"_25":3707,"_26":3708,"_32":2287,"_33":3711},"np.mapparms","np.mapparms(old, new_)","Get linear mapping parameters between domains.\r","Get linear mapping parameters between domains.\r\n\r\nReturns [offset, scale] such that new = offset + scale * old",[3709,3710],{"_19":3696,"_25":3697,"_31":6},{"_19":3699,"_25":3700,"_31":6},[],{"_19":3713,"_21":3714,"_23":3715,"_25":3716,"_26":3717,"_32":3724,"_33":3725},"np.mask_indices","np.mask_indices(n, func, k?)","Return indices that are non-zero in the mask.\r","Return indices that are non-zero in the mask.\r\n\r\nCalling this function with a mask function that returns a 2-D array\r\nwill return indices appropriate for accessing the elements that would\r\nbe selected by the mask.",[3718,3720,3722],{"_19":1516,"_25":3719,"_31":6},"- Size of the array for which indices are needed",{"_19":220,"_25":3721,"_31":6},"- A function whose call signature is similar to that of triu, tril.\r\n That is, func(n, k) returns a boolean array of shape (n, n).",{"_19":1010,"_25":3723,"_31":61},"- Diagonal offset","Promise<[NDArray, NDArray]>",[],{"_19":3727,"_21":3728,"_23":3729,"_25":3730,"_26":3731,"_32":357,"_33":3736},"np.matmul","np.matmul(a, b)","Matrix multiplication of two arrays.\r","Matrix multiplication of two arrays.\r\n\r\nFor 2-D arrays: regular matrix multiplication.\r\nFor N-D arrays: broadcast over batch dimensions, matmul on last two.",[3732,3734],{"_19":189,"_25":3733,"_31":6},"- First array (..., M, K)",{"_19":191,"_25":3735,"_31":6},"- Second array (..., K, N)",[],{"_19":3738,"_21":3739,"_23":3740,"_25":3740,"_26":3741,"_32":477,"_33":3749},"np.matrix_norm","np.matrix_norm(x, ord?, keepdims?)","Compute the matrix norm.",[3742,3744,3747],{"_19":29,"_25":3743,"_31":6},"- Input matrix (..., M, N)",{"_19":3745,"_25":3746,"_31":61},"ord","- Order of the norm ('fro', 'nuc', 1, 2, -1, -2, Infinity, -Infinity)",{"_19":326,"_25":3748,"_31":61},"- If true, axes are left with size one",[],{"_19":3751,"_21":3752,"_23":3753,"_25":3753,"_26":3754,"_32":357,"_33":3759},"np.matrix_power","np.matrix_power(a, n)","Raise a square matrix to the (integer) power n.",[3755,3757],{"_19":189,"_25":3756,"_31":6},"- Square matrix",{"_19":1516,"_25":3758,"_31":6},"- Exponent (can be negative for inverse)",[],{"_19":3761,"_21":3762,"_23":3763,"_25":3763,"_26":3764,"_32":1244,"_33":3771},"np.matrix_rank","np.matrix_rank(A, tol?)","Return matrix rank using SVD method.",[3765,3768],{"_19":3766,"_25":3767,"_31":6},"A","- Matrix to determine rank of",{"_19":3769,"_25":3770,"_31":61},"tol","- Threshold for considering singular values as zero",[],{"_19":3773,"_21":3774,"_23":3775,"_25":3776,"_26":3777,"_32":30,"_33":3780},"np.matrix_transpose","np.matrix_transpose(x)","Transposes the last two dimensions of an array.\r","Transposes the last two dimensions of an array.\r\n\r\nNumPy 2.0 addition: Equivalent to swapaxes(a, -2, -1).",[3778],{"_19":29,"_25":3779,"_31":6},"- Input array, must have at least 2 dimensions",[],{"_19":3782,"_21":3783,"_23":3784,"_25":3785,"_26":3786,"_32":357,"_33":3791},"np.matvec","np.matvec(x1, x2)","Matrix-vector product.\r","Matrix-vector product.\r\n\r\nNumPy 2.0 addition. Computes the matrix-vector product of x1 and x2.\r\nEquivalent to matmul with 2D @ 1D broadcasting.",[3787,3789],{"_19":311,"_25":3788,"_31":6},"- Matrix (..., M, N)",{"_19":313,"_25":3790,"_31":6},"- Vector (..., N)",[],{"_19":3793,"_21":3794,"_23":3795,"_25":3795,"_26":3796,"_32":477,"_33":3801},"np.max","np.max(a, axis?, keepdims?)","Return the maximum of an array or maximum along an axis.",[3797,3798,3800],{"_19":189,"_25":321,"_31":6},{"_19":323,"_25":3799,"_31":61},"- Axis along which to find maximum. null finds maximum of all elements.",{"_19":326,"_25":476,"_31":61},[],{"_19":3803,"_21":3804,"_23":3805,"_25":3805,"_26":3806,"_32":30,"_33":3809},"np.maximum","np.maximum(x1, x2)","Element-wise maximum of array elements (propagates NaN).",[3807,3808],{"_19":311,"_25":30,"_31":6},{"_19":313,"_25":30,"_31":6},[],{"_19":3811,"_21":3812,"_23":3813,"_25":3813,"_26":3814,"_32":477,"_33":3821},"np.mean","np.mean(a, axis?, keepdims?, dtype?)","Compute the arithmetic mean along the specified axis.",[3815,3816,3818,3819],{"_19":189,"_25":321,"_31":6},{"_19":323,"_25":3817,"_31":61},"- Axis along which to compute mean. null computes mean of all elements.",{"_19":326,"_25":476,"_31":61},{"_19":196,"_25":3820,"_31":61},"- Output dtype (default: float64 for integers, same as input otherwise)",[],{"_19":3823,"_21":3824,"_23":3825,"_25":3825,"_26":3826,"_32":477,"_33":3831},"np.median","np.median(a, axis?, keepdims?)","Compute the median along the specified axis.",[3827,3828,3830],{"_19":189,"_25":321,"_31":6},{"_19":323,"_25":3829,"_31":61},"- Axis along which to compute median. null computes median of all elements.",{"_19":326,"_25":476,"_31":61},[],{"_19":3833,"_21":3834,"_23":3835,"_25":3835,"_26":3836,"_32":836,"_33":3840},"np.meshgrid","np.meshgrid(xi)","Return coordinate matrices from coordinate vectors.",[3837],{"_19":3838,"_25":3839,"_31":6},"xi","- 1D coordinate arrays",[],{"_19":3842,"_21":3843,"_23":3844,"_25":3844,"_26":3845,"_32":477,"_33":3850},"np.min","np.min(a, axis?, keepdims?)","Return the minimum of an array or minimum along an axis.",[3846,3847,3849],{"_19":189,"_25":321,"_31":6},{"_19":323,"_25":3848,"_31":61},"- Axis along which to find minimum. null finds minimum of all elements.",{"_19":326,"_25":476,"_31":61},[],{"_19":3852,"_21":3853,"_23":3854,"_25":3855,"_26":3856,"_32":1172,"_33":3859},"np.min_scalar_type","np.min_scalar_type(value)","Return the minimum scalar type needed to represent the value.\r","Return the minimum scalar type needed to represent the value.\r\n\r\nFor scalars, returns the smallest dtype that can hold the value.\r\nFor integers, finds the smallest integer type.\r\nFor floats, returns float64 (to preserve precision).",[3857],{"_19":2051,"_25":3858,"_31":6},"- A scalar value",[],{"_19":3861,"_21":3862,"_23":3863,"_25":3863,"_26":3864,"_32":30,"_33":3867},"np.minimum","np.minimum(x1, x2)","Element-wise minimum of array elements (propagates NaN).",[3865,3866],{"_19":311,"_25":30,"_31":6},{"_19":313,"_25":30,"_31":6},[],{"_19":3869,"_21":3870,"_23":3871,"_25":3872,"_26":3873,"_32":1602,"_33":3875},"np.modf","np.modf(x)","Return the fractional and integral parts of an array, element-wise.\r","Return the fractional and integral parts of an array, element-wise.\r\nThe fractional and integral parts are negative if the given number is negative.",[3874],{"_19":29,"_25":321,"_31":6},[],{"_19":3877,"_21":3878,"_23":3879,"_25":3879,"_26":3880,"_32":30,"_33":3888},"np.moveaxis","np.moveaxis(a, source, destination)","Move axes of an array to new positions.",[3881,3882,3885],{"_19":189,"_25":321,"_31":6},{"_19":3883,"_25":3884,"_31":6},"source","- Original positions of the axes to move",{"_19":3886,"_25":3887,"_31":6},"destination","- Destination positions for each axis",[],{"_19":3890,"_21":3891,"_23":3892,"_25":3893,"_26":3894,"_32":357,"_33":3897},"np.multi_dot","np.multi_dot(arrays)","Compute the dot product of two or more arrays in a single function call,\r","Compute the dot product of two or more arrays in a single function call,\r\nwhile automatically selecting the fastest evaluation order.\r\n\r\nUses dynamic programming to find the optimal parenthesization that\r\nminimizes the total number of scalar multiplications.",[3895],{"_19":825,"_25":3896,"_31":6},"- List of arrays to multiply together",[],{"_19":3899,"_21":3900,"_23":3901,"_25":3901,"_26":3902,"_32":30,"_33":3905},"np.multiply","np.multiply(x1, x2)","Multiply arguments element-wise.",[3903,3904],{"_19":311,"_25":30,"_31":6},{"_19":313,"_25":30,"_31":6},[],{"_19":3907,"_21":3908,"_23":3909,"_25":3909,"_26":3910,"_32":357,"_33":3921},"np.nan_to_num","np.nan_to_num(x, nan?, posinf?, neginf?)","Replace NaN with zero and infinity with large finite numbers.",[3911,3912,3915,3918],{"_19":29,"_25":321,"_31":6},{"_19":3913,"_25":3914,"_31":61},"nan","- Value to replace NaN with (default: 0.0)",{"_19":3916,"_25":3917,"_31":61},"posinf","- Value to replace positive infinity with (default: largest finite float)",{"_19":3919,"_25":3920,"_31":61},"neginf","- Value to replace negative infinity with (default: most negative finite float)",[],{"_19":3923,"_21":3924,"_23":3925,"_25":3925,"_26":3926,"_32":477,"_33":3932},"np.nanargmax","np.nanargmax(a, axis?, keepdims?)","Return the indices of the maximum values along an axis, ignoring NaNs.",[3927,3928,3930],{"_19":189,"_25":321,"_31":6},{"_19":323,"_25":3929,"_31":61},"- Axis along which to operate (null = flattened array)",{"_19":326,"_25":3931,"_31":61},"- If true, reduced axes are left with size one",[],{"_19":3934,"_21":3935,"_23":3936,"_25":3936,"_26":3937,"_32":477,"_33":3941},"np.nanargmin","np.nanargmin(a, axis?, keepdims?)","Return the indices of the minimum values along an axis, ignoring NaNs.",[3938,3939,3940],{"_19":189,"_25":321,"_31":6},{"_19":323,"_25":3929,"_31":61},{"_19":326,"_25":3931,"_31":61},[],{"_19":3943,"_21":3944,"_23":3945,"_25":3946,"_26":3947,"_32":357,"_33":3952},"np.nancumprod","np.nancumprod(a, axis?, dtype?)","Return the cumulative product of array elements treating NaNs as one.\r","Return the cumulative product of array elements treating NaNs as one.\r\n\r\nThe cumulative product does not change when NaNs are encountered and\r\nleading NaNs are replaced by ones.",[3948,3949,3951],{"_19":189,"_25":321,"_31":6},{"_19":323,"_25":3950,"_31":61},"- Axis along which to compute. null = flatten first",{"_19":196,"_25":1426,"_31":61},[],{"_19":3954,"_21":3955,"_23":3956,"_25":3957,"_26":3958,"_32":357,"_33":3962},"np.nancumsum","np.nancumsum(a, axis?, dtype?)","Return the cumulative sum of array elements treating NaNs as zero.\r","Return the cumulative sum of array elements treating NaNs as zero.\r\n\r\nThe cumulative sum does not change when NaNs are encountered and\r\nleading NaNs are replaced by zeros.",[3959,3960,3961],{"_19":189,"_25":321,"_31":6},{"_19":323,"_25":3950,"_31":61},{"_19":196,"_25":1426,"_31":61},[],{"_19":3964,"_21":3965,"_23":3966,"_25":3966,"_26":3967,"_32":477,"_33":3973},"np.nanmax","np.nanmax(a, axis?, keepdims?)","Return maximum of an array or maximum along an axis, ignoring any NaNs.",[3968,3970,3972],{"_19":189,"_25":3969,"_31":6},"- Array containing numbers",{"_19":323,"_25":3971,"_31":61},"- Axis or axes along which to operate (null = all elements)",{"_19":326,"_25":3931,"_31":61},[],{"_19":3975,"_21":3976,"_23":3977,"_25":3977,"_26":3978,"_32":477,"_33":3986},"np.nanmean","np.nanmean(a, axis?, keepdims?, dtype?)","Compute the arithmetic mean along the specified axis, ignoring NaNs.",[3979,3981,3983,3984],{"_19":189,"_25":3980,"_31":6},"- Array containing numbers whose mean is desired",{"_19":323,"_25":3982,"_31":61},"- Axis or axes along which the means are computed (null = all elements)",{"_19":326,"_25":3931,"_31":61},{"_19":196,"_25":3985,"_31":61},"- Type to use in computing the mean",[],{"_19":3988,"_21":3989,"_23":3990,"_25":3990,"_26":3991,"_32":477,"_33":3996},"np.nanmedian","np.nanmedian(a, axis?, keepdims?)","Compute the median along the specified axis, while ignoring NaNs.",[3992,3993,3995],{"_19":189,"_25":321,"_31":6},{"_19":323,"_25":3994,"_31":61},"- Axis or axes along which the medians are computed (null = all elements)",{"_19":326,"_25":3931,"_31":61},[],{"_19":3998,"_21":3999,"_23":4000,"_25":4000,"_26":4001,"_32":477,"_33":4005},"np.nanmin","np.nanmin(a, axis?, keepdims?)","Return minimum of an array or minimum along an axis, ignoring any NaNs.",[4002,4003,4004],{"_19":189,"_25":3969,"_31":6},{"_19":323,"_25":3971,"_31":61},{"_19":326,"_25":3931,"_31":61},[],{"_19":4007,"_21":4008,"_23":4009,"_25":4010,"_26":4011,"_32":477,"_33":4022},"np.nanpercentile","np.nanpercentile(a, q, axis?, interpolation?, keepdims?)","Compute the q-th percentile of the data along the specified axis,\r","Compute the q-th percentile of the data along the specified axis,\r\nwhile ignoring NaN values.",[4012,4013,4016,4018,4021],{"_19":189,"_25":321,"_31":6},{"_19":4014,"_25":4015,"_31":6},"q","- Percentile(s) to compute, in range [0, 100]",{"_19":323,"_25":4017,"_31":61},"- Axis along which to compute (null = all elements)",{"_19":4019,"_25":4020,"_31":61},"interpolation","- Interpolation method ('linear', 'lower', 'higher', 'midpoint', 'nearest')",{"_19":326,"_25":3931,"_31":61},[],{"_19":4024,"_21":4025,"_23":4026,"_25":4026,"_26":4027,"_32":477,"_33":4035},"np.nanprod","np.nanprod(a, axis?, keepdims?, _dtype?)","Return the product of array elements over a given axis treating NaNs as one.",[4028,4030,4032,4033],{"_19":189,"_25":4029,"_31":6},"- Array containing numbers whose product is desired",{"_19":323,"_25":4031,"_31":61},"- Axis or axes along which the product is computed (null = all elements)",{"_19":326,"_25":3931,"_31":61},{"_19":4034,"_25":1172,"_31":61},"_dtype",[],{"_19":4037,"_21":4038,"_23":4039,"_25":4040,"_26":4041,"_32":477,"_33":4048},"np.nanquantile","np.nanquantile(a, q, axis?, interpolation?, keepdims?)","Compute the q-th quantile of the data along the specified axis,\r","Compute the q-th quantile of the data along the specified axis,\r\nwhile ignoring NaN values.",[4042,4043,4045,4046,4047],{"_19":189,"_25":321,"_31":6},{"_19":4014,"_25":4044,"_31":6},"- Quantile(s) to compute, in range [0, 1]",{"_19":323,"_25":4017,"_31":61},{"_19":4019,"_25":4020,"_31":61},{"_19":326,"_25":3931,"_31":61},[],{"_19":4050,"_21":4051,"_23":4052,"_25":4052,"_26":4053,"_32":477,"_33":4062},"np.nanstd","np.nanstd(a, axis?, ddof?, keepdims?, dtype?)","Compute the standard deviation along the specified axis, ignoring NaNs.",[4054,4055,4057,4059,4060],{"_19":189,"_25":3969,"_31":6},{"_19":323,"_25":4056,"_31":61},"- Axis or axes along which the standard deviation is computed (null = all elements)",{"_19":1370,"_25":4058,"_31":61},"- Delta Degrees of Freedom (divisor is N - ddof)",{"_19":326,"_25":3931,"_31":61},{"_19":196,"_25":4061,"_31":61},"- Type to use in computing the standard deviation",[],{"_19":4064,"_21":4065,"_23":4066,"_25":4066,"_26":4067,"_32":477,"_33":4075},"np.nansum","np.nansum(a, axis?, keepdims?, dtype?)","Return the sum of array elements over a given axis treating NaNs as zero.",[4068,4070,4072,4073],{"_19":189,"_25":4069,"_31":6},"- Array containing numbers whose sum is desired",{"_19":323,"_25":4071,"_31":61},"- Axis or axes along which the sum is computed (null = all elements)",{"_19":326,"_25":3931,"_31":61},{"_19":196,"_25":4074,"_31":61},"- The type of the returned array",[],{"_19":4077,"_21":4078,"_23":4079,"_25":4079,"_26":4080,"_32":477,"_33":4088},"np.nanvar","np.nanvar(a, axis?, ddof?, keepdims?, dtype?)","Compute the variance along the specified axis, while ignoring NaNs.",[4081,4082,4084,4085,4086],{"_19":189,"_25":3969,"_31":6},{"_19":323,"_25":4083,"_31":61},"- Axis or axes along which the variance is computed (null = all elements)",{"_19":1370,"_25":4058,"_31":61},{"_19":326,"_25":3931,"_31":61},{"_19":196,"_25":4087,"_31":61},"- Type to use in computing the variance",[],{"_19":4090,"_21":4091,"_23":4092,"_25":4092,"_26":4093,"_32":4096,"_33":4097},"np.ndenumerate","np.ndenumerate(arr)","Iterate over array with indices and values.",[4094],{"_19":374,"_25":4095,"_31":6},"- Array to iterate","Generator<[number[], number]>",[],{"_19":4099,"_21":4100,"_23":4101,"_25":4101,"_26":4102,"_32":4105,"_33":4106},"np.ndindex","np.ndindex(shape)","Generate all index combinations for a shape.",[4103],{"_19":531,"_25":4104,"_31":6},"- Dimensions","Generator",[],{"_19":4108,"_21":4109,"_23":4110,"_25":4110,"_26":4111,"_32":4113,"_33":4114},"np.nditer","np.nditer(arr)","Iterate over array elements.",[4112],{"_19":374,"_25":4095,"_31":6},"Generator",[],{"_19":4116,"_21":4117,"_23":4118,"_25":4118,"_26":4119,"_32":30,"_33":4121},"np.negative","np.negative(x)","Numerical negative, element-wise.",[4120],{"_19":29,"_25":30,"_31":6},[],{"_19":4123,"_21":4124,"_23":4125,"_25":4125,"_26":4126,"_32":30,"_33":4131},"np.nextafter","np.nextafter(x1, x2)","Return the next floating-point value after x1 towards x2, element-wise.",[4127,4129],{"_19":311,"_25":4128,"_31":6},"- Starting values",{"_19":313,"_25":4130,"_31":6},"- Direction values",[],{"_19":4133,"_21":4134,"_23":4135,"_25":4136,"_26":4137,"_32":357,"_33":4139},"np.nonzero","np.nonzero(arr)","Find indices of nonzero elements.\r","Find indices of nonzero elements.\r\n\r\nReturns a 2D array of shape (num_nonzero, ndim) where each row\r\ncontains the multi-dimensional index of a nonzero element.",[4138],{"_19":374,"_25":321,"_31":6},[],{"_19":4141,"_21":4142,"_23":4143,"_25":4143,"_26":4144,"_32":1244,"_33":4148},"np.norm","np.norm(x, ord?)","Matrix or vector norm.",[4145,4146],{"_19":29,"_25":321,"_31":6},{"_19":3745,"_25":4147,"_31":61},"- Order of the norm (default: 2 for vectors, 'fro' for matrices)\r\n Vector norms: 1, 2, inf, -inf, or any positive number\r\n Matrix norms: 1, 2, inf, -inf, 'fro', 'nuc'",[],{"_19":4150,"_21":4151,"_23":4152,"_25":4152,"_26":4153,"_32":30,"_33":4156},"np.not_equal","np.not_equal(x1, x2)","Return (x1 != x2) element-wise.",[4154,4155],{"_19":311,"_25":30,"_31":6},{"_19":313,"_25":30,"_31":6},[],{"_19":4158,"_21":4159,"_23":4160,"_25":4160,"_26":4161,"_32":546,"_33":4165},"np.octalRepr","np.octalRepr(num, width?)","Return the octal representation of a number.",[4162,4163],{"_19":724,"_25":725,"_31":6},{"_19":753,"_25":4164,"_31":61},"- Minimum number of octal digits",[],{"_19":4167,"_21":4168,"_23":4169,"_25":4169,"_26":4170,"_32":357,"_33":4173},"np.ones","np.ones(shape, options?)","Create a new NDArray filled with ones.",[4171,4172],{"_19":531,"_25":1752,"_31":6},{"_19":534,"_25":535,"_31":61},[],{"_19":4175,"_21":4176,"_23":4177,"_25":4177,"_26":4178,"_32":357,"_33":4180},"np.ones_like","np.ones_like(a)","Create an array of ones with the same shape and type as a given array.",[4179],{"_19":189,"_25":1761,"_31":6},[],{"_19":4182,"_21":4183,"_23":4184,"_25":4185,"_26":4186,"_32":4191,"_33":4192},"np.openMemmap","np.openMemmap(file, options?)","Open a memory-mapped file.\r","Open a memory-mapped file.\r\n\r\nConvenience function wrapping Memmap.open().",[4187,4189],{"_19":2136,"_25":4188,"_31":6},"- File path or ArrayBuffer",{"_19":534,"_25":4190,"_31":61},"- Memmap options","Promise",[],{"_19":4194,"_21":4195,"_23":4196,"_25":4196,"_26":4197,"_32":357,"_33":4200},"np.outer","np.outer(a, b)","Compute the outer product of two vectors.",[4198,4199],{"_19":189,"_25":30,"_31":6},{"_19":191,"_25":30,"_31":6},[],{"_19":4202,"_21":4203,"_23":4204,"_25":4205,"_26":4206,"_32":357,"_33":4214},"np.packbits","np.packbits(a, axis?, bitorder?)","Pack the elements of a binary array into bits in a uint8 array.\r","Pack the elements of a binary array into bits in a uint8 array.\r\n\r\nThe result is padded to full bytes with zeros.",[4207,4209,4211],{"_19":189,"_25":4208,"_31":6},"- Input array of uint8 values (each treated as a single bit: 0 or non-zero)",{"_19":323,"_25":4210,"_31":61},"- The axis along which to pack. If null, the input is flattened",{"_19":4212,"_25":4213,"_31":61},"bitorder","- Order of bits in the packed representation. 'big' (default) means\r\n the first bit goes into the highest bit of the byte; 'little' means\r\n the first bit goes into the lowest bit of the byte",[],{"_19":4216,"_21":4217,"_23":4218,"_25":4218,"_26":4219,"_32":357,"_33":4229},"np.pad","np.pad(arr, pad_width, mode?, constant_values?)","Pad an array.",[4220,4221,4224,4226],{"_19":374,"_25":321,"_31":6},{"_19":4222,"_25":4223,"_31":6},"pad_width","- Number of values padded to edges of each axis",{"_19":1137,"_25":4225,"_31":61},"- Padding mode (default: 'constant')",{"_19":4227,"_25":4228,"_31":61},"constant_values","- Value to use for constant padding (default: 0)",[],{"_19":4231,"_21":4232,"_23":4233,"_25":4234,"_26":4235,"_32":357,"_33":4239},"np.partition","np.partition(a, kth, axis?)","Return a partitioned copy of an array.\r","Return a partitioned copy of an array.\r\n\r\nCreates a copy of the array with its elements rearranged so that\r\nelements smaller than the kth element are moved before it and\r\nelements greater are moved after it.",[4236,4237,4238],{"_19":189,"_25":495,"_31":6},{"_19":497,"_25":498,"_31":6},{"_19":323,"_25":500,"_31":61},[],{"_19":4241,"_21":4242,"_23":4243,"_25":4243,"_26":4244,"_32":477,"_33":4251},"np.percentile","np.percentile(a, q, axis?, keepdims?)","Compute the q-th percentile of the data along the specified axis.",[4245,4246,4248,4250],{"_19":189,"_25":321,"_31":6},{"_19":4014,"_25":4247,"_31":6},"- Percentile to compute, in range [0, 100]",{"_19":323,"_25":4249,"_31":61},"- Axis along which to compute percentile. null computes percentile of flattened array.",{"_19":326,"_25":476,"_31":61},[],{"_19":4253,"_21":4254,"_23":4255,"_25":4255,"_26":4256,"_32":357,"_33":4261},"np.permutation","np.permutation(x, axis?)","Randomly permute a sequence, or return a permuted range.",[4257,4259],{"_19":29,"_25":4258,"_31":6},"- If an integer, randomly permute arange(x).\r\n If an array, make a copy and shuffle the elements randomly.",{"_19":323,"_25":4260,"_31":61},"- Axis along which to permute (default 0)",[],{"_19":4263,"_21":4264,"_23":4265,"_25":4266,"_26":4267,"_32":30,"_33":4271},"np.permute_dims","np.permute_dims(a, axes?)","Permute the dimensions of an array.\r","Permute the dimensions of an array.\r\nThis is an alias for transpose, added in NumPy 2.0.",[4268,4269],{"_19":189,"_25":321,"_31":6},{"_19":406,"_25":4270,"_31":61},"- Permutation of axes (optional, reverses all axes if not provided)",[],{"_19":4273,"_21":4274,"_23":4275,"_25":4276,"_26":4277,"_32":357,"_33":4288},"np.piecewise","np.piecewise(x, condlist, funclist, args)","Evaluate a piecewise-defined function.\r","Evaluate a piecewise-defined function.\r\n\r\nGiven a set of conditions and corresponding functions, evaluate each\r\nfunction on the input only where its condition is true.",[4278,4280,4283,4286],{"_19":29,"_25":4279,"_31":6},"- Input array (domain of the piecewise function)",{"_19":4281,"_25":4282,"_31":6},"condlist","- List of boolean arrays defining conditions",{"_19":4284,"_25":4285,"_31":6},"funclist","- List of functions or constants for each condition.\r\n If funclist has one more element than condlist, the last\r\n element is used as the default (\"otherwise\") case.",{"_19":223,"_25":4287,"_31":6},"- Additional arguments passed to all functions",[],{"_19":4290,"_21":4291,"_23":4292,"_25":4292,"_26":4293,"_32":357,"_33":4297},"np.pinv","np.pinv(a, rcond?)","Compute the (Moore-Penrose) pseudo-inverse of a matrix.",[4294,4296],{"_19":189,"_25":4295,"_31":6},"- Matrix to pseudo-invert",{"_19":982,"_25":983,"_31":61},[],{"_19":4299,"_21":4300,"_23":4301,"_25":4302,"_26":4303,"_32":1947,"_33":4312},"np.place","np.place(arr, mask, vals)","Change elements of an array based on conditional and input values.\r","Change elements of an array based on conditional and input values.\r\nSimilar to putmask, but places values sequentially.",[4304,4306,4309],{"_19":374,"_25":4305,"_31":6},"- Array to modify (in place)",{"_19":4307,"_25":4308,"_31":6},"mask","- Boolean mask array",{"_19":4310,"_25":4311,"_31":6},"vals","- Values to place (used sequentially, cycled if needed)",[],{"_19":4314,"_21":4315,"_23":4316,"_25":4317,"_26":4318,"_32":931,"_33":4322},"np.poly","np.poly(seq_of_zeros)","Find the coefficients of a polynomial with the given sequence of roots.\r","Find the coefficients of a polynomial with the given sequence of roots.\r\n\r\nThis is a NumPy legacy function. Returns coefficients in descending\r\npowers order (highest power first), which is the opposite of the numpy.polynomial\r\nmodule convention.\r\n\r\nNOTE: This is the legacy numpy.poly function. For the modern API, use\r\npolyfromroots() from the polynomial module which uses ascending powers order.",[4319],{"_19":4320,"_25":4321,"_31":6},"seq_of_zeros","- A sequence of polynomial roots",[],{"_19":4324,"_21":4325,"_23":4326,"_25":4326,"_26":4327,"_32":931,"_33":4331},"np.poly2cheb","np.poly2cheb(pol)","Convert power series coefficients to Chebyshev coefficients.",[4328],{"_19":4329,"_25":4330,"_31":6},"pol","- Power series coefficients",[],{"_19":4333,"_21":4334,"_23":4335,"_25":4335,"_26":4336,"_32":931,"_33":4338},"np.poly2herm","np.poly2herm(pol)","Convert power series to Hermite coefficients.",[4337],{"_19":4329,"_25":931,"_31":6},[],{"_19":4340,"_21":4341,"_23":4342,"_25":4342,"_26":4343,"_32":931,"_33":4345},"np.poly2herme","np.poly2herme(pol)","Convert power series to HermiteE coefficients.",[4344],{"_19":4329,"_25":931,"_31":6},[],{"_19":4347,"_21":4348,"_23":4349,"_25":4349,"_26":4350,"_32":931,"_33":4352},"np.poly2lag","np.poly2lag(pol)","Convert power series to Laguerre coefficients.",[4351],{"_19":4329,"_25":931,"_31":6},[],{"_19":4354,"_21":4355,"_23":4356,"_25":4356,"_26":4357,"_32":931,"_33":4359},"np.poly2leg","np.poly2leg(pol)","Convert power series to Legendre coefficients.",[4358],{"_19":4329,"_25":931,"_31":6},[],{"_19":4361,"_21":4362,"_23":4363,"_25":4363,"_26":4364,"_32":931,"_33":4369},"np.polyadd","np.polyadd(c1, c2)","Add two coefficient arrays (power series).",[4365,4367],{"_19":939,"_25":4366,"_31":6},"- First coefficient array",{"_19":941,"_25":4368,"_31":6},"- Second coefficient array",[],{"_19":4371,"_21":4372,"_23":4373,"_25":4373,"_26":4374,"_32":612,"_33":4376},"np.polycompanion","np.polycompanion(c)","Generate companion matrix.",[4375],{"_19":929,"_25":949,"_31":6},[],{"_19":4378,"_21":4379,"_23":4380,"_25":4380,"_26":4381,"_32":931,"_33":4384},"np.polyder","np.polyder(c, m?)","Polynomial derivative.",[4382,4383],{"_19":929,"_25":949,"_31":6},{"_19":958,"_25":959,"_31":61},[],{"_19":4386,"_21":4387,"_23":4388,"_25":4388,"_26":4389,"_32":968,"_33":4394},"np.polydiv","np.polydiv(c1, c2)","Divide two coefficient arrays (power series).",[4390,4392],{"_19":939,"_25":4391,"_31":6},"- Dividend coefficient array",{"_19":941,"_25":4393,"_31":6},"- Divisor coefficient array",[],{"_19":4396,"_21":4397,"_23":4398,"_25":4398,"_26":4399,"_32":990,"_33":4406},"np.polyfit","np.polyfit(x, y, deg, rcond?, full?, w?)","Least squares polynomial fit.",[4400,4401,4402,4403,4404,4405],{"_19":29,"_25":976,"_31":6},{"_19":135,"_25":978,"_31":6},{"_19":355,"_25":980,"_31":6},{"_19":982,"_25":983,"_31":61},{"_19":985,"_25":986,"_31":61},{"_19":988,"_25":989,"_31":61},[],{"_19":4408,"_21":4409,"_23":4410,"_25":4410,"_26":4411,"_32":931,"_33":4413},"np.polyfromroots","np.polyfromroots(roots)","Construct polynomial from roots.",[4412],{"_19":998,"_25":999,"_31":6},[],{"_19":4415,"_21":4416,"_23":4417,"_25":4417,"_26":4418,"_32":931,"_33":4423},"np.polyint","np.polyint(c, m?, k?, lbnd?)","Polynomial integral.",[4419,4420,4421,4422],{"_19":929,"_25":949,"_31":6},{"_19":958,"_25":1008,"_31":61},{"_19":1010,"_25":1011,"_31":61},{"_19":1013,"_25":1014,"_31":61},[],{"_19":4425,"_21":4426,"_23":4427,"_25":4428,"_26":4429,"_32":931,"_33":4432},"np.polymul","np.polymul(c1, c2)","Multiply two coefficient arrays (power series).\r","Multiply two coefficient arrays (power series).\r\nUses convolution.",[4430,4431],{"_19":939,"_25":4366,"_31":6},{"_19":941,"_25":4368,"_31":6},[],{"_19":4434,"_21":4435,"_23":4436,"_25":4436,"_26":4437,"_32":931,"_33":4443},"np.polypow","np.polypow(c, pow, maxpower?)","Raise polynomial to a non-negative integer power.",[4438,4439,4441],{"_19":929,"_25":949,"_31":6},{"_19":1046,"_25":4440,"_31":6},"- Non-negative integer power",{"_19":1048,"_25":4442,"_31":61},"- Maximum allowed power (default: 100)",[],{"_19":4445,"_21":4446,"_23":4447,"_25":4447,"_26":4448,"_32":1029,"_33":4450},"np.polyroots","np.polyroots(c)","Find polynomial roots.",[4449],{"_19":929,"_25":949,"_31":6},[],{"_19":4452,"_21":4453,"_23":4454,"_25":4454,"_26":4455,"_32":931,"_33":4458},"np.polysub","np.polysub(c1, c2)","Subtract two coefficient arrays (power series).",[4456,4457],{"_19":939,"_25":4366,"_31":6},{"_19":941,"_25":4368,"_31":6},[],{"_19":4460,"_21":4461,"_23":4462,"_25":4462,"_26":4463,"_32":198,"_33":4467},"np.polyval","np.polyval(x, c)","Evaluate polynomial at x using Horner's method.",[4464,4465],{"_19":29,"_25":1071,"_31":6},{"_19":929,"_25":4466,"_31":6},"- Coefficient array [c0, c1, c2, ...] for c0 + c1*x + c2*x^2 + ...",[],{"_19":4469,"_21":4470,"_23":4471,"_25":4471,"_26":4472,"_32":931,"_33":4476},"np.polyval2d","np.polyval2d(x, y, c)","Evaluate 2D polynomial on x-y pairs.",[4473,4474,4475],{"_19":29,"_25":1081,"_31":6},{"_19":135,"_25":1083,"_31":6},{"_19":929,"_25":1085,"_31":6},[],{"_19":4478,"_21":4479,"_23":4480,"_25":4480,"_26":4481,"_32":931,"_33":4488},"np.polyval3d","np.polyval3d(x, y, z, c)","Evaluate 3D polynomial on x-y-z triples.",[4482,4483,4484,4486],{"_19":29,"_25":1081,"_31":6},{"_19":135,"_25":1083,"_31":6},{"_19":352,"_25":4485,"_31":6},"- z coordinates",{"_19":929,"_25":4487,"_31":6},"- 3D coefficient array",[],{"_19":4490,"_21":4491,"_23":4492,"_25":4492,"_26":4493,"_32":612,"_33":4496},"np.polyvander","np.polyvander(x, deg)","Generate Vandermonde matrix.",[4494,4495],{"_19":29,"_25":1093,"_31":6},{"_19":355,"_25":1095,"_31":6},[],{"_19":4498,"_21":4499,"_23":4500,"_25":4500,"_26":4501,"_32":612,"_33":4508},"np.polyvander2d","np.polyvander2d(x, y, deg)","Generate 2D Vandermonde matrix.",[4502,4504,4506],{"_19":29,"_25":4503,"_31":6},"- x sample points",{"_19":135,"_25":4505,"_31":6},"- y sample points",{"_19":355,"_25":4507,"_31":6},"- [degree in x, degree in y]",[],{"_19":4510,"_21":4511,"_23":4512,"_25":4512,"_26":4513,"_32":30,"_33":4515},"np.positive","np.positive(x)","Numerical positive (returns a copy).",[4514],{"_19":29,"_25":30,"_31":6},[],{"_19":4517,"_21":4518,"_23":4519,"_25":4519,"_26":4520,"_32":30,"_33":4523},"np.power","np.power(x1, x2)","First array elements raised to powers from second array, element-wise.",[4521,4522],{"_19":311,"_25":30,"_31":6},{"_19":313,"_25":30,"_31":6},[],{"_19":4525,"_21":4526,"_23":4527,"_25":4527,"_26":4528,"_32":477,"_33":4534},"np.prod","np.prod(a, axis?, keepdims?, dtype?)","Return the product of array elements over a given axis.",[4529,4530,4532,4533],{"_19":189,"_25":321,"_31":6},{"_19":323,"_25":4531,"_31":61},"- Axis along which to compute product. null computes product of all elements.",{"_19":326,"_25":476,"_31":61},{"_19":196,"_25":3820,"_31":61},[],{"_19":4536,"_21":4537,"_23":4538,"_25":4539,"_26":4540,"_32":1172,"_33":4547},"np.promoteTypes","np.promoteTypes(dtype1, dtype2)","Get result type when combining two dtypes.\r","Get result type when combining two dtypes.\r\nFollows NumPy promotion rules.",[4541,4544],{"_19":4542,"_25":4543,"_31":6},"dtype1","- First dtype",{"_19":4545,"_25":4546,"_31":6},"dtype2","- Second dtype",[],{"_19":4549,"_21":4550,"_23":4551,"_25":4552,"_26":4553,"_32":477,"_33":4558},"np.ptp","np.ptp(a, axis?, keepdims?)","Range of values (maximum - minimum) along an axis.\r","Range of values (maximum - minimum) along an axis.\r\n\r\nThe name of the function comes from the acronym for 'peak to peak'.",[4554,4555,4557],{"_19":189,"_25":321,"_31":6},{"_19":323,"_25":4556,"_31":61},"- Axis along which to find the peak-to-peak value. null computes ptp of flattened array.",{"_19":326,"_25":476,"_31":61},[],{"_19":4560,"_21":4561,"_23":4562,"_25":4562,"_26":4563,"_32":1947,"_33":4571},"np.put","np.put(arr, indices, values, mode?)","Put values into an array at specified flat indices.",[4564,4566,4568,4570],{"_19":374,"_25":4565,"_31":6},"- Target array (modified in place)",{"_19":878,"_25":4567,"_31":6},"- Array of flat indices",{"_19":376,"_25":4569,"_31":6},"- Values to put (broadcast if smaller)",{"_19":1137,"_25":1138,"_31":61},[],{"_19":4573,"_21":4574,"_23":4575,"_25":4575,"_26":4576,"_32":1947,"_33":4585},"np.put_along_axis","np.put_along_axis(arr, indicesArr, values, axis)","Put values into the destination array by matching 1d index and data slices.",[4577,4579,4581,4583],{"_19":374,"_25":4578,"_31":6},"- Destination array (modified in place)",{"_19":4580,"_25":30,"_31":6},"indicesArr",{"_19":376,"_25":4582,"_31":6},"- Values to put",{"_19":323,"_25":4584,"_31":6},"- The axis to put along",[],{"_19":4587,"_21":4588,"_23":4301,"_25":4589,"_26":4590,"_32":1947,"_33":4595},"np.putmask","np.putmask(arr, mask, values)","Change elements of an array based on conditional and input values.\r\nSets a.flat[n] = values[n % len(values)] for each n where mask.flat[n]==True.",[4591,4592,4593],{"_19":374,"_25":4305,"_31":6},{"_19":4307,"_25":4308,"_31":6},{"_19":376,"_25":4594,"_31":6},"- Values to put (cycled if smaller than number of True in mask)",[],{"_19":4597,"_21":4598,"_23":4599,"_25":4600,"_26":4601,"_32":4604,"_33":4605},"np.qr","np.qr(a)","QR decomposition.\r","QR decomposition.\r\n\r\nFactor the matrix a as qr, where q is orthonormal and r is upper-triangular.",[4602],{"_19":189,"_25":4603,"_31":6},"- Matrix to factor (M x N)","Promise",[],{"_19":4607,"_21":4608,"_23":4609,"_25":4609,"_26":4610,"_32":477,"_33":4617},"np.quantile","np.quantile(a, q, axis?, keepdims?)","Compute the q-th quantile of the data along the specified axis.",[4611,4612,4614,4616],{"_19":189,"_25":321,"_31":6},{"_19":4014,"_25":4613,"_31":6},"- Quantile to compute, in range [0, 1]",{"_19":323,"_25":4615,"_31":61},"- Axis along which to compute quantile. null computes quantile of flattened array.",{"_19":326,"_25":476,"_31":61},[],{"_19":4619,"_21":4620,"_23":4621,"_25":4621,"_26":4622,"_32":30,"_33":4624},"np.radians","np.radians(x)","Convert angles from degrees to radians.",[4623],{"_19":29,"_25":30,"_31":6},[],{"_19":4626,"_21":4627,"_23":4628,"_25":4629,"_26":4630,"_32":4632,"_33":4633},"np.rand","np.rand(shape)","Random values in a given shape.\r","Random values in a given shape.\r\n\r\nCreate an array of the given shape and populate it with random samples\r\nfrom a uniform distribution over [0, 1).",[4631],{"_19":531,"_25":931,"_31":6},"NDArray | number",[],{"_19":4635,"_21":4636,"_23":4637,"_25":4637,"_26":4638,"_32":4632,"_33":4647},"np.randint","np.randint(low, high?, size?)","Return random integers from low (inclusive) to high (exclusive).",[4639,4642,4645],{"_19":4640,"_25":4641,"_31":6},"low","- Lower bound",{"_19":4643,"_25":4644,"_31":61},"high","- Upper bound (optional)",{"_19":1105,"_25":4646,"_31":61},"- Output shape",[],{"_19":4649,"_21":4650,"_23":4651,"_25":4651,"_26":4652,"_32":4632,"_33":4654},"np.randn","np.randn(args)","Draw samples from a standard normal distribution.",[4653],{"_19":223,"_25":931,"_31":6},[],{"_19":4656,"_21":4657,"_23":4658,"_25":4658,"_26":4659,"_32":4632,"_33":4661},"np.random","np.random(size?)","Return random floats in the half-open interval [0.0, 1.0).",[4660],{"_19":1105,"_25":4646,"_31":61},[],{"_19":4663,"_21":4664,"_23":4637,"_25":4637,"_26":4665,"_32":4632,"_33":4671},"np.random_integers","np.random_integers(low, high?, size?)",[4666,4668,4670],{"_19":4640,"_25":4667,"_31":6},"- Lowest integer (unless high is None, then range is [0, low))",{"_19":4643,"_25":4669,"_31":61},"- Upper bound (exclusive). If None, range is [0, low)",{"_19":1105,"_25":4646,"_31":61},[],{"_19":4673,"_21":4674,"_23":4658,"_25":4658,"_26":4675,"_32":4632,"_33":4677},"np.random_sample","np.random_sample(size?)",[4676],{"_19":1105,"_25":4646,"_31":61},[],{"_19":4679,"_21":4680,"_23":4658,"_25":4658,"_26":4681,"_32":4632,"_33":4683},"np.ranf","np.ranf(size?)",[4682],{"_19":1105,"_25":4646,"_31":61},[],{"_19":4685,"_21":4686,"_23":4687,"_25":4687,"_26":4688,"_32":30,"_33":4690},"np.ravel","np.ravel(a)","Return a contiguous flattened array.",[4689],{"_19":189,"_25":321,"_31":6},[],{"_19":4692,"_21":4693,"_23":4694,"_25":4694,"_26":4695,"_32":1029,"_33":4701},"np.ravelMultiIndex","np.ravelMultiIndex(coords, shape)","Convert a tuple of coordinate arrays into flat indices.",[4696,4699],{"_19":4697,"_25":4698,"_31":6},"coords","- Array of coordinate arrays, one per dimension",{"_19":531,"_25":4700,"_31":6},"- Shape of the array",[],{"_19":4703,"_21":4704,"_23":4705,"_25":4706,"_26":4707,"_32":30,"_33":4709},"np.real","np.real(val)","Return the real part of the complex argument.\r","Return the real part of the complex argument.\r\n\r\nFor non-complex arrays, returns a copy of the input.",[4708],{"_19":56,"_25":321,"_31":6},[],{"_19":4711,"_21":4712,"_23":4713,"_25":4714,"_26":4715,"_32":357,"_33":4719},"np.real_if_close","np.real_if_close(a, tol?)","If input is complex with all imaginary parts close to zero, return real parts.\r","If input is complex with all imaginary parts close to zero, return real parts.\r\n\r\n\"Close to zero\" is defined as `tol` times the machine epsilon of the type.",[4716,4717],{"_19":189,"_25":321,"_31":6},{"_19":3769,"_25":4718,"_31":61},"- Tolerance in machine epsilons for complex128, or absolute\r\n tolerance if tol < 1. Default is 100.",[],{"_19":4721,"_21":4722,"_23":4723,"_25":4723,"_26":4724,"_32":4729,"_33":4730},"np.recArray","np.recArray(data?, options?)","Create a record array.",[4725,4727],{"_19":528,"_25":4726,"_31":61},"- Input data (list of tuples, existing array, or null for empty)",{"_19":534,"_25":4728,"_31":61},"- Creation options","Promise",[],{"_19":4732,"_21":4733,"_23":4734,"_25":4734,"_26":4735,"_32":4729,"_33":4740},"np.recFromarrays","np.recFromarrays(arrayList, options?)","Create a record array from a list of arrays (columns).",[4736,4739],{"_19":4737,"_25":4738,"_31":6},"arrayList","- List of arrays, one per field",{"_19":534,"_25":4728,"_31":61},[],{"_19":4742,"_21":4743,"_23":4744,"_25":4744,"_26":4745,"_32":4729,"_33":4754},"np.recFromfile","np.recFromfile(file, dtype, shape?, offset?)","Create a record array from a file.",[4746,4748,4750,4752],{"_19":2136,"_25":4747,"_31":6},"- File path (Node.js) or File object (browser)",{"_19":196,"_25":4749,"_31":6},"- Structured dtype",{"_19":531,"_25":4751,"_31":61},"- Shape of output array",{"_19":1551,"_25":4753,"_31":61},"- Byte offset into file",[],{"_19":4756,"_21":4757,"_23":4758,"_25":4758,"_26":4759,"_32":4729,"_33":4764},"np.recFromrecords","np.recFromrecords(recList, options?)","Create a record array from a list of records (rows).",[4760,4763],{"_19":4761,"_25":4762,"_31":6},"recList","- List of records (tuples or arrays)",{"_19":534,"_25":4728,"_31":61},[],{"_19":4766,"_21":4767,"_23":4768,"_25":4768,"_26":4769,"_32":4729,"_33":4777},"np.recFromstring","np.recFromstring(datastring, dtype, shape?, offset?)","Create a record array from a binary string/buffer.",[4770,4773,4774,4775],{"_19":4771,"_25":4772,"_31":6},"datastring","- Binary data (ArrayBuffer or typed array)",{"_19":196,"_25":4749,"_31":6},{"_19":531,"_25":4751,"_31":61},{"_19":1551,"_25":4776,"_31":61},"- Byte offset into data",[],{"_19":4779,"_21":4780,"_23":4781,"_25":4781,"_26":4782,"_32":30,"_33":4784},"np.reciprocal","np.reciprocal(x)","Return the reciprocal of the argument, element-wise.",[4783],{"_19":29,"_25":30,"_31":6},[],{"_19":4786,"_21":4787,"_23":4788,"_25":4788,"_26":4789,"_32":30,"_33":4792},"np.remainder","np.remainder(x1, x2)","Return element-wise remainder of division (Python-style modulo).",[4790,4791],{"_19":311,"_25":30,"_31":6},{"_19":313,"_25":30,"_31":6},[],{"_19":4794,"_21":4795,"_23":4796,"_25":4796,"_26":4797,"_32":357,"_33":4804},"np.repeat","np.repeat(arr, repeats, axis?)","Repeat elements of an array.",[4798,4799,4802],{"_19":374,"_25":321,"_31":6},{"_19":4800,"_25":4801,"_31":6},"repeats","- Number of repetitions for each element",{"_19":323,"_25":4803,"_31":61},"- Axis along which to repeat (default: flatten first)",[],{"_19":4806,"_21":4807,"_23":4808,"_25":4808,"_26":4809,"_32":62,"_33":4810},"np.resetPrintoptions","np.resetPrintoptions()","Reset print options to defaults.",[],[],{"_19":4812,"_21":4813,"_23":4814,"_25":4814,"_26":4815,"_32":30,"_33":4821},"np.reshape","np.reshape(a, newshape)","Gives a new shape to an array without changing its data.",[4816,4818],{"_19":189,"_25":4817,"_31":6},"- Array to be reshaped",{"_19":4819,"_25":4820,"_31":6},"newshape","- New shape (can include one -1 for auto-calculation)",[],{"_19":4823,"_21":4824,"_23":4825,"_25":4826,"_26":4827,"_32":357,"_33":4832},"np.resize","np.resize(arr, new_shape)","Return a new array with the specified shape.\r","Return a new array with the specified shape.\r\nIf the new array is larger than the original, it is filled with repeated copies.",[4828,4829],{"_19":374,"_25":321,"_31":6},{"_19":4830,"_25":4831,"_31":6},"new_shape","- Shape of the resized array",[],{"_19":4834,"_21":4835,"_23":4836,"_25":4836,"_26":4837,"_32":1172,"_33":4840},"np.result_type","np.result_type(dtypes)","Return the type that results from applying the type promotion rules to the arguments.",[4838],{"_19":1170,"_25":4839,"_31":6},"- Input dtypes",[],{"_19":4842,"_21":4843,"_23":4844,"_25":4845,"_26":4846,"_32":30,"_33":4852},"np.rfft","np.rfft(a, n?, axis?, norm?)","Compute the one-dimensional discrete Fourier Transform for real input.\r","Compute the one-dimensional discrete Fourier Transform for real input.\r\n\r\nThis function computes the one-dimensional n-point DFT of a real-valued\r\narray. The output is Hermitian-symmetric, so only the positive frequencies\r\nare returned: output has shape (..., n//2 + 1).",[4847,4848,4850,4851],{"_19":189,"_25":2770,"_31":6},{"_19":1516,"_25":4849,"_31":61},"- Number of points in the FFT. If n < a.shape[axis], input is truncated.\r\n If n > a.shape[axis], input is zero-padded.",{"_19":323,"_25":2611,"_31":61},{"_19":1883,"_25":1898,"_31":61},[],{"_19":4854,"_21":4855,"_23":4856,"_25":4856,"_26":4857,"_32":30,"_33":4862},"np.rfft2","np.rfft2(a, s?, axes?, norm?)","Compute the 2-dimensional FFT of a real array.",[4858,4859,4860,4861],{"_19":189,"_25":30,"_31":6},{"_19":1893,"_25":2740,"_31":61},{"_19":406,"_25":2287,"_31":61},{"_19":1883,"_25":2743,"_31":61},[],{"_19":4864,"_21":4865,"_23":4866,"_25":4867,"_26":4868,"_32":357,"_33":4871},"np.rfftfreq","np.rfftfreq(n, d?)","Return the Discrete Fourier Transform sample frequencies for rfft.\r","Return the Discrete Fourier Transform sample frequencies for rfft.\r\n\r\nReturns an array of length n//2 + 1 with the positive sample frequencies:\r\nf = [0, 1, ..., n//2] / (d*n)",[4869,4870],{"_19":1516,"_25":1907,"_31":6},{"_19":1909,"_25":1910,"_31":61},[],{"_19":4873,"_21":4874,"_23":4875,"_25":4876,"_26":4877,"_32":30,"_33":4882},"np.rfftn","np.rfftn(a, s?, axes?, norm?)","Compute the N-dimensional discrete Fourier Transform for real input.\r","Compute the N-dimensional discrete Fourier Transform for real input.\r\n\r\nThe output has Hermitian symmetry along the last transformed axis.\r\nOutput shape along the last axis: s[-1]//2 + 1",[4878,4879,4880,4881],{"_19":189,"_25":30,"_31":6},{"_19":1893,"_25":2448,"_31":61},{"_19":406,"_25":2448,"_31":61},{"_19":1883,"_25":2743,"_31":61},[],{"_19":4884,"_21":4885,"_23":4886,"_25":4886,"_26":4887,"_32":30,"_33":4896},"np.rfind","np.rfind(a, sub, start?, end?)","For each element, return the highest index where substring is found.",[4888,4889,4892,4894],{"_19":189,"_25":1770,"_31":6},{"_19":4890,"_25":4891,"_31":6},"sub","- Substring to search for",{"_19":415,"_25":4893,"_31":61},"- Start position for search (default 0)",{"_19":418,"_25":4895,"_31":61},"- End position for search (default string length)",[],{"_19":4898,"_21":4899,"_23":4900,"_25":4900,"_26":4901,"_32":30,"_33":4904},"np.right_shift","np.right_shift(x1, x2)","Shift the bits of an integer to the right.",[4902,4903],{"_19":311,"_25":30,"_31":6},{"_19":313,"_25":30,"_31":6},[],{"_19":4906,"_21":4907,"_23":4908,"_25":4908,"_26":4909,"_32":30,"_33":4914},"np.rindex","np.rindex(a, sub, start?, end?)","Like rfind, but raises ValueError if substring is not found.",[4910,4911,4912,4913],{"_19":189,"_25":1770,"_31":6},{"_19":4890,"_25":4891,"_31":6},{"_19":415,"_25":4893,"_31":61},{"_19":418,"_25":4895,"_31":61},[],{"_19":4916,"_21":4917,"_23":4918,"_25":4918,"_26":4919,"_32":30,"_33":4921},"np.rint","np.rint(x)","Round elements of the array to the nearest integer.",[4920],{"_19":29,"_25":30,"_31":6},[],{"_19":4923,"_21":4924,"_23":4925,"_25":4925,"_26":4926,"_32":30,"_33":4930},"np.rjust","np.rjust(a, width, fillchar?)","Return element-wise right-justified string of given width.",[4927,4928,4929],{"_19":189,"_25":1770,"_31":6},{"_19":753,"_25":3524,"_31":6},{"_19":3526,"_25":3527,"_31":61},[],{"_19":4932,"_21":4933,"_23":4934,"_25":4934,"_26":4935,"_32":30,"_33":4942},"np.roll","np.roll(arr, shift, axis?)","Roll array elements along a given axis.",[4936,4937,4940],{"_19":374,"_25":321,"_31":6},{"_19":4938,"_25":4939,"_31":6},"shift","- Number of places to shift elements",{"_19":323,"_25":4941,"_31":61},"- Axis along which to roll (default: flatten, roll, reshape)",[],{"_19":4944,"_21":4945,"_23":4946,"_25":4946,"_26":4947,"_32":30,"_33":4953},"np.rollaxis","np.rollaxis(a, axis, start?)","Roll the specified axis backwards, until it lies in a given position.",[4948,4949,4951],{"_19":189,"_25":321,"_31":6},{"_19":323,"_25":4950,"_31":6},"- The axis to be rolled",{"_19":415,"_25":4952,"_31":61},"- Start position (default: 0)",[],{"_19":4955,"_21":4956,"_23":4957,"_25":4958,"_26":4959,"_32":1029,"_33":4962},"np.roots","np.roots(p)","Find the roots of a polynomial with coefficients given in c.\r","Find the roots of a polynomial with coefficients given in c.\r\n\r\nThis is a NumPy legacy function. The coefficients are given in descending\r\npowers order (highest power first), which is the opposite of the numpy.polynomial\r\nmodule convention.\r\n\r\nNOTE: This is the legacy numpy.roots function. For the modern API, use\r\npolyroots() from the polynomial module which uses ascending powers order.",[4960],{"_19":1111,"_25":4961,"_31":6},"- Coefficient array in descending powers order [c_n, c_{n-1}, ..., c_1, c_0]",[],{"_19":4964,"_21":4965,"_23":4966,"_25":4966,"_26":4967,"_32":30,"_33":4974},"np.rot90","np.rot90(arr, k?, axes?)","Rotate an array by 90 degrees in the plane specified by axes.",[4968,4970,4972],{"_19":374,"_25":4969,"_31":6},"- Array with at least 2 dimensions",{"_19":1010,"_25":4971,"_31":61},"- Number of times to rotate by 90 degrees (default: 1)",{"_19":406,"_25":4973,"_31":61},"- The two axes that define the plane of rotation (default: [0, 1])",[],{"_19":4976,"_21":4977,"_23":4978,"_25":4978,"_26":4979,"_32":30,"_33":4981},"np.round","np.round(x)","Round to nearest even value (banker's rounding).",[4980],{"_19":29,"_25":30,"_31":6},[],{"_19":4983,"_21":4984,"_23":4985,"_25":4985,"_26":4986,"_32":30,"_33":4990},"np.rpartition","np.rpartition(a, sep)","Partition each element around the last occurrence of sep.",[4987,4988],{"_19":189,"_25":1770,"_31":6},{"_19":2206,"_25":4989,"_31":6},"- Separator string",[],{"_19":4992,"_21":4993,"_23":4994,"_25":4994,"_26":4995,"_32":30,"_33":4998},"np.rstrip","np.rstrip(a, chars?)","Return element-wise copy with trailing characters removed.",[4996,4997],{"_19":189,"_25":1770,"_31":6},{"_19":3671,"_25":3672,"_31":61},[],{"_19":5000,"_21":5001,"_23":4658,"_25":4658,"_26":5002,"_32":4632,"_33":5004},"np.sample","np.sample(size?)",[5003],{"_19":1105,"_25":4646,"_31":61},[],{"_19":5006,"_21":5007,"_23":5008,"_25":5008,"_26":5009,"_32":5016,"_33":5017},"np.save","np.save(file, arr, _options?)","Save an array to a binary file in NPY format.",[5010,5012,5014],{"_19":2136,"_25":5011,"_31":6},"- File path (Node.js), FileSystemFileHandle (browser), or null to return ArrayBuffer",{"_19":374,"_25":5013,"_31":6},"- Array to save",{"_19":3537,"_25":5015,"_31":61},"SaveOptions","Promise",[],{"_19":5019,"_21":5020,"_23":5021,"_25":5021,"_26":5022,"_32":1947,"_33":5029},"np.savetxt","np.savetxt(file, arr, options?)","Save an array to a text file.",[5023,5025,5027],{"_19":2136,"_25":5024,"_31":6},"- Output file (path or FileSystemFileHandle)",{"_19":374,"_25":5026,"_31":6},"- 1D or 2D array to save",{"_19":534,"_25":5028,"_31":61},"- Formatting options",[],{"_19":5031,"_21":5032,"_23":5033,"_25":5034,"_26":5035,"_32":5016,"_33":5039},"np.savez","np.savez(file, args)","Save multiple arrays to a single file in uncompressed `.npz` format.\r","Save multiple arrays to a single file in uncompressed `.npz` format.\r\n\r\nThe `.npz` file format is a ZIP archive containing multiple `.npy` files,\r\none for each array. Arrays are named 'arr_0', 'arr_1', etc. for positional\r\narguments, or by their keyword argument names.",[5036,5037],{"_19":2136,"_25":5011,"_31":6},{"_19":223,"_25":5038,"_31":6},"- Arrays to save (positional) or object mapping names to arrays",[],{"_19":5041,"_21":5042,"_23":5043,"_25":5044,"_26":5045,"_32":5016,"_33":5048},"np.savez_compressed","np.savez_compressed(file, args)","Save multiple arrays to a single file in compressed `.npz` format.\r","Save multiple arrays to a single file in compressed `.npz` format.\r\n\r\nSimilar to `savez`, but each array is individually compressed using DEFLATE.\r\nThis can significantly reduce file size for sparse or repetitive data.",[5046,5047],{"_19":2136,"_25":5011,"_31":6},{"_19":223,"_25":5038,"_31":6},[],{"_19":5050,"_21":5051,"_23":5052,"_25":5052,"_26":5053,"_32":477,"_33":5060},"np.searchsorted","np.searchsorted(a, v, side?)","Find indices where elements should be inserted to maintain order.",[5054,5056,5057],{"_19":189,"_25":5055,"_31":6},"- Sorted 1D input array",{"_19":1273,"_25":2835,"_31":6},{"_19":5058,"_25":5059,"_31":61},"side","- 'left' or 'right' side to insert",[],{"_19":5062,"_21":5063,"_23":5064,"_25":5064,"_26":5065,"_32":62,"_33":5068},"np.seed","np.seed(seed)","Seed the default random generator.",[5066],{"_19":1459,"_25":5067,"_31":6},"- Seed value",[],{"_19":5070,"_21":5071,"_23":5072,"_25":5072,"_26":5073,"_32":357,"_33":5082},"np.select","np.select(condlist, choicelist, defaultValue?)","Return an array drawn from elements in choicelist, depending on conditions.",[5074,5076,5079],{"_19":4281,"_25":5075,"_31":6},"- List of boolean arrays (conditions)",{"_19":5077,"_25":5078,"_31":6},"choicelist","- List of arrays from which output elements are taken",{"_19":5080,"_25":5081,"_31":61},"defaultValue","- Value used when all conditions are False (default: 0)",[],{"_19":5084,"_21":5085,"_23":5086,"_25":5087,"_26":5088,"_32":357,"_33":5092},"np.setdiff1d","np.setdiff1d(ar1, ar2, options?)","Find the set difference of two arrays.\r","Find the set difference of two arrays.\r\n\r\nReturns the sorted unique values in ar1 that are not in ar2.",[5089,5090,5091],{"_19":2789,"_25":2866,"_31":6},{"_19":2792,"_25":2868,"_31":6},{"_19":534,"_25":1685,"_31":61},[],{"_19":5094,"_21":5095,"_23":5096,"_25":5096,"_26":5097,"_32":62,"_33":5100},"np.setPrintoptions","np.setPrintoptions(options)","Set printing options globally.",[5098],{"_19":534,"_25":5099,"_31":6},"- New print options (partial, merged with current)",[],{"_19":5102,"_21":5103,"_23":5104,"_25":5105,"_26":5106,"_32":357,"_33":5110},"np.setxor1d","np.setxor1d(ar1, ar2, options?)","Find the set exclusive-or of two arrays.\r","Find the set exclusive-or of two arrays.\r\n\r\nReturns the sorted unique values in exactly one (not both) of the input arrays.",[5107,5108,5109],{"_19":2789,"_25":2866,"_31":6},{"_19":2792,"_25":2868,"_31":6},{"_19":534,"_25":1685,"_31":61},[],{"_19":5112,"_21":5113,"_23":5114,"_25":5114,"_26":5115,"_32":343,"_33":5118},"np.shapesAreBroadcastable","np.shapesAreBroadcastable(shape1, shape2)","Check if two shapes are broadcast-compatible.",[5116,5117],{"_19":844,"_25":845,"_31":6},{"_19":847,"_25":848,"_31":6},[],{"_19":5120,"_21":5121,"_23":5122,"_25":5122,"_26":5123,"_32":1947,"_33":5128},"np.shuffle","np.shuffle(x, axis?)","Randomly shuffle elements of an array in-place along an axis.",[5124,5126],{"_19":29,"_25":5125,"_31":6},"- Array to shuffle (modified in-place)",{"_19":323,"_25":5127,"_31":61},"- Axis along which to shuffle (default 0)",[],{"_19":5130,"_21":5131,"_23":5132,"_25":5132,"_26":5133,"_32":30,"_33":5135},"np.sign","np.sign(x)","Returns element-wise sign: -1, 0, or +1.",[5134],{"_19":29,"_25":30,"_31":6},[],{"_19":5137,"_21":5138,"_23":5139,"_25":5139,"_26":5140,"_32":30,"_33":5142},"np.signbit","np.signbit(x)","Return element-wise True where signbit is set (less than zero).",[5141],{"_19":29,"_25":30,"_31":6},[],{"_19":5144,"_21":5145,"_23":5146,"_25":5146,"_26":5147,"_32":30,"_33":5149},"np.sin","np.sin(x)","Trigonometric sine, element-wise.",[5148],{"_19":29,"_25":30,"_31":6},[],{"_19":5151,"_21":5152,"_23":5153,"_25":5154,"_26":5155,"_32":30,"_33":5157},"np.sinc","np.sinc(x)","Return the normalized sinc function: sin(pi*x) / (pi*x).\r","Return the normalized sinc function: sin(pi*x) / (pi*x).\r\nThe sinc function is used in various signal processing applications.",[5156],{"_19":29,"_25":321,"_31":6},[],{"_19":5159,"_21":5160,"_23":5161,"_25":5161,"_26":5162,"_32":30,"_33":5164},"np.sinh","np.sinh(x)","Hyperbolic sine, element-wise.",[5163],{"_19":29,"_25":30,"_31":6},[],{"_19":5166,"_21":5167,"_23":5168,"_25":5168,"_26":5169,"_32":5176,"_33":5177},"np.slice","np.slice(start?, stop?, step?)","Factory function for creating slices with cleaner syntax.",[5170,5172,5174],{"_19":415,"_25":5171,"_31":61},"- Start index (null for default)",{"_19":2261,"_25":5173,"_31":61},"- Stop index (null for default)",{"_19":421,"_25":5175,"_31":61},"- Step size (null for 1)","Slice",[],{"_19":5179,"_21":5180,"_23":5181,"_25":5182,"_26":5183,"_32":5185,"_33":5186},"np.slogdet","np.slogdet(a)","Compute sign and (natural) logarithm of the determinant.\r","Compute sign and (natural) logarithm of the determinant.\r\nMore numerically stable than computing det directly for large matrices.",[5184],{"_19":189,"_25":30,"_31":6},"Promise",[],{"_19":5188,"_21":5189,"_23":5190,"_25":5190,"_26":5191,"_32":357,"_33":5196},"np.solve","np.solve(a, b)","Solve a linear matrix equation: a @ x = b",[5192,5194],{"_19":189,"_25":5193,"_31":6},"- Coefficient matrix (N x N)",{"_19":191,"_25":5195,"_31":6},"- Ordinate values (N,) or (N x NRHS)",[],{"_19":5198,"_21":5199,"_23":5200,"_25":5200,"_26":5201,"_32":357,"_33":5206},"np.sort","np.sort(a, axis?, kind?)","Return a sorted copy of an array.",[5202,5203,5204],{"_19":189,"_25":508,"_31":6},{"_19":323,"_25":510,"_31":61},{"_19":512,"_25":5205,"_31":61},"- Sorting algorithm: 'quicksort', 'mergesort', 'heapsort', or 'stable'",[],{"_19":5208,"_21":5209,"_23":5210,"_25":5211,"_26":5212,"_32":30,"_33":5214},"np.sort_complex","np.sort_complex(a)","Sort a complex array using the real part first, then the imaginary part.\r","Sort a complex array using the real part first, then the imaginary part.\r\n\r\nThe input array is flattened before sorting. Non-complex arrays are\r\nconverted to complex in the output.",[5213],{"_19":189,"_25":2790,"_31":6},[],{"_19":5216,"_21":5217,"_23":5218,"_25":5219,"_26":5220,"_32":30,"_33":5222},"np.spacing","np.spacing(x)","Return the distance between x and the nearest adjacent number.\r","Return the distance between x and the nearest adjacent number.\r\nThis is effectively the ulp (unit in the last place) of x.",[5221],{"_19":29,"_25":2355,"_31":6},[],{"_19":5224,"_21":5225,"_23":5226,"_25":5227,"_26":5228,"_32":581,"_33":5233},"np.split","np.split(arr, indices_or_sections, axis?)","Split an array into multiple sub-arrays of equal size.\r","Split an array into multiple sub-arrays of equal size.\r\nRaises error if array cannot be split into equal sections.",[5229,5230,5232],{"_19":374,"_25":575,"_31":6},{"_19":577,"_25":5231,"_31":6},"- Number of equal sections or split indices",{"_19":323,"_25":580,"_31":61},[],{"_19":5235,"_21":5236,"_23":5237,"_25":5237,"_26":5238,"_32":30,"_33":5240},"np.sqrt","np.sqrt(x)","Return the non-negative square-root of an array, element-wise.",[5239],{"_19":29,"_25":30,"_31":6},[],{"_19":5242,"_21":5243,"_23":5244,"_25":5244,"_26":5245,"_32":30,"_33":5247},"np.square","np.square(x)","Return the element-wise square of the input.",[5246],{"_19":29,"_25":30,"_31":6},[],{"_19":5249,"_21":5250,"_23":5251,"_25":5251,"_26":5252,"_32":30,"_33":5256},"np.squeeze","np.squeeze(a, axis?)","Remove axes of length one from array.",[5253,5254],{"_19":189,"_25":321,"_31":6},{"_19":323,"_25":5255,"_31":61},"- Specific axis to squeeze (optional, -1 for all size-1 axes)",[],{"_19":5258,"_21":5259,"_23":5260,"_25":5260,"_26":5261,"_32":30,"_33":5266},"np.stack","np.stack(arrays, axis?)","Join a sequence of arrays along a new axis.",[5262,5264],{"_19":825,"_25":5263,"_31":6},"- Sequence of arrays with the same shape",{"_19":323,"_25":5265,"_31":61},"- The axis in the result along which to stack (default: 0)",[],{"_19":5268,"_21":5269,"_23":5270,"_25":5270,"_26":5271,"_32":30,"_33":5278},"np.startswith","np.startswith(a, prefix, start?, end?)","Return true for each element if the string starts with prefix.",[5272,5273,5276,5277],{"_19":189,"_25":1770,"_31":6},{"_19":5274,"_25":5275,"_31":6},"prefix","- Prefix to check",{"_19":415,"_25":1785,"_31":61},{"_19":418,"_25":1787,"_31":61},[],{"_19":5280,"_21":5281,"_23":5282,"_25":5282,"_26":5283,"_32":477,"_33":5292},"np.std","np.std(a, axis?, ddof?, keepdims?, dtype?)","Compute the standard deviation along the specified axis.",[5284,5285,5287,5289,5290],{"_19":189,"_25":321,"_31":6},{"_19":323,"_25":5286,"_31":61},"- Axis along which to compute std. null computes std of all elements.",{"_19":1370,"_25":5288,"_31":61},"- Delta Degrees of Freedom. Divisor is N - ddof. Default: 0",{"_19":326,"_25":476,"_31":61},{"_19":196,"_25":5291,"_31":61},"- Output dtype",[],{"_19":5294,"_21":5295,"_23":5296,"_25":5296,"_26":5297,"_32":30,"_33":5299},"np.str_len","np.str_len(a)","Return the length of each element.",[5298],{"_19":189,"_25":1770,"_31":6},[],{"_19":5301,"_21":5302,"_23":5303,"_25":5303,"_26":5304,"_32":30,"_33":5307},"np.strAdd","np.strAdd(x1, x2)","Return element-wise string concatenation.",[5305,5306],{"_19":311,"_25":1187,"_31":6},{"_19":313,"_25":1189,"_31":6},[],{"_19":5309,"_21":5310,"_23":5311,"_25":5311,"_26":5312,"_32":30,"_33":5314},"np.strCapitalize","np.strCapitalize(a)","Return element-wise copy with first character capitalized and rest lowercase.",[5313],{"_19":189,"_25":1770,"_31":6},[],{"_19":5316,"_21":5317,"_23":5318,"_25":5318,"_26":5319,"_32":30,"_33":5323},"np.strCenter","np.strCenter(a, width, fillchar?)","Return element-wise centered string of given width.",[5320,5321,5322],{"_19":189,"_25":1770,"_31":6},{"_19":753,"_25":3524,"_31":6},{"_19":3526,"_25":3527,"_31":61},[],{"_19":5325,"_21":5326,"_23":5327,"_25":5327,"_26":5328,"_32":30,"_33":5334},"np.strCount","np.strCount(a, sub, start?, end?)","Return the number of non-overlapping occurrences of substring.",[5329,5330,5332,5333],{"_19":189,"_25":1770,"_31":6},{"_19":4890,"_25":5331,"_31":6},"- Substring to count",{"_19":415,"_25":4893,"_31":61},{"_19":418,"_25":4895,"_31":61},[],{"_19":5336,"_21":5337,"_23":5338,"_25":5338,"_26":5339,"_32":30,"_33":5344},"np.strEqual","np.strEqual(x1, x2)","Return (x1 == x2) element-wise for string arrays.",[5340,5342],{"_19":311,"_25":5341,"_31":6},"- First string array or JS string array",{"_19":313,"_25":5343,"_31":6},"- Second string array or JS string array",[],{"_19":5346,"_21":5347,"_23":5348,"_25":5348,"_26":5349,"_32":30,"_33":5354},"np.strFind","np.strFind(a, sub, start?, end?)","For each element, return the lowest index where substring is found.",[5350,5351,5352,5353],{"_19":189,"_25":1770,"_31":6},{"_19":4890,"_25":4891,"_31":6},{"_19":415,"_25":4893,"_31":61},{"_19":418,"_25":4895,"_31":61},[],{"_19":5356,"_21":5357,"_23":5358,"_25":5359,"_26":5360,"_32":30,"_33":5363},"np.strGreater","np.strGreater(x1, x2)","Return (x1 > x2) element-wise for string arrays.\r","Return (x1 > x2) element-wise for string arrays.\r\nComparison is lexicographic.",[5361,5362],{"_19":311,"_25":1187,"_31":6},{"_19":313,"_25":1189,"_31":6},[],{"_19":5365,"_21":5366,"_23":5367,"_25":5368,"_26":5369,"_32":30,"_33":5372},"np.strGreaterEqual","np.strGreaterEqual(x1, x2)","Return (x1 >= x2) element-wise for string arrays.\r","Return (x1 >= x2) element-wise for string arrays.\r\nComparison is lexicographic.",[5370,5371],{"_19":311,"_25":1187,"_31":6},{"_19":313,"_25":1189,"_31":6},[],{"_19":5374,"_21":5375,"_23":5376,"_25":5376,"_26":5377,"_32":30,"_33":5382},"np.strIndex","np.strIndex(a, sub, start?, end?)","Like find, but raises ValueError if substring is not found.",[5378,5379,5380,5381],{"_19":189,"_25":1770,"_31":6},{"_19":4890,"_25":4891,"_31":6},{"_19":415,"_25":4893,"_31":61},{"_19":418,"_25":4895,"_31":61},[],{"_19":5384,"_21":5385,"_23":5386,"_25":5386,"_26":5387,"_32":30,"_33":5390},"np.strip","np.strip(a, chars?)","Return element-wise copy with leading and trailing characters removed.",[5388,5389],{"_19":189,"_25":1770,"_31":6},{"_19":3671,"_25":3672,"_31":61},[],{"_19":5392,"_21":5393,"_23":5394,"_25":5395,"_26":5396,"_32":30,"_33":5399},"np.strLess","np.strLess(x1, x2)","Return (x1 < x2) element-wise for string arrays.\r","Return (x1 < x2) element-wise for string arrays.\r\nComparison is lexicographic (dictionary order).",[5397,5398],{"_19":311,"_25":1187,"_31":6},{"_19":313,"_25":1189,"_31":6},[],{"_19":5401,"_21":5402,"_23":5403,"_25":5404,"_26":5405,"_32":30,"_33":5408},"np.strLessEqual","np.strLessEqual(x1, x2)","Return (x1 <= x2) element-wise for string arrays.\r","Return (x1 <= x2) element-wise for string arrays.\r\nComparison is lexicographic.",[5406,5407],{"_19":311,"_25":1187,"_31":6},{"_19":313,"_25":1189,"_31":6},[],{"_19":5410,"_21":5411,"_23":5412,"_25":5413,"_26":5414,"_32":30,"_33":5419},"np.strMod","np.strMod(a, values)","Return element-wise (a % i), i.e. string formatting.\r","Return element-wise (a % i), i.e. string formatting.\r\n\r\nThis is the printf-style string formatting operation.\r\nEach string in `a` is interpreted as a format string,\r\nand the corresponding values in `values` are substituted.",[5415,5417],{"_19":189,"_25":5416,"_31":6},"- Input format string array",{"_19":376,"_25":5418,"_31":6},"- Values to substitute (array or single value)",[],{"_19":5421,"_21":5422,"_23":5423,"_25":5423,"_26":5424,"_32":30,"_33":5429},"np.strMultiply","np.strMultiply(a, i)","Return element-wise (a * i), string repeated i times.",[5425,5426],{"_19":189,"_25":1770,"_31":6},{"_19":5427,"_25":5428,"_31":6},"i","- Number of repetitions (or array of repetition counts)",[],{"_19":5431,"_21":5432,"_23":5433,"_25":5433,"_26":5434,"_32":30,"_33":5437},"np.strNotEqual","np.strNotEqual(x1, x2)","Return (x1 != x2) element-wise for string arrays.",[5435,5436],{"_19":311,"_25":1187,"_31":6},{"_19":313,"_25":1189,"_31":6},[],{"_19":5439,"_21":5440,"_23":5441,"_25":5441,"_26":5442,"_32":30,"_33":5445},"np.strPartition","np.strPartition(a, sep)","Partition each element around the first occurrence of sep.",[5443,5444],{"_19":189,"_25":1770,"_31":6},{"_19":2206,"_25":4989,"_31":6},[],{"_19":5447,"_21":5448,"_23":5449,"_25":5449,"_26":5450,"_32":30,"_33":5458},"np.strReplace","np.strReplace(a, old, new_, count?)","Return element-wise copy with occurrences of old replaced by new.",[5451,5452,5454,5456],{"_19":189,"_25":1770,"_31":6},{"_19":3696,"_25":5453,"_31":6},"- Substring to replace",{"_19":3699,"_25":5455,"_31":6},"- Replacement string",{"_19":2209,"_25":5457,"_31":61},"- Maximum replacements per element (-1 for all)",[],{"_19":5460,"_21":5461,"_23":5462,"_25":5463,"_26":5464,"_32":30,"_33":5472},"np.strSlice","np.strSlice(a, start?, stop?, step?)","Return element-wise sliced strings.\r","Return element-wise sliced strings.\r\n\r\nThis is the NumPy 2.0 string slicing function, providing\r\nPython-style string slicing for each element.",[5465,5466,5468,5470],{"_19":189,"_25":1770,"_31":6},{"_19":415,"_25":5467,"_31":61},"- Start index (default 0)",{"_19":2261,"_25":5469,"_31":61},"- Stop index (default: end of string)",{"_19":421,"_25":5471,"_31":61},"- Step size (default 1)",[],{"_19":5474,"_21":5475,"_23":5476,"_25":5477,"_26":5478,"_32":30,"_33":5480},"np.strTitle","np.strTitle(a)","Return element-wise titlecased version.\r","Return element-wise titlecased version.\r\nWords start with uppercase, remaining characters are lowercase.",[5479],{"_19":189,"_25":1770,"_31":6},[],{"_19":5482,"_21":5483,"_23":5484,"_25":5485,"_26":5486,"_32":30,"_33":5494},"np.strTranslate","np.strTranslate(a, table, deletechars?)","Return element-wise translation of string using a translation table.\r","Return element-wise translation of string using a translation table.\r\n\r\nEach character in the string is mapped through the translation table.\r\nCharacters not in the table are left unchanged.",[5487,5488,5491],{"_19":189,"_25":1770,"_31":6},{"_19":5489,"_25":5490,"_31":6},"table","- Translation table as a Map, object, or string pairs",{"_19":5492,"_25":5493,"_31":61},"deletechars","- Characters to delete (optional)",[],{"_19":5496,"_21":5497,"_23":5498,"_25":5498,"_26":5499,"_32":198,"_33":5501},"np.structDtypeSize","np.structDtypeSize(dtype)","Get byte size for a given dtype.",[5500],{"_19":196,"_25":1172,"_31":6},[],{"_19":5503,"_21":5504,"_23":5505,"_25":5505,"_26":5506,"_32":30,"_33":5509},"np.subtract","np.subtract(x1, x2)","Subtract arguments, element-wise.",[5507,5508],{"_19":311,"_25":30,"_31":6},{"_19":313,"_25":30,"_31":6},[],{"_19":5511,"_21":5512,"_23":5513,"_25":5513,"_26":5514,"_32":477,"_33":5520},"np.sum","np.sum(a, axis?, keepdims?, dtype?)","Sum of array elements over a given axis.",[5515,5516,5518,5519],{"_19":189,"_25":321,"_31":6},{"_19":323,"_25":5517,"_31":61},"- Axis along which to sum. null sums all elements.",{"_19":326,"_25":476,"_31":61},{"_19":196,"_25":3820,"_31":61},[],{"_19":5522,"_21":5523,"_23":5524,"_25":5524,"_26":5525,"_32":5531,"_33":5532},"np.svd","np.svd(a, fullMatrices?)","Singular Value Decomposition.",[5526,5528],{"_19":189,"_25":5527,"_31":6},"- Matrix to decompose (M x N)",{"_19":5529,"_25":5530,"_31":61},"fullMatrices","- If true, U and Vh have full shapes (M x M) and (N x N)\r\n If false, shapes are reduced (M x K) and (K x N)","Promise",[],{"_19":5534,"_21":5535,"_23":5536,"_25":5536,"_26":5537,"_32":357,"_33":5539},"np.svdvals","np.svdvals(a)","Return singular values only.",[5538],{"_19":189,"_25":30,"_31":6},[],{"_19":5541,"_21":5542,"_23":5543,"_25":5543,"_26":5544,"_32":30,"_33":5550},"np.swapaxes","np.swapaxes(a, axis1, axis2)","Interchange two axes of an array.",[5545,5546,5548],{"_19":189,"_25":321,"_31":6},{"_19":1554,"_25":5547,"_31":6},"- First axis",{"_19":1556,"_25":5549,"_31":6},"- Second axis",[],{"_19":5552,"_21":5553,"_23":5554,"_25":5554,"_26":5555,"_32":30,"_33":5557},"np.swapcase","np.swapcase(a)","Return element-wise copy with uppercase and lowercase swapped.",[5556],{"_19":189,"_25":1770,"_31":6},[],{"_19":5559,"_21":5560,"_23":5561,"_25":5561,"_26":5562,"_32":357,"_33":5569},"np.take","np.take(arr, indices, axis?, mode?)","Take elements from an array along an axis.",[5563,5564,5566,5568],{"_19":374,"_25":1303,"_31":6},{"_19":878,"_25":5565,"_31":6},"- Array of indices to take",{"_19":323,"_25":5567,"_31":61},"- Axis along which to take (default: 0)",{"_19":1137,"_25":1138,"_31":61},[],{"_19":5571,"_21":5572,"_23":5573,"_25":5573,"_26":5574,"_32":357,"_33":5579},"np.take_along_axis","np.take_along_axis(arr, indicesArr, axis)","Take values from the input array by matching 1d index and data slices.",[5575,5576,5577],{"_19":374,"_25":1303,"_31":6},{"_19":4580,"_25":30,"_31":6},{"_19":323,"_25":5578,"_31":6},"- The axis to take along",[],{"_19":5581,"_21":5582,"_23":5583,"_25":5583,"_26":5584,"_32":357,"_33":5589},"np.takeFlat","np.takeFlat(arr, indices, mode?)","Take elements from a flattened array.",[5585,5587,5588],{"_19":374,"_25":5586,"_31":6},"- Source array (will be flattened conceptually)",{"_19":878,"_25":4567,"_31":6},{"_19":1137,"_25":1138,"_31":61},[],{"_19":5591,"_21":5592,"_23":5593,"_25":5593,"_26":5594,"_32":30,"_33":5596},"np.tan","np.tan(x)","Compute tangent element-wise.",[5595],{"_19":29,"_25":30,"_31":6},[],{"_19":5598,"_21":5599,"_23":5600,"_25":5600,"_26":5601,"_32":30,"_33":5603},"np.tanh","np.tanh(x)","Compute hyperbolic tangent element-wise.",[5602],{"_19":29,"_25":30,"_31":6},[],{"_19":5605,"_21":5606,"_23":5607,"_25":5608,"_26":5609,"_32":357,"_33":5616},"np.tensordot","np.tensordot(a, b, axes?)","Compute tensor dot product along specified axes.\r","Compute tensor dot product along specified axes.\r\n\r\nFor tensors a and b, tensordot(a, b, axes) computes the sum of products\r\nover the specified axes.",[5610,5612,5614],{"_19":189,"_25":5611,"_31":6},"- First tensor",{"_19":191,"_25":5613,"_31":6},"- Second tensor",{"_19":406,"_25":5615,"_31":61},"- Axes to sum over:\r\n- number N: last N axes of a with first N axes of b\r\n- [axesA, axesB]: specific axes for each tensor",[],{"_19":5618,"_21":5619,"_23":5620,"_25":5621,"_26":5622,"_32":357,"_33":5628},"np.tensorinv","np.tensorinv(a, ind?)","Compute the 'inverse' of an N-dimensional array.\r","Compute the 'inverse' of an N-dimensional array.\r\n\r\nThe result is an inverse for a with respect to the tensordot operation\r\ntensordot(a, b, ind).",[5623,5625],{"_19":189,"_25":5624,"_31":6},"- Tensor to pseudo-invert",{"_19":5626,"_25":5627,"_31":61},"ind","- Number of first indices that are involved in the inverse sum",[],{"_19":5630,"_21":5631,"_23":5632,"_25":5633,"_26":5634,"_32":357,"_33":5641},"np.tensorsolve","np.tensorsolve(a, b, axes?)","Solve the tensor equation a x = b for x.\r","Solve the tensor equation a x = b for x.\r\n\r\nIt is assumed that all indices of x are summed over in the product,\r\ntogether with the rightmost indices of a.",[5635,5637,5639],{"_19":189,"_25":5636,"_31":6},"- Coefficient tensor",{"_19":191,"_25":5638,"_31":6},"- Right-hand side tensor",{"_19":406,"_25":5640,"_31":61},"- Axes in a to reorder to the right, for the solve",[],{"_19":5643,"_21":5644,"_23":5645,"_25":5645,"_26":5646,"_32":357,"_33":5651},"np.tile","np.tile(arr, reps)","Construct an array by repeating arr the number of times given by reps.",[5647,5648],{"_19":374,"_25":321,"_31":6},{"_19":5649,"_25":5650,"_31":6},"reps","- Number of repetitions along each axis",[],{"_19":5653,"_21":5654,"_23":5655,"_25":5655,"_26":5656,"_32":1244,"_33":5661},"np.trace","np.trace(a, offset?, axis1?, axis2?)","Return the sum along diagonals of the array.",[5657,5658,5659,5660],{"_19":189,"_25":30,"_31":6},{"_19":1551,"_25":198,"_31":61},{"_19":1554,"_25":198,"_31":61},{"_19":1556,"_25":198,"_31":61},[],{"_19":5663,"_21":5664,"_23":5665,"_25":5665,"_26":5666,"_32":30,"_33":5669},"np.transpose","np.transpose(a, axes?)","Reverse or permute the axes of an array.",[5667,5668],{"_19":189,"_25":321,"_31":6},{"_19":406,"_25":4270,"_31":61},[],{"_19":5671,"_21":5672,"_23":5673,"_25":5674,"_26":5675,"_32":477,"_33":5685},"np.trapezoid","np.trapezoid(y, x?, dx?, axis?)","Integrate along the given axis using the composite trapezoidal rule.\r","Integrate along the given axis using the composite trapezoidal rule.\r\n\r\nIf x is provided, the integration happens in sequence along its elements.\r\nOtherwise, the default sample distance of 1 is used.",[5676,5678,5680,5683],{"_19":135,"_25":5677,"_31":6},"- Array to be integrated",{"_19":29,"_25":5679,"_31":61},"- The sample points corresponding to y values. If null, dx is used.",{"_19":5681,"_25":5682,"_31":61},"dx","- Spacing between sample points when x is null. Default is 1.",{"_19":323,"_25":5684,"_31":61},"- Axis along which to integrate",[],{"_19":5687,"_21":5688,"_23":5689,"_25":5689,"_26":5690,"_32":357,"_33":5695},"np.tri","np.tri(N, M?, k?, options?)","Create a 2D array with ones at and below the given diagonal.",[5691,5692,5693,5694],{"_19":1863,"_25":1864,"_31":6},{"_19":715,"_25":1866,"_31":61},{"_19":1010,"_25":1508,"_31":61},{"_19":534,"_25":535,"_31":61},[],{"_19":5697,"_21":5698,"_23":5699,"_25":5700,"_26":5701,"_32":357,"_33":5705},"np.tril","np.tril(arr, k?)","Lower triangle of an array.\r","Lower triangle of an array.\r\n\r\nReturn a copy of an array with elements above the k-th diagonal zeroed.",[5702,5703],{"_19":374,"_25":321,"_31":6},{"_19":1010,"_25":5704,"_31":61},"- Diagonal above which to zero elements (default: 0)",[],{"_19":5707,"_21":5708,"_23":5709,"_25":5709,"_26":5710,"_32":3724,"_33":5715},"np.tril_indices","np.tril_indices(n, k?, m?)","Return the indices for the lower-triangle of an (n, m) array.",[5711,5712,5713],{"_19":1516,"_25":1864,"_31":6},{"_19":1010,"_25":1868,"_31":61},{"_19":958,"_25":5714,"_31":61},"- Number of columns (default: n)",[],{"_19":5717,"_21":5718,"_23":5719,"_25":5720,"_26":5721,"_32":3724,"_33":5726},"np.tril_indices_from","np.tril_indices_from(arr, k?)","Return the indices for the lower-triangle of an (n, m) array.\r","Return the indices for the lower-triangle of an (n, m) array.\r\n\r\nThis is a specialized version that gets the shape from an input array.",[5722,5724],{"_19":374,"_25":5723,"_31":6},"- Input array from which to get shape",{"_19":1010,"_25":5725,"_31":61},"- Diagonal offset (k=0 is main diagonal, k<0 is below, k>0 is above)",[],{"_19":5728,"_21":5729,"_23":5730,"_25":5730,"_26":5731,"_32":30,"_33":5736},"np.trim_zeros","np.trim_zeros(arr, trim?)","Trim the leading and/or trailing zeros from a 1-D array.",[5732,5734],{"_19":374,"_25":5733,"_31":6},"- Input 1-D array",{"_19":610,"_25":5735,"_31":61},"- 'f' for front, 'b' for back, 'fb' for both (default: 'fb')",[],{"_19":5738,"_21":5739,"_23":5740,"_25":5741,"_26":5742,"_32":931,"_33":5746},"np.trimcoef","np.trimcoef(c, tol?)","Remove small trailing coefficients.\r","Remove small trailing coefficients.\r\n\r\nTrailing elements with absolute value less than or equal to `tol` are removed.",[5743,5744],{"_19":929,"_25":949,"_31":6},{"_19":3769,"_25":5745,"_31":61},"- Tolerance for considering coefficients as zero (default: 0)",[],{"_19":5748,"_21":5749,"_23":5750,"_25":5750,"_26":5751,"_32":931,"_33":5755},"np.trimseq","np.trimseq(seq)","Remove trailing zeros from a sequence.",[5752],{"_19":5753,"_25":5754,"_31":6},"seq","- Input sequence",[],{"_19":5757,"_21":5758,"_23":5759,"_25":5760,"_26":5761,"_32":357,"_33":5765},"np.triu","np.triu(arr, k?)","Upper triangle of an array.\r","Upper triangle of an array.\r\n\r\nReturn a copy of an array with elements below the k-th diagonal zeroed.",[5762,5763],{"_19":374,"_25":321,"_31":6},{"_19":1010,"_25":5764,"_31":61},"- Diagonal below which to zero elements (default: 0)",[],{"_19":5767,"_21":5768,"_23":5769,"_25":5769,"_26":5770,"_32":3724,"_33":5774},"np.triu_indices","np.triu_indices(n, k?, m?)","Return the indices for the upper-triangle of an (n, m) array.",[5771,5772,5773],{"_19":1516,"_25":1864,"_31":6},{"_19":1010,"_25":1868,"_31":61},{"_19":958,"_25":5714,"_31":61},[],{"_19":5776,"_21":5777,"_23":5778,"_25":5779,"_26":5780,"_32":3724,"_33":5783},"np.triu_indices_from","np.triu_indices_from(arr, k?)","Return the indices for the upper-triangle of an (n, m) array.\r","Return the indices for the upper-triangle of an (n, m) array.\r\n\r\nThis is a specialized version that gets the shape from an input array.",[5781,5782],{"_19":374,"_25":5723,"_31":6},{"_19":1010,"_25":5725,"_31":61},[],{"_19":5785,"_21":5786,"_23":5787,"_25":5787,"_26":5788,"_32":30,"_33":5790},"np.trunc","np.trunc(x)","Return the truncated value of the input, element-wise.",[5789],{"_19":29,"_25":30,"_31":6},[],{"_19":5792,"_21":5793,"_23":5794,"_25":5794,"_26":5795,"_32":1172,"_33":5798},"np.typedArrayToDType","np.typedArrayToDType(arr)","Infer DType from a TypedArray.",[5796],{"_19":374,"_25":5797,"_31":6},"- TypedArray instance",[],{"_19":5800,"_21":5801,"_23":5802,"_25":5803,"_26":5804,"_32":357,"_33":5807},"np.union1d","np.union1d(ar1, ar2)","Find the union of two arrays.\r","Find the union of two arrays.\r\n\r\nReturns the sorted unique values that are in either of the input arrays.",[5805,5806],{"_19":2789,"_25":2866,"_31":6},{"_19":2792,"_25":2868,"_31":6},[],{"_19":5809,"_21":5810,"_23":5811,"_25":5811,"_26":5812,"_32":5815,"_33":5816},"np.unique","np.unique(arr, options?)","Find the unique elements of an array.",[5813,5814],{"_19":374,"_25":2790,"_31":6},{"_19":534,"_25":1685,"_31":61},"Promise",[],{"_19":5818,"_21":5819,"_23":5820,"_25":5820,"_26":5821,"_32":5823,"_33":5824},"np.uniqueAll","np.uniqueAll(arr)","Return unique values, indices, inverse, and counts.",[5822],{"_19":374,"_25":321,"_31":6},"Promise",[],{"_19":5826,"_21":5827,"_23":5828,"_25":5828,"_26":5829,"_32":5831,"_33":5832},"np.uniqueCounts","np.uniqueCounts(arr)","Return unique values and their counts.",[5830],{"_19":374,"_25":321,"_31":6},"Promise<{\r\n values: NDArray;\r\n counts: NDArray;\r\n}>",[],{"_19":5834,"_21":5835,"_23":5836,"_25":5836,"_26":5837,"_32":5839,"_33":5840},"np.uniqueIndex","np.uniqueIndex(arr)","Return unique values and indices of first occurrence.",[5838],{"_19":374,"_25":321,"_31":6},"Promise<{\r\n values: NDArray;\r\n indices: NDArray;\r\n}>",[],{"_19":5842,"_21":5843,"_23":5844,"_25":5844,"_26":5845,"_32":5847,"_33":5848},"np.uniqueInverse","np.uniqueInverse(arr)","Return unique values and indices to reconstruct original.",[5846],{"_19":374,"_25":321,"_31":6},"Promise<{\r\n values: NDArray;\r\n inverse: NDArray;\r\n}>",[],{"_19":5850,"_21":5851,"_23":5852,"_25":5852,"_26":5853,"_32":357,"_33":5855},"np.uniqueValues","np.uniqueValues(arr)","Return only the unique values (simplified interface).",[5854],{"_19":374,"_25":321,"_31":6},[],{"_19":5857,"_21":5858,"_23":5859,"_25":5860,"_26":5861,"_32":357,"_33":5870},"np.unpackbits","np.unpackbits(a, axis?, count?, bitorder?)","Unpack elements of a uint8 array into a binary array.\r","Unpack elements of a uint8 array into a binary array.\r\n\r\nEach element is unpacked into 8 bits (or fewer for the last element\r\nif count is specified).",[5862,5864,5866,5868],{"_19":189,"_25":5863,"_31":6},"- Input array of uint8 values",{"_19":323,"_25":5865,"_31":61},"- The axis along which to unpack. If null, the input is flattened",{"_19":2209,"_25":5867,"_31":61},"- Number of bits to unpack from the last dimension. If null,\r\n all bits are unpacked. Negative count removes bits from the end.",{"_19":4212,"_25":5869,"_31":61},"- Order of bits in the packed representation. 'big' (default) means\r\n the highest bit is unpacked first; 'little' means the lowest\r\n bit is unpacked first",[],{"_19":5872,"_21":5873,"_23":5874,"_25":5874,"_26":5875,"_32":5878,"_33":5879},"np.unravelIndex","np.unravelIndex(indices, shape)","Convert a flat index into a tuple of coordinate arrays.",[5876,5877],{"_19":878,"_25":4567,"_31":6},{"_19":531,"_25":4700,"_31":6},"Promise",[],{"_19":5881,"_21":5882,"_23":5883,"_25":5884,"_26":5885,"_32":581,"_33":5890},"np.unstack","np.unstack(arr, axis?)","Unpack the array along a given axis.\r","Unpack the array along a given axis.\r\nThe inverse of stack.",[5886,5888],{"_19":374,"_25":5887,"_31":6},"- Array to unpack",{"_19":323,"_25":5889,"_31":61},"- Axis along which to unpack (default: 0)",[],{"_19":5892,"_21":5893,"_23":5894,"_25":5895,"_26":5896,"_32":357,"_33":5906},"np.unwrap","np.unwrap(p, discont?, axis?, period?)","Unwrap by taking the complement of large deltas with respect to the period.\r","Unwrap by taking the complement of large deltas with respect to the period.\r\n\r\nThis unwraps a signal by changing absolute jumps greater than discont to\r\ntheir 2*pi complement.",[5897,5898,5901,5903],{"_19":1111,"_25":321,"_31":6},{"_19":5899,"_25":5900,"_31":61},"discont","- Maximum discontinuity between values, default is pi",{"_19":323,"_25":5902,"_31":61},"- Axis along which to unwrap",{"_19":5904,"_25":5905,"_31":61},"period","- Size of the range over which the input wraps, default is 2*pi",[],{"_19":5908,"_21":5909,"_23":5910,"_25":5910,"_26":5911,"_32":30,"_33":5913},"np.upper","np.upper(a)","Return element-wise copy with lowercase characters converted to uppercase.",[5912],{"_19":189,"_25":1770,"_31":6},[],{"_19":5915,"_21":5916,"_23":5917,"_25":5918,"_26":5919,"_32":357,"_33":5928},"np.vander","np.vander(x, N?, increasing?, options?)","Generate a Vandermonde matrix.\r","Generate a Vandermonde matrix.\r\n\r\nThe columns of the output matrix are powers of the input vector.\r\nThe order of the powers is determined by the `increasing` parameter.",[5920,5922,5924,5927],{"_19":29,"_25":5921,"_31":6},"- 1D input array",{"_19":1863,"_25":5923,"_31":61},"- Number of columns (default: length of x)",{"_19":5925,"_25":5926,"_31":61},"increasing","- Order of powers (default: false, decreasing)",{"_19":534,"_25":535,"_31":61},[],{"_19":5930,"_21":5931,"_23":5932,"_25":5932,"_26":5933,"_32":477,"_33":5941},"np.variance","np.variance(a, axis?, ddof?, keepdims?, dtype?)","Compute the variance along the specified axis.",[5934,5935,5937,5939,5940],{"_19":189,"_25":321,"_31":6},{"_19":323,"_25":5936,"_31":61},"- Axis along which to compute variance. null computes variance of all elements.",{"_19":1370,"_25":5938,"_31":61},"- Delta Degrees of Freedom. Divisor is N - ddof. Default: 0 (population variance)",{"_19":326,"_25":476,"_31":61},{"_19":196,"_25":5291,"_31":61},[],{"_19":5943,"_21":5944,"_23":5945,"_25":5946,"_26":5947,"_32":1244,"_33":5950},"np.vdot","np.vdot(a, b)","Compute the dot product of two vectors (flattened inputs).\r","Compute the dot product of two vectors (flattened inputs).\r\nFor complex arrays, the first argument is conjugated.",[5948,5949],{"_19":189,"_25":30,"_31":6},{"_19":191,"_25":30,"_31":6},[],{"_19":5952,"_21":5953,"_23":5954,"_25":5955,"_26":5956,"_32":477,"_33":5961},"np.vecdot","np.vecdot(x1, x2, axis?)","Compute the vector dot product of two arrays along the last axis.\r","Compute the vector dot product of two arrays along the last axis.\r\n\r\nNumPy 2.0 addition. For 1-D arrays, this is the same as dot.\r\nFor N-D arrays, sums the product of elements along the last axis.",[5957,5958,5959],{"_19":311,"_25":2866,"_31":6},{"_19":313,"_25":2868,"_31":6},{"_19":323,"_25":5960,"_31":61},"- Axis along which to compute the dot product (default: -1)",[],{"_19":5963,"_21":5964,"_23":5965,"_25":5966,"_26":5967,"_32":357,"_33":5971},"np.vecmat","np.vecmat(x1, x2)","Vector-matrix product.\r","Vector-matrix product.\r\n\r\nNumPy 2.0 addition. Computes the vector-matrix product of x1 and x2.\r\nEquivalent to matmul with 1D @ 2D broadcasting.",[5968,5970],{"_19":311,"_25":5969,"_31":6},"- Vector (..., M)",{"_19":313,"_25":3788,"_31":6},[],{"_19":5973,"_21":5974,"_23":5975,"_25":5975,"_26":5976,"_32":477,"_33":5983},"np.vector_norm","np.vector_norm(x, ord?, axis?, keepdims?)","Compute the vector norm.",[5977,5978,5980,5982],{"_19":29,"_25":321,"_31":6},{"_19":3745,"_25":5979,"_31":61},"- Order of the norm (default: 2, Euclidean)",{"_19":323,"_25":5981,"_31":61},"- Axis along which to compute. null = flatten",{"_19":326,"_25":3748,"_31":61},[],{"_19":5985,"_21":5986,"_23":5987,"_25":5987,"_26":5988,"_32":5994,"_33":5995},"np.vectorize","np.vectorize(pyfunc, options?)","Factory function for creating a Vectorize instance.",[5989,5992],{"_19":5990,"_25":5991,"_31":6},"pyfunc","- Function to vectorize",{"_19":534,"_25":5993,"_31":61},"- Vectorization options","Vectorize",[],{"_19":5997,"_21":5998,"_23":5999,"_25":5999,"_26":6000,"_32":581,"_33":6003},"np.vsplit","np.vsplit(arr, indices_or_sections)","Split an array into multiple sub-arrays vertically (row-wise).",[6001,6002],{"_19":374,"_25":4969,"_31":6},{"_19":577,"_25":578,"_31":6},[],{"_19":6005,"_21":6006,"_23":6007,"_25":6008,"_26":6009,"_32":30,"_33":6011},"np.vstack","np.vstack(tup)","Stack arrays in sequence vertically (row-wise).\r","Stack arrays in sequence vertically (row-wise).\r\nEquivalent to concatenation along the first axis after making 1-D arrays 2-D.",[6010],{"_19":1161,"_25":1628,"_31":6},[],{"_19":6013,"_21":6014,"_23":6015,"_25":6016,"_26":6017,"_32":357,"_33":6024},"np.where","np.where(condition, x?, y?)","Return elements chosen from x or y depending on condition.\r","Return elements chosen from x or y depending on condition.\r\n\r\nIf x and y are provided, returns an array where elements are taken\r\nfrom x where condition is true, and from y where condition is false.\r\n\r\nIf only condition is provided, returns the indices where condition is true\r\n(equivalent to nonzero).",[6018,6020,6022],{"_19":1197,"_25":6019,"_31":6},"- Boolean condition array",{"_19":29,"_25":6021,"_31":61},"- Values where condition is true (optional)",{"_19":135,"_25":6023,"_31":61},"- Values where condition is false (optional)",[],{"_19":6026,"_21":6027,"_23":6028,"_25":6028,"_26":6029,"_32":6035,"_33":6036},"np.withPrintoptions","np.withPrintoptions(options, fn)","Execute a function with temporary print options.",[6030,6032],{"_19":534,"_25":6031,"_31":6},"- Temporary print options",{"_19":6033,"_25":6034,"_31":6},"fn","- Function to execute","T",[],{"_19":6038,"_21":6039,"_23":6040,"_25":6040,"_26":6041,"_32":357,"_33":6044},"np.zeros","np.zeros(shape, options?)","Create a new NDArray filled with zeros.",[6042,6043],{"_19":531,"_25":1752,"_31":6},{"_19":534,"_25":535,"_31":61},[],{"_19":6046,"_21":6047,"_23":6048,"_25":6048,"_26":6049,"_32":357,"_33":6051},"np.zeros_like","np.zeros_like(a)","Create an array of zeros with the same shape and type as a given array.",[6050],{"_19":189,"_25":1761,"_31":6},[],{"_19":6053,"_21":6054,"_23":6055,"_25":6056,"_26":6057,"_32":30,"_33":6060},"np.zfill","np.zfill(a, width)","Return element-wise numeric string left-padded with zeros.\r","Return element-wise numeric string left-padded with zeros.\r\nSign prefix is handled correctly.",[6058,6059],{"_19":189,"_25":1770,"_31":6},{"_19":753,"_25":3524,"_31":6},[],"allPackages",[6063,7165,7521,7715,8324,9438,9637,9942,10319,14150,36,14891,15107,16540,18643,18905,19951,21025,22270],{"_37":6064,"_19":6065,"_25":6066,"_41":42,"_43":6067,"_47":6068},"core","Core Functions","Essential functions for array creation, mathematics, aggregation, and manipulation. Always available.","🔧",[6069,6093,6106,6121,6142,6161,6180,6193,6205,6230,6251,6285,6303,6315,6327,6340,6350,6363,6378,6393,6404,6415,6433,6446,6458,6470,6484,6498,6510,6521,6531,6554,6570,6583,6595,6607,6619,6640,6656,6683,6701,6712,6724,6735,6751,6765,6779,6796,6807,6818,6832,6846,6858,6870,6890,6902,6922,6940,6953,6966,6979,6992,7014,7032,7052,7065,7079,7097,7112,7125,7136,7147],{"_19":6070,"_21":6071,"_23":6072,"_25":6073,"_26":6074,"_32":6079,"_33":6080,"_6088":6089},"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.",[6075,6077],{"_19":958,"_25":6076},"Number of rows",{"_19":1516,"_25":6078,"_31":61},"Number of columns","NDArray of zeros with the given shape",[6081,6085],{"_281":6082,"_6083":6084},"zeros(3)","output","0 0 0\n0 0 0\n0 0 0",{"_281":6086,"_6083":6087},"zeros(2, 4)","0 0 0 0\n0 0 0 0","seeAlso",[6090,6091,6092],"ones","eye","rand",{"_19":6090,"_21":6094,"_23":6095,"_25":6096,"_26":6097,"_32":6100,"_33":6101,"_6088":6105},"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.",[6098,6099],{"_19":958,"_25":6076},{"_19":1516,"_25":6078,"_31":61},"NDArray of ones with the given shape",[6102],{"_281":6103,"_6083":6104},"ones(2, 3)","1 1 1\n1 1 1",[6070,6091],{"_19":6091,"_21":6107,"_23":6108,"_25":6109,"_26":6110,"_32":6113,"_33":6114,"_6088":6118},"I = eye(n)","Identity matrix","Creates an n×n identity matrix with ones on the diagonal and zeros elsewhere.",[6111],{"_19":1516,"_25":6112},"Size of the square matrix","n×n identity NDArray",[6115],{"_281":6116,"_6083":6117},"eye(3)","1 0 0\n0 1 0\n0 0 1",[6070,6090,6119,6120],"diag","magic",{"_19":6120,"_21":6122,"_23":6123,"_25":6124,"_26":6125,"_32":6128,"_33":6129,"_6088":6139},"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.",[6126],{"_19":1516,"_25":6127},"Size of the magic square (n ≥ 1)","n×n magic square NDArray",[6130,6133,6136],{"_281":6131,"_6083":6132},"magic(3)","8 1 6\n3 5 7\n4 9 2",{"_281":6134,"_6083":6135},"magic(4)","16 2 3 13\n 5 11 10 8\n 9 7 6 12\n 4 14 15 1",{"_281":6137,"_6083":6138},"sum(magic(5))","65 65 65 65 65",[6091,6090,6070,6140,6141],"pascal","hilb",{"_19":6143,"_21":6144,"_23":6145,"_25":6146,"_26":6147,"_32":6154,"_33":6155,"_6088":6159},"linspace","v = linspace(a, b, n)","Generate linearly spaced vector","Returns a row vector of `n` evenly spaced points between `a` and `b` (inclusive).",[6148,6150,6152],{"_19":189,"_25":6149},"Start value",{"_19":191,"_25":6151},"End value",{"_19":1516,"_25":6153},"Number of points","1×n NDArray",[6156],{"_281":6157,"_6083":6158},"linspace(0, 1, 5)","0 0.25 0.5 0.75 1",[6160,6070,6090],"logspace",{"_19":6160,"_21":6162,"_23":6163,"_25":6164,"_26":6165,"_32":6154,"_33":6172,"_6088":6179},"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.",[6166,6168,6170],{"_19":189,"_25":6167},"Exponent of start value (10^a)",{"_19":191,"_25":6169},"Exponent of end value (10^b)",{"_19":1516,"_25":6171,"_31":61},"Number of points (default: 50)",[6173,6176],{"_281":6174,"_6083":6175},"logspace(0, 2, 5)","1 3.1623 10 31.623 100",{"_281":6177,"_6083":6178},"logspace(-2, 0, 3)","0.01 0.1 1",[6143,6070,6090],{"_19":6092,"_21":6181,"_23":6182,"_25":6183,"_26":6184,"_32":6187,"_33":6188,"_6088":6191},"R = rand(n)\nR = rand(m, n)","Uniformly distributed random numbers","Creates an array of uniformly distributed random numbers in the interval (0, 1).",[6185,6186],{"_19":958,"_25":6076},{"_19":1516,"_25":6078,"_31":61},"NDArray of random values in (0, 1)",[6189],{"_281":6190},"rand(2, 3)",[6192,6070],"randn",{"_19":6192,"_21":6194,"_23":6195,"_25":6196,"_26":6197,"_32":6200,"_33":6201,"_6088":6204},"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).",[6198,6199],{"_19":958,"_25":6076},{"_19":1516,"_25":6078,"_31":61},"NDArray of normally distributed random values",[6202],{"_281":6203},"randn(2, 3)",[6092],{"_19":6206,"_21":6207,"_23":6208,"_25":6209,"_26":6210,"_32":6218,"_33":6219,"_6088":6227},"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.",[6211,6213,6215],{"_19":29,"_25":6212},"X-coordinate vector",{"_19":135,"_25":6214,"_31":61},"Y-coordinate vector (defaults to x if omitted)",{"_19":6216,"_25":6217,"_31":61},"indexing","Indexing mode: 'xy' (default, MATLAB style) or 'ij' (NumPy matrix style)","Two NDArrays [X, Y] of coordinate matrices",[6220,6222,6224],{"_281":6221},"[X, Y] = meshgrid(1:3, 1:2)",{"_281":6223},"[X, Y] = meshgrid(-2:0.5:2)",{"_281":6225,"_6083":6226},"[X, Y] = meshgrid(1:3, 1:5, 'ij')","% X is 3x5, Y is 3x5 (NumPy style)",[6228,6229,6143],"surf","mesh",{"_19":6231,"_21":6232,"_23":6233,"_25":6234,"_26":6235,"_32":6238,"_33":6239,"_6088":6249},"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.",[6236],{"_19":1516,"_25":6237,"_31":61},"Grid size (default: 49). Returns an n×n matrix.","n×n NDArray of Z values, or [X, Y, Z] coordinate matrices",[6240,6243,6246],{"_281":6241,"_6083":6242},"surf(peaks())","% 49×49 surface plot",{"_281":6244,"_6083":6245},"Z = peaks(30)","% 30×30 matrix",{"_281":6247,"_6083":6248},"[X, Y, Z] = peaks(25)","% Returns all coordinate matrices",[6228,6229,6206,6250],"gallery",{"_19":6250,"_21":6252,"_23":6253,"_25":6254,"_26":6255,"_32":6264,"_33":6265,"_6088":6281},"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'.",[6256,6259,6261],{"_19":6257,"_25":6258},"matname","Name of the test matrix type (string)",{"_19":1516,"_25":6260,"_31":61},"Size or first parameter (depends on matrix type)",{"_19":6262,"_25":6263,"_31":61},"...","Additional parameters (depends on matrix type)","Test matrix of the specified type",[6266,6269,6272,6275,6278],{"_281":6267,"_6083":6268},"gallery('hilb', 4)","4×4 Hilbert matrix",{"_281":6270,"_6083":6271},"gallery('pascal', 5)","5×5 Pascal matrix",{"_281":6273,"_6083":6274},"gallery('lehmer', 3)","1.0000 0.5000 0.3333\n0.5000 1.0000 0.6667\n0.3333 0.6667 1.0000",{"_281":6276,"_6083":6277},"gallery('pei', 3, 2)","3×3 Pei matrix with alpha=2",{"_281":6279,"_6083":6280},"gallery('kms', 4, 0.5)","4×4 KMS Toeplitz matrix with rho=0.5",[6141,6282,6140,6120,6283,6284],"invhilb","toeplitz","hankel",{"_19":6286,"_21":6287,"_23":6288,"_25":6289,"_26":6290,"_32":6294,"_33":6295,"_6088":6299},"sin","Y = sin(X)","Sine of argument in radians","Computes the sine of each element. Operates element-wise on arrays.",[6291],{"_19":6292,"_25":6293},"X","Input angle in radians (scalar or NDArray)","Sine values (same shape as input)",[6296],{"_281":6297,"_6083":6298},"sin(pi/2)","1",[6300,6301,6302],"cos","tan","asin",{"_19":6300,"_21":6304,"_23":6305,"_25":6306,"_26":6307,"_32":6309,"_33":6310,"_6088":6313},"Y = cos(X)","Cosine of argument in radians","Computes the cosine of each element. Operates element-wise on arrays.",[6308],{"_19":6292,"_25":6293},"Cosine values (same shape as input)",[6311],{"_281":6312,"_6083":6298},"cos(0)",[6286,6301,6314],"acos",{"_19":6301,"_21":6316,"_23":6317,"_25":6318,"_26":6319,"_32":6321,"_33":6322,"_6088":6325},"Y = tan(X)","Tangent of argument in radians","Computes the tangent of each element. Operates element-wise on arrays.",[6320],{"_19":6292,"_25":6293},"Tangent values (same shape as input)",[6323],{"_281":6324,"_6083":6298},"tan(pi/4)",[6286,6300,6326],"atan",{"_19":6302,"_21":6328,"_23":6329,"_25":6330,"_26":6331,"_32":6334,"_33":6335,"_6088":6339},"Y = asin(X)","Inverse sine (arcsine)","Computes the inverse sine of each element. Result is in radians in the range [-pi/2, pi/2].",[6332],{"_19":6292,"_25":6333},"Input values in [-1, 1] (scalar or NDArray)","Angle in radians",[6336],{"_281":6337,"_6083":6338},"asin(1)","1.5708",[6286,6314,6326],{"_19":6314,"_21":6341,"_23":6342,"_25":6343,"_26":6344,"_32":6334,"_33":6346,"_6088":6349},"Y = acos(X)","Inverse cosine (arccosine)","Computes the inverse cosine of each element. Result is in radians in the range [0, pi].",[6345],{"_19":6292,"_25":6333},[6347],{"_281":6348,"_6083":6338},"acos(0)",[6300,6302,6326],{"_19":6326,"_21":6351,"_23":6352,"_25":6353,"_26":6354,"_32":6334,"_33":6357,"_6088":6361},"Y = atan(X)","Inverse tangent (arctangent)","Computes the inverse tangent of each element. Result is in radians in the range (-pi/2, pi/2).",[6355],{"_19":6292,"_25":6356},"Input value (scalar or NDArray)",[6358],{"_281":6359,"_6083":6360},"atan(1)","0.7854",[6301,6362,6302],"atan2",{"_19":6362,"_21":6364,"_23":6365,"_25":6366,"_26":6367,"_32":6373,"_33":6374,"_6088":6377},"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.",[6368,6371],{"_19":6369,"_25":6370},"B","Y-coordinates (scalar or NDArray)",{"_19":3766,"_25":6372},"X-coordinates (scalar or NDArray)","Angle in radians in (-pi, pi]",[6375],{"_281":6376,"_6083":6360},"atan2(1, 1)",[6326,6286,6300],{"_19":6379,"_21":6380,"_23":6381,"_25":6382,"_26":6383,"_32":6385,"_33":6386,"_6088":6390},"sinh","Y = sinh(X)","Hyperbolic sine","Computes the hyperbolic sine of each element.",[6384],{"_19":6292,"_25":6356},"Hyperbolic sine values",[6387],{"_281":6388,"_6083":6389},"sinh(0)","0",[6391,6392,6286],"cosh","tanh",{"_19":6391,"_21":6394,"_23":6395,"_25":6396,"_26":6397,"_32":6399,"_33":6400,"_6088":6403},"Y = cosh(X)","Hyperbolic cosine","Computes the hyperbolic cosine of each element.",[6398],{"_19":6292,"_25":6356},"Hyperbolic cosine values",[6401],{"_281":6402,"_6083":6298},"cosh(0)",[6379,6392,6300],{"_19":6392,"_21":6405,"_23":6406,"_25":6407,"_26":6408,"_32":6410,"_33":6411,"_6088":6414},"Y = tanh(X)","Hyperbolic tangent","Computes the hyperbolic tangent of each element.",[6409],{"_19":6292,"_25":6356},"Hyperbolic tangent values",[6412],{"_281":6413,"_6083":6389},"tanh(0)",[6379,6391,6301],{"_19":6416,"_21":6417,"_23":6418,"_25":6419,"_26":6420,"_32":6423,"_33":6424,"_6088":6430},"exp","Y = exp(X)","Exponential (e^x)","Computes e raised to the power of each element.",[6421],{"_19":6292,"_25":6422},"Exponent values (scalar or NDArray)","Exponential values",[6425,6427],{"_281":6426,"_6083":6298},"exp(0)",{"_281":6428,"_6083":6429},"exp(1)","2.7183",[6431,6432],"log","log10",{"_19":6431,"_21":6434,"_23":6435,"_25":6436,"_26":6437,"_32":6440,"_33":6441,"_6088":6444},"Y = log(X)","Natural logarithm","Computes the natural logarithm (base e) of each element.",[6438],{"_19":6292,"_25":6439},"Input values > 0 (scalar or NDArray)","Natural log values",[6442],{"_281":6443,"_6083":6298},"log(exp(1))",[6416,6432,6445],"log2",{"_19":6432,"_21":6447,"_23":6448,"_25":6449,"_26":6450,"_32":6452,"_33":6453,"_6088":6457},"Y = log10(X)","Common logarithm (base 10)","Computes the base-10 logarithm of each element.",[6451],{"_19":6292,"_25":6439},"Base-10 log values",[6454],{"_281":6455,"_6083":6456},"log10(100)","2",[6431,6445,6416],{"_19":6445,"_21":6459,"_23":6460,"_25":6461,"_26":6462,"_32":6464,"_33":6465,"_6088":6469},"Y = log2(X)","Base-2 logarithm","Computes the base-2 logarithm of each element.",[6463],{"_19":6292,"_25":6439},"Base-2 log values",[6466],{"_281":6467,"_6083":6468},"log2(8)","3",[6431,6432,6416],{"_19":6471,"_21":6472,"_23":6473,"_25":6474,"_26":6475,"_32":6478,"_33":6479,"_6088":6482},"sqrt","Y = sqrt(X)","Square root","Computes the square root of each element.",[6476],{"_19":6292,"_25":6477},"Input values >= 0 (scalar or NDArray)","Square root values",[6480],{"_281":6481,"_6083":6468},"sqrt(9)",[6483,6416],"abs",{"_19":6483,"_21":6485,"_23":6486,"_25":6487,"_26":6488,"_32":6490,"_33":6491,"_6088":6495},"Y = abs(X)","Absolute value","Computes the absolute value of each element.",[6489],{"_19":6292,"_25":6356},"Absolute values",[6492],{"_281":6493,"_6083":6494},"abs(-5)","5",[6471,6496,6497],"floor","ceil",{"_19":6496,"_21":6499,"_23":6500,"_25":6501,"_26":6502,"_32":6504,"_33":6505,"_6088":6508},"Y = floor(X)","Round toward negative infinity","Rounds each element to the nearest integer toward negative infinity.",[6503],{"_19":6292,"_25":6356},"Rounded values",[6506],{"_281":6507,"_6083":6468},"floor(3.7)",[6497,6509,6483],"round",{"_19":6497,"_21":6511,"_23":6512,"_25":6513,"_26":6514,"_32":6504,"_33":6516,"_6088":6520},"Y = ceil(X)","Round toward positive infinity","Rounds each element to the nearest integer toward positive infinity.",[6515],{"_19":6292,"_25":6356},[6517],{"_281":6518,"_6083":6519},"ceil(3.2)","4",[6496,6509,6483],{"_19":6509,"_21":6522,"_23":6523,"_25":6524,"_26":6525,"_32":6504,"_33":6527,"_6088":6530},"Y = round(X)","Round to nearest integer","Rounds each element to the nearest integer.",[6526],{"_19":6292,"_25":6356},[6528],{"_281":6529,"_6083":6519},"round(3.5)",[6496,6497],{"_19":6532,"_21":6533,"_23":6534,"_25":6535,"_26":6536,"_32":6542,"_33":6543,"_6088":6550},"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).",[6537,6539],{"_19":3766,"_25":6538},"Input array (scalar or NDArray)",{"_19":6540,"_25":6541,"_31":61},"dim","Dimension to sum along (1-indexed)","Sum value (scalar or NDArray)",[6544,6547],{"_281":6545,"_6083":6546},"sum([1 2 3])","6",{"_281":6548,"_6083":6549},"A = [1 2; 3 4]; sum(A, 1)","4 6",[6551,6552,6553],"mean","min","max",{"_19":6551,"_21":6555,"_23":6556,"_25":6557,"_26":6558,"_32":6562,"_33":6563,"_6088":6567},"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.",[6559,6560],{"_19":3766,"_25":6538},{"_19":6540,"_25":6561,"_31":61},"Dimension to average along (1-indexed)","Mean value (scalar or NDArray)",[6564],{"_281":6565,"_6083":6566},"mean([1 2 3 4])","2.5",[6532,6568,6569],"std","var",{"_19":6568,"_21":6571,"_23":6572,"_25":6573,"_26":6574,"_32":6578,"_33":6579,"_6088":6582},"S = std(A)\nS = std(A, dim)","Standard deviation","Returns the standard deviation of the elements. With a dimension argument, computes along that dimension.",[6575,6576],{"_19":3766,"_25":6538},{"_19":6540,"_25":6577,"_31":61},"Dimension (1-indexed)","Standard deviation (scalar or NDArray)",[6580],{"_281":6581,"_6083":6456},"std([2 4 4 4 5 5 7 9])",[6569,6551],{"_19":6569,"_21":6584,"_23":6585,"_25":6586,"_26":6587,"_32":6590,"_33":6591,"_6088":6594},"V = var(A)\nV = var(A, dim)","Variance","Returns the variance of the elements. With a dimension argument, computes along that dimension.",[6588,6589],{"_19":3766,"_25":6538},{"_19":6540,"_25":6577,"_31":61},"Variance (scalar or NDArray)",[6592],{"_281":6593,"_6083":6519},"var([2 4 4 4 5 5 7 9])",[6568,6551],{"_19":6552,"_21":6596,"_23":6597,"_25":6598,"_26":6599,"_32":6602,"_33":6603,"_6088":6606},"M = min(A)\nM = min(A, dim)","Minimum value","Returns the smallest element. With a dimension argument, returns the minimum along that dimension.",[6600,6601],{"_19":3766,"_25":6538},{"_19":6540,"_25":6577,"_31":61},"Minimum value (scalar or NDArray)",[6604],{"_281":6605,"_6083":6298},"min([3 1 4 1 5])",[6553,6532],{"_19":6553,"_21":6608,"_23":6609,"_25":6610,"_26":6611,"_32":6614,"_33":6615,"_6088":6618},"M = max(A)\nM = max(A, dim)","Maximum value","Returns the largest element. With a dimension argument, returns the maximum along that dimension.",[6612,6613],{"_19":3766,"_25":6538},{"_19":6540,"_25":6577,"_31":61},"Maximum value (scalar or NDArray)",[6616],{"_281":6617,"_6083":6494},"max([3 1 4 1 5])",[6552,6532],{"_19":6620,"_21":6621,"_23":6622,"_25":6623,"_26":6624,"_32":6628,"_33":6629,"_6088":6637},"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.",[6625,6626],{"_19":3766,"_25":6538},{"_19":6540,"_25":6627,"_31":61},"Dimension to operate along (1-indexed)","1 if any element is nonzero, 0 otherwise",[6630,6632,6634],{"_281":6631,"_6083":6298},"any([0 0 1 0])",{"_281":6633,"_6083":6389},"any([0 0 0])",{"_281":6635,"_6083":6636},"A = [1 0; 0 0]; any(A, 1)","1 0",[6638,6639],"all","find",{"_19":6638,"_21":6641,"_23":6642,"_25":6643,"_26":6644,"_32":6647,"_33":6648,"_6088":6655},"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.",[6645,6646],{"_19":3766,"_25":6538},{"_19":6540,"_25":6627,"_31":61},"1 if all elements are nonzero, 0 otherwise",[6649,6651,6653],{"_281":6650,"_6083":6298},"all([1 2 3])",{"_281":6652,"_6083":6389},"all([1 0 3])",{"_281":6654,"_6083":6636},"A = [1 1; 1 0]; all(A, 1)",[6620,6639],{"_19":6639,"_21":6657,"_23":6658,"_25":6659,"_26":6660,"_32":6668,"_33":6669,"_6088":6682},"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.",[6661,6663,6665],{"_19":6292,"_25":6662},"Input array",{"_19":1516,"_25":6664,"_31":61},"Number of indices to return",{"_19":6666,"_25":6667,"_31":61},"direction","'first' (default) or 'last' - which indices to return","Vector of indices (1-based)",[6670,6673,6676,6679],{"_281":6671,"_6083":6672},"find([1 0 3 0 5])","1 3 5",{"_281":6674,"_6083":6675},"find([1 0 3 0 5], 2)","1 3",{"_281":6677,"_6083":6678},"find([1 0 3 0 5], 2, 'last')","3 5",{"_281":6680,"_6083":6681},"A = [1 2 3 4 5]; find(A > 3)","4 5",[6620,6638],{"_19":1105,"_21":6684,"_23":6685,"_25":6686,"_26":6687,"_32":6691,"_33":6692,"_6088":6698},"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.",[6688,6689],{"_19":3766,"_25":6662},{"_19":6540,"_25":6690,"_31":61},"Dimension to query (1-indexed)","Size as NDArray or scalar",[6693,6696],{"_281":6694,"_6083":6695},"A = zeros(3, 4); size(A)","3 4",{"_281":6697,"_6083":6519},"size(A, 2)",[890,6699,6700],"numel","ndims",{"_19":890,"_21":6702,"_23":6703,"_25":6704,"_26":6705,"_32":6707,"_33":6708,"_6088":6711},"n = length(A)","Length of largest array dimension","Returns the length of the largest dimension of the array.",[6706],{"_19":3766,"_25":6662},"Scalar length",[6709],{"_281":6710,"_6083":6494},"length([1 2 3 4 5])",[1105,6699],{"_19":6699,"_21":6713,"_23":6714,"_25":6715,"_26":6716,"_32":6718,"_33":6719,"_6088":6723},"n = numel(A)","Number of array elements","Returns the total number of elements in the array.",[6717],{"_19":3766,"_25":6662},"Scalar count",[6720],{"_281":6721,"_6083":6722},"A = zeros(3, 4); numel(A)","12",[1105,890],{"_19":6700,"_21":6725,"_23":6726,"_25":6727,"_26":6728,"_32":6730,"_33":6731,"_6088":6734},"n = ndims(A)","Number of array dimensions","Returns the number of dimensions of the array.",[6729],{"_19":3766,"_25":6662},"Scalar dimension count",[6732],{"_281":6733,"_6083":6456},"A = zeros(3, 4); ndims(A)",[1105,890],{"_19":6736,"_21":6737,"_23":6738,"_25":6739,"_26":6740,"_32":6744,"_33":6745,"_6088":6749},"reshape","B = reshape(A, m, n)","Reshape array","Reshapes array A into an m-by-n matrix. The number of elements must not change.",[6741,6742,6743],{"_19":3766,"_25":6662},{"_19":958,"_25":6076},{"_19":1516,"_25":6078},"Reshaped NDArray",[6746],{"_281":6747,"_6083":6748},"reshape([1 2 3 4 5 6], 2, 3)","1 3 5\n2 4 6",[1105,6750],"transpose",{"_19":6750,"_21":6752,"_23":6753,"_25":6754,"_26":6755,"_32":6758,"_33":6759,"_6088":6763},"B = transpose(A)\nB = A'","Transpose matrix","Transposes a matrix (swaps rows and columns).",[6756],{"_19":3766,"_25":6757},"Input matrix","Transposed NDArray",[6760],{"_281":6761,"_6083":6762},"A = [1 2; 3 4]; A'","1 3\n2 4",[6736,6764],"flip",{"_19":6119,"_21":6766,"_23":6767,"_25":6768,"_26":6769,"_32":6773,"_33":6774,"_6088":6778},"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.",[6770],{"_19":6771,"_25":6772},"v/A","Input vector or matrix","Diagonal matrix or diagonal vector",[6775],{"_281":6776,"_6083":6777},"diag([1 2 3])","1 0 0\n0 2 0\n0 0 3",[6091,6070],{"_19":6764,"_21":6780,"_23":6781,"_25":6782,"_26":6783,"_32":6787,"_33":6788,"_6088":6792},"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).",[6784,6785],{"_19":3766,"_25":6662},{"_19":6540,"_25":6786,"_31":61},"Dimension to flip along","Flipped NDArray",[6789],{"_281":6790,"_6083":6791},"flip([1 2 3])","3 2 1",[6793,6794,6795],"fliplr","flipud","rot90",{"_19":6793,"_21":6797,"_23":6798,"_25":6799,"_26":6800,"_32":6787,"_33":6802,"_6088":6806},"B = fliplr(A)","Flip array left to right","Flips a matrix left to right (reverses columns).",[6801],{"_19":3766,"_25":6757},[6803],{"_281":6804,"_6083":6805},"fliplr([1 2 3; 4 5 6])","3 2 1\n6 5 4",[6794,6764,6795],{"_19":6794,"_21":6808,"_23":6809,"_25":6810,"_26":6811,"_32":6787,"_33":6813,"_6088":6817},"B = flipud(A)","Flip array up to down","Flips a matrix up to down (reverses rows).",[6812],{"_19":3766,"_25":6757},[6814],{"_281":6815,"_6083":6816},"flipud([1 2; 3 4])","3 4\n1 2",[6793,6764,6795],{"_19":6795,"_21":6819,"_23":6820,"_25":6821,"_26":6822,"_32":6826,"_33":6827,"_6088":6831},"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.",[6823,6824],{"_19":3766,"_25":6757},{"_19":1010,"_25":6825,"_31":61},"Number of 90° rotations (default: 1)","Rotated NDArray",[6828],{"_281":6829,"_6083":6830},"rot90([1 2; 3 4])","2 4\n1 3",[6764,6750],{"_19":6833,"_21":6834,"_23":6835,"_25":6836,"_26":6837,"_32":6840,"_33":6841,"_6088":6845},"lower","s = lower(str)","Convert string to lowercase","Converts all uppercase characters in the string to lowercase.",[6838],{"_19":2103,"_25":6839},"Input string","Lowercase string",[6842],{"_281":6843,"_6083":6844},"lower(\"Hello World\")","'hello world'",[1123],{"_19":1123,"_21":6847,"_23":6848,"_25":6849,"_26":6850,"_32":6852,"_33":6853,"_6088":6857},"s = upper(str)","Convert string to uppercase","Converts all lowercase characters in the string to uppercase.",[6851],{"_19":2103,"_25":6839},"Uppercase string",[6854],{"_281":6855,"_6083":6856},"upper(\"Hello World\")","'HELLO WORLD'",[6833],{"_19":6859,"_21":6860,"_23":6861,"_25":6862,"_26":6863,"_32":6865,"_33":6866,"_6088":6869},"strlength","n = strlength(str)","Length of string","Returns the number of characters in the string.",[6864],{"_19":2103,"_25":6839},"Number of characters",[6867],{"_281":6868,"_6083":6494},"strlength(\"hello\")",[890],{"_19":6871,"_21":6872,"_23":6873,"_25":6874,"_26":6875,"_32":6882,"_33":6883,"_6088":6888},"strcmp","tf = strcmp(s1, s2)","Compare strings","Returns 1 if the strings are identical, 0 otherwise.",[6876,6879],{"_19":6877,"_25":6878},"s1","First string",{"_19":6880,"_25":6881},"s2","Second string","1 if equal, 0 otherwise",[6884,6886],{"_281":6885,"_6083":6298},"strcmp(\"abc\", \"abc\")",{"_281":6887,"_6083":6389},"strcmp(\"abc\", \"def\")",[6889],"strcmpi",{"_19":6889,"_21":6891,"_23":6892,"_25":6893,"_26":6894,"_32":6897,"_33":6898,"_6088":6901},"tf = strcmpi(s1, s2)","Compare strings (case-insensitive)","Returns 1 if the strings are identical ignoring case, 0 otherwise.",[6895,6896],{"_19":6877,"_25":6878},{"_19":6880,"_25":6881},"1 if equal (ignoring case), 0 otherwise",[6899],{"_281":6900,"_6083":6298},"strcmpi(\"Hello\", \"hello\")",[6871],{"_19":6903,"_21":6904,"_23":6905,"_25":6906,"_26":6907,"_32":6913,"_33":6914,"_6088":6918},"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.",[6908,6910],{"_19":2103,"_25":6909},"String to search in",{"_19":6911,"_25":6912},"pattern","Pattern to find","Array of starting indices",[6915],{"_281":6916,"_6083":6917},"strfind(\"abcabc\", \"bc\")","[2, 5]",[6919,6920,6921],"contains","startsWith","endsWith",{"_19":6923,"_21":6924,"_23":6925,"_25":6926,"_26":6927,"_32":6934,"_33":6935,"_6088":6939},"strrep","s = strrep(str, old, new)","Replace substring","Replaces all occurrences of old with new in str.",[6928,6929,6931],{"_19":2103,"_25":6839},{"_19":3696,"_25":6930},"Substring to replace",{"_19":6932,"_25":6933},"new","Replacement string","String with replacements made",[6936],{"_281":6937,"_6083":6938},"strrep(\"hello world\", \"world\", \"there\")","'hello there'",[6903],{"_19":6941,"_21":6942,"_23":6943,"_25":6944,"_26":6945,"_32":6947,"_33":6948,"_6088":6952},"strip","s = strip(str)","Remove leading and trailing whitespace","Removes leading and trailing whitespace characters from the string.",[6946],{"_19":2103,"_25":6839},"Trimmed string",[6949],{"_281":6950,"_6083":6951},"strip(\" hello \")","'hello'",[],{"_19":6920,"_21":6954,"_23":6955,"_25":6956,"_26":6957,"_32":6961,"_33":6962,"_6088":6965},"tf = startsWith(str, prefix)","Check if string starts with prefix","Returns 1 if str starts with prefix, 0 otherwise.",[6958,6959],{"_19":2103,"_25":6839},{"_19":5274,"_25":6960},"Prefix to check","1 if starts with prefix, 0 otherwise",[6963],{"_281":6964,"_6083":6298},"startsWith(\"hello\", \"hel\")",[6921,6919],{"_19":6921,"_21":6967,"_23":6968,"_25":6969,"_26":6970,"_32":6974,"_33":6975,"_6088":6978},"tf = endsWith(str, suffix)","Check if string ends with suffix","Returns 1 if str ends with suffix, 0 otherwise.",[6971,6972],{"_19":2103,"_25":6839},{"_19":1782,"_25":6973},"Suffix to check","1 if ends with suffix, 0 otherwise",[6976],{"_281":6977,"_6083":6298},"endsWith(\"hello\", \"lo\")",[6920,6919],{"_19":6919,"_21":6980,"_23":6981,"_25":6982,"_26":6983,"_32":6987,"_33":6988,"_6088":6991},"tf = contains(str, pattern)","Check if string contains pattern","Returns 1 if str contains pattern, 0 otherwise.",[6984,6985],{"_19":2103,"_25":6839},{"_19":6911,"_25":6986},"Pattern to search for","1 if contains pattern, 0 otherwise",[6989],{"_281":6990,"_6083":6298},"contains(\"hello world\", \"wor\")",[6920,6921,6903],{"_19":6993,"_21":6994,"_23":6995,"_25":6996,"_26":6997,"_32":7004,"_33":7005,"_6088":7012},"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).",[6998,7001],{"_19":6999,"_25":7000},"format","Format string with conversion specifiers",{"_19":7002,"_25":7003},"A1, A2, ...","Values to format","Formatted string",[7006,7009],{"_281":7007,"_6083":7008},"sprintf(\"x = %d\", 42)","'x = 42'",{"_281":7010,"_6083":7011},"sprintf(\"pi = %.4f\", pi)","'pi = 3.1416'",[7013],"disp",{"_19":7015,"_21":7016,"_23":7017,"_25":7018,"_26":7019,"_32":7022,"_33":7023,"_6088":7030},"char","c = char(n)","Convert to character","Converts numeric code to character, or ensures input is a character array.",[7020],{"_19":1516,"_25":7021},"Numeric ASCII/Unicode code or string","Character string",[7024,7027],{"_281":7025,"_6083":7026},"char(65)","'A'",{"_281":7028,"_6083":7029},"char([72 101 108 108 111])","'Hello'",[7031],"double",{"_19":7033,"_21":7034,"_23":7035,"_25":7036,"_26":7037,"_32":7042,"_33":7043,"_6088":7050},"num2str","s = num2str(A)\ns = num2str(A, precision)","Convert number to string","Converts numeric array to string representation.",[7038,7040],{"_19":3766,"_25":7039},"Numeric value or array",{"_19":157,"_25":7041,"_31":61},"Number of significant digits","String representation of number",[7044,7047],{"_281":7045,"_6083":7046},"num2str(3.14159)","'3.1416'",{"_281":7048,"_6083":7049},"num2str(pi, 10)","'3.141592654'",[7051,6993],"str2num",{"_19":7051,"_21":7053,"_23":7054,"_25":7055,"_26":7056,"_32":7059,"_33":7060,"_6088":7064},"n = str2num(str)","Convert string to number","Converts string representation of number to numeric value.",[7057],{"_19":2103,"_25":7058},"String containing numeric value","Numeric value",[7061],{"_281":7062,"_6083":7063},"str2num(\"3.14\")","3.14",[7033],{"_19":7066,"_21":7067,"_23":7068,"_25":7069,"_26":7070,"_32":7074,"_33":7075,"_6088":7078},"strcat","s = strcat(s1, s2, ...)","Concatenate strings","Concatenates strings horizontally.",[7071],{"_19":7072,"_25":7073},"s1, s2, ...","Strings to concatenate","Concatenated string",[7076],{"_281":7077,"_6083":6844},"strcat(\"hello\", \" \", \"world\")",[],{"_19":7080,"_21":7081,"_23":7082,"_25":7083,"_26":7084,"_32":7091,"_33":7092,"_6088":7096},"strjoin","s = strjoin(strs, delimiter)","Join strings with delimiter","Joins an array of strings with the specified delimiter.",[7085,7088],{"_19":7086,"_25":7087},"strs","Cell array or string array",{"_19":7089,"_25":7090,"_31":61},"delimiter","Delimiter string (default: space)","Joined string",[7093],{"_281":7094,"_6083":7095},"strjoin([\"a\", \"b\", \"c\"], \"-\")","'a-b-c'",[7066],{"_19":7098,"_21":7099,"_23":7100,"_25":7101,"_26":7102,"_32":7106,"_33":7107,"_6088":7111},"strsplit","parts = strsplit(str, delimiter)","Split string at delimiter","Splits a string at each occurrence of delimiter.",[7103,7104],{"_19":2103,"_25":6839},{"_19":7089,"_25":7105,"_31":61},"Delimiter string (default: whitespace)","Array of substrings",[7108],{"_281":7109,"_6083":7110},"strsplit(\"a-b-c\", \"-\")","['a', 'b', 'c']",[7080],{"_19":7013,"_21":7113,"_23":7114,"_25":7115,"_26":7116,"_32":7119,"_33":7120,"_6088":7124},"disp(X)","Display value","Displays the value of a variable or expression without the variable name.",[7117],{"_19":6292,"_25":7118},"Value to display","The input value (also displayed as output)",[7121],{"_281":7122,"_6083":7123},"disp('hello')","hello",[],{"_19":7126,"_21":7126,"_23":7127,"_25":7128,"_26":7129,"_32":62,"_33":7130,"_6088":7134},"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.",[],[7131],{"_281":7132,"_6083":7133},"tic\nA = rand(100);\ntoc","Elapsed time is 0.012345 seconds.",[7135],"toc",{"_19":7135,"_21":7137,"_23":7138,"_25":7139,"_26":7140,"_32":7141,"_33":7142,"_6088":7146},"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)",[7143],{"_281":7144,"_6083":7145},"tic\nfor i = 1:100\n rand(10);\nend\nt = toc","Elapsed time is 0.005123 seconds.\nt = 0.005123",[7126],{"_19":7148,"_21":7149,"_23":7150,"_25":7151,"_26":7152,"_32":7156,"_33":7157,"_6088":7164},"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.",[7153],{"_19":7154,"_25":7155},"expression","String containing M-Code to evaluate","Result of the evaluated expression",[7158,7161],{"_281":7159,"_6083":7160},"eval('x = 5')","x = 5",{"_281":7162,"_6083":7163},"Z = eval('magic(3)')","Z = [8 1 6; 3 5 7; 4 9 2]",[],{"_37":7166,"_19":7167,"_25":7168,"_41":42,"_43":7169,"_47":7170},"linalg","Linear Algebra","Matrix decompositions, solvers, products, norms, and other linear algebra operations.","📐",[7171,7190,7206,7217,7233,7248,7263,7275,7290,7304,7315,7329,7340,7358,7369,7387,7401,7413,7431,7447,7462,7476,7492,7508],{"_19":7172,"_21":7173,"_23":7174,"_25":7175,"_26":7176,"_32":7179,"_33":7180,"_6088":7186},"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.",[7177],{"_19":3766,"_25":7178},"Square matrix (n×n)","Eigenvalue vector, or [V, D] decomposition",[7181,7184],{"_281":7182,"_6083":7183},"eig([2 1; 1 2])","3\n1",{"_281":7185},"[V,D] = eig([2 1; 1 2])",[7187,7188,7189],"svd","det","inv",{"_19":7191,"_21":7192,"_23":7193,"_25":7194,"_26":7195,"_32":7179,"_33":7198,"_6088":7204},"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.",[7196],{"_19":3766,"_25":7197},"Symmetric/Hermitian matrix (n×n)",[7199,7202],{"_281":7200,"_6083":7201},"A = [2 1; 1 2];\nD = eigh(A)","1\n3",{"_281":7203},"[V, D] = eigh([2 1; 1 2])",[7172,7205,7187],"eigvalsh",{"_19":7205,"_21":7207,"_23":7208,"_25":7209,"_26":7210,"_32":7212,"_33":7213,"_6088":7216},"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.",[7211],{"_19":3766,"_25":7197},"Vector of eigenvalues in ascending order",[7214],{"_281":7215,"_6083":7201},"eigvalsh([2 1; 1 2])",[7191,7172],{"_19":7187,"_21":7218,"_23":7219,"_25":7220,"_26":7221,"_32":7224,"_33":7225,"_6088":7231},"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.",[7222],{"_19":3766,"_25":7223},"Input matrix (m×n)","Singular value vector, or [U, S, V] decomposition",[7226,7229],{"_281":7227,"_6083":7228},"svd([1 0; 0 2])","2\n1",{"_281":7230},"[U,S,V] = svd([1 0; 0 2])",[7172,7232,1883],"rank",{"_19":7234,"_21":7235,"_23":7236,"_25":7237,"_26":7238,"_32":7240,"_33":7241,"_6088":7246},"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).",[7239],{"_19":3766,"_25":7223},"R matrix, or [Q, R] decomposition",[7242,7244],{"_281":7243,"_6083":6117},"qr(eye(3))",{"_281":7245},"[Q,R] = qr([1 2; 3 4])",[7187,7247,7172],"chol",{"_19":7249,"_21":7250,"_23":7251,"_25":7252,"_26":7253,"_32":7255,"_33":7256,"_6088":7261},"lu","L = lu(A)\n[L,U,P] = lu(A)","LU decomposition with partial pivoting","Factorizes matrix A into lower triangular L (unit diagonal), upper triangular U, and permutation matrix P such that P*A = L*U. With one output, returns the lower triangular factor only.",[7254],{"_19":3766,"_25":7223},"Lower triangular factor L, or [L, U, P] decomposition",[7257,7259],{"_281":7258},"[L,U,P] = lu([2 1; 4 3])",{"_281":7260},"L = lu([1 2; 3 4])",[7234,7187,7247,7262],"linsolve",{"_19":7247,"_21":7264,"_23":7265,"_25":7266,"_26":7267,"_32":7270,"_33":7271,"_6088":7274},"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.",[7268],{"_19":3766,"_25":7269},"Symmetric positive-definite matrix (n×n)","Upper-triangular Cholesky factor R",[7272],{"_281":7273},"chol([4 2; 2 3])",[7234,7187,7189],{"_19":7188,"_21":7276,"_23":7277,"_25":7278,"_26":7279,"_32":7281,"_33":7282,"_6088":7288},"d = det(A)","Matrix determinant","Computes the determinant of a square matrix.",[7280],{"_19":3766,"_25":7178},"Scalar determinant value",[7283,7286],{"_281":7284,"_6083":7285},"det([1 2; 3 4])","-2",{"_281":7287,"_6083":6298},"det(eye(3))",[7189,7232,7289],"trace",{"_19":7189,"_21":7291,"_23":7292,"_25":7293,"_26":7294,"_32":7297,"_33":7298,"_6088":7302},"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.",[7295],{"_19":3766,"_25":7296},"Non-singular square matrix (n×n)","Inverse matrix (n×n)",[7299],{"_281":7300,"_6083":7301},"inv([1 2; 3 4])","-2.0000 1.0000\n1.5000 -0.5000",[7188,7303,7262],"pinv",{"_19":7303,"_21":7305,"_23":7306,"_25":7307,"_26":7308,"_32":7310,"_33":7311,"_6088":7314},"B = pinv(A)","Moore-Penrose pseudo-inverse","Computes the pseudo-inverse of a matrix. Works for non-square and singular matrices.",[7309],{"_19":3766,"_25":7223},"Pseudo-inverse matrix (n×m)",[7312],{"_281":7313},"pinv([1 0; 0 0])",[7189,7262,7232],{"_19":7232,"_21":7316,"_23":7317,"_25":7318,"_26":7319,"_32":7321,"_33":7322,"_6088":7327},"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.",[7320],{"_19":3766,"_25":6757},"Scalar rank",[7323,7325],{"_281":7324,"_6083":6468},"rank(eye(3))",{"_281":7326,"_6083":6298},"rank([1 2; 2 4])",[7187,7188,7328],"cond",{"_19":7289,"_21":7330,"_23":7331,"_25":7332,"_26":7333,"_32":7335,"_33":7336,"_6088":7339},"t = trace(A)","Sum of diagonal elements","Returns the sum of the elements on the main diagonal of a matrix.",[7334],{"_19":3766,"_25":6757},"Scalar trace value",[7337],{"_281":7338,"_6083":6519},"trace(eye(4))",[6119,7188,7172],{"_19":1883,"_21":7341,"_23":7342,"_25":7343,"_26":7344,"_32":7348,"_33":7349,"_6088":7357},"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).",[7345,7346],{"_19":3766,"_25":6772},{"_19":1111,"_25":7347,"_31":61},"Norm order or type: number (1, 2, Inf), or string ('fro', 'nuc')","Scalar norm value",[7350,7352,7355],{"_281":7351,"_6083":6494},"norm([3 4])",{"_281":7353,"_6083":7354},"norm([3 4], 1)","7",{"_281":7356},"norm([1 2; 3 4], 'fro')",[7328,7232,7188],{"_19":7328,"_21":7359,"_23":7360,"_25":7361,"_26":7362,"_32":7364,"_33":7365,"_6088":7368},"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.",[7363],{"_19":3766,"_25":6757},"Scalar condition number",[7366],{"_281":7367,"_6083":6298},"cond(eye(3))",[1883,7232,7188],{"_19":7370,"_21":7371,"_23":7372,"_25":7373,"_26":7374,"_32":7379,"_33":7380,"_6088":7385},"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.",[7375,7377],{"_19":3766,"_25":7376},"Coefficient matrix (m×n)",{"_19":191,"_25":7378},"Ordinate values (m×1) or (m×k)","Solution vector x, or [x, residuals, rank, s]",[7381,7383],{"_281":7382},"A = [1 0; 1 1; 1 2]; b = [1; 2; 3];\nx = lstsq(A, b)",{"_281":7384},"[x, res, rnk, s] = lstsq(A, b)",[7386,7303,7234],"mldivide",{"_19":7262,"_21":7388,"_23":7389,"_25":7390,"_26":7391,"_32":7396,"_33":7397,"_6088":7400},"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.",[7392,7394],{"_19":3766,"_25":7393},"Coefficient matrix (n×n)",{"_19":191,"_25":7395},"Right-hand side vector or matrix","Solution vector or matrix x",[7398],{"_281":7399},"A = [1 2; 3 4]; b = [5; 6]; linsolve(A, b)",[7386,7189,7188],{"_19":7386,"_21":7402,"_23":7403,"_25":7404,"_26":7405,"_32":7396,"_33":7409,"_6088":7412},"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.",[7406,7408],{"_19":3766,"_25":7407},"Coefficient matrix",{"_19":191,"_25":7395},[7410],{"_281":7411},"A = [1 2; 3 4]; b = [5; 6]; mldivide(A, b)",[7262,7189],{"_19":7414,"_21":7415,"_23":7416,"_25":7417,"_26":7418,"_32":7423,"_33":7424,"_6088":7427},"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.",[7419,7421],{"_19":3766,"_25":7420},"First array (..., M, K)",{"_19":6369,"_25":7422},"Second array (..., K, N)","Matrix product (..., M, N)",[7425],{"_281":7426},"matmul([1 2; 3 4], [5 6; 7 8])",[7428,7429,7430],"dot","kron","mpower",{"_19":7428,"_21":7432,"_23":7433,"_25":7434,"_26":7435,"_32":7440,"_33":7441,"_6088":7445},"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.",[7436,7438],{"_19":189,"_25":7437},"First input array",{"_19":191,"_25":7439},"Second input array","Dot product result",[7442],{"_281":7443,"_6083":7444},"dot([1 2 3], [4 5 6])","32",[7446,7429],"cross",{"_19":7446,"_21":7448,"_23":7449,"_25":7450,"_26":7451,"_32":7456,"_33":7457,"_6088":7461},"c = cross(a, b)","Cross product","Computes the cross product of two 3-element vectors.",[7452,7454],{"_19":189,"_25":7453},"First 3-element vector",{"_19":191,"_25":7455},"Second 3-element vector","3-element cross product vector",[7458],{"_281":7459,"_6083":7460},"cross([1 0 0], [0 1 0])","0 0 1",[7428,7429],{"_19":7429,"_21":7463,"_23":7464,"_25":7465,"_26":7466,"_32":7471,"_33":7472,"_6088":7475},"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.",[7467,7469],{"_19":3766,"_25":7468},"First input matrix",{"_19":6369,"_25":7470},"Second input matrix","Kronecker product matrix",[7473],{"_281":7474},"kron([1 0; 0 1], [1 2; 3 4])",[7428,7446],{"_19":7477,"_21":7478,"_23":7479,"_25":7480,"_26":7481,"_32":7486,"_33":7487,"_6088":7491},"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).",[7482,7484],{"_19":189,"_25":7483},"First vector (m-element)",{"_19":191,"_25":7485},"Second vector (n-element)","Outer product matrix (m x n)",[7488],{"_281":7489,"_6083":7490},"outer([1 2 3], [4 5])","4 5\n8 10\n12 15",[7428,7446,7429],{"_19":7493,"_21":7494,"_23":7495,"_25":7496,"_26":7497,"_32":7503,"_33":7504,"_6088":7507},"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).",[7498,7500],{"_19":1730,"_25":7499},"Subscript string (e.g., \"ij,jk->ik\")",{"_19":7501,"_25":7502},"A,B,...","Input arrays","Result array according to subscripts",[7505],{"_281":7506},"einsum('ij,jk->ik', A, B)",[7428,7414],{"_19":7430,"_21":7509,"_23":7510,"_25":7511,"_26":7512,"_32":7516,"_33":7517,"_6088":7520},"B = mpower(A, n)","Matrix power","Raises a square matrix to an integer power. Negative exponents compute the inverse raised to the absolute power.",[7513,7514],{"_19":3766,"_25":7178},{"_19":1516,"_25":7515},"Integer exponent","Matrix raised to power n",[7518],{"_281":7519,"_6083":6117},"mpower(eye(3), 2)",[7189,7188],{"_37":7522,"_19":7523,"_25":7524,"_41":42,"_43":7525,"_47":7526},"fft","Fourier Analysis","Fast Fourier Transform, inverse transforms, frequency utilities, and window functions for spectral analysis.","〰️",[7527,7547,7564,7577,7589,7601,7613,7626,7638,7652,7669,7680,7691,7702],{"_19":7522,"_21":7528,"_23":7529,"_25":7530,"_26":7531,"_32":7536,"_33":7537,"_6088":7542},"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.",[7532,7534],{"_19":6292,"_25":7533},"Input signal (vector or array)",{"_19":1516,"_25":7535,"_31":61},"Transform length (zero-pads or truncates)","Complex-valued frequency-domain representation",[7538,7540],{"_281":7539},"fft([1 2 3 4])",{"_281":7541},"fft([1 0 1 0], 8)",[7543,7544,7545,7546],"ifft","fft2","fftshift","fftfreq",{"_19":7543,"_21":7548,"_23":7549,"_25":7550,"_26":7551,"_32":7557,"_33":7558,"_6088":7561},"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.",[7552,7555],{"_19":7553,"_25":7554},"Y","Frequency-domain input",{"_19":1516,"_25":7556,"_31":61},"Transform length","Time-domain signal",[7559],{"_281":7560},"ifft(fft([1 2 3 4]))",[7522,7562,7563],"ifft2","ifftn",{"_19":7544,"_21":7565,"_23":7566,"_25":7567,"_26":7568,"_32":7571,"_33":7572,"_6088":7575},"Y = fft2(X)","2-D Fast Fourier Transform","Computes the two-dimensional discrete Fourier Transform. Useful for image processing and 2-D signal analysis.",[7569],{"_19":6292,"_25":7570},"Input 2-D array","2-D frequency-domain representation",[7573],{"_281":7574},"fft2(eye(4))",[7562,7522,7576],"fftn",{"_19":7562,"_21":7578,"_23":7579,"_25":7580,"_26":7581,"_32":7584,"_33":7585,"_6088":7588},"x = ifft2(Y)","2-D inverse FFT","Computes the two-dimensional inverse discrete Fourier Transform.",[7582],{"_19":7553,"_25":7583},"Frequency-domain 2-D input","Spatial-domain 2-D signal",[7586],{"_281":7587},"ifft2(fft2(eye(4)))",[7544,7543,7563],{"_19":7576,"_21":7590,"_23":7591,"_25":7592,"_26":7593,"_32":7596,"_33":7597,"_6088":7600},"Y = fftn(X)","N-dimensional FFT","Computes the N-dimensional discrete Fourier Transform over all axes of the input array.",[7594],{"_19":6292,"_25":7595},"Input N-D array","N-D frequency-domain representation",[7598],{"_281":7599},"fftn(ones(4, 4))",[7563,7522,7544],{"_19":7563,"_21":7602,"_23":7603,"_25":7604,"_26":7605,"_32":7608,"_33":7609,"_6088":7612},"x = ifftn(Y)","N-dimensional inverse FFT","Computes the N-dimensional inverse discrete Fourier Transform.",[7606],{"_19":7553,"_25":7607},"Frequency-domain N-D input","Spatial-domain N-D signal",[7610],{"_281":7611},"ifftn(fftn(ones(4, 4)))",[7576,7543,7562],{"_19":7545,"_21":7614,"_23":7615,"_25":7616,"_26":7617,"_32":7620,"_33":7621,"_6088":7624},"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.",[7618],{"_19":6292,"_25":7619},"Input array (typically output of fft)","Shifted array",[7622],{"_281":7623},"fftshift(fft([1 2 3 4 5 6 7 8]))",[7625,7522,7546],"ifftshift",{"_19":7625,"_21":7627,"_23":7628,"_25":7629,"_26":7630,"_32":7633,"_33":7634,"_6088":7637},"Y = ifftshift(X)","Inverse of fftshift","Undoes the effect of `fftshift`. Shifts the zero-frequency component back to the beginning of the array.",[7631],{"_19":6292,"_25":7632},"Shifted input array","Unshifted array",[7635],{"_281":7636},"ifftshift(fftshift([1 2 3 4]))",[7545,7522],{"_19":7546,"_21":7639,"_23":7640,"_25":7641,"_26":7642,"_32":7647,"_33":7648,"_6088":7651},"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`.",[7643,7645],{"_19":1516,"_25":7644},"Window length (number of samples)",{"_19":1909,"_25":7646,"_31":61},"Sample spacing (default: 1.0)","Array of sample frequencies",[7649],{"_281":7650},"fftfreq(8, 0.1)",[7522,7545],{"_19":7653,"_21":7654,"_23":7655,"_25":7656,"_26":7657,"_32":7660,"_33":7661,"_6088":7664},"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.",[7658],{"_19":715,"_25":7659},"Number of points in the window","M-point Bartlett window vector",[7662],{"_281":7663},"bartlett(8)",[7665,7666,7667,7668],"hamming","hanning","blackman","kaiser",{"_19":7667,"_21":7670,"_23":7671,"_25":7672,"_26":7673,"_32":7675,"_33":7676,"_6088":7679},"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.",[7674],{"_19":715,"_25":7659},"M-point Blackman window vector",[7677],{"_281":7678},"blackman(8)",[7665,7666,7653,7668],{"_19":7665,"_21":7681,"_23":7682,"_25":7683,"_26":7684,"_32":7686,"_33":7687,"_6088":7690},"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)).",[7685],{"_19":715,"_25":7659},"M-point Hamming window vector",[7688],{"_281":7689},"hamming(8)",[7666,7667,7653,7668],{"_19":7666,"_21":7692,"_23":7693,"_25":7694,"_26":7695,"_32":7697,"_33":7698,"_6088":7701},"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))).",[7696],{"_19":715,"_25":7659},"M-point Hanning window vector",[7699],{"_281":7700},"hanning(8)",[7665,7667,7653,7668],{"_19":7668,"_21":7703,"_23":7704,"_25":7705,"_26":7706,"_32":7710,"_33":7711,"_6088":7714},"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).",[7707,7708],{"_19":715,"_25":7659},{"_19":3202,"_25":7709},"Shape parameter controlling the trade-off","M-point Kaiser window vector",[7712],{"_281":7713},"kaiser(8, 5)",[7665,7666,7667,7653],{"_37":7716,"_19":7717,"_25":7718,"_41":42,"_43":7719,"_47":7720},"plotting","Data Visualization","M-Code-style plotting functions for inline Chart.js visualizations.","📊",[7721,7741,7755,7766,7777,7792,7806,7830,7856,7894,7908,7919,7935,7946,7956,7968,7982,7997,8010,8023,8033,8047,8057,8070,8082,8093,8103,8112,8121,8133,8149,8161,8180,8200,8213,8223,8244,8269,8289,8310],{"_19":7722,"_21":7723,"_23":7724,"_25":7725,"_26":7726,"_32":7731,"_33":7732,"_6088":7735},"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.",[7727,7729],{"_19":29,"_25":7728,"_31":61},"X-axis data (NDArray or scalar)",{"_19":135,"_25":7730},"Y-axis data (NDArray or scalar)","null (renders chart inline)",[7733],{"_281":7734},"x = linspace(0, 2*pi, 50);\nplot(x, sin(x))",[7736,7737,7738,7739,7740],"scatter","bar","loglog","semilogx","semilogy",{"_19":7738,"_21":7742,"_23":7743,"_25":7744,"_26":7745,"_32":7748,"_33":7749,"_6088":7754},"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.",[7746,7747],{"_19":29,"_25":7728,"_31":61},{"_19":135,"_25":7730},"Line handle",[7750,7752],{"_281":7751},"x = 1:100;\ny = x.^2;\nloglog(x, y)",{"_281":7753},"x = logspace(0, 3, 50);\nloglog(x, x.^(-1.5))",[7722,7739,7740],{"_19":7739,"_21":7756,"_23":7757,"_25":7758,"_26":7759,"_32":7748,"_33":7762,"_6088":7765},"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.",[7760,7761],{"_19":29,"_25":7728,"_31":61},{"_19":135,"_25":7730},[7763],{"_281":7764},"x = logspace(0, 3, 50);\nsemilogx(x, log10(x))",[7722,7738,7740],{"_19":7740,"_21":7767,"_23":7768,"_25":7769,"_26":7770,"_32":7748,"_33":7773,"_6088":7776},"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.",[7771,7772],{"_19":29,"_25":7728,"_31":61},{"_19":135,"_25":7730},[7774],{"_281":7775},"x = 1:10;\ny = 10.^x;\nsemilogy(x, y)",[7722,7738,7739],{"_19":7737,"_21":7778,"_23":7779,"_25":7780,"_26":7781,"_32":7731,"_33":7786,"_6088":7789},"bar(y)\nbar(x, y)","Bar chart","Creates a vertical bar chart.",[7782,7784],{"_19":29,"_25":7783,"_31":61},"Category positions or labels (NDArray)",{"_19":135,"_25":7785},"Bar heights (NDArray)",[7787],{"_281":7788},"bar([3 7 2 5])",[7722,7790,7791],"histogram","pie",{"_19":7736,"_21":7793,"_23":7794,"_25":7795,"_26":7796,"_32":7731,"_33":7801,"_6088":7804},"scatter(x, y)","Scatter plot","Creates a scatter plot of y versus x.",[7797,7799],{"_19":29,"_25":7798},"X-coordinates (NDArray)",{"_19":135,"_25":7800},"Y-coordinates (NDArray)",[7802],{"_281":7803},"scatter(rand(20, 1), rand(20, 1))",[7722,7737,7805],"spy",{"_19":7805,"_21":7807,"_23":7808,"_25":7809,"_26":7810,"_32":7731,"_33":7820,"_6088":7827},"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.",[7811,7814,7817],{"_19":7812,"_25":7813},"S","Input matrix (sparse or full)",{"_19":7815,"_25":7816,"_31":61},"linespec","Line specification for marker style (e.g., 'ro' for red circles)",{"_19":7818,"_25":7819,"_31":61},"markersize","Marker size in points (default: auto-scaled based on matrix size)",[7821,7823,7825],{"_281":7822},"A = eye(10);\nspy(A)",{"_281":7824},"B = rand(20, 20) > 0.8;\nspy(B)",{"_281":7826},"spy(magic(10) > 50, 'ro', 8)",[7736,7828,6639,7829],"imagesc","nnz",{"_19":7831,"_21":7832,"_23":7833,"_25":7834,"_26":7835,"_32":7849,"_33":7850,"_6088":7855},"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).",[7836,7838,7840,7843,7846],{"_19":6292,"_25":7837,"_31":61},"Arrow base X-coordinates (matrix or vector)",{"_19":7553,"_25":7839,"_31":61},"Arrow base Y-coordinates (matrix or vector)",{"_19":7841,"_25":7842},"U","Arrow X-direction components (matrix or vector)",{"_19":7844,"_25":7845},"V","Arrow Y-direction components (matrix or vector)",{"_19":7847,"_25":7848,"_31":61},"scale","Arrow scaling factor (default: 1, 0 disables auto-scaling)","Graphics handle",[7851,7853],{"_281":7852},"[X, Y] = meshgrid(1:5, 1:5);\nquiver(X, Y, ones(5), ones(5))",{"_281":7854},"U = cos(linspace(0, 2*pi, 25));\nV = sin(linspace(0, 2*pi, 25));\nquiver(U, V)",[7722,7736,6206],{"_19":7857,"_21":7858,"_23":7859,"_25":7860,"_26":7861,"_32":7849,"_33":7884,"_6088":7891},"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].",[7862,7864,7866,7869,7872,7875,7878,7881],{"_19":6292,"_25":7863},"X-coordinates of polygon vertices (vector)",{"_19":7553,"_25":7865},"Y-coordinates of polygon vertices (vector)",{"_19":7867,"_25":7868,"_31":61},"C","Color specification: short name, long name, or RGB triplet",{"_19":7870,"_25":7871,"_31":61},"FaceColor","Fill color (Name-Value pair)",{"_19":7873,"_25":7874,"_31":61},"FaceAlpha","Fill transparency 0-1 (Name-Value pair)",{"_19":7876,"_25":7877,"_31":61},"EdgeColor","Edge color or 'none' (Name-Value pair)",{"_19":7879,"_25":7880,"_31":61},"LineWidth","Edge line width (Name-Value pair)",{"_19":7882,"_25":7883,"_31":61},"LineStyle","Edge line style: '-', '--', ':', '-.', 'none' (Name-Value pair)",[7885,7887,7889],{"_281":7886},"fill([0 1 0.5], [0 0 1], 'r')",{"_281":7888},"x = cos(linspace(0, 2*pi, 6));\ny = sin(linspace(0, 2*pi, 6));\nfill(x, y, 'b', 'FaceAlpha', 0.5)",{"_281":7890},"fill([0 1 1 0], [0 0 1 1], [0.2 0.6 0.8], 'EdgeColor', 'none')",[7722,7892,7893],"patch","area",{"_19":7790,"_21":7895,"_23":7896,"_25":7897,"_26":7898,"_32":7731,"_33":7904,"_6088":7907},"histogram(data)\nhistogram(data, numBins)","Histogram","Creates a histogram of the data, auto-binned into the specified number of bins (default 10).",[7899,7901],{"_19":528,"_25":7900},"Input data (NDArray)",{"_19":7902,"_25":7903,"_31":61},"numBins","Number of bins (default: 10)",[7905],{"_281":7906},"histogram(randn(100, 1))",[7737,7722],{"_19":7791,"_21":7909,"_23":7910,"_25":7911,"_26":7912,"_32":7731,"_33":7915,"_6088":7918},"pie(data)","Pie chart","Creates a pie chart from the data values.",[7913],{"_19":528,"_25":7914},"Slice values (NDArray)",[7916],{"_281":7917},"pie([30 20 50])",[7737,7790],{"_19":7920,"_21":7921,"_23":7922,"_25":7923,"_26":7924,"_32":7927,"_33":7928,"_6088":7931},"title","title(str)","Add title to current chart","Sets the title of the most recently created chart.",[7925],{"_19":2103,"_25":7926},"Title string","null",[7929],{"_281":7930},"plot([1 4 9 16]);\ntitle('Squares')",[7932,7933,7934],"xlabel","ylabel","legend",{"_19":7932,"_21":7936,"_23":7937,"_25":7938,"_26":7939,"_32":7927,"_33":7942,"_6088":7945},"xlabel(str)","Label x-axis","Sets the x-axis label of the most recently created chart.",[7940],{"_19":2103,"_25":7941},"Label string",[7943],{"_281":7944},"xlabel('Time (s)')",[7933,7920],{"_19":7933,"_21":7947,"_23":7948,"_25":7949,"_26":7950,"_32":7927,"_33":7952,"_6088":7955},"ylabel(str)","Label y-axis","Sets the y-axis label of the most recently created chart.",[7951],{"_19":2103,"_25":7941},[7953],{"_281":7954},"ylabel('Amplitude')",[7932,7920],{"_19":7934,"_21":7957,"_23":7958,"_25":7959,"_26":7960,"_32":7927,"_33":7964,"_6088":7967},"legend('label1', 'label2', ...)","Add legend to current chart","Adds a legend to the most recently created chart with the given labels.",[7961],{"_19":7962,"_25":7963},"labels","One or more string labels",[7965],{"_281":7966},"legend('sin', 'cos')",[7920,7932,7933],{"_19":7969,"_21":7970,"_23":7971,"_25":7972,"_26":7973,"_32":7927,"_33":7976,"_6088":7979},"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.",[7974],{"_19":1516,"_25":7975,"_31":61},"Figure number",[7977],{"_281":7978},"plot([1 2 3]);\nfigure();\nplot([4 5 6])",[7722,7737,7736,7980,7981],"gcf","clf",{"_19":7983,"_21":7984,"_23":7985,"_25":7986,"_26":7987,"_32":7927,"_33":7992,"_6088":7995},"xlim","xlim([min max])","Set x-axis limits","Sets the minimum and maximum values for the x-axis of the current chart.",[7988,7990],{"_19":6552,"_25":7989},"Minimum x value",{"_19":6553,"_25":7991},"Maximum x value",[7993],{"_281":7994},"plot([1 2 3 4]);\nxlim([0 5])",[7996,323],"ylim",{"_19":7996,"_21":7998,"_23":7999,"_25":8000,"_26":8001,"_32":7927,"_33":8006,"_6088":8009},"ylim([min max])","Set y-axis limits","Sets the minimum and maximum values for the y-axis of the current chart.",[8002,8004],{"_19":6552,"_25":8003},"Minimum y value",{"_19":6553,"_25":8005},"Maximum y value",[8007],{"_281":8008},"plot([1 2 3 4]);\nylim([0 5])",[7983,323],{"_19":8011,"_21":8012,"_23":8013,"_25":8014,"_26":8015,"_32":7927,"_33":8018,"_6088":8021},"xticks","xticks(values)","Set x-axis tick values","Sets custom tick mark positions on the x-axis.",[8016],{"_19":376,"_25":8017},"Vector of tick positions",[8019],{"_281":8020},"plot([1 2 3 4]);\nxticks([1 2 3 4])",[8022,7983],"yticks",{"_19":8022,"_21":8024,"_23":8025,"_25":8026,"_26":8027,"_32":7927,"_33":8029,"_6088":8032},"yticks(values)","Set y-axis tick values","Sets custom tick mark positions on the y-axis.",[8028],{"_19":376,"_25":8017},[8030],{"_281":8031},"bar([10 20 30]);\nyticks([0 10 20 30])",[8011,7996],{"_19":8034,"_21":8035,"_23":8036,"_25":8037,"_26":8038,"_32":7927,"_33":8042,"_6088":8045},"xtickangle","xtickangle(angle)","Rotate x-axis tick labels","Sets the rotation angle (in degrees) for x-axis tick labels.",[8039],{"_19":8040,"_25":8041},"angle","Rotation angle in degrees",[8043],{"_281":8044},"bar([1 2 3]);\nxtickangle(45)",[8046,8011],"ytickangle",{"_19":8046,"_21":8048,"_23":8049,"_25":8050,"_26":8051,"_32":7927,"_33":8053,"_6088":8056},"ytickangle(angle)","Rotate y-axis tick labels","Sets the rotation angle (in degrees) for y-axis tick labels.",[8052],{"_19":8040,"_25":8041},[8054],{"_281":8055},"bar([1 2 3]);\nytickangle(90)",[8034,8022],{"_19":8058,"_21":8059,"_23":8060,"_25":8061,"_26":8062,"_32":7927,"_33":8066,"_6088":8069},"grid","grid\ngrid('on')\ngrid('off')","Toggle grid lines","Controls the visibility of grid lines on the current chart.",[8063],{"_19":8064,"_25":8065,"_31":61},"state","'on' or 'off' (default: toggle)",[8067],{"_281":8068},"plot([1 2 3]);\ngrid('on')",[323,7983,7996],{"_19":323,"_21":8071,"_23":8072,"_25":8073,"_26":8074,"_32":7927,"_33":8078,"_6088":8081},"axis([xmin xmax ymin ymax])","Set axis limits and scaling","Sets the limits for both x and y axes simultaneously.",[8075],{"_19":8076,"_25":8077},"limits","4-element vector [xmin xmax ymin ymax]",[8079],{"_281":8080},"plot([1 2 3]);\naxis([0 4 0 4])",[7983,7996,8058],{"_19":8083,"_21":8084,"_23":8085,"_25":8086,"_26":8087,"_32":7927,"_33":8089,"_6088":8092},"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.",[8088],{"_19":8064,"_25":8065,"_31":61},[8090],{"_281":8091},"plot([1 2 3]);\nhold('on');\nbar([2 3 4])",[7969,7722],{"_19":7980,"_21":8094,"_23":8095,"_25":8096,"_26":8097,"_32":8098,"_33":8099,"_6088":8101},"f = gcf","Get current figure","Returns the handle (ID) of the current figure.",[],"Figure ID number",[8100],{"_281":8094},[7969,8102,7981],"gca",{"_19":8102,"_21":8104,"_23":8105,"_25":8106,"_26":8107,"_32":8108,"_33":8109,"_6088":8111},"ax = gca","Get current axes","Returns the handle (ID) of the current axes (same as gcf in this implementation).",[],"Axes ID number",[8110],{"_281":8104},[7980,7969],{"_19":7981,"_21":7981,"_23":8113,"_25":8114,"_26":8115,"_32":7927,"_33":8116,"_6088":8119},"Clear current figure","Clears all charts from the current figure, resetting its state.",[],[8117],{"_281":8118},"plot([1 2 3]);\nclf()",[8120,7969],"close",{"_19":8120,"_21":8122,"_23":8123,"_25":8124,"_26":8125,"_32":7927,"_33":8129,"_6088":8132},"close\nclose(fig)","Close figure","Closes the current figure or the specified figure by ID.",[8126],{"_19":8127,"_25":8128,"_31":61},"fig","Figure ID to close",[8130],{"_281":8131},"close()",[7981,7969],{"_19":8134,"_21":8135,"_23":8136,"_25":8137,"_26":8138,"_32":7927,"_33":8145,"_6088":8148},"text","text(x, y, str)","Add text annotation","Adds a text annotation at the specified (x, y) coordinates in data units.",[8139,8141,8143],{"_19":29,"_25":8140},"X-coordinate",{"_19":135,"_25":8142},"Y-coordinate",{"_19":2103,"_25":8144},"Text string",[8146],{"_281":8147},"plot([1 2 3]);\ntext(2, 2.5, 'Peak')",[7920,7932,7933],{"_19":8150,"_21":8151,"_23":8152,"_25":8153,"_26":8154,"_32":7927,"_33":8157,"_6088":8160},"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.",[8155],{"_19":5058,"_25":8156},"'left' or 'right'",[8158],{"_281":8159},"plot([1 2 3]);\nyyaxis('right');\nplot([10 20 30])",[7933,7996],{"_19":8162,"_21":8163,"_23":8164,"_25":8165,"_26":8166,"_32":7927,"_33":8176,"_6088":8179},"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).",[8167,8170,8173],{"_19":8168,"_25":8169},"rows","Number of rows in grid",{"_19":8171,"_25":8172},"cols","Number of columns in grid",{"_19":8174,"_25":8175},"index","1-based position in grid (row-major order)",[8177],{"_281":8178},"subplot(2, 2, 1);\nplot([1 2 3]);\nsubplot(2, 2, 2);\nbar([4 5 6])",[7969,7722],{"_19":6229,"_21":8181,"_23":8182,"_25":8183,"_26":8184,"_32":8194,"_33":8195,"_6088":8198},"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.",[8185,8187,8189,8192],{"_19":6292,"_25":8186,"_31":61},"X-coordinate matrix (auto-generated if omitted)",{"_19":7553,"_25":8188,"_31":61},"Y-coordinate matrix (auto-generated if omitted)",{"_19":8190,"_25":8191},"Z","Height matrix (required)",{"_19":7867,"_25":8193,"_31":61},"Color data matrix (defaults to Z)","null (renders 3D chart inline)",[8196],{"_281":8197},"[X, Y] = meshgrid(-2:0.2:2);\nZ = X .* exp(-X.^2 - Y.^2);\nmesh(X, Y, Z)",[6228,6206,8199],"zlabel",{"_19":6228,"_21":8201,"_23":8202,"_25":8203,"_26":8204,"_32":8194,"_33":8209,"_6088":8212},"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.",[8205,8206,8207,8208],{"_19":6292,"_25":8186,"_31":61},{"_19":7553,"_25":8188,"_31":61},{"_19":8190,"_25":8191},{"_19":7867,"_25":8193,"_31":61},[8210],{"_281":8211},"[X, Y] = meshgrid(-2:0.2:2);\nZ = X .* exp(-X.^2 - Y.^2);\nsurf(X, Y, Z)",[6229,6206,8199],{"_19":8199,"_21":8214,"_23":8215,"_25":8216,"_26":8217,"_32":7927,"_33":8219,"_6088":8222},"zlabel(str)","Label z-axis","Sets the z-axis label of the most recently created 3D chart.",[8218],{"_19":2103,"_25":7941},[8220],{"_281":8221},"[X, Y] = meshgrid(-2:0.2:2);\nZ = X .* exp(-X.^2 - Y.^2);\nsurf(X, Y, Z);\nzlabel('Height')",[7932,7933,7920,6229,6228],{"_19":8224,"_21":8225,"_23":8226,"_25":8227,"_26":8228,"_32":8235,"_33":8236,"_6088":8243},"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).",[8229,8232],{"_19":8230,"_25":8231,"_31":61},"az","Azimuth angle in degrees",{"_19":8233,"_25":8234,"_31":61},"el","Elevation angle in degrees","With no arguments, returns [az, el] of current view",[8237,8239,8241],{"_281":8238},"[X, Y] = meshgrid(-2:0.2:2);\nZ = X .* exp(-X.^2 - Y.^2);\nsurf(X, Y, Z);\nview(45, 30)",{"_281":8240},"[X, Y] = meshgrid(-2:0.2:2);\nZ = sin(X) .* cos(Y);\nsurf(X, Y, Z);\nview(2) % Top-down view",{"_281":8242},"[X, Y] = meshgrid(-2:0.2:2);\nZ = X.^2 - Y.^2;\nmesh(X, Y, Z);\nview(3) % Default 3D view",[6229,6228,8199],{"_19":7828,"_21":8245,"_23":8246,"_25":8247,"_26":8248,"_32":8258,"_33":8259,"_6088":8266},"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.",[8249,8251,8253,8255],{"_19":29,"_25":8250,"_31":61},"X-axis coordinates for columns (2-element vector or full vector)",{"_19":135,"_25":8252,"_31":61},"Y-axis coordinates for rows (2-element vector or full vector)",{"_19":7867,"_25":8254},"Data matrix to display",{"_19":8256,"_25":8257,"_31":61},"clims","Color limits [cmin cmax]","null (renders heatmap inline)",[8260,8262,8264],{"_281":8261},"A = magic(5);\nimagesc(A)",{"_281":8263},"A = peaks(50);\nimagesc(A)\ncolorbar",{"_281":8265},"imagesc([0 10], [0 5], rand(10, 20))\ntitle('Random data')",[8267,8268,6229,6228],"colorbar","colormap",{"_19":8267,"_21":8270,"_23":8271,"_25":8272,"_26":8273,"_32":8277,"_33":8278,"_6088":8287},"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().",[8274],{"_19":8275,"_25":8276,"_31":61},"location","Location string: 'eastoutside' (default), 'westoutside', 'northoutside', 'southoutside', or 'off'","Colorbar handle (when assigned to variable)",[8279,8281,8283,8285],{"_281":8280},"imagesc(peaks(30));\ncolorbar",{"_281":8282},"surf(peaks(30));\ncolorbar('southoutside')",{"_281":8284},"imagesc(rand(20));\nc = colorbar;\nset(c, 'Title', 'Values')",{"_281":8286},"mesh(peaks);\ncolorbar('off')",[7828,8268,6229,6228,8288],"set",{"_19":8268,"_21":8290,"_23":8291,"_25":8292,"_26":8293,"_32":8299,"_33":8300,"_6088":8309},"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].",[8294,8296],{"_19":19,"_25":8295,"_31":61},"Colormap name: viridis (default), jet, hot, cool, gray, grayscale, parula, turbo, coolwarm, rainbow, bone, copper, spring, summer, autumn, winter",{"_19":8297,"_25":8298,"_31":61},"map","Mx3 matrix of RGB values (each in [0,1])","Mx3 RGB matrix (query mode) or null (set mode)",[8301,8303,8305,8307],{"_281":8302},"imagesc(peaks(30));\ncolormap('jet');\ncolorbar",{"_281":8304},"surf(peaks(25));\ncolormap('hot')",{"_281":8306},"cmap = colormap % returns 256x3 matrix",{"_281":8308},"colormap([0 0 1; 1 1 1; 1 0 0]) % custom blue-white-red",[7828,8267,6229,6228],{"_19":8311,"_21":8312,"_23":8313,"_25":8314,"_26":8315,"_32":7927,"_33":8318,"_6088":8323},"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.",[8316],{"_19":1137,"_25":8317},"Shading mode: 'faceted' (default), 'flat', or 'interp'",[8319,8321],{"_281":8320},"surf(peaks(30));\nshading interp",{"_281":8322},"[X, Y] = meshgrid(-2:0.2:2);\nZ = X .* exp(-X.^2 - Y.^2);\nsurf(X, Y, Z);\nshading flat;\ncolorbar",[6228,6229,8268,8267],{"_37":8325,"_19":8326,"_25":8327,"_41":42,"_43":8328,"_47":8329},"poly","Polynomial Functions","Polynomial operations across power, Chebyshev, Legendre, Hermite, HermiteE, and Laguerre bases with fitting, evaluation, calculus, arithmetic, and conversion utilities.","∑",[8330,8349,8367,8381,8396,8412,8431,8445,8458,8471,8486,8500,8511,8522,8537,8552,8565,8577,8594,8609,8625,8636,8647,8660,8675,8685,8696,8705,8717,8730,8740,8748,8760,8772,8786,8801,8813,8823,8836,8845,8854,8863,8873,8884,8892,8900,8910,8920,8931,8944,8953,8963,8972,8981,8990,8999,9008,9016,9024,9032,9041,9051,9062,9073,9082,9092,9101,9110,9119,9128,9137,9145,9153,9161,9170,9180,9191,9204,9213,9223,9232,9241,9250,9259,9268,9276,9284,9292,9301,9311,9322,9332,9340,9348,9356,9364,9380,9393,9409,9425],{"_19":8331,"_21":8332,"_23":8333,"_25":8334,"_26":8335,"_32":8340,"_33":8341,"_6088":8345},"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 + ...",[8336,8338],{"_19":29,"_25":8337},"Point at which to evaluate",{"_19":929,"_25":8339},"Coefficient array in ascending order [c0, c1, c2, ...]","Polynomial value at x",[8342],{"_281":8343,"_6083":8344},"polyval(2, [1 2 3])","17",[8346,8347,8348],"polyfit","polyder","polyint",{"_19":8350,"_21":8351,"_23":8352,"_25":8353,"_26":8354,"_32":8361,"_33":8362,"_6088":8365},"polyval2d","z = polyval2d(x, y, c)","Evaluate 2-D power series polynomial","Evaluates a 2-D power series polynomial on x-y pairs.",[8355,8357,8359],{"_19":29,"_25":8356},"x coordinates",{"_19":135,"_25":8358},"y coordinates",{"_19":929,"_25":8360},"2-D coefficient array","Polynomial values at (x, y) pairs",[8363],{"_281":8364},"polyval2d([1 2], [1 2], [1 0; 0 1])",[8331,8366],"polyval3d",{"_19":8366,"_21":8368,"_23":8369,"_25":8370,"_26":8371,"_32":8378,"_33":8379,"_6088":8380},"w = polyval3d(x, y, z, c)","Evaluate 3-D power series polynomial","Evaluates a 3-D power series polynomial on x-y-z triples.",[8372,8373,8374,8376],{"_19":29,"_25":8356},{"_19":135,"_25":8358},{"_19":352,"_25":8375},"z coordinates",{"_19":929,"_25":8377},"3-D coefficient array","Polynomial values at (x, y, z) triples",[],[8331,8350],{"_19":8347,"_21":8382,"_23":8383,"_25":8384,"_26":8385,"_32":8390,"_33":8391,"_6088":8395},"dc = polyder(c)\ndc = polyder(c, m)","Power series derivative","Differentiates a power series polynomial m times. Default m = 1.",[8386,8388],{"_19":929,"_25":8387},"Coefficient array in ascending order",{"_19":958,"_25":8389,"_31":61},"Number of derivatives (default: 1)","Differentiated coefficient array",[8392],{"_281":8393,"_6083":8394},"polyder([1 2 3])","[2 6]",[8348,8331],{"_19":8348,"_21":8397,"_23":8398,"_25":8399,"_26":8400,"_32":8406,"_33":8407,"_6088":8411},"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].",[8401,8402,8404],{"_19":929,"_25":8387},{"_19":958,"_25":8403,"_31":61},"Number of integrations (default: 1)",{"_19":1010,"_25":8405,"_31":61},"Integration constants (default: all zero)","Integrated coefficient array",[8408],{"_281":8409,"_6083":8410},"polyint([2 6])","[0 2 3]",[8347,8331],{"_19":8413,"_21":8414,"_23":8415,"_25":8416,"_26":8417,"_32":8422,"_33":8423,"_6088":8427},"polymul","c = polymul(c1, c2)","Multiply two power series polynomials","Multiplies two power series coefficient arrays using convolution.",[8418,8420],{"_19":939,"_25":8419},"First coefficient array",{"_19":941,"_25":8421},"Second coefficient array","Product coefficient array",[8424],{"_281":8425,"_6083":8426},"polymul([1 1], [1 1])","[1 2 1]",[8428,8429,8430],"polydiv","polyadd","polysub",{"_19":8428,"_21":8432,"_23":8433,"_25":8434,"_26":8435,"_32":8440,"_33":8441,"_6088":8444},"[q, r] = polydiv(c1, c2)","Divide two power series polynomials","Divides two power series coefficient arrays. Returns quotient and remainder.",[8436,8438],{"_19":939,"_25":8437},"Dividend coefficient array",{"_19":941,"_25":8439},"Divisor coefficient array","Quotient and remainder coefficient arrays",[8442],{"_281":8443},"polydiv([1 2 1], [1 1])",[8413,8429,8430],{"_19":8429,"_21":8446,"_23":8447,"_25":8448,"_26":8449,"_32":8452,"_33":8453,"_6088":8457},"c = polyadd(c1, c2)","Add two power series polynomials","Adds two power series coefficient arrays.",[8450,8451],{"_19":939,"_25":8419},{"_19":941,"_25":8421},"Sum coefficient array",[8454],{"_281":8455,"_6083":8456},"polyadd([1 2], [3 4])","[4 6]",[8430,8413,8428],{"_19":8430,"_21":8459,"_23":8460,"_25":8461,"_26":8462,"_32":8465,"_33":8466,"_6088":8470},"c = polysub(c1, c2)","Subtract two power series polynomials","Subtracts two power series coefficient arrays.",[8463,8464],{"_19":939,"_25":8419},{"_19":941,"_25":8421},"Difference coefficient array",[8467],{"_281":8468,"_6083":8469},"polysub([3 4], [1 2])","[2 2]",[8429,8413,8428],{"_19":8472,"_21":8473,"_23":8474,"_25":8475,"_26":8476,"_32":8481,"_33":8482,"_6088":8485},"polypow","c = polypow(c, n)","Raise power series polynomial to a power","Raises a power series polynomial to a non-negative integer power.",[8477,8479],{"_19":929,"_25":8478},"Coefficient array",{"_19":1516,"_25":8480},"Non-negative integer power","Resulting coefficient array",[8483],{"_281":8484,"_6083":8426},"polypow([1 1], 2)",[8413],{"_19":8487,"_21":8488,"_23":8489,"_25":8490,"_26":8491,"_32":8493,"_33":8494,"_6088":8497},"polyroots","r = polyroots(c)","Find power series polynomial roots","Finds roots of a power series polynomial using companion matrix eigenvalues.",[8492],{"_19":929,"_25":8387},"Array of roots",[8495],{"_281":8496},"polyroots([-1 0 1])",[8498,8499],"polyfromroots","polycompanion",{"_19":8498,"_21":8501,"_23":8502,"_25":8503,"_26":8504,"_32":8387,"_33":8507,"_6088":8510},"c = polyfromroots(r)","Construct power series from roots","Constructs a power series polynomial from its roots.",[8505],{"_19":8506,"_25":8493},"r",[8508],{"_281":8509},"polyfromroots([1 -1])",[8487],{"_19":8499,"_21":8512,"_23":8513,"_25":8514,"_26":8515,"_32":8517,"_33":8518,"_6088":8521},"C = polycompanion(c)","Power series companion matrix","Generates the companion matrix for a power series polynomial.",[8516],{"_19":929,"_25":8478},"Companion matrix",[8519],{"_281":8520},"polycompanion([-1 0 1])",[8487],{"_19":8523,"_21":8524,"_23":8525,"_25":8526,"_26":8527,"_32":8532,"_33":8533,"_6088":8536},"polyvander","V = polyvander(x, deg)","Power series Vandermonde matrix","Generates a Vandermonde matrix of the given degree for the given sample points.",[8528,8530],{"_19":29,"_25":8529},"Sample points",{"_19":355,"_25":8531},"Degree of polynomial","Vandermonde matrix",[8534],{"_281":8535},"polyvander([1 2 3], 2)",[8346],{"_19":8346,"_21":8538,"_23":8539,"_25":8540,"_26":8541,"_32":8387,"_33":8548,"_6088":8551},"c = polyfit(x, y, deg)","Least-squares power series fit","Fits a power series polynomial of the given degree to data using least squares.",[8542,8544,8546],{"_19":29,"_25":8543},"x values",{"_19":135,"_25":8545},"y values",{"_19":355,"_25":8547},"Degree of fitting polynomial",[8549],{"_281":8550},"polyfit([0 1 2 3], [0 1 4 9], 2)",[8331,8523],{"_19":998,"_21":8553,"_23":8554,"_25":8555,"_26":8556,"_32":8559,"_33":8560,"_6088":8564},"r = roots(p)","Polynomial roots (M-Code convention)","Finds roots of a polynomial specified by descending-order coefficients [a_n, ..., a_1, a_0].",[8557],{"_19":1111,"_25":8558},"Coefficient vector in descending order","Column vector of roots",[8561],{"_281":8562,"_6083":8563},"roots([1 0 -1])","[1; -1]",[8325,8487],{"_19":8325,"_21":8566,"_23":8567,"_25":8568,"_26":8569,"_32":8558,"_33":8572,"_6088":8576},"p = poly(r)","Polynomial from roots (M-Code convention)","Constructs polynomial coefficients in descending order from a vector of roots.",[8570],{"_19":8506,"_25":8571},"Vector of roots",[8573],{"_281":8574,"_6083":8575},"poly([1 -1])","[1 0 -1]",[998,8498],{"_19":8578,"_21":8579,"_23":8580,"_25":8581,"_26":8582,"_32":8588,"_33":8589,"_6088":8592},"conv","w = conv(u, v)","Convolution / polynomial multiplication (M-Code convention)","Convolves two vectors, equivalent to polynomial multiplication with descending-order coefficients.",[8583,8586],{"_19":8584,"_25":8585},"u","First input vector (descending order)",{"_19":1273,"_25":8587},"Second input vector (descending order)","Convolution result (descending order)",[8590],{"_281":8591,"_6083":8426},"conv([1 1], [1 1])",[8593,8413],"deconv",{"_19":8593,"_21":8595,"_23":8596,"_25":8597,"_26":8598,"_32":8603,"_33":8604,"_6088":8608},"[q, r] = deconv(b, a)","Deconvolution / polynomial division (M-Code convention)","Deconvolves two vectors, equivalent to polynomial long division with descending-order coefficients.",[8599,8601],{"_19":191,"_25":8600},"Dividend vector (descending order)",{"_19":189,"_25":8602},"Divisor vector (descending order)","Quotient vector (descending order)",[8605],{"_281":8606,"_6083":8607},"deconv([1 2 1], [1 1])","[1 1]",[8578,8428],{"_19":8610,"_21":8611,"_23":8612,"_25":8613,"_26":8614,"_32":8340,"_33":8618,"_6088":8621},"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 + ...",[8615,8616],{"_19":29,"_25":8337},{"_19":929,"_25":8617},"Chebyshev coefficient array",[8619],{"_281":8620},"chebval(0.5, [1 2 3])",[8622,8623,8624],"chebfit","chebder","chebint",{"_19":8626,"_21":8627,"_23":8628,"_25":8629,"_26":8630,"_32":8361,"_33":8634,"_6088":8635},"chebval2d","z = chebval2d(x, y, c)","Evaluate 2-D Chebyshev polynomial","Evaluates a 2-D Chebyshev polynomial on x-y pairs.",[8631,8632,8633],{"_19":29,"_25":8356},{"_19":135,"_25":8358},{"_19":929,"_25":8360},[],[8610],{"_19":8623,"_21":8637,"_23":8638,"_25":8639,"_26":8640,"_32":8390,"_33":8643,"_6088":8646},"dc = chebder(c)\ndc = chebder(c, m)","Chebyshev derivative","Differentiates a Chebyshev polynomial m times.",[8641,8642],{"_19":929,"_25":8617},{"_19":958,"_25":8389,"_31":61},[8644],{"_281":8645},"chebder([1 2 3])",[8624,8610],{"_19":8624,"_21":8648,"_23":8649,"_25":8650,"_26":8651,"_32":8406,"_33":8656,"_6088":8659},"ic = chebint(c)\nic = chebint(c, m)\nic = chebint(c, m, k)","Chebyshev integral","Integrates a Chebyshev polynomial m times with integration constants k.",[8652,8653,8654],{"_19":929,"_25":8617},{"_19":958,"_25":8403,"_31":61},{"_19":1010,"_25":8655,"_31":61},"Integration constants",[8657],{"_281":8658},"chebint([2 6])",[8623,8610],{"_19":8661,"_21":8662,"_23":8663,"_25":8664,"_26":8665,"_32":8422,"_33":8668,"_6088":8671},"chebmul","c = chebmul(c1, c2)","Multiply two Chebyshev polynomials","Multiplies two Chebyshev coefficient arrays.",[8666,8667],{"_19":939,"_25":8419},{"_19":941,"_25":8421},[8669],{"_281":8670},"chebmul([1 1], [1 1])",[8672,8673,8674],"chebdiv","chebadd","chebsub",{"_19":8672,"_21":8676,"_23":8677,"_25":8678,"_26":8679,"_32":8682,"_33":8683,"_6088":8684},"[q, r] = chebdiv(c1, c2)","Divide two Chebyshev polynomials","Divides two Chebyshev coefficient arrays. Returns quotient and remainder.",[8680,8681],{"_19":939,"_25":8437},{"_19":941,"_25":8439},"Quotient and remainder",[],[8661],{"_19":8673,"_21":8686,"_23":8687,"_25":8688,"_26":8689,"_32":8452,"_33":8692,"_6088":8695},"c = chebadd(c1, c2)","Add two Chebyshev polynomials","Adds two Chebyshev coefficient arrays.",[8690,8691],{"_19":939,"_25":8419},{"_19":941,"_25":8421},[8693],{"_281":8694},"chebadd([1 2], [3 4])",[8674,8661],{"_19":8674,"_21":8697,"_23":8698,"_25":8699,"_26":8700,"_32":8465,"_33":8703,"_6088":8704},"c = chebsub(c1, c2)","Subtract two Chebyshev polynomials","Subtracts two Chebyshev coefficient arrays.",[8701,8702],{"_19":939,"_25":8419},{"_19":941,"_25":8421},[],[8673,8661],{"_19":8706,"_21":8707,"_23":8708,"_25":8709,"_26":8710,"_32":8481,"_33":8713,"_6088":8716},"chebpow","c = chebpow(c, n)","Raise Chebyshev polynomial to a power","Raises a Chebyshev polynomial to a non-negative integer power.",[8711,8712],{"_19":929,"_25":8478},{"_19":1516,"_25":8480},[8714],{"_281":8715},"chebpow([1 1], 2)",[8661],{"_19":8718,"_21":8719,"_23":8720,"_25":8721,"_26":8722,"_32":8493,"_33":8724,"_6088":8727},"chebroots","r = chebroots(c)","Find Chebyshev polynomial roots","Finds roots of a Chebyshev polynomial using companion matrix eigenvalues.",[8723],{"_19":929,"_25":8617},[8725],{"_281":8726},"chebroots([1 0 -1])",[8728,8729],"chebfromroots","chebcompanion",{"_19":8728,"_21":8731,"_23":8732,"_25":8733,"_26":8734,"_32":8617,"_33":8736,"_6088":8739},"c = chebfromroots(r)","Construct Chebyshev polynomial from roots","Constructs Chebyshev coefficient array from roots.",[8735],{"_19":8506,"_25":8493},[8737],{"_281":8738},"chebfromroots([1 -1])",[8718],{"_19":8729,"_21":8741,"_23":8742,"_25":8743,"_26":8744,"_32":8517,"_33":8746,"_6088":8747},"C = chebcompanion(c)","Chebyshev companion matrix","Generates the companion matrix for a Chebyshev polynomial.",[8745],{"_19":929,"_25":8617},[],[8718],{"_19":8749,"_21":8750,"_23":8751,"_25":8752,"_26":8753,"_32":8532,"_33":8756,"_6088":8759},"chebvander","V = chebvander(x, deg)","Chebyshev Vandermonde matrix","Generates a Chebyshev Vandermonde matrix for the given sample points and degree.",[8754,8755],{"_19":29,"_25":8529},{"_19":355,"_25":8531},[8757],{"_281":8758},"chebvander([0 0.5 1], 2)",[8622],{"_19":8622,"_21":8761,"_23":8762,"_25":8763,"_26":8764,"_32":8617,"_33":8768,"_6088":8771},"c = chebfit(x, y, deg)","Least-squares Chebyshev fit","Fits a Chebyshev polynomial of the given degree to data using least squares.",[8765,8766,8767],{"_19":29,"_25":8543},{"_19":135,"_25":8545},{"_19":355,"_25":8547},[8769],{"_281":8770},"chebfit([0 0.5 1], [1 1.5 2], 1)",[8610,8749],{"_19":8773,"_21":8774,"_23":8775,"_25":8776,"_26":8777,"_32":8780,"_33":8781,"_6088":8784},"cheb2poly","p = cheb2poly(c)","Convert Chebyshev to power series","Converts Chebyshev coefficients to power series coefficients.",[8778],{"_19":929,"_25":8779},"Chebyshev coefficients","Power series coefficients",[8782],{"_281":8783},"cheb2poly([1 0 1])",[8785],"poly2cheb",{"_19":8787,"_21":8788,"_23":8789,"_25":8790,"_26":8791,"_32":8340,"_33":8795,"_6088":8798},"legval","y = legval(x, c)","Evaluate Legendre polynomial","Evaluates a Legendre polynomial at point x.",[8792,8793],{"_19":29,"_25":8337},{"_19":929,"_25":8794},"Legendre coefficient array",[8796],{"_281":8797},"legval(0.5, [1 2 3])",[8799,8800],"legfit","legder",{"_19":8800,"_21":8802,"_23":8803,"_25":8804,"_26":8805,"_32":8390,"_33":8808,"_6088":8811},"dc = legder(c)\ndc = legder(c, m)","Legendre derivative","Differentiates a Legendre polynomial m times.",[8806,8807],{"_19":929,"_25":8794},{"_19":958,"_25":8389,"_31":61},[8809],{"_281":8810},"legder([1 2 3])",[8812,8787],"legint",{"_19":8812,"_21":8814,"_23":8815,"_25":8816,"_26":8817,"_32":8406,"_33":8821,"_6088":8822},"ic = legint(c)\nic = legint(c, m)\nic = legint(c, m, k)","Legendre integral","Integrates a Legendre polynomial m times.",[8818,8819,8820],{"_19":929,"_25":8794},{"_19":958,"_25":8403,"_31":61},{"_19":1010,"_25":8655,"_31":61},[],[8800,8787],{"_19":8824,"_21":8825,"_23":8826,"_25":8827,"_26":8828,"_32":8422,"_33":8831,"_6088":8832},"legmul","c = legmul(c1, c2)","Multiply two Legendre polynomials","Multiplies two Legendre coefficient arrays.",[8829,8830],{"_19":939,"_25":8419},{"_19":941,"_25":8421},[],[8833,8834,8835],"legdiv","legadd","legsub",{"_19":8833,"_21":8837,"_23":8838,"_25":8839,"_26":8840,"_32":8682,"_33":8843,"_6088":8844},"[q, r] = legdiv(c1, c2)","Divide two Legendre polynomials","Divides two Legendre coefficient arrays.",[8841,8842],{"_19":939,"_25":8437},{"_19":941,"_25":8439},[],[8824],{"_19":8834,"_21":8846,"_23":8847,"_25":8848,"_26":8849,"_32":8452,"_33":8852,"_6088":8853},"c = legadd(c1, c2)","Add two Legendre polynomials","Adds two Legendre coefficient arrays.",[8850,8851],{"_19":939,"_25":8419},{"_19":941,"_25":8421},[],[8835,8824],{"_19":8835,"_21":8855,"_23":8856,"_25":8857,"_26":8858,"_32":8465,"_33":8861,"_6088":8862},"c = legsub(c1, c2)","Subtract two Legendre polynomials","Subtracts two Legendre coefficient arrays.",[8859,8860],{"_19":939,"_25":8419},{"_19":941,"_25":8421},[],[8834,8824],{"_19":8864,"_21":8865,"_23":8866,"_25":8867,"_26":8868,"_32":8481,"_33":8871,"_6088":8872},"legpow","c = legpow(c, n)","Raise Legendre polynomial to a power","Raises a Legendre polynomial to a non-negative integer power.",[8869,8870],{"_19":929,"_25":8478},{"_19":1516,"_25":8480},[],[8824],{"_19":8874,"_21":8875,"_23":8876,"_25":8877,"_26":8878,"_32":8493,"_33":8880,"_6088":8881},"legroots","r = legroots(c)","Find Legendre polynomial roots","Finds roots of a Legendre polynomial.",[8879],{"_19":929,"_25":8794},[],[8882,8883],"legfromroots","legcompanion",{"_19":8882,"_21":8885,"_23":8886,"_25":8887,"_26":8888,"_32":8794,"_33":8890,"_6088":8891},"c = legfromroots(r)","Construct Legendre polynomial from roots","Constructs Legendre coefficient array from roots.",[8889],{"_19":8506,"_25":8493},[],[8874],{"_19":8883,"_21":8893,"_23":8894,"_25":8895,"_26":8896,"_32":8517,"_33":8898,"_6088":8899},"C = legcompanion(c)","Legendre companion matrix","Generates the companion matrix for a Legendre polynomial.",[8897],{"_19":929,"_25":8794},[],[8874],{"_19":8901,"_21":8902,"_23":8903,"_25":8904,"_26":8905,"_32":8532,"_33":8908,"_6088":8909},"legvander","V = legvander(x, deg)","Legendre Vandermonde matrix","Generates a Legendre Vandermonde matrix.",[8906,8907],{"_19":29,"_25":8529},{"_19":355,"_25":8531},[],[8799],{"_19":8799,"_21":8911,"_23":8912,"_25":8913,"_26":8914,"_32":8794,"_33":8918,"_6088":8919},"c = legfit(x, y, deg)","Least-squares Legendre fit","Fits a Legendre polynomial of the given degree to data using least squares.",[8915,8916,8917],{"_19":29,"_25":8543},{"_19":135,"_25":8545},{"_19":355,"_25":8547},[],[8787,8901],{"_19":8921,"_21":8922,"_23":8923,"_25":8924,"_26":8925,"_32":8780,"_33":8928,"_6088":8929},"leg2poly","p = leg2poly(c)","Convert Legendre to power series","Converts Legendre coefficients to power series coefficients.",[8926],{"_19":929,"_25":8927},"Legendre coefficients",[],[8930],"poly2leg",{"_19":8932,"_21":8933,"_23":8934,"_25":8935,"_26":8936,"_32":8340,"_33":8940,"_6088":8943},"hermval","y = hermval(x, c)","Evaluate Hermite polynomial","Evaluates a physicist's Hermite polynomial at point x.",[8937,8938],{"_19":29,"_25":8337},{"_19":929,"_25":8939},"Hermite coefficient array",[8941],{"_281":8942},"hermval(1, [1 2 3])",[2518,2385],{"_19":2385,"_21":8945,"_23":8946,"_25":8947,"_26":8948,"_32":8390,"_33":8951,"_6088":8952},"dc = hermder(c)\ndc = hermder(c, m)","Hermite derivative","Differentiates a Hermite polynomial m times.",[8949,8950],{"_19":929,"_25":8939},{"_19":958,"_25":8389,"_31":61},[],[2537,8932],{"_19":2537,"_21":8954,"_23":8955,"_25":8956,"_26":8957,"_32":8406,"_33":8961,"_6088":8962},"ic = hermint(c)\nic = hermint(c, m)\nic = hermint(c, m, k)","Hermite integral","Integrates a Hermite polynomial m times.",[8958,8959,8960],{"_19":929,"_25":8939},{"_19":958,"_25":8403,"_31":61},{"_19":1010,"_25":8655,"_31":61},[],[2385,8932],{"_19":2547,"_21":8964,"_23":8965,"_25":8966,"_26":8967,"_32":8422,"_33":8970,"_6088":8971},"c = hermmul(c1, c2)","Multiply two Hermite polynomials","Multiplies two Hermite coefficient arrays.",[8968,8969],{"_19":939,"_25":8419},{"_19":941,"_25":8421},[],[2393,2369],{"_19":2393,"_21":8973,"_23":8974,"_25":8975,"_26":8976,"_32":8682,"_33":8979,"_6088":8980},"[q, r] = hermdiv(c1, c2)","Divide two Hermite polynomials","Divides two Hermite coefficient arrays.",[8977,8978],{"_19":939,"_25":8437},{"_19":941,"_25":8439},[],[2547],{"_19":2369,"_21":8982,"_23":8983,"_25":8984,"_26":8985,"_32":8452,"_33":8988,"_6088":8989},"c = hermadd(c1, c2)","Add two Hermite polynomials","Adds two Hermite coefficient arrays.",[8986,8987],{"_19":939,"_25":8419},{"_19":941,"_25":8421},[],[2571,2547],{"_19":2571,"_21":8991,"_23":8992,"_25":8993,"_26":8994,"_32":8465,"_33":8997,"_6088":8998},"c = hermsub(c1, c2)","Subtract two Hermite polynomials","Subtracts two Hermite coefficient arrays.",[8995,8996],{"_19":939,"_25":8419},{"_19":941,"_25":8421},[],[2369,2547],{"_19":2555,"_21":9000,"_23":9001,"_25":9002,"_26":9003,"_32":8481,"_33":9006,"_6088":9007},"c = hermpow(c, n)","Raise Hermite polynomial to a power","Raises a Hermite polynomial to a non-negative integer power.",[9004,9005],{"_19":929,"_25":8478},{"_19":1516,"_25":8480},[],[2547],{"_19":2564,"_21":9009,"_23":9010,"_25":9011,"_26":9012,"_32":8493,"_33":9014,"_6088":9015},"r = hermroots(c)","Find Hermite polynomial roots","Finds roots of a Hermite polynomial.",[9013],{"_19":929,"_25":8939},[],[2530,2378],{"_19":2530,"_21":9017,"_23":9018,"_25":9019,"_26":9020,"_32":8939,"_33":9022,"_6088":9023},"c = hermfromroots(r)","Construct Hermite polynomial from roots","Constructs Hermite coefficient array from roots.",[9021],{"_19":8506,"_25":8493},[],[2564],{"_19":2378,"_21":9025,"_23":9026,"_25":9027,"_26":9028,"_32":8517,"_33":9030,"_6088":9031},"C = hermcompanion(c)","Hermite companion matrix","Generates the companion matrix for a Hermite polynomial.",[9029],{"_19":929,"_25":8939},[],[2564],{"_19":2587,"_21":9033,"_23":9034,"_25":9035,"_26":9036,"_32":8532,"_33":9039,"_6088":9040},"V = hermvander(x, deg)","Hermite Vandermonde matrix","Generates a Hermite Vandermonde matrix.",[9037,9038],{"_19":29,"_25":8529},{"_19":355,"_25":8531},[],[2518],{"_19":2518,"_21":9042,"_23":9043,"_25":9044,"_26":9045,"_32":8939,"_33":9049,"_6088":9050},"c = hermfit(x, y, deg)","Least-squares Hermite fit","Fits a Hermite polynomial of the given degree to data using least squares.",[9046,9047,9048],{"_19":29,"_25":8543},{"_19":135,"_25":8545},{"_19":355,"_25":8547},[],[8932,2587],{"_19":9052,"_21":9053,"_23":9054,"_25":9055,"_26":9056,"_32":8780,"_33":9059,"_6088":9060},"herm2poly","p = herm2poly(c)","Convert Hermite to power series","Converts Hermite coefficients to power series coefficients.",[9057],{"_19":929,"_25":9058},"Hermite coefficients",[],[9061],"poly2herm",{"_19":9063,"_21":9064,"_23":9065,"_25":9066,"_26":9067,"_32":8340,"_33":9071,"_6088":9072},"hermeval","y = hermeval(x, c)","Evaluate probabilist's Hermite polynomial","Evaluates a probabilist's Hermite (HermiteE) polynomial at point x.",[9068,9069],{"_19":29,"_25":8337},{"_19":929,"_25":9070},"HermiteE coefficient array",[],[2439,2423],{"_19":2423,"_21":9074,"_23":9075,"_25":9076,"_26":9077,"_32":8390,"_33":9080,"_6088":9081},"dc = hermeder(c)\ndc = hermeder(c, m)","HermiteE derivative","Differentiates a HermiteE polynomial m times.",[9078,9079],{"_19":929,"_25":9070},{"_19":958,"_25":8389,"_31":61},[],[2460,9063],{"_19":2460,"_21":9083,"_23":9084,"_25":9085,"_26":9086,"_32":8406,"_33":9090,"_6088":9091},"ic = hermeint(c)\nic = hermeint(c, m)\nic = hermeint(c, m, k)","HermiteE integral","Integrates a HermiteE polynomial m times.",[9087,9088,9089],{"_19":929,"_25":9070},{"_19":958,"_25":8403,"_31":61},{"_19":1010,"_25":8655,"_31":61},[],[2423,9063],{"_19":2470,"_21":9093,"_23":9094,"_25":9095,"_26":9096,"_32":8422,"_33":9099,"_6088":9100},"c = hermemul(c1, c2)","Multiply two HermiteE polynomials","Multiplies two HermiteE coefficient arrays.",[9097,9098],{"_19":939,"_25":8419},{"_19":941,"_25":8421},[],[2431,2408],{"_19":2431,"_21":9102,"_23":9103,"_25":9104,"_26":9105,"_32":8682,"_33":9108,"_6088":9109},"[q, r] = hermediv(c1, c2)","Divide two HermiteE polynomials","Divides two HermiteE coefficient arrays.",[9106,9107],{"_19":939,"_25":8437},{"_19":941,"_25":8439},[],[2470],{"_19":2408,"_21":9111,"_23":9112,"_25":9113,"_26":9114,"_32":8452,"_33":9117,"_6088":9118},"c = hermeadd(c1, c2)","Add two HermiteE polynomials","Adds two HermiteE coefficient arrays.",[9115,9116],{"_19":939,"_25":8419},{"_19":941,"_25":8421},[],[2494,2470],{"_19":2494,"_21":9120,"_23":9121,"_25":9122,"_26":9123,"_32":8465,"_33":9126,"_6088":9127},"c = hermesub(c1, c2)","Subtract two HermiteE polynomials","Subtracts two HermiteE coefficient arrays.",[9124,9125],{"_19":939,"_25":8419},{"_19":941,"_25":8421},[],[2408,2470],{"_19":2478,"_21":9129,"_23":9130,"_25":9131,"_26":9132,"_32":8481,"_33":9135,"_6088":9136},"c = hermepow(c, n)","Raise HermiteE polynomial to a power","Raises a HermiteE polynomial to a non-negative integer power.",[9133,9134],{"_19":929,"_25":8478},{"_19":1516,"_25":8480},[],[2470],{"_19":2487,"_21":9138,"_23":9139,"_25":9140,"_26":9141,"_32":8493,"_33":9143,"_6088":9144},"r = hermeroots(c)","Find HermiteE polynomial roots","Finds roots of a HermiteE polynomial.",[9142],{"_19":929,"_25":9070},[],[2453,2416],{"_19":2453,"_21":9146,"_23":9147,"_25":9148,"_26":9149,"_32":9070,"_33":9151,"_6088":9152},"c = hermefromroots(r)","Construct HermiteE polynomial from roots","Constructs HermiteE coefficient array from roots.",[9150],{"_19":8506,"_25":8493},[],[2487],{"_19":2416,"_21":9154,"_23":9155,"_25":9156,"_26":9157,"_32":8517,"_33":9159,"_6088":9160},"C = hermecompanion(c)","HermiteE companion matrix","Generates the companion matrix for a HermiteE polynomial.",[9158],{"_19":929,"_25":9070},[],[2487],{"_19":2510,"_21":9162,"_23":9163,"_25":9164,"_26":9165,"_32":8532,"_33":9168,"_6088":9169},"V = hermevander(x, deg)","HermiteE Vandermonde matrix","Generates a HermiteE Vandermonde matrix.",[9166,9167],{"_19":29,"_25":8529},{"_19":355,"_25":8531},[],[2439],{"_19":2439,"_21":9171,"_23":9172,"_25":9173,"_26":9174,"_32":9070,"_33":9178,"_6088":9179},"c = hermefit(x, y, deg)","Least-squares HermiteE fit","Fits a HermiteE polynomial of the given degree to data using least squares.",[9175,9176,9177],{"_19":29,"_25":8543},{"_19":135,"_25":8545},{"_19":355,"_25":8547},[],[9063,2510],{"_19":9181,"_21":9182,"_23":9183,"_25":9184,"_26":9185,"_32":8780,"_33":9188,"_6088":9189},"herme2poly","p = herme2poly(c)","Convert HermiteE to power series","Converts HermiteE coefficients to power series coefficients.",[9186],{"_19":929,"_25":9187},"HermiteE coefficients",[],[9190],"poly2herme",{"_19":9192,"_21":9193,"_23":9194,"_25":9195,"_26":9196,"_32":8340,"_33":9200,"_6088":9203},"lagval","y = lagval(x, c)","Evaluate Laguerre polynomial","Evaluates a Laguerre polynomial at point x.",[9197,9198],{"_19":29,"_25":8337},{"_19":929,"_25":9199},"Laguerre coefficient array",[9201],{"_281":9202},"lagval(1, [1 2 3])",[3255,3239],{"_19":3239,"_21":9205,"_23":9206,"_25":9207,"_26":9208,"_32":8390,"_33":9211,"_6088":9212},"dc = lagder(c)\ndc = lagder(c, m)","Laguerre derivative","Differentiates a Laguerre polynomial m times.",[9209,9210],{"_19":929,"_25":9199},{"_19":958,"_25":8389,"_31":61},[],[3274,9192],{"_19":3274,"_21":9214,"_23":9215,"_25":9216,"_26":9217,"_32":8406,"_33":9221,"_6088":9222},"ic = lagint(c)\nic = lagint(c, m)\nic = lagint(c, m, k)","Laguerre integral","Integrates a Laguerre polynomial m times.",[9218,9219,9220],{"_19":929,"_25":9199},{"_19":958,"_25":8403,"_31":61},{"_19":1010,"_25":8655,"_31":61},[],[3239,9192],{"_19":3284,"_21":9224,"_23":9225,"_25":9226,"_26":9227,"_32":8422,"_33":9230,"_6088":9231},"c = lagmul(c1, c2)","Multiply two Laguerre polynomials","Multiplies two Laguerre coefficient arrays.",[9228,9229],{"_19":939,"_25":8419},{"_19":941,"_25":8421},[],[3247,3224],{"_19":3247,"_21":9233,"_23":9234,"_25":9235,"_26":9236,"_32":8682,"_33":9239,"_6088":9240},"[q, r] = lagdiv(c1, c2)","Divide two Laguerre polynomials","Divides two Laguerre coefficient arrays.",[9237,9238],{"_19":939,"_25":8437},{"_19":941,"_25":8439},[],[3284],{"_19":3224,"_21":9242,"_23":9243,"_25":9244,"_26":9245,"_32":8452,"_33":9248,"_6088":9249},"c = lagadd(c1, c2)","Add two Laguerre polynomials","Adds two Laguerre coefficient arrays.",[9246,9247],{"_19":939,"_25":8419},{"_19":941,"_25":8421},[],[3308,3284],{"_19":3308,"_21":9251,"_23":9252,"_25":9253,"_26":9254,"_32":8465,"_33":9257,"_6088":9258},"c = lagsub(c1, c2)","Subtract two Laguerre polynomials","Subtracts two Laguerre coefficient arrays.",[9255,9256],{"_19":939,"_25":8419},{"_19":941,"_25":8421},[],[3224,3284],{"_19":3292,"_21":9260,"_23":9261,"_25":9262,"_26":9263,"_32":8481,"_33":9266,"_6088":9267},"c = lagpow(c, n)","Raise Laguerre polynomial to a power","Raises a Laguerre polynomial to a non-negative integer power.",[9264,9265],{"_19":929,"_25":8478},{"_19":1516,"_25":8480},[],[3284],{"_19":3301,"_21":9269,"_23":9270,"_25":9271,"_26":9272,"_32":8493,"_33":9274,"_6088":9275},"r = lagroots(c)","Find Laguerre polynomial roots","Finds roots of a Laguerre polynomial.",[9273],{"_19":929,"_25":9199},[],[3267,3232],{"_19":3267,"_21":9277,"_23":9278,"_25":9279,"_26":9280,"_32":9199,"_33":9282,"_6088":9283},"c = lagfromroots(r)","Construct Laguerre polynomial from roots","Constructs Laguerre coefficient array from roots.",[9281],{"_19":8506,"_25":8493},[],[3301],{"_19":3232,"_21":9285,"_23":9286,"_25":9287,"_26":9288,"_32":8517,"_33":9290,"_6088":9291},"C = lagcompanion(c)","Laguerre companion matrix","Generates the companion matrix for a Laguerre polynomial.",[9289],{"_19":929,"_25":9199},[],[3301],{"_19":3324,"_21":9293,"_23":9294,"_25":9295,"_26":9296,"_32":8532,"_33":9299,"_6088":9300},"V = lagvander(x, deg)","Laguerre Vandermonde matrix","Generates a Laguerre Vandermonde matrix.",[9297,9298],{"_19":29,"_25":8529},{"_19":355,"_25":8531},[],[3255],{"_19":3255,"_21":9302,"_23":9303,"_25":9304,"_26":9305,"_32":9199,"_33":9309,"_6088":9310},"c = lagfit(x, y, deg)","Least-squares Laguerre fit","Fits a Laguerre polynomial of the given degree to data using least squares.",[9306,9307,9308],{"_19":29,"_25":8543},{"_19":135,"_25":8545},{"_19":355,"_25":8547},[],[9192,3324],{"_19":9312,"_21":9313,"_23":9314,"_25":9315,"_26":9316,"_32":8780,"_33":9319,"_6088":9320},"lag2poly","p = lag2poly(c)","Convert Laguerre to power series","Converts Laguerre coefficients to power series coefficients.",[9317],{"_19":929,"_25":9318},"Laguerre coefficients",[],[9321],"poly2lag",{"_19":8785,"_21":9323,"_23":9324,"_25":9325,"_26":9326,"_32":8779,"_33":9328,"_6088":9331},"cc = poly2cheb(c)","Convert power series to Chebyshev","Converts power series coefficients to Chebyshev coefficients.",[9327],{"_19":929,"_25":8780},[9329],{"_281":9330},"poly2cheb([1 0 1])",[8773],{"_19":8930,"_21":9333,"_23":9334,"_25":9335,"_26":9336,"_32":8927,"_33":9338,"_6088":9339},"lc = poly2leg(c)","Convert power series to Legendre","Converts power series coefficients to Legendre coefficients.",[9337],{"_19":929,"_25":8780},[],[8921],{"_19":9061,"_21":9341,"_23":9342,"_25":9343,"_26":9344,"_32":9058,"_33":9346,"_6088":9347},"hc = poly2herm(c)","Convert power series to Hermite","Converts power series coefficients to Hermite coefficients.",[9345],{"_19":929,"_25":8780},[],[9052],{"_19":9190,"_21":9349,"_23":9350,"_25":9351,"_26":9352,"_32":9187,"_33":9354,"_6088":9355},"hc = poly2herme(c)","Convert power series to HermiteE","Converts power series coefficients to HermiteE coefficients.",[9353],{"_19":929,"_25":8780},[],[9181],{"_19":9321,"_21":9357,"_23":9358,"_25":9359,"_26":9360,"_32":9318,"_33":9362,"_6088":9363},"lc = poly2lag(c)","Convert power series to Laguerre","Converts power series coefficients to Laguerre coefficients.",[9361],{"_19":929,"_25":8780},[],[9312],{"_19":9365,"_21":9366,"_23":9367,"_25":9368,"_26":9369,"_32":9373,"_33":9374,"_6088":9378},"trimcoef","ct = trimcoef(c)\nct = trimcoef(c, tol)","Remove small trailing coefficients","Removes trailing elements with absolute value less than or equal to tol.",[9370,9371],{"_19":929,"_25":8478},{"_19":3769,"_25":9372,"_31":61},"Tolerance (default: 0)","Trimmed coefficient array",[9375],{"_281":9376,"_6083":9377},"trimcoef([1 2 3 0 0])","[1 2 3]",[9379],"trimseq",{"_19":9379,"_21":9381,"_23":9382,"_25":9383,"_26":9384,"_32":9387,"_33":9388,"_6088":9392},"ct = trimseq(c)","Remove trailing zeros","Removes trailing zeros from a coefficient sequence.",[9385],{"_19":929,"_25":9386},"Coefficient sequence","Trimmed sequence",[9389],{"_281":9390,"_6083":9391},"trimseq([1 2 0 0])","[1 2]",[9365],{"_19":9394,"_21":9395,"_23":9396,"_25":9397,"_26":9398,"_32":9401,"_33":9402,"_6088":9406},"getdomain","d = getdomain(x)","Get domain from data points","Returns the minimum and maximum of the data as the domain [min, max].",[9399],{"_19":29,"_25":9400},"Data points","[min, max] domain",[9403],{"_281":9404,"_6083":9405},"getdomain([1 2 3 4 5])","[1 5]",[9407,9408],"mapdomain","mapparms",{"_19":9407,"_21":9410,"_23":9411,"_25":9412,"_26":9413,"_32":9420,"_33":9421,"_6088":9424},"y = mapdomain(x, old, new)","Map values between domains","Maps x from the old domain to the new domain using a linear transformation.",[9414,9416,9418],{"_19":29,"_25":9415},"Values to map",{"_19":3696,"_25":9417},"Original domain [min, max]",{"_19":6932,"_25":9419},"Target domain [min, max]","Mapped values",[9422],{"_281":9423,"_6083":6389},"mapdomain(0.5, [0 1], [-1 1])",[9408,9394],{"_19":9408,"_21":9426,"_23":9427,"_25":9428,"_26":9429,"_32":9432,"_33":9433,"_6088":9437},"[off, scl] = mapparms(old, new)","Get linear mapping parameters","Returns [offset, scale] such that new = offset + scale * old.",[9430,9431],{"_19":3696,"_25":9417},{"_19":6932,"_25":9419},"[offset, scale]",[9434],{"_281":9435,"_6083":9436},"mapparms([0 1], [-1 1])","[-1 2]",[9407,9394],{"_37":9439,"_19":9440,"_25":9441,"_41":42,"_43":9442,"_47":9443},"symbolic","Symbolic Mathematics","MATLAB-compatible symbolic mathematics functions for creating symbolic variables, solving equations, expanding expressions, and more. Powered by SymEngine via symngwasm.","🔣",[9444,9468,9486,9505,9524,9541,9556,9582,9603,9624],{"_19":9445,"_21":9446,"_23":9447,"_25":9448,"_26":9449,"_32":9452,"_33":9453,"_6088":9464},"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.",[9450],{"_19":1893,"_25":9451},"Variable name (string) or numeric value to convert","Symbolic variable or expression",[9454,9456,9458,9461],{"_281":9455,"_6083":29},"x = sym('x')",{"_281":9457,"_6083":29},"sym x",{"_281":9459,"_6083":9460},"f = sym('x^2 + 2*x + 1')","x^2 + 2*x + 1",{"_281":9462,"_6083":9463},"half = sym(1/2)","1/2",[9465,9466,9467],"syms","solve","expand",{"_19":9465,"_21":9469,"_23":9470,"_25":9471,"_26":9472,"_32":9476,"_33":9477,"_6088":9484},"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.",[9473],{"_19":9474,"_25":9475},"vars","Variable names (space-separated for command syntax, or multiple string arguments)","Creates variables in workspace (no return value)",[9478,9481],{"_281":9479,"_6083":9480},"syms x y z","% Creates x, y, z as symbolic variables",{"_281":9482,"_6083":9483},"syms('a', 'b')","% Creates a, b as symbolic variables",[9445,9466,9485],"subs",{"_19":9466,"_21":9487,"_23":9488,"_25":9489,"_26":9490,"_32":9496,"_33":9497,"_6088":9504},"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).",[9491,9494],{"_19":9492,"_25":9493},"eqn","Symbolic equation or expression (assumed = 0)",{"_19":6569,"_25":9495,"_31":61},"Variable to solve for","Array of symbolic solutions",[9498,9501],{"_281":9499,"_6083":9500},"syms x; solve(x^2 - 1, x)","[-1, 1]",{"_281":9502,"_6083":9503},"syms x; solve(x^2 + x - 6, x)","[-3, 2]",[9445,9465,9467,9485],{"_19":9485,"_21":9506,"_23":9507,"_25":9508,"_26":9509,"_32":9516,"_33":9517,"_6088":9523},"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.",[9510,9512,9514],{"_19":2310,"_25":9511},"Symbolic expression",{"_19":3696,"_25":9513},"Symbol or expression to replace",{"_19":6932,"_25":9515},"Replacement value or expression","Expression with substitution applied",[9518,9520],{"_281":9519,"_6083":6494},"syms x; subs(x^2 + 1, x, 2)",{"_281":9521,"_6083":9522},"syms x y; subs(x + y, x, y^2)","y^2 + y",[9445,9466,9467],{"_19":9467,"_21":9525,"_23":9526,"_25":9527,"_26":9528,"_32":9531,"_33":9532,"_6088":9538},"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",[9529],{"_19":2310,"_25":9530},"Symbolic expression to expand","Expanded expression",[9533,9535],{"_281":9534,"_6083":9460},"syms x; expand((x + 1)^2)",{"_281":9536,"_6083":9537},"syms x y; expand((x + y)*(x - y))","x^2 - y^2",[9445,9539,9540],"simplify","factor",{"_19":9539,"_21":9542,"_23":9543,"_25":9544,"_26":9545,"_32":9548,"_33":9549,"_6088":9554},"g = simplify(f)","Simplify symbolic expression","Simplifies a symbolic expression using various algebraic rules. Combines like terms, cancels common factors, and applies trigonometric identities.",[9546],{"_19":2310,"_25":9547},"Symbolic expression to simplify","Simplified expression",[9550,9552],{"_281":9551,"_6083":29},"syms x; simplify(x^2/x)",{"_281":9553,"_6083":6298},"syms x; simplify(sin(x)^2 + cos(x)^2)",[9467,9540,9555],"collect",{"_19":9557,"_21":9558,"_23":9559,"_25":9560,"_26":9561,"_32":9568,"_33":9569,"_6088":9579},"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.",[9562,9564,9566],{"_19":2310,"_25":9563},"Symbolic expression to differentiate",{"_19":29,"_25":9565},"Variable to differentiate with respect to",{"_19":1516,"_25":9567,"_31":61},"Order of derivative (default: 1)","Derivative expression",[9570,9573,9576],{"_281":9571,"_6083":9572},"syms x; diff(x^3, x)","3*x^2",{"_281":9574,"_6083":9575},"syms x; diff(sin(x), x)","cos(x)",{"_281":9577,"_6083":9578},"syms x; diff(x^3, x, 2)","6*x",[9580,9581,9445],"int","taylor",{"_19":9581,"_21":9583,"_23":9584,"_25":9585,"_26":9586,"_32":9594,"_33":9595,"_6088":9602},"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.",[9587,9588,9590,9592],{"_19":2310,"_25":9530},{"_19":29,"_25":9589},"Expansion variable",{"_19":189,"_25":9591,"_31":61},"Expansion point (default: 0)",{"_19":1516,"_25":9593,"_31":61},"Number of terms (default: 6)","Taylor polynomial",[9596,9599],{"_281":9597,"_6083":9598},"syms x; taylor(exp(x), x, 0, 4)","1 + x + x^2/2 + x^3/6",{"_281":9600,"_6083":9601},"syms x; taylor(sin(x), x)","x - x^3/6 + x^5/120",[9557,9467,9445],{"_19":9604,"_21":9605,"_23":9606,"_25":9607,"_26":9608,"_32":9614,"_33":9615,"_6088":9622},"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",[9609,9611],{"_19":29,"_25":9610},"Symbolic variable",{"_19":9612,"_25":9613},"prop","Property to assume (e.g., 'positive', 'real', 'integer')","Nothing (modifies variable in place)",[9616,9619],{"_281":9617,"_6083":9618},"syms x; assume(x, 'positive')","% x is now assumed positive",{"_281":9620,"_6083":9621},"assume x real","% x is now assumed real",[9623,9445,9465],"assumptions",{"_19":9623,"_21":9625,"_23":9626,"_25":9627,"_26":9628,"_32":9631,"_33":9632,"_6088":9636},"a = assumptions(x)","Get assumptions on symbolic variable","Returns the current assumptions on a symbolic variable as a string.",[9629],{"_19":29,"_25":9630},"Symbolic variable to query","String describing assumptions",[9633],{"_281":9634,"_6083":9635},"syms x; assume(x, 'positive'); assumptions(x)","'positive'",[9604,9445,9465],{"_37":9638,"_19":9639,"_25":9640,"_41":42,"_43":9641,"_45":9638,"_47":9642},"vtk","3D Visualization (VTK)","Advanced 3D visualization functions powered by VTK.js for volumetric data, FEM meshes, and scientific visualization.","🧊",[9643,9666,9689,9710,9731,9755,9774,9797,9815,9831,9842,9854,9865,9874,9883,9896,9909,9925],{"_19":9644,"_21":9645,"_23":9646,"_25":9647,"_26":9648,"_32":9658,"_33":9659,"_6088":9662},"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.",[9649,9652,9655],{"_19":9650,"_25":9651},"points","Nx3 matrix of point coordinates",{"_19":9653,"_25":9654},"polys","Polygon connectivity array (VTK format: [npts, p1, p2, ...])",{"_19":9656,"_25":9657,"_31":61},"scalars","Per-point scalar values for coloring","null (renders VTK visualization inline)",[9660],{"_281":9661},"% 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)",[9663,9664,9665],"vtk.volume","vtk.femgrid","vtk.sphere",{"_19":9663,"_21":9667,"_23":9668,"_25":9669,"_26":9670,"_32":9682,"_33":9683,"_6088":9686},"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.",[9671,9673,9676,9679],{"_19":528,"_25":9672},"Flat array of scalar values (nx*ny*nz elements)",{"_19":9674,"_25":9675},"dims","3-element vector [nx, ny, nz] specifying grid dimensions",{"_19":9677,"_25":9678,"_31":61},"spacing","3-element vector [dx, dy, dz] for voxel spacing (default: [1,1,1])",{"_19":9680,"_25":9681,"_31":61},"origin","3-element vector [x0, y0, z0] for grid origin (default: [0,0,0])","null (renders VTK volume inline)",[9684],{"_281":9685},"% 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))",[9687,9688,9644],"vtk.isosurface","vtk.slice",{"_19":9687,"_21":9690,"_23":9691,"_25":9692,"_26":9693,"_32":9705,"_33":9706,"_6088":9709},"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.",[9694,9696,9698,9700,9702],{"_19":528,"_25":9695},"Flat array of scalar values",{"_19":9674,"_25":9697},"3-element vector [nx, ny, nz]",{"_19":9677,"_25":9699,"_31":61},"Voxel spacing (default: [1,1,1])",{"_19":9680,"_25":9701,"_31":61},"Grid origin (default: [0,0,0])",{"_19":9703,"_25":9704},"isovalue","Scalar value for the isosurface","null (renders isosurface inline)",[9707],{"_281":9708},"% 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",[9663,9644],{"_19":9664,"_21":9711,"_23":9712,"_25":9713,"_26":9714,"_32":9726,"_33":9727,"_6088":9730},"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).",[9715,9718,9721,9724],{"_19":9716,"_25":9717},"nodes","Nx3 matrix of node coordinates",{"_19":9719,"_25":9720},"elements","Cell connectivity in VTK format [npts, n1, n2, ...]",{"_19":9722,"_25":9723},"elementTypes","Array of VTK cell type codes for each element",{"_19":9656,"_25":9725,"_31":61},"Per-node or per-cell scalar field (e.g., stress, temperature)","null (renders FEM mesh inline)",[9728],{"_281":9729},"% 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)",[9644,9663],{"_19":9665,"_21":9732,"_23":9733,"_25":9734,"_26":9735,"_32":9745,"_33":9746,"_6088":9751},"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.",[9736,9739,9742],{"_19":9737,"_25":9738,"_31":61},"radius","Sphere radius (default: 1)",{"_19":9740,"_25":9741,"_31":61},"center","3-element vector [x, y, z] for center (default: [0,0,0])",{"_19":9743,"_25":9744,"_31":61},"resolution","Number of phi/theta divisions (default: 32)","null (renders sphere inline)",[9747,9749],{"_281":9748},"vtk.sphere() % unit sphere at origin",{"_281":9750},"vtk.sphere(2, [1 0 0], 64) % radius 2, centered at (1,0,0), high resolution",[9752,9753,9754],"vtk.cone","vtk.cube","vtk.cylinder",{"_19":9752,"_21":9756,"_23":9757,"_25":9758,"_26":9759,"_32":9767,"_33":9768,"_6088":9773},"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.",[9760,9763,9765],{"_19":9761,"_25":9762,"_31":61},"height","Cone height (default: 1)",{"_19":9737,"_25":9764,"_31":61},"Base radius (default: 0.5)",{"_19":9740,"_25":9766,"_31":61},"3-element center position (default: [0,0,0])","null (renders cone inline)",[9769,9771],{"_281":9770},"vtk.cone()",{"_281":9772},"vtk.cone(2, 1, [0 0 1])",[9665,9753,9754],{"_19":9753,"_21":9775,"_23":9776,"_25":9777,"_26":9778,"_32":9790,"_33":9791,"_6088":9796},"vtk.cube()\nvtk.cube(size)\nvtk.cube(xLen, yLen, zLen)","Create cube/box geometry","Creates a VTK cube (box) source with specified dimensions.",[9779,9781,9784,9787],{"_19":1105,"_25":9780,"_31":61},"Uniform size for all dimensions (default: 1)",{"_19":9782,"_25":9783,"_31":61},"xLen","X dimension length",{"_19":9785,"_25":9786,"_31":61},"yLen","Y dimension length",{"_19":9788,"_25":9789,"_31":61},"zLen","Z dimension length","null (renders cube inline)",[9792,9794],{"_281":9793},"vtk.cube()",{"_281":9795},"vtk.cube(2, 1, 0.5) % rectangular box",[9665,9752,9754],{"_19":9754,"_21":9798,"_23":9799,"_25":9800,"_26":9801,"_32":9808,"_33":9809,"_6088":9814},"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.",[9802,9804,9806],{"_19":9761,"_25":9803,"_31":61},"Cylinder height (default: 1)",{"_19":9737,"_25":9805,"_31":61},"Cylinder radius (default: 0.5)",{"_19":9743,"_25":9807,"_31":61},"Number of facets around circumference (default: 32)","null (renders cylinder inline)",[9810,9812],{"_281":9811},"vtk.cylinder()",{"_281":9813},"vtk.cylinder(3, 0.5, 64)",[9665,9752,9753],{"_19":9816,"_21":9817,"_23":9818,"_25":9819,"_26":9820,"_32":7927,"_33":9823,"_6088":9828},"vtk.colormap","vtk.colormap('name')","Set VTK colormap","Sets the colormap for subsequent VTK visualizations. Available colormaps: 'viridis', 'rainbow', 'coolwarm', 'grayscale', 'jet', 'hot'.",[9821],{"_19":19,"_25":9822},"Colormap name",[9824,9826],{"_281":9825},"vtk.colormap('coolwarm')",{"_281":9827},"vtk.colormap('viridis'); vtk.volume(data, dims)",[9829,9830],"vtk.opacity","vtk.edges",{"_19":9829,"_21":9832,"_23":9833,"_25":9834,"_26":9835,"_32":7927,"_33":9838,"_6088":9841},"vtk.opacity(value)","Set VTK opacity","Sets the opacity (0-1) for subsequent VTK visualizations.",[9836],{"_19":2051,"_25":9837},"Opacity value between 0 (transparent) and 1 (opaque)",[9839],{"_281":9840},"vtk.opacity(0.7)",[9816,9830],{"_19":9830,"_21":9843,"_23":9844,"_25":9845,"_26":9846,"_32":7927,"_33":9849,"_6088":9852},"vtk.edges('on')\nvtk.edges('off')","Toggle edge visibility","Enables or disables edge rendering for surface meshes. Useful for FEM visualization.",[9847],{"_19":8064,"_25":9848},"'on' or 'off'",[9850],{"_281":9851},"vtk.edges('on')",[9816,9853],"vtk.wireframe",{"_19":9853,"_21":9855,"_23":9856,"_25":9857,"_26":9858,"_32":7927,"_33":9859,"_6088":9862},"vtk.wireframe()","Set wireframe rendering","Sets the rendering mode to wireframe for subsequent VTK visualizations.",[],[9860],{"_281":9861},"vtk.wireframe(); vtk.sphere()",[9863,9864,9830],"vtk.surface","vtk.points",{"_19":9863,"_21":9866,"_23":9867,"_25":9868,"_26":9869,"_32":7927,"_33":9870,"_6088":9873},"vtk.surface()","Set surface rendering","Sets the rendering mode to filled surface for subsequent VTK visualizations (default mode).",[],[9871],{"_281":9872},"vtk.surface(); vtk.sphere()",[9853,9864],{"_19":9864,"_21":9875,"_23":9876,"_25":9877,"_26":9878,"_32":7927,"_33":9879,"_6088":9882},"vtk.points()","Set point rendering","Sets the rendering mode to points only for subsequent VTK visualizations.",[],[9880],{"_281":9881},"vtk.points(); vtk.sphere()",[9853,9863],{"_19":9884,"_21":9885,"_23":9886,"_25":9887,"_26":9888,"_32":9658,"_33":9891,"_6088":9894},"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.",[9889],{"_19":6229,"_25":9890},"MFEM Mesh object (from mfem.mesh.makeCartesian2D, etc.)",[9892],{"_281":9893},"mesh = mfem.mesh.makeCartesian2D(10, 10, 'TRIANGLE', true, 1.0, 1.0)\nvtk.edges('on')\nvtk.mesh(mesh)",[9895,9664,9816],"vtk.gridfunction",{"_19":9897,"_21":9898,"_23":9899,"_25":9900,"_26":9901,"_32":9904,"_33":9905,"_6088":9908},"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.",[9902],{"_19":6229,"_25":9903},"MFEM Mesh object","Struct with fields: x, y, z (NDArrays) and numVertices (number)",[9906],{"_281":9907},"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",[9884,9895],{"_19":9895,"_21":9910,"_23":9911,"_25":9912,"_26":9913,"_32":9658,"_33":9919,"_6088":9924},"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.",[9914,9916],{"_19":6229,"_25":9915},"MFEM Mesh object (the mesh on which the GridFunction is defined)",{"_19":9917,"_25":9918},"gf","MFEM GridFunction object containing the finite element solution",[9920,9922],{"_281":9921},"vtk.colormap('viridis')\nvtk.gridfunction(mesh, solution)",{"_281":9923},"vtk.colormap('coolwarm')\nvtk.edges('on')\nvtk.gridfunction(mesh, x)",[9884,9816,9830],{"_19":9926,"_21":9927,"_23":9928,"_25":9929,"_26":9930,"_32":9937,"_33":9938,"_6088":9941},"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).",[9931,9932,9934],{"_19":6229,"_25":9903},{"_19":8584,"_25":9933},"Vector GridFunction containing displacement [ux, uy, uz] per node",{"_19":9935,"_25":9936,"_31":61},"scaleFactor","Deformation amplification factor (default: 1)","null (renders deformed mesh inline)",[9939],{"_281":9940},"vtk.colormap('coolwarm')\nvtk.displacement(mesh, u, 100) % amplify by 100x",[9895,9884],{"_37":2807,"_19":9943,"_25":9944,"_41":42,"_43":9945,"_47":9946},"Sparse Matrices","Sparse matrix creation, manipulation, and iterative solvers for large-scale linear systems.","🔳",[9947,9974,9986,10002,10015,10027,10044,10060,10074,10088,10103,10114,10126,10137,10149,10163,10178,10203,10217,10231,10247,10263,10276,10293,10307],{"_19":2807,"_21":9948,"_23":9949,"_25":9950,"_26":9951,"_32":9962,"_33":9963,"_6088":9970},"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.",[9952,9955,9958,9960,9961],{"_19":9953,"_25":9954},"A/i","Dense matrix, or row index vector (1-based)",{"_19":9956,"_25":9957,"_31":61},"j/n","Column index vector (1-based), or number of columns",{"_19":1273,"_25":9959,"_31":61},"Values vector",{"_19":958,"_25":6076,"_31":61},{"_19":1516,"_25":6078,"_31":61},"Sparse matrix (CSR format)",[9964,9966,9968],{"_281":9965},"S = sparse(eye(5))",{"_281":9967},"S = sparse([1 2 3], [1 2 3], [10 20 30], 3, 3)",{"_281":9969},"S = sparse(5, 5) % empty 5x5 sparse",[9971,9972,985,9973],"speye","sprand","issparse",{"_19":9971,"_21":9975,"_23":9976,"_25":9977,"_26":9978,"_32":9976,"_33":9982,"_6088":9985},"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.",[9979,9981],{"_19":958,"_25":9980},"Size (or number of rows)",{"_19":1516,"_25":6078,"_31":61},[9983],{"_281":9984},"I = speye(100)",[2807,6091,9972],{"_19":9972,"_21":9987,"_23":9988,"_25":9989,"_26":9990,"_32":9995,"_33":9996,"_6088":9999},"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).",[9991,9992,9993],{"_19":958,"_25":6076},{"_19":1516,"_25":6078},{"_19":2626,"_25":9994},"Approximate density (0 to 1)","Sparse random matrix",[9997],{"_281":9998},"S = sprand(100, 100, 0.05)",[10000,10001,2807],"sprandn","sprandsym",{"_19":10000,"_21":10003,"_23":10004,"_25":10005,"_26":10006,"_32":10010,"_33":10011,"_6088":10014},"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.",[10007,10008,10009],{"_19":958,"_25":6076},{"_19":1516,"_25":6078},{"_19":2626,"_25":9994},"Sparse random matrix with normal distribution",[10012],{"_281":10013},"S = sprandn(100, 100, 0.05)",[9972,10001,2807],{"_19":10001,"_21":10016,"_23":10017,"_25":10018,"_26":10019,"_32":10017,"_33":10023,"_6088":10026},"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.",[10020,10022],{"_19":1516,"_25":10021},"Matrix size",{"_19":2626,"_25":9994},[10024],{"_281":10025},"S = sprandsym(50, 0.1)",[9972,10000],{"_19":10028,"_21":10029,"_23":10030,"_25":10031,"_26":10032,"_32":10039,"_33":10040,"_6088":10043},"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.",[10033,10035,10037,10038],{"_19":6369,"_25":10034},"Matrix whose columns are the diagonals",{"_19":1909,"_25":10036},"Vector of diagonal positions (0 = main, positive = above, negative = below)",{"_19":958,"_25":6076},{"_19":1516,"_25":6078},"Sparse matrix with specified diagonals",[10041],{"_281":10042},"e = ones(5,1);\nS = spdiags([-e 2*e -e], [-1 0 1], 5, 5)",[2807,9971,6119],{"_19":10045,"_21":10046,"_23":10047,"_25":10048,"_26":10049,"_32":10055,"_33":10056,"_6088":10059},"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).",[10050,10051,10052],{"_19":958,"_25":6076},{"_19":1516,"_25":6078},{"_19":10053,"_25":10054},"nz","Number of nonzero elements to allocate (hint)","Empty sparse matrix",[10057],{"_281":10058},"S = spalloc(10, 10, 50)",[2807,9971],{"_19":10061,"_21":10062,"_23":10063,"_25":10064,"_26":10065,"_32":10069,"_33":10070,"_6088":10073},"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].",[10066],{"_19":10067,"_25":10068},"D","Dense matrix with columns [i, j, v]","Sparse matrix",[10071],{"_281":10072},"D = [1 1 10; 2 2 20; 3 3 30];\nS = spconvert(D)",[2807,6639],{"_19":9973,"_21":10075,"_23":10076,"_25":10077,"_26":10078,"_32":10081,"_33":10082,"_6088":10087},"tf = issparse(S)","Determine if matrix is sparse","Returns true (1) if S is a sparse matrix, false (0) otherwise.",[10079],{"_19":7812,"_25":10080},"Input value to test","Logical 1 or 0",[10083,10085],{"_281":10084,"_6083":6298},"issparse(speye(5))",{"_281":10086,"_6083":6389},"issparse(eye(5))",[2807,985],{"_19":7829,"_21":10089,"_23":10090,"_25":10091,"_26":10092,"_32":10095,"_33":10096,"_6088":10100},"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.",[10093],{"_19":7812,"_25":10094},"Sparse or full matrix","Number of nonzeros",[10097],{"_281":10098,"_6083":10099},"nnz(speye(100))","100",[10101,10102,9973],"nonzeros","nzmax",{"_19":10101,"_21":10104,"_23":10105,"_25":10106,"_26":10107,"_32":10109,"_33":10110,"_6088":10113},"v = nonzeros(S)","Nonzero matrix elements","Returns a column vector of the nonzero elements in sparse matrix S.",[10108],{"_19":7812,"_25":10069},"Column vector of nonzero values",[10111],{"_281":10112},"nonzeros(sparse([1 0; 0 2]))",[7829,6639,10102],{"_19":10102,"_21":10115,"_23":10116,"_25":10117,"_26":10118,"_32":10120,"_33":10121,"_6088":10125},"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.",[10119],{"_19":7812,"_25":10069},"Allocated storage size",[10122],{"_281":10123,"_6083":10124},"nzmax(speye(10))","10",[7829,10101],{"_19":985,"_21":10127,"_23":10128,"_25":10129,"_26":10130,"_32":10132,"_33":10133,"_6088":10136},"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.",[10131],{"_19":7812,"_25":10094},"Full (dense) matrix",[10134],{"_281":10135},"full(speye(3))",[2807,9973,7805],{"_19":10138,"_21":10139,"_23":10140,"_25":10141,"_26":10142,"_32":10144,"_33":10145,"_6088":10148},"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.",[10143],{"_19":7812,"_25":10069},"Sparse matrix with ones at nonzero positions",[10146],{"_281":10147},"full(spones(sparse([1 0; 0 5])))",[7829,10101,2807],{"_19":10150,"_21":10151,"_23":10152,"_25":10153,"_26":10154,"_32":10158,"_33":10159,"_6088":10162},"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.",[10155,10157],{"_19":220,"_25":10156},"Function handle to apply (e.g., @sqrt, @exp)",{"_19":7812,"_25":10069},"Sparse matrix with function applied to nonzeros",[10160],{"_281":10161},"full(spfun(@sqrt, sparse([4 0; 0 9])))",[10138,10101],{"_19":10164,"_21":10165,"_23":10166,"_25":10167,"_26":10168,"_32":10174,"_33":10175,"_6088":10177},"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.",[10169,10172],{"_19":10170,"_25":10171,"_31":61},"key","Parameter name",{"_19":2051,"_25":10173,"_31":61},"Parameter value","Current parameter values, or null",[10176],{"_281":10164},[2807],{"_19":10179,"_21":10180,"_23":10181,"_25":10182,"_26":10183,"_32":10196,"_33":10197,"_6088":10200},"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.",[10184,10186,10188,10191,10193],{"_19":3766,"_25":10185},"Sparse coefficient matrix (n x n)",{"_19":191,"_25":10187},"Right-hand side vector",{"_19":10189,"_25":10190,"_31":61},"restart","Restart parameter (default 20)",{"_19":3769,"_25":10192,"_31":61},"Convergence tolerance (default 1e-6)",{"_19":10194,"_25":10195,"_31":61},"maxit","Maximum iterations","Solution vector x, or [x, flag, relres, iter]",[10198],{"_281":10199},"A = speye(3); b = [1;2;3];\nx = gmres(A, b)",[10201,10202,2807],"bicgstab","pcg",{"_19":10201,"_21":10204,"_23":10205,"_25":10206,"_26":10207,"_32":10196,"_33":10213,"_6088":10216},"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.",[10208,10210,10211,10212],{"_19":3766,"_25":10209},"Sparse coefficient matrix",{"_19":191,"_25":10187},{"_19":3769,"_25":10192,"_31":61},{"_19":10194,"_25":10195,"_31":61},[10214],{"_281":10215},"x = bicgstab(A, b)",[10179,10202],{"_19":10202,"_21":10218,"_23":10219,"_25":10220,"_26":10221,"_32":10196,"_33":10227,"_6088":10230},"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.",[10222,10224,10225,10226],{"_19":3766,"_25":10223},"Symmetric positive definite sparse matrix",{"_19":191,"_25":10187},{"_19":3769,"_25":10192,"_31":61},{"_19":10194,"_25":10195,"_31":61},[10228],{"_281":10229},"x = pcg(A, b)",[10179,10201],{"_19":10232,"_21":10233,"_23":10234,"_25":10235,"_26":10236,"_32":10242,"_33":10243,"_6088":10246},"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.",[10237,10239,10240,10241],{"_19":3766,"_25":10238},"Sparse matrix (possibly non-square)",{"_19":191,"_25":10187},{"_19":3769,"_25":10192,"_31":61},{"_19":10194,"_25":10195,"_31":61},"Solution vector x, or [x, flag]",[10244],{"_281":10245},"x = lsqr(A, b)",[10202,10179],{"_19":10248,"_21":10249,"_23":10250,"_25":10251,"_26":10252,"_32":10257,"_33":10258,"_6088":10261},"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.",[10253,10255],{"_19":3766,"_25":10254},"Sparse matrix or LinearOperator",{"_19":1010,"_25":10256,"_31":61},"Number of eigenvalues (default 6)","Eigenvalues vector, or [V, D] decomposition",[10259],{"_281":10260},"d = eigs(speye(10), 3)",[7172,10262],"svds",{"_19":10262,"_21":10264,"_23":10265,"_25":10266,"_26":10267,"_32":10271,"_33":10272,"_6088":10275},"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.",[10268,10269],{"_19":3766,"_25":10069},{"_19":1010,"_25":10270,"_31":61},"Number of singular values (default 6)","Singular values vector, or [U, S, V] decomposition",[10273],{"_281":10274},"s = svds(A, 3)",[7187,10248],{"_19":10277,"_21":10278,"_23":10279,"_25":10280,"_26":10281,"_32":10287,"_33":10288,"_6088":10291},"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.",[10282,10284],{"_19":3766,"_25":10283},"Sparse square matrix",{"_19":10285,"_25":10286,"_31":61},"setup","Options struct with type and droptol","[L, U] incomplete factors",[10289],{"_281":10290},"[L, U] = ilu(speye(5))",[10292,10202,10179],"ichol",{"_19":10292,"_21":10294,"_23":10295,"_25":10296,"_26":10297,"_32":10302,"_33":10303,"_6088":10306},"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.",[10298,10299],{"_19":3766,"_25":10223},{"_19":10300,"_25":10301,"_31":61},"opts","Options struct","Lower triangular incomplete factor L",[10304],{"_281":10305},"L = ichol(speye(5))",[10277,10202],{"_19":10308,"_21":10309,"_23":10310,"_25":10311,"_26":10312,"_32":10314,"_33":10315,"_6088":10318},"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.",[10313],{"_19":3766,"_25":10069},"Structural rank (integer)",[10316],{"_281":10317,"_6083":6494},"sprank(speye(5))",[7829,2807],{"_37":10320,"_19":10321,"_25":10322,"_41":42,"_43":10323,"_45":10324,"_47":10325},"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",[10326,10339,10353,10362,10378,10396,10410,10419,10428,10440,10447,10456,10465,10474,10484,10492,10502,10519,10530,10537,10550,10558,10570,10580,10592,10602,10610,10618,10627,10636,10647,10664,10681,10696,10708,10720,10729,10741,10756,10766,10779,10788,10797,10810,10819,10831,10840,10848,10857,10866,10878,10887,10898,10907,10916,10928,10939,10948,10957,10966,10975,10987,10998,11008,11017,11030,11041,11054,11065,11076,11085,11095,11104,11114,11125,11134,11142,11150,11159,11167,11175,11183,11191,11201,11213,11224,11232,11239,11247,11256,11263,11272,11280,11288,11295,11303,11311,11321,11330,11338,11346,11354,11363,11373,11381,11395,11405,11417,11429,11441,11452,11460,11468,11476,11488,11495,11511,11522,11533,11544,11554,11564,11574,11587,11597,11606,11617,11628,11638,11646,11656,11668,11683,11693,11705,11714,11729,11741,11751,11762,11772,11782,11791,11802,11817,11835,11846,11857,11870,11882,11894,11904,11915,11926,11936,11947,11956,11964,11972,11985,11998,12007,12020,12029,12041,12050,12059,12069,12078,12086,12098,12106,12114,12122,12130,12141,12147,12154,12160,12166,12173,12179,12185,12192,12199,12206,12212,12218,12225,12234,12245,12254,12263,12271,12278,12289,12298,12308,12318,12329,12336,12351,12358,12367,12375,12388,12398,12408,12416,12429,12439,12445,12452,12459,12466,12481,12491,12498,12504,12511,12523,12534,12544,12554,12568,12577,12587,12596,12603,12610,12618,12625,12636,12642,12650,12657,12665,12672,12682,12689,12696,12703,12713,12722,12728,12738,12745,12751,12757,12764,12771,12778,12785,12791,12797,12804,12816,12824,12832,12839,12851,12862,12871,12880,12889,12898,12907,12916,12925,12934,12947,12956,12965,12972,12984,12995,13007,13019,13039,13057,13069,13082,13093,13103,13114,13123,13133,13146,13157,13168,13181,13189,13204,13217,13226,13234,13242,13250,13259,13267,13278,13289,13297,13304,13314,13325,13336,13348,13356,13366,13375,13386,13396,13408,13415,13425,13434,13441,13448,13455,13462,13469,13476,13483,13490,13497,13504,13511,13518,13525,13535,13542,13549,13556,13565,13572,13579,13586,13593,13600,13607,13614,13621,13628,13635,13642,13650,13659,13666,13678,13686,13697,13705,13715,13725,13732,13739,13746,13755,13762,13769,13776,13783,13790,13799,13806,13813,13820,13828,13836,13844,13851,13858,13864,13871,13877,13883,13890,13899,13907,13916,13922,13929,13935,13941,13952,13960,13971,13987,13997,14009,14020,14029,14035,14042,14049,14056,14063,14070,14076,14084,14094,14103,14110,14117,14130,14140],{"_19":10327,"_21":10328,"_23":10329,"_25":10330,"_26":10331,"_32":62,"_33":10338},"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",[10332,10335],{"_19":10333,"_25":10334,"_31":6},"blf","- BilinearForm instance",{"_19":10336,"_25":10337,"_31":61},"coeff","- Optional scalar coefficient",[],{"_19":10340,"_21":10341,"_23":10342,"_25":10343,"_26":10344,"_32":62,"_33":10352},"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",[10345,10346,10349],{"_19":10333,"_25":10334,"_31":6},{"_19":10347,"_25":10348,"_31":6},"velocity","- Vector coefficient for velocity field",{"_19":10350,"_25":10351,"_31":61},"alpha","- Scaling factor (defaults to 1.0)",[],{"_19":10354,"_21":10355,"_23":10356,"_25":10357,"_26":10358,"_32":62,"_33":10361},"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",[10359,10360],{"_19":10333,"_25":10334,"_31":6},{"_19":10336,"_25":10337,"_31":61},[],{"_19":10363,"_21":10364,"_23":10365,"_25":10366,"_26":10367,"_32":62,"_33":10377},"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.",[10368,10369,10371,10374],{"_19":10333,"_25":10334,"_31":6},{"_19":10336,"_25":10370,"_31":6},"- Diffusion coefficient (optional)",{"_19":10372,"_25":10373,"_31":6},"sigma","- Symmetry parameter (-1 = SIPG, 0 = IIPG, 1 = NIPG)",{"_19":10375,"_25":10376,"_31":6},"kappa","- Penalty parameter (typically 10 * p^2 / h)",[],{"_19":10379,"_21":10380,"_23":10381,"_25":10382,"_26":10383,"_32":62,"_33":10395},"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.",[10384,10385,10388,10391,10393],{"_19":10333,"_25":10334,"_31":6},{"_19":10386,"_25":10387,"_31":6},"lambda","- Lamé first parameter",{"_19":10389,"_25":10390,"_31":6},"mu","- Shear modulus",{"_19":10350,"_25":10392,"_31":61},"- Symmetry parameter (default: -1.0 for symmetric form)",{"_19":10375,"_25":10394,"_31":61},"- Penalty parameter for stability",[],{"_19":10397,"_21":10398,"_23":10399,"_25":10400,"_26":10401,"_32":62,"_33":10409},"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.",[10402,10403,10405,10407],{"_19":10333,"_25":10334,"_31":6},{"_19":10336,"_25":10404,"_31":61},"- Optional coefficient (VectorCoefficient)",{"_19":10350,"_25":10406,"_31":61},"- Upwinding parameter (default: 0)",{"_19":3202,"_25":10408,"_31":61},"- Penalty parameter (default: 0)",[],{"_19":10411,"_21":10412,"_23":10413,"_25":10414,"_26":10415,"_32":62,"_33":10418},"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",[10416,10417],{"_19":10333,"_25":10334,"_31":6},{"_19":10336,"_25":10337,"_31":61},[],{"_19":10420,"_21":10421,"_23":10422,"_25":10423,"_26":10424,"_32":62,"_33":10427},"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",[10425,10426],{"_19":10333,"_25":10334,"_31":6},{"_19":10336,"_25":10337,"_31":61},[],{"_19":10429,"_21":10430,"_23":10431,"_25":10432,"_26":10433,"_32":62,"_33":10439},"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",[10434,10435,10437],{"_19":10333,"_25":10334,"_31":6},{"_19":10386,"_25":10436,"_31":6},"- Lamé first parameter (scalar coefficient)",{"_19":10389,"_25":10438,"_31":6},"- Shear modulus / Lamé second parameter (scalar coefficient)",[],{"_19":10441,"_21":10442,"_23":10443,"_25":10443,"_26":10444,"_32":62,"_33":10446},"mfem.bilinearForms.addGradientIntegrator","mfem.bilinearForms.addGradientIntegrator(blf)","Add a gradient integrator to the bilinear form.",[10445],{"_19":10333,"_25":10334,"_31":6},[],{"_19":10448,"_21":10449,"_23":10450,"_25":10451,"_26":10452,"_32":62,"_33":10455},"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",[10453,10454],{"_19":10333,"_25":10334,"_31":6},{"_19":10336,"_25":10337,"_31":61},[],{"_19":10457,"_21":10458,"_23":10459,"_25":10460,"_26":10461,"_32":62,"_33":10464},"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.",[10462,10463],{"_19":10333,"_25":10334,"_31":6},{"_19":10336,"_25":10337,"_31":61},[],{"_19":10466,"_21":10467,"_23":10468,"_25":10469,"_26":10470,"_32":62,"_33":10473},"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",[10471,10472],{"_19":10333,"_25":10334,"_31":6},{"_19":10336,"_25":10337,"_31":61},[],{"_19":10475,"_21":10476,"_23":10477,"_25":10477,"_26":10478,"_32":62,"_33":10483},"mfem.bilinearForms.assemble","mfem.bilinearForms.assemble(blf, skipZeros?)","Assemble bilinear form into sparse matrix.",[10479,10480],{"_19":10333,"_25":10334,"_31":6},{"_19":10481,"_25":10482,"_31":61},"skipZeros","- If true, skip storing zeros in the matrix (default: true)",[],{"_19":10485,"_21":10486,"_23":10487,"_25":10488,"_26":10489,"_32":62,"_33":10491},"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.",[10490],{"_19":10333,"_25":10334,"_31":6},[],{"_19":10493,"_21":10494,"_23":10495,"_25":10495,"_26":10496,"_32":10500,"_33":10501},"mfem.bilinearForms.create","mfem.bilinearForms.create(fespace)","Create a bilinear form on a finite element space.",[10497],{"_19":10498,"_25":10499,"_31":6},"fespace","- FiniteElementSpace instance","Promise",[],{"_19":10503,"_21":10504,"_23":10505,"_25":10506,"_26":10507,"_32":62,"_33":10518},"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.",[10508,10509,10512,10515],{"_19":10333,"_25":10334,"_31":6},{"_19":10510,"_25":10511,"_31":6},"essentialDofs","- Essential DOF indices",{"_19":10513,"_25":10514,"_31":6},"sol","- Solution vector with boundary values",{"_19":10516,"_25":10517,"_31":6},"rhs","- Right-hand side vector (modified in place)",[],{"_19":10520,"_21":10521,"_23":10522,"_25":10523,"_26":10524,"_32":10528,"_33":10529},"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.",[10525,10527],{"_19":10333,"_25":10526,"_31":6},"- BilinearForm instance (must be assembled first)",{"_19":10510,"_25":10511,"_31":6},"SparseMatrix",[],{"_19":10531,"_21":10532,"_23":10533,"_25":10533,"_26":10534,"_32":10528,"_33":10536},"mfem.bilinearForms.getMatrix","mfem.bilinearForms.getMatrix(blf)","Get assembled sparse matrix from a bilinear form.",[10535],{"_19":10333,"_25":10526,"_31":6},[],{"_19":10538,"_21":10539,"_23":10540,"_25":10540,"_26":10541,"_32":10548,"_33":10549},"mfem.bilinearForms.createMixed","mfem.bilinearForms.createMixed(trialFES, testFES)","Create a mixed bilinear form on trial and test spaces.",[10542,10545],{"_19":10543,"_25":10544,"_31":6},"trialFES","- Trial FiniteElementSpace",{"_19":10546,"_25":10547,"_31":6},"testFES","- Test FiniteElementSpace","Promise",[],{"_19":10551,"_21":10552,"_23":10553,"_25":10553,"_26":10554,"_32":10500,"_33":10557},"mfem.bilinearForms.BilinearForm.create","mfem.bilinearForms.BilinearForm.create(fespace)","Creates a new bilinear form on the specified finite element space.",[10555],{"_19":10498,"_25":10556,"_31":6},"- The finite element space",[],{"_19":10559,"_21":10560,"_23":10561,"_25":10561,"_26":10562,"_32":10548,"_33":10569},"mfem.bilinearForms.MixedBilinearForm.create","mfem.bilinearForms.MixedBilinearForm.create(trialFespace, testFespace)","Creates a new mixed bilinear form.",[10563,10566],{"_19":10564,"_25":10565,"_31":6},"trialFespace","- The trial finite element space",{"_19":10567,"_25":10568,"_31":6},"testFespace","- The test finite element space",[],{"_19":10571,"_21":10572,"_23":10573,"_25":10573,"_26":10574,"_32":10578,"_33":10579},"mfem.block.BlockMatrix.createSquare","mfem.block.BlockMatrix.createSquare(offsets)","Create a square BlockMatrix with the same offsets for rows and columns.",[10575],{"_19":10576,"_25":10577,"_31":6},"offsets","- Block offsets array (used for both rows and columns)","Promise",[],{"_19":10581,"_21":10582,"_23":10583,"_25":10583,"_26":10584,"_32":10578,"_33":10591},"mfem.block.BlockMatrix.create","mfem.block.BlockMatrix.create(rowOffsets, colOffsets)","Create a rectangular BlockMatrix with different row and column offsets.",[10585,10588],{"_19":10586,"_25":10587,"_31":6},"rowOffsets","- Row block offsets array",{"_19":10589,"_25":10590,"_31":6},"colOffsets","- Column block offsets array",[],{"_19":10593,"_21":10594,"_23":10595,"_25":10596,"_26":10597,"_32":10578,"_33":10601},"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.",[10598],{"_19":10599,"_25":10600,"_31":6},"ptr","- WASM pointer to an existing MFEM BlockMatrix",[],{"_19":10603,"_21":10604,"_23":10605,"_25":10605,"_26":10606,"_32":10608,"_33":10609},"mfem.block.BlockOperator.createSquare","mfem.block.BlockOperator.createSquare(offsets)","Create a square BlockOperator with the same offsets for rows and columns.",[10607],{"_19":10576,"_25":10577,"_31":6},"Promise",[],{"_19":10611,"_21":10612,"_23":10613,"_25":10613,"_26":10614,"_32":10608,"_33":10617},"mfem.block.BlockOperator.create","mfem.block.BlockOperator.create(rowOffsets, colOffsets)","Create a rectangular BlockOperator with different row and column offsets.",[10615,10616],{"_19":10586,"_25":10587,"_31":6},{"_19":10589,"_25":10590,"_31":6},[],{"_19":10619,"_21":10620,"_23":10621,"_25":10622,"_26":10623,"_32":10608,"_33":10626},"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.",[10624],{"_19":10599,"_25":10625,"_31":6},"- WASM pointer to an existing MFEM BlockOperator",[],{"_19":10628,"_21":10629,"_23":10630,"_25":10630,"_26":10631,"_32":10634,"_33":10635},"mfem.block.BlockVector.create","mfem.block.BlockVector.create(offsets)","Create a new BlockVector with the specified block offsets.",[10632],{"_19":10576,"_25":10633,"_31":6},"- Array where offsets[i+1] - offsets[i] defines block i size","Promise",[],{"_19":10637,"_21":10638,"_23":10639,"_25":10640,"_26":10641,"_32":10634,"_33":10646},"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.",[10642,10644],{"_19":10599,"_25":10643,"_31":6},"- WASM pointer to an existing MFEM BlockVector",{"_19":10576,"_25":10645,"_31":6},"- Block offsets array",[],{"_19":10648,"_21":10649,"_23":10650,"_25":10650,"_26":10651,"_32":1947,"_33":10663},"mfem.boundaryConditions.addBoundaryRobinIntegrator","mfem.boundaryConditions.addBoundaryRobinIntegrator(blf, lf, alpha, g, bdrAttrs)","Add Robin boundary condition integrator (legacy name)",[10652,10654,10657,10659,10661],{"_19":10333,"_25":10653,"_31":6},"BilinearForm",{"_19":10655,"_25":10656,"_31":6},"lf","LinearForm",{"_19":10350,"_25":10658,"_31":6},"number | CoefficientLike_15",{"_19":10660,"_25":10658,"_31":6},"g",{"_19":10662,"_25":931,"_31":6},"bdrAttrs",[],{"_19":10665,"_21":10666,"_23":10667,"_25":10668,"_26":10669,"_32":1947,"_33":10680},"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.",[10670,10672,10674,10676,10678],{"_19":10671,"_25":10334,"_31":6},"bf",{"_19":10655,"_25":10673,"_31":6},"- LinearForm instance",{"_19":10350,"_25":10675,"_31":6},"- Coefficient for u term (scalar value or CoefficientLike)",{"_19":10660,"_25":10677,"_31":6},"- RHS coefficient g (scalar value or CoefficientLike)",{"_19":10662,"_25":10679,"_31":6},"- Array of boundary attributes where Robin BC applies",[],{"_19":10682,"_21":10683,"_23":10684,"_25":10685,"_26":10686,"_32":62,"_33":10695},"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.",[10687,10689,10691,10693],{"_19":10333,"_25":10688,"_31":6},"- BilinearForm instance (system matrix)",{"_19":10510,"_25":10690,"_31":6},"- Array of essential DOF indices",{"_19":29,"_25":10692,"_31":6},"- GridFunction with Dirichlet values set",{"_19":191,"_25":10694,"_31":6},"- LinearForm (RHS) to modify",[],{"_19":10697,"_21":10698,"_23":10699,"_25":10700,"_26":10701,"_32":10706,"_33":10707},"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.",[10702,10704],{"_19":6229,"_25":10703,"_31":6},"- Mesh instance",{"_19":10662,"_25":10705,"_31":6},"- Array of boundary attribute numbers to mark (1-based)","Int32Array",[],{"_19":10709,"_21":10710,"_23":10711,"_25":10712,"_26":10713,"_32":62,"_33":10719},"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.",[10714,10715,10716],{"_19":10333,"_25":10334,"_31":6},{"_19":10510,"_25":10690,"_31":6},{"_19":10717,"_25":10718,"_31":61},"diagPolicy","- Diagonal policy (default: DIAG_ONE)",[],{"_19":10721,"_21":10722,"_23":10723,"_25":10723,"_26":10724,"_32":931,"_33":10728},"mfem.boundaryConditions.getEssentialTrueDofs","mfem.boundaryConditions.getEssentialTrueDofs(fespace, bdrAttrs)","Get essential true DOF indices for given boundary attributes.",[10725,10726],{"_19":10498,"_25":10499,"_31":6},{"_19":10662,"_25":10727,"_31":6},"- Array of boundary attribute numbers",[],{"_19":10730,"_21":10731,"_23":10732,"_25":10733,"_26":10734,"_32":10739,"_33":10740},"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.",[10735,10737],{"_19":10498,"_25":10736,"_31":6},"- FiniteElementSpace (typically on a periodic mesh)",{"_19":534,"_25":10738,"_31":6},"- Configuration including translation vectors and tolerance","Promise",[],{"_19":10742,"_21":10743,"_23":10744,"_25":10745,"_26":10746,"_32":10754,"_33":10755},"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.",[10747,10749,10752],{"_19":6229,"_25":10748,"_31":6},"- Original mesh",{"_19":10750,"_25":10751,"_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":3769,"_25":10753,"_31":61},"- Tolerance for vertex matching (relative to mesh diameter).\r\n Default is 1e-8.","Promise",[],{"_19":10757,"_21":10758,"_23":10759,"_25":10759,"_26":10760,"_32":225,"_33":10765},"mfem.boundaryConditions.makePeriodic","mfem.boundaryConditions.makePeriodic(_fespace, _mesh)","Create periodic finite element space (legacy name).",[10761,10763],{"_19":10762,"_25":225,"_31":6},"_fespace",{"_19":10764,"_25":225,"_31":6},"_mesh",[],{"_19":10767,"_21":10768,"_23":10769,"_25":10770,"_26":10771,"_32":10777,"_33":10778},"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.",[10772,10774,10776],{"_19":6229,"_25":10773,"_31":6},"- Mesh to analyze",{"_19":10750,"_25":10775,"_31":6},"- Array of translation vectors defining periodicity",{"_19":3769,"_25":10753,"_31":61},"Promise",[],{"_19":10780,"_21":10781,"_23":10782,"_25":10782,"_26":10783,"_32":62,"_33":10787},"mfem.boundaryConditions.makePeriodicVertices","mfem.boundaryConditions.makePeriodicVertices(_mesh, _v2v)","Set periodic vertex mapping on mesh (legacy name).",[10784,10785],{"_19":10764,"_25":225,"_31":6},{"_19":10786,"_25":612,"_31":6},"_v2v",[],{"_19":10789,"_21":10790,"_23":10791,"_25":10791,"_26":10792,"_32":10795,"_33":10796},"mfem.coefficients.constant","mfem.coefficients.constant(value)","Create a constant scalar coefficient.",[10793],{"_19":2051,"_25":10794,"_31":6},"- Constant value","Promise",[],{"_19":10798,"_21":10799,"_23":10800,"_25":10800,"_26":10801,"_32":10808,"_33":10809},"mfem.coefficients.crossProduct","mfem.coefficients.crossProduct(v1, v2)","Create a cross product coefficient from two vector coefficients.",[10802,10805],{"_19":10803,"_25":10804,"_31":6},"v1","- First vector coefficient (must be 3D)",{"_19":10806,"_25":10807,"_31":6},"v2","- Second vector coefficient (must be 3D)","Promise",[],{"_19":10811,"_21":10812,"_23":10813,"_25":10813,"_26":10814,"_32":10817,"_33":10818},"mfem.coefficients.curl","mfem.coefficients.curl(gf)","Create a curl vector coefficient from a vector GridFunction.",[10815],{"_19":9917,"_25":10816,"_31":6},"- Vector GridFunction instance","Promise",[],{"_19":10820,"_21":10821,"_23":10822,"_25":10822,"_26":10823,"_32":10829,"_33":10830},"mfem.coefficients.delta","mfem.coefficients.delta(center, weight?)","Create a Dirac delta coefficient (point source).",[10824,10826],{"_19":9740,"_25":10825,"_31":6},"- Center point of the delta function",{"_19":10827,"_25":10828,"_31":61},"weight","- Weight (scale) of the delta function (defaults to 1.0)","Promise",[],{"_19":10832,"_21":10833,"_23":10834,"_25":10834,"_26":10835,"_32":10838,"_33":10839},"mfem.coefficients.diagonal","mfem.coefficients.diagonal(values)","Create a diagonal matrix coefficient from an array of values.",[10836],{"_19":376,"_25":10837,"_31":6},"- Array of diagonal values","Promise",[],{"_19":10841,"_21":10842,"_23":10843,"_25":10843,"_26":10844,"_32":10846,"_33":10847},"mfem.coefficients.divergence","mfem.coefficients.divergence(gf)","Create a divergence scalar coefficient from a vector GridFunction.",[10845],{"_19":9917,"_25":10816,"_31":6},"Promise",[],{"_19":10849,"_21":10850,"_23":10851,"_25":10851,"_26":10852,"_32":10855,"_33":10856},"mfem.coefficients.functionCoefficient","mfem.coefficients.functionCoefficient(fn)","Create a coefficient from a JavaScript function.",[10853],{"_19":6033,"_25":10854,"_31":6},"- Function (x, y, z) => number","Promise",[],{"_19":10858,"_21":10859,"_23":10860,"_25":10860,"_26":10861,"_32":10864,"_33":10865},"mfem.coefficients.gradient","mfem.coefficients.gradient(gf)","Create a gradient vector coefficient from a scalar GridFunction.",[10862],{"_19":9917,"_25":10863,"_31":6},"- Scalar GridFunction instance","Promise",[],{"_19":10867,"_21":10868,"_23":10869,"_25":10869,"_26":10870,"_32":10876,"_33":10877},"mfem.coefficients.gridFunctionCoefficient","mfem.coefficients.gridFunctionCoefficient(gf, component?)","Create a coefficient from a GridFunction.",[10871,10873],{"_19":9917,"_25":10872,"_31":6},"- GridFunction instance",{"_19":10874,"_25":10875,"_31":61},"component","- Component to use (1-based, for vector GridFunctions)","Promise",[],{"_19":10879,"_21":10880,"_23":10881,"_25":10881,"_26":10882,"_32":10885,"_33":10886},"mfem.coefficients.identity","mfem.coefficients.identity(dim)","Create an identity matrix coefficient.",[10883],{"_19":6540,"_25":10884,"_31":6},"- Dimension of the identity matrix","Promise",[],{"_19":10888,"_21":10889,"_23":10890,"_25":10890,"_26":10891,"_32":10896,"_33":10897},"mfem.coefficients.innerProduct","mfem.coefficients.innerProduct(v1, v2)","Create an inner product coefficient from two vector coefficients.",[10892,10894],{"_19":10803,"_25":10893,"_31":6},"- First vector coefficient",{"_19":10806,"_25":10895,"_31":6},"- Second vector coefficient","Promise",[],{"_19":10899,"_21":10900,"_23":10901,"_25":10901,"_26":10902,"_32":10905,"_33":10906},"mfem.coefficients.inverse","mfem.coefficients.inverse(m)","Create an inverse of a matrix coefficient.",[10903],{"_19":958,"_25":10904,"_31":6},"- Matrix coefficient to invert","Promise",[],{"_19":10908,"_21":10909,"_23":10910,"_25":10910,"_26":10911,"_32":10914,"_33":10915},"mfem.coefficients.matrixConstant","mfem.coefficients.matrixConstant(values)","Create a constant matrix coefficient.",[10912],{"_19":376,"_25":10913,"_31":6},"- 2D array of values (row-major)","Promise",[],{"_19":10917,"_21":10918,"_23":10919,"_25":10919,"_26":10920,"_32":10926,"_33":10927},"mfem.coefficients.matrixFunction","mfem.coefficients.matrixFunction(fn, height, width?)","Create a matrix coefficient from a JavaScript function.",[10921,10923,10924],{"_19":6033,"_25":10922,"_31":6},"- Function (x, y, z) => number[][]",{"_19":9761,"_25":1864,"_31":6},{"_19":753,"_25":10925,"_31":61},"- Number of columns (defaults to height)","Promise",[],{"_19":10929,"_21":10930,"_23":10931,"_25":10931,"_26":10932,"_32":10937,"_33":10938},"mfem.coefficients.matrixProduct","mfem.coefficients.matrixProduct(a, b)","Create a matrix product coefficient from two matrix coefficients.",[10933,10935],{"_19":189,"_25":10934,"_31":6},"- First matrix coefficient",{"_19":191,"_25":10936,"_31":6},"- Second matrix coefficient","Promise",[],{"_19":10940,"_21":10941,"_23":10942,"_25":10942,"_26":10943,"_32":10946,"_33":10947},"mfem.coefficients.normalizedVector","mfem.coefficients.normalizedVector(v)","Create a normalized vector coefficient from a vector coefficient.",[10944],{"_19":1273,"_25":10945,"_31":6},"- Vector coefficient to normalize","Promise",[],{"_19":10949,"_21":10950,"_23":10951,"_25":10951,"_26":10952,"_32":10955,"_33":10956},"mfem.coefficients.outerProduct","mfem.coefficients.outerProduct(a, b)","Create an outer product coefficient from two vector coefficients.",[10953,10954],{"_19":189,"_25":10893,"_31":6},{"_19":191,"_25":10895,"_31":6},"Promise",[],{"_19":10958,"_21":10959,"_23":10960,"_25":10960,"_26":10961,"_32":10964,"_33":10965},"mfem.coefficients.piecewiseConstant","mfem.coefficients.piecewiseConstant(values)","Create a piecewise constant coefficient by element attribute.",[10962],{"_19":376,"_25":10963,"_31":6},"- Map of attribute number (1-based) to value","Promise",[],{"_19":10967,"_21":10968,"_23":10969,"_25":10969,"_26":10970,"_32":10973,"_33":10974},"mfem.coefficients.position","mfem.coefficients.position(dim?)","Create a position vector coefficient that returns the spatial position x.",[10971],{"_19":6540,"_25":10972,"_31":61},"- Spatial dimension (1, 2, or 3). Defaults to 3.","Promise",[],{"_19":10976,"_21":10977,"_23":10978,"_25":10978,"_26":10979,"_32":10985,"_33":10986},"mfem.coefficients.power","mfem.coefficients.power(c, exponent)","Create a power of a coefficient.",[10980,10982],{"_19":929,"_25":10981,"_31":6},"- Base coefficient",{"_19":10983,"_25":10984,"_31":6},"exponent","- Exponent value","Promise",[],{"_19":10988,"_21":10989,"_23":10990,"_25":10990,"_26":10991,"_32":10996,"_33":10997},"mfem.coefficients.product","mfem.coefficients.product(c1, c2)","Create a product of two coefficients.",[10992,10994],{"_19":939,"_25":10993,"_31":6},"- First coefficient",{"_19":941,"_25":10995,"_31":6},"- Second coefficient","Promise",[],{"_19":10999,"_21":11000,"_23":11001,"_25":11001,"_26":11002,"_32":11006,"_33":11007},"mfem.coefficients.quadratureFunctionCoefficient","mfem.coefficients.quadratureFunctionCoefficient(qf)","Create a coefficient from a scalar quadrature function.",[11003],{"_19":11004,"_25":11005,"_31":6},"qf","- The quadrature function (vdim=1)","Promise",[],{"_19":11009,"_21":11010,"_23":11011,"_25":11011,"_26":11012,"_32":11015,"_33":11016},"mfem.coefficients.vectorQuadratureFunctionCoefficient","mfem.coefficients.vectorQuadratureFunctionCoefficient(qf)","Create a vector coefficient from a quadrature function.",[11013],{"_19":11004,"_25":11014,"_31":6},"- The quadrature function","Promise",[],{"_19":11018,"_21":11019,"_23":11020,"_25":11020,"_26":11021,"_32":11028,"_33":11029},"mfem.coefficients.restricted","mfem.coefficients.restricted(baseCoeff, attributes)","Create a restricted coefficient from a base coefficient.",[11022,11025],{"_19":11023,"_25":11024,"_31":6},"baseCoeff","- The base coefficient to restrict",{"_19":11026,"_25":11027,"_31":6},"attributes","- Array of mesh attributes where the coefficient is active (1-based)","Promise",[],{"_19":11031,"_21":11032,"_23":11033,"_25":11033,"_26":11034,"_32":11039,"_33":11040},"mfem.coefficients.scalarVectorProduct","mfem.coefficients.scalarVectorProduct(s, v)","Create a scalar-vector product coefficient.",[11035,11037],{"_19":1893,"_25":11036,"_31":6},"- Scalar coefficient",{"_19":1273,"_25":11038,"_31":6},"- Vector coefficient","Promise",[],{"_19":11042,"_21":11043,"_23":11044,"_25":11044,"_26":11045,"_32":11052,"_33":11053},"mfem.coefficients.sum","mfem.coefficients.sum(c1, c2, alpha?, beta?)","Create a sum of two coefficients.",[11046,11047,11048,11050],{"_19":939,"_25":10993,"_31":6},{"_19":941,"_25":10995,"_31":6},{"_19":10350,"_25":11049,"_31":61},"- Scale factor for c1 (default 1.0)",{"_19":3202,"_25":11051,"_31":61},"- Scale factor for c2 (default 1.0)","Promise",[],{"_19":11055,"_21":11056,"_23":11057,"_25":11057,"_26":11058,"_32":11063,"_33":11064},"mfem.coefficients.symmetric","mfem.coefficients.symmetric(fn, dim)","Create a symmetric matrix coefficient from a JavaScript function.",[11059,11061],{"_19":6033,"_25":11060,"_31":6},"- Function (position: number[]) => number[][]",{"_19":6540,"_25":11062,"_31":6},"- Dimension of the symmetric matrix","Promise",[],{"_19":11066,"_21":11067,"_23":11068,"_25":11068,"_26":11069,"_32":11074,"_33":11075},"mfem.coefficients.transformed","mfem.coefficients.transformed(coeff, fn)","Create a transformed coefficient that applies a function to another coefficient.",[11070,11072],{"_19":10336,"_25":11071,"_31":6},"- Source coefficient to transform",{"_19":6033,"_25":11073,"_31":6},"- Transformation function (value) => transformedValue","Promise",[],{"_19":11077,"_21":11078,"_23":11079,"_25":11079,"_26":11080,"_32":11083,"_33":11084},"mfem.coefficients.transpose","mfem.coefficients.transpose(m)","Create a transpose of a matrix coefficient.",[11081],{"_19":958,"_25":11082,"_31":6},"- Matrix coefficient to transpose","Promise",[],{"_19":11086,"_21":11087,"_23":11088,"_25":11088,"_26":11089,"_32":11093,"_33":11094},"mfem.coefficients.vectorArray","mfem.coefficients.vectorArray(coeffs)","Create a vector coefficient from an array of scalar coefficients.",[11090],{"_19":11091,"_25":11092,"_31":6},"coeffs","- Array of scalar coefficients for each component","Promise",[],{"_19":11096,"_21":11097,"_23":11098,"_25":11098,"_26":11099,"_32":11102,"_33":11103},"mfem.coefficients.vectorConstant","mfem.coefficients.vectorConstant(values)","Create a constant vector coefficient.",[11100],{"_19":376,"_25":11101,"_31":6},"- Array of constant values","Promise",[],{"_19":11105,"_21":11106,"_23":11107,"_25":11107,"_26":11108,"_32":11112,"_33":11113},"mfem.coefficients.vectorDelta","mfem.coefficients.vectorDelta(center, direction)","Create a vector Dirac delta coefficient (directional point source).",[11109,11110],{"_19":9740,"_25":10825,"_31":6},{"_19":6666,"_25":11111,"_31":6},"- Direction vector of the source","Promise",[],{"_19":11115,"_21":11116,"_23":11117,"_25":11117,"_26":11118,"_32":11123,"_33":11124},"mfem.coefficients.vectorFunction","mfem.coefficients.vectorFunction(fn, dim?)","Create a vector coefficient from a JavaScript function.",[11119,11121],{"_19":6033,"_25":11120,"_31":6},"- Function (x, y, z) => number[]",{"_19":6540,"_25":11122,"_31":61},"- Output vector dimension (defaults to 3)","Promise",[],{"_19":11126,"_21":11127,"_23":11128,"_25":11128,"_26":11129,"_32":11132,"_33":11133},"mfem.coefficients.vectorRotProduct","mfem.coefficients.vectorRotProduct(a, b)","Create a 2D cross product (rotation product) of two vector coefficients.",[11130,11131],{"_19":189,"_25":10893,"_31":6},{"_19":191,"_25":10895,"_31":6},"Promise",[],{"_19":11135,"_21":11136,"_23":11137,"_25":11137,"_26":11138,"_32":10795,"_33":11141},"mfem.coefficients.ConstantCoefficient.create","mfem.coefficients.ConstantCoefficient.create(value)","Creates a new constant coefficient with the specified value.",[11139],{"_19":2051,"_25":11140,"_31":6},"- The constant value",[],{"_19":11143,"_21":11144,"_23":11145,"_25":11145,"_26":11146,"_32":10817,"_33":11149},"mfem.coefficients.CurlCoefficient.create","mfem.coefficients.CurlCoefficient.create(gf)","Creates a new curl coefficient from a vector GridFunction.",[11147],{"_19":9917,"_25":11148,"_31":6},"- The vector GridFunction whose curl to compute",[],{"_19":11151,"_21":11152,"_23":11153,"_25":11153,"_26":11154,"_32":10829,"_33":11158},"mfem.coefficients.DeltaCoefficient.create","mfem.coefficients.DeltaCoefficient.create(center, weight?)","Creates a new delta coefficient (point source).",[11155,11157],{"_19":9740,"_25":11156,"_31":6},"- Center point of the delta function [x] or [x, y] or [x, y, z]",{"_19":10827,"_25":10828,"_31":61},[],{"_19":11160,"_21":11161,"_23":11162,"_25":11162,"_26":11163,"_32":10838,"_33":11166},"mfem.coefficients.DiagonalMatrixCoefficient.create","mfem.coefficients.DiagonalMatrixCoefficient.create(values)","Creates a new diagonal matrix coefficient.",[11164],{"_19":376,"_25":11165,"_31":6},"- Array of diagonal values. The length determines the matrix dimension.",[],{"_19":11168,"_21":11169,"_23":11170,"_25":11170,"_26":11171,"_32":10846,"_33":11174},"mfem.coefficients.DivergenceCoefficient.create","mfem.coefficients.DivergenceCoefficient.create(gf)","Creates a new divergence coefficient from a vector GridFunction.",[11172],{"_19":9917,"_25":11173,"_31":6},"- The vector GridFunction whose divergence to compute",[],{"_19":11176,"_21":11177,"_23":11178,"_25":11178,"_26":11179,"_32":10855,"_33":11182},"mfem.coefficients.FunctionCoefficient.create","mfem.coefficients.FunctionCoefficient.create(fn)","Creates a new function coefficient with the specified evaluation function.",[11180],{"_19":6033,"_25":11181,"_31":6},"- Function that takes (x, y, z) coordinates and returns a scalar value",[],{"_19":11184,"_21":11185,"_23":11186,"_25":11186,"_26":11187,"_32":10864,"_33":11190},"mfem.coefficients.GradientCoefficient.create","mfem.coefficients.GradientCoefficient.create(gf)","Creates a new gradient coefficient from a scalar GridFunction.",[11188],{"_19":9917,"_25":11189,"_31":6},"- The scalar GridFunction whose gradient to compute",[],{"_19":11192,"_21":11193,"_23":11194,"_25":11194,"_26":11195,"_32":10876,"_33":11200},"mfem.coefficients.GridFunctionCoefficient.create","mfem.coefficients.GridFunctionCoefficient.create(gf, component?)","Creates a new GridFunction coefficient.",[11196,11198],{"_19":9917,"_25":11197,"_31":6},"- The GridFunction to evaluate",{"_19":10874,"_25":11199,"_31":61},"- Component to use for vector GridFunctions (1-based, default 1)",[],{"_19":11202,"_21":11203,"_23":11204,"_25":11204,"_26":11205,"_32":10914,"_33":11212},"mfem.coefficients.MatrixConstantCoefficient.create","mfem.coefficients.MatrixConstantCoefficient.create(values, height?, width?)","Creates a new constant matrix coefficient with the specified values.",[11206,11208,11210],{"_19":376,"_25":11207,"_31":6},"- 2D array of values (row-major) or 1D array with explicit dimensions",{"_19":9761,"_25":11209,"_31":61},"- Number of rows (required if values is 1D array)",{"_19":753,"_25":11211,"_31":61},"- Number of columns (required if values is 1D array)",[],{"_19":11214,"_21":11215,"_23":11216,"_25":11216,"_26":11217,"_32":10926,"_33":11223},"mfem.coefficients.MatrixFunctionCoefficient.create","mfem.coefficients.MatrixFunctionCoefficient.create(fn, height, width?)","Creates a new matrix function coefficient.",[11218,11220,11221],{"_19":6033,"_25":11219,"_31":6},"- Function that takes (x, y, z) and returns a 2D array",{"_19":9761,"_25":1864,"_31":6},{"_19":753,"_25":11222,"_31":61},"- Number of columns (defaults to height for square matrices)",[],{"_19":11225,"_21":11226,"_23":11227,"_25":11227,"_26":11228,"_32":10937,"_33":11231},"mfem.coefficients.MatrixProductCoefficient.create","mfem.coefficients.MatrixProductCoefficient.create(a, b)","Creates a new matrix product coefficient: A * B",[11229,11230],{"_19":189,"_25":10934,"_31":6},{"_19":191,"_25":10936,"_31":6},[],{"_19":11233,"_21":11234,"_23":11235,"_25":11235,"_26":11236,"_32":10946,"_33":11238},"mfem.coefficients.NormalizedVectorCoefficient.create","mfem.coefficients.NormalizedVectorCoefficient.create(v)","Creates a new normalized vector coefficient: v / ||v||",[11237],{"_19":1273,"_25":10945,"_31":6},[],{"_19":11240,"_21":11241,"_23":11242,"_25":11242,"_26":11243,"_32":10964,"_33":11246},"mfem.coefficients.PWConstCoefficient.create","mfem.coefficients.PWConstCoefficient.create(values)","Creates a new piecewise constant coefficient.",[11244],{"_19":376,"_25":11245,"_31":6},"- Array of values for each attribute (index i corresponds to attribute i+1)",[],{"_19":11248,"_21":11249,"_23":11250,"_25":11250,"_26":11251,"_32":10964,"_33":11255},"mfem.coefficients.PWConstCoefficient.createFromMap","mfem.coefficients.PWConstCoefficient.createFromMap(attrValues)","Creates a new piecewise constant coefficient from a Map.",[11252],{"_19":11253,"_25":11254,"_31":6},"attrValues","- Map of attribute numbers (1-based) to values",[],{"_19":11257,"_21":11258,"_23":11259,"_25":11259,"_26":11260,"_32":10973,"_33":11262},"mfem.coefficients.PositionVectorCoefficient.create","mfem.coefficients.PositionVectorCoefficient.create(dim?)","Creates a new position vector coefficient.",[11261],{"_19":6540,"_25":10972,"_31":61},[],{"_19":11264,"_21":11265,"_23":11266,"_25":11266,"_26":11267,"_32":10985,"_33":11271},"mfem.coefficients.PowerCoefficient.create","mfem.coefficients.PowerCoefficient.create(c, exponent)","Creates a new power coefficient: c^p",[11268,11269],{"_19":929,"_25":10981,"_31":6},{"_19":10983,"_25":11270,"_31":6},"- Power exponent",[],{"_19":11273,"_21":11274,"_23":11275,"_25":11275,"_26":11276,"_32":10996,"_33":11279},"mfem.coefficients.ProductCoefficient.create","mfem.coefficients.ProductCoefficient.create(c1, c2)","Creates a new product coefficient: c1 * c2",[11277,11278],{"_19":939,"_25":10993,"_31":6},{"_19":941,"_25":10995,"_31":6},[],{"_19":11281,"_21":11282,"_23":11283,"_25":11283,"_26":11284,"_32":11006,"_33":11287},"mfem.coefficients.QuadratureFunctionCoefficient.create","mfem.coefficients.QuadratureFunctionCoefficient.create(qf)","Creates a new coefficient from a scalar quadrature function.",[11285],{"_19":11004,"_25":11286,"_31":6},"- The quadrature function (must have vdim=1)",[],{"_19":11289,"_21":11290,"_23":11291,"_25":11291,"_26":11292,"_32":11015,"_33":11294},"mfem.coefficients.VectorQuadratureFunctionCoefficient.create","mfem.coefficients.VectorQuadratureFunctionCoefficient.create(qf)","Creates a new vector coefficient from a quadrature function.",[11293],{"_19":11004,"_25":11014,"_31":6},[],{"_19":11296,"_21":11297,"_23":11298,"_25":11298,"_26":11299,"_32":11028,"_33":11302},"mfem.coefficients.RestrictedCoefficient.create","mfem.coefficients.RestrictedCoefficient.create(baseCoeff, attributes)","Creates a new restricted coefficient.",[11300,11301],{"_19":11023,"_25":11024,"_31":6},{"_19":11026,"_25":11027,"_31":6},[],{"_19":11304,"_21":11305,"_23":11306,"_25":11306,"_26":11307,"_32":11039,"_33":11310},"mfem.coefficients.ScalarVectorProductCoefficient.create","mfem.coefficients.ScalarVectorProductCoefficient.create(s, v)","Creates a new scalar-vector product coefficient: s * v",[11308,11309],{"_19":1893,"_25":11036,"_31":6},{"_19":1273,"_25":11038,"_31":6},[],{"_19":11312,"_21":11313,"_23":11314,"_25":11314,"_26":11315,"_32":11052,"_33":11320},"mfem.coefficients.SumCoefficient.create","mfem.coefficients.SumCoefficient.create(c1, c2, alpha?, beta?)","Creates a new sum coefficient: alpha * c1 + beta * c2",[11316,11317,11318,11319],{"_19":939,"_25":10993,"_31":6},{"_19":941,"_25":10995,"_31":6},{"_19":10350,"_25":11049,"_31":61},{"_19":3202,"_25":11051,"_31":61},[],{"_19":11322,"_21":11323,"_23":11324,"_25":11324,"_26":11325,"_32":11063,"_33":11329},"mfem.coefficients.SymmetricMatrixCoefficient.create","mfem.coefficients.SymmetricMatrixCoefficient.create(fn, dim)","Creates a new symmetric matrix function coefficient.",[11326,11328],{"_19":6033,"_25":11327,"_31":6},"- Function that takes position [x, y, z] and returns a symmetric 2D array",{"_19":6540,"_25":11062,"_31":6},[],{"_19":11331,"_21":11332,"_23":11333,"_25":11333,"_26":11334,"_32":11074,"_33":11337},"mfem.coefficients.TransformedCoefficient.create","mfem.coefficients.TransformedCoefficient.create(coeff, fn)","Creates a new transformed coefficient: F(Q)",[11335,11336],{"_19":10336,"_25":11071,"_31":6},{"_19":6033,"_25":11073,"_31":6},[],{"_19":11339,"_21":11340,"_23":11341,"_25":11341,"_26":11342,"_32":11093,"_33":11345},"mfem.coefficients.VectorArrayCoefficient.create","mfem.coefficients.VectorArrayCoefficient.create(dim)","Creates a new vector array coefficient of the specified dimension.",[11343],{"_19":6540,"_25":11344,"_31":6},"- Vector dimension",[],{"_19":11347,"_21":11348,"_23":11349,"_25":11349,"_26":11350,"_32":11102,"_33":11353},"mfem.coefficients.VectorConstantCoefficient.create","mfem.coefficients.VectorConstantCoefficient.create(values)","Creates a new constant vector coefficient with the specified values.",[11351],{"_19":376,"_25":11352,"_31":6},"- Array of constant values for each component",[],{"_19":11355,"_21":11356,"_23":11357,"_25":11357,"_26":11358,"_32":11112,"_33":11362},"mfem.coefficients.VectorDeltaCoefficient.create","mfem.coefficients.VectorDeltaCoefficient.create(center, direction)","Creates a new vector delta coefficient (directional point source).",[11359,11360],{"_19":9740,"_25":11156,"_31":6},{"_19":6666,"_25":11361,"_31":6},"- Direction vector of the source (must match spatial dimension)",[],{"_19":11364,"_21":11365,"_23":11366,"_25":11366,"_26":11367,"_32":11123,"_33":11372},"mfem.coefficients.VectorFunctionCoefficient.create","mfem.coefficients.VectorFunctionCoefficient.create(fn, dim)","Creates a new vector function coefficient.",[11368,11370],{"_19":6033,"_25":11369,"_31":6},"- Function that takes (x, y, z) and returns a vector",{"_19":6540,"_25":11371,"_31":6},"- Output vector dimension",[],{"_19":11374,"_21":11375,"_23":11376,"_25":11376,"_26":11377,"_32":11132,"_33":11380},"mfem.coefficients.VectorRotProductCoefficient.create","mfem.coefficients.VectorRotProductCoefficient.create(a, b)","Creates a new VectorRotProductCoefficient: A_x * B_y - A_y * B_x",[11378,11379],{"_19":189,"_25":10893,"_31":6},{"_19":191,"_25":10895,"_31":6},[],{"_19":11382,"_21":11383,"_23":11384,"_25":11385,"_26":11386,"_32":11393,"_33":11394},"mfem.eigenvalue.getEigenvalues","mfem.eigenvalue.getEigenvalues(solver, numEigs?)","Get computed eigenvalues after solve.\r","Get computed eigenvalues after solve.\r\n\r\nCall this after solve() to retrieve the computed eigenvalues.\r\nIf numEigs is not specified, returns all converged eigenvalues.",[11387,11390],{"_19":11388,"_25":11389,"_31":6},"solver","- LOBPCG solver instance with solved eigenvalues",{"_19":11391,"_25":11392,"_31":61},"numEigs","- Number of eigenvalues to retrieve (defaults to number of converged)","Float64Array",[],{"_19":11396,"_21":11397,"_23":11398,"_25":2370,"_26":11399,"_32":11403,"_33":11404},"mfem.eigenvalue.getEigenvectors","mfem.eigenvalue.getEigenvectors(eigenvectorMatrix)","getEigenvectors",[11400],{"_19":11401,"_25":11402,"_31":6},"eigenvectorMatrix","DenseMatrix","Float64Array[]",[],{"_19":11406,"_21":11407,"_23":11408,"_25":11409,"_26":11410,"_32":62,"_33":11416},"mfem.eigenvalue.setNumModes","mfem.eigenvalue.setNumModes(solver, numModes)","Set the number of eigenvalues/eigenvectors to compute.\r","Set the number of eigenvalues/eigenvectors to compute.\r\n\r\nThis should match the number of columns in the eigenvector DenseMatrix\r\npassed to solve().",[11411,11413],{"_19":11388,"_25":11412,"_31":6},"- LOBPCG solver instance",{"_19":11414,"_25":11415,"_31":6},"numModes","- Number of eigenpairs to compute",[],{"_19":11418,"_21":11419,"_23":11420,"_25":11421,"_26":11422,"_32":62,"_33":11428},"mfem.eigenvalue.setOperators","mfem.eigenvalue.setOperators(solver, A, B?)","Set A and B operators for generalized eigenvalue problem Ax = λBx.\r","Set A and B operators for generalized eigenvalue problem Ax = λBx.\r\n\r\nFor standard eigenvalue problems (Ax = λx), only pass A.\r\nFor generalized problems (Ax = λBx), pass both A and B.",[11423,11424,11426],{"_19":11388,"_25":11412,"_31":6},{"_19":3766,"_25":11425,"_31":6},"- Stiffness matrix/operator A (e.g., SparseMatrix, BilinearForm)",{"_19":6369,"_25":11427,"_31":61},"- Mass matrix/operator B for generalized problem (optional)",[],{"_19":11430,"_21":11431,"_23":11432,"_25":11433,"_26":11434,"_32":62,"_33":11440},"mfem.eigenvalue.solve","mfem.eigenvalue.solve(solver, eigenvectors)","Solve the eigenvalue problem using LOBPCG.\r","Solve the eigenvalue problem using LOBPCG.\r\n\r\nSolves: Ax = λBx (generalized) or Ax = λx (standard if B is not set)\r\n\r\nThe eigenvectors will be stored as columns in the provided DenseMatrix.\r\nThe matrix should be pre-allocated with dimensions [nDofs × numModes].",[11435,11437],{"_19":11388,"_25":11436,"_31":6},"- LOBPCG solver instance (must have operators set)",{"_19":11438,"_25":11439,"_31":6},"eigenvectors","- DenseMatrix to store computed eigenvectors (columns are eigenvectors)",[],{"_19":11442,"_21":11443,"_23":11444,"_25":11445,"_26":11446,"_32":11450,"_33":11451},"mfem.eigenvalue.DenseMatrix.create","mfem.eigenvalue.DenseMatrix.create(height, width)","Creates a new dense matrix of specified dimensions.\r","Creates a new dense matrix of specified dimensions.\r\nElements are uninitialized.",[11447,11448],{"_19":9761,"_25":1864,"_31":6},{"_19":753,"_25":11449,"_31":6},"- Number of columns","Promise",[],{"_19":11453,"_21":11454,"_23":11455,"_25":11455,"_26":11456,"_32":11450,"_33":11459},"mfem.eigenvalue.DenseMatrix.zeros","mfem.eigenvalue.DenseMatrix.zeros(height, width)","Creates a zero matrix of specified dimensions.",[11457,11458],{"_19":9761,"_25":1864,"_31":6},{"_19":753,"_25":11449,"_31":6},[],{"_19":11461,"_21":11462,"_23":11463,"_25":11463,"_26":11464,"_32":11450,"_33":11467},"mfem.eigenvalue.DenseMatrix.identity","mfem.eigenvalue.DenseMatrix.identity(n)","Creates an identity matrix of size n x n.",[11465],{"_19":1516,"_25":11466,"_31":6},"- Matrix dimension",[],{"_19":11469,"_21":11470,"_23":11471,"_25":11471,"_26":11472,"_32":11450,"_33":11475},"mfem.eigenvalue.DenseMatrix.fromArray","mfem.eigenvalue.DenseMatrix.fromArray(data)","Creates a DenseMatrix from a 2D array.",[11473],{"_19":528,"_25":11474,"_31":6},"- 2D array in row-major order (data[row][col])",[],{"_19":11477,"_21":11478,"_23":11479,"_25":11480,"_26":11481,"_32":11450,"_33":11487},"mfem.eigenvalue.DenseMatrix.fromPointer","mfem.eigenvalue.DenseMatrix.fromPointer(ptr, ownsMemory?)","Creates a DenseMatrix from an existing WASM pointer.\r","Creates a DenseMatrix from an existing WASM pointer.\r\nUse with caution - the caller is responsible for pointer validity.",[11482,11484],{"_19":10599,"_25":11483,"_31":6},"- WASM pointer to an existing MFEM DenseMatrix",{"_19":11485,"_25":11486,"_31":61},"ownsMemory","- Whether this wrapper owns the memory (default: false)",[],{"_19":11489,"_21":11490,"_23":11491,"_25":11491,"_26":11492,"_32":11493,"_33":11494},"mfem.eigenvalue.LOBPCGSolver.create","mfem.eigenvalue.LOBPCGSolver.create()","Creates a new LOBPCG solver.",[],"Promise",[],{"_19":11496,"_21":11497,"_23":11498,"_25":11499,"_26":11500,"_32":11509,"_33":11510},"mfem.fespace.createDG","mfem.fespace.createDG(mesh, order, vdim?)","Creates a Discontinuous Galerkin (DG) finite element space.\r","Creates a Discontinuous Galerkin (DG) finite element space.\r\n\r\nThis is an alias for . DG spaces are L2 spaces used in\r\nDiscontinuous Galerkin methods, where numerical fluxes connect elements.\r\n\r\nDG methods are popular for:\r\n- Hyperbolic conservation laws\r\n- Advection-dominated transport\r\n- Problems with sharp gradients or shocks\r\n- hp-adaptivity",[11501,11503,11506],{"_19":6229,"_25":11502,"_31":6},"- The mesh on which to define the space",{"_19":11504,"_25":11505,"_31":6},"order","- Polynomial order (0 = piecewise constant, 1 = linear, etc.)",{"_19":11507,"_25":11508,"_31":61},"vdim","- Vector dimension (default 1 for scalar fields)","Promise",[],{"_19":11512,"_21":11513,"_23":11514,"_25":11515,"_26":11516,"_32":11509,"_33":11521},"mfem.fespace.createH1","mfem.fespace.createH1(mesh, order, vdim?)","Creates an H1 (continuous Lagrange) finite element space.\r","Creates an H1 (continuous Lagrange) finite element space.\r\n\r\nH1 spaces use continuous piecewise polynomial functions that are globally\r\nconforming in H1 (functions with square-integrable first derivatives).\r\nThey are the most common choice for:\r\n- Scalar problems (heat transfer, Poisson equation)\r\n- Vector problems (elasticity, Stokes flow)",[11517,11518,11520],{"_19":6229,"_25":11502,"_31":6},{"_19":11504,"_25":11519,"_31":6},"- Polynomial order (1 = linear, 2 = quadratic, 3 = cubic, etc.)",{"_19":11507,"_25":11508,"_31":61},[],{"_19":11523,"_21":11524,"_23":11525,"_25":11526,"_26":11527,"_32":11509,"_33":11532},"mfem.fespace.createH1Positive","mfem.fespace.createH1Positive(mesh, order, vdim?)","Creates an H1 finite element space with positive (Bernstein) basis.\r","Creates an H1 finite element space with positive (Bernstein) basis.\r\n\r\nBernstein basis functions are non-negative and form a partition of unity,\r\nmaking them ideal for applications requiring positivity preservation:\r\n- Concentration fields that must remain positive\r\n- Probability distributions\r\n- NURBS-like representations\r\n\r\nThe space has the same approximation properties as standard H1 but with\r\ndifferent basis function properties.",[11528,11529,11531],{"_19":6229,"_25":11502,"_31":6},{"_19":11504,"_25":11530,"_31":6},"- Polynomial order (1 = linear, 2 = quadratic, etc.)",{"_19":11507,"_25":11508,"_31":61},[],{"_19":11534,"_21":11535,"_23":11536,"_25":11537,"_26":11538,"_32":11509,"_33":11543},"mfem.fespace.createHcurl","mfem.fespace.createHcurl(mesh, order)","Creates an H(curl) (Nedelec) finite element space.\r","Creates an H(curl) (Nedelec) finite element space.\r\n\r\nH(curl) spaces are designed for vector fields where the curl is well-defined\r\nand square-integrable. They are essential for:\r\n- Electromagnetics (electric field, magnetic vector potential)\r\n- Maxwell's equations\r\n- Edge element discretizations\r\n\r\nThe tangential component is continuous across element faces while the\r\nnormal component may be discontinuous.",[11539,11541],{"_19":6229,"_25":11540,"_31":6},"- The mesh on which to define the space (must be 2D or 3D)",{"_19":11504,"_25":11542,"_31":6},"- Polynomial order (1 = lowest order Nedelec, etc.)",[],{"_19":11545,"_21":11546,"_23":11547,"_25":11548,"_26":11549,"_32":11509,"_33":11553},"mfem.fespace.createHdiv","mfem.fespace.createHdiv(mesh, order)","Creates an H(div) (Raviart-Thomas) finite element space.\r","Creates an H(div) (Raviart-Thomas) finite element space.\r\n\r\nH(div) spaces are designed for vector fields where the divergence is\r\nwell-defined and square-integrable. They are essential for:\r\n- Fluid flow (velocity fields)\r\n- Mixed finite element methods\r\n- Darcy flow and porous media\r\n- Magnetic flux density in electromagnetics\r\n\r\nThe normal component is continuous across element faces while the\r\ntangential component may be discontinuous.",[11550,11551],{"_19":6229,"_25":11540,"_31":6},{"_19":11504,"_25":11552,"_31":6},"- Polynomial order (0 = lowest order RT, etc.)",[],{"_19":11555,"_21":11556,"_23":11557,"_25":11558,"_26":11559,"_32":11509,"_33":11563},"mfem.fespace.createL2","mfem.fespace.createL2(mesh, order, vdim?)","Creates an L2 (discontinuous) finite element space.\r","Creates an L2 (discontinuous) finite element space.\r\n\r\nL2 spaces use piecewise polynomial functions with no continuity constraints\r\nacross element boundaries. This allows for:\r\n- Discontinuous Galerkin (DG) methods\r\n- Higher accuracy for advection-dominated problems\r\n- Local conservation properties\r\n- Representation of discontinuous fields\r\n\r\nL2 spaces have more DOFs than H1 spaces for the same mesh and order,\r\nas each element has its own independent polynomial representation.",[11560,11561,11562],{"_19":6229,"_25":11502,"_31":6},{"_19":11504,"_25":11505,"_31":6},{"_19":11507,"_25":11508,"_31":61},[],{"_19":11565,"_21":11566,"_23":11567,"_25":11568,"_26":11569,"_32":11509,"_33":11573},"mfem.fespace.createND","mfem.fespace.createND(mesh, order)","Creates a Nedelec (ND) finite element space.\r","Creates a Nedelec (ND) finite element space.\r\n\r\nThis is an alias for . Nedelec elements are edge elements\r\nthat conform to H(curl), named after Jean-Claude Nédélec who introduced them.\r\n\r\nCommon applications:\r\n- Electric field in electromagnetics\r\n- Magnetic vector potential\r\n- Any vector field where curl is the primary differential operator",[11570,11571],{"_19":6229,"_25":11540,"_31":6},{"_19":11504,"_25":11572,"_31":6},"- Polynomial order (1 = lowest order, etc.)",[],{"_19":11575,"_21":11576,"_23":11577,"_25":11578,"_26":11579,"_32":11585,"_33":11586},"mfem.fespace.createNURBS","mfem.fespace.createNURBS(mesh, order?, vdim?)","Creates a NURBS finite element space.\r","Creates a NURBS finite element space.\r\n\r\nNURBS (Non-Uniform Rational B-Splines) spaces are used for isogeometric\r\nanalysis (IGA), where the same basis functions used for CAD geometry\r\nrepresentation are used for the finite element analysis. This provides\r\nexact geometry representation and higher continuity across elements.\r\n\r\nThe mesh must be a NURBS mesh (created from NURBS patch data). Standard\r\nmeshes created with `makeCartesian2D` or similar functions cannot be used.",[11580,11582,11584],{"_19":6229,"_25":11581,"_31":6},"- A NURBS mesh instance (must have NURBS extension)",{"_19":11504,"_25":11583,"_31":61},"- Polynomial order. Use -1 or 0 for variable order (uses\r\n the mesh's native NURBS order from each patch)",{"_19":11507,"_25":11508,"_31":61},"FiniteElementSpace",[],{"_19":11588,"_21":11589,"_23":11590,"_25":11591,"_26":11592,"_32":11509,"_33":11596},"mfem.fespace.createRT","mfem.fespace.createRT(mesh, order)","Creates a Raviart-Thomas (RT) finite element space.\r","Creates a Raviart-Thomas (RT) finite element space.\r\n\r\nThis is an alias for . Raviart-Thomas elements are face\r\nelements that conform to H(div), named after Pierre-Arnaud Raviart and\r\nJean-Marie Thomas who introduced them.\r\n\r\nCommon applications:\r\n- Velocity in mixed formulations\r\n- Flux variables in conservation laws\r\n- Magnetic flux density",[11593,11594],{"_19":6229,"_25":11540,"_31":6},{"_19":11504,"_25":11595,"_31":6},"- Polynomial order (0 = lowest order, etc.)",[],{"_19":11598,"_21":11599,"_23":11600,"_25":11601,"_26":11602,"_32":11604,"_33":11605},"mfem.fespace.getAllDofCoordinates","mfem.fespace.getAllDofCoordinates(fespace)","Gets the physical coordinates for all degrees of freedom in a finite element space.\r","Gets the physical coordinates for all degrees of freedom in a finite element space.\r\n\r\nThis function iterates over all elements in the mesh and collects the physical\r\ncoordinates of each DOF. For DOFs shared between elements, the coordinates from\r\nthe first encountered element are used.\r\n\r\n**Performance note:** This function allocates temporary WASM memory and iterates\r\nover all elements. For large meshes, consider caching the result.",[11603],{"_19":10498,"_25":10556,"_31":6},"Promise>",[],{"_19":11607,"_21":11608,"_23":11609,"_25":11610,"_26":11611,"_32":931,"_33":11616},"mfem.fespace.getBoundaryDofs","mfem.fespace.getBoundaryDofs(fespace, bdrAttr)","Gets the DOF indices on a boundary with a specific attribute.\r","Gets the DOF indices on a boundary with a specific attribute.\r\n\r\nReturns the true (global) DOF indices that lie on boundary elements\r\nwith the specified attribute. This is useful for applying Dirichlet\r\nboundary conditions on specific parts of the domain boundary.",[11612,11613],{"_19":10498,"_25":10556,"_31":6},{"_19":11614,"_25":11615,"_31":6},"bdrAttr","- The boundary attribute (1-based, as defined in the mesh)",[],{"_19":11618,"_21":11619,"_23":11620,"_25":11621,"_26":11622,"_32":10706,"_33":11627},"mfem.fespace.getDofMap","mfem.fespace.getDofMap(fespace, elemIndex)","Gets the DOF indices for a specific element.\r","Gets the DOF indices for a specific element.\r\n\r\nReturns the global DOF indices associated with the specified element.\r\nThis is useful for assembling local element contributions into global\r\nmatrices and vectors.",[11623,11624],{"_19":10498,"_25":10556,"_31":6},{"_19":11625,"_25":11626,"_31":6},"elemIndex","- The element index (0-based)",[],{"_19":11629,"_21":11630,"_23":11631,"_25":11632,"_26":11633,"_32":931,"_33":11637},"mfem.fespace.getEssentialDofs","mfem.fespace.getEssentialDofs(fespace, bdrAttrs)","Gets the essential (Dirichlet) DOF indices for specified boundary attributes.\r","Gets the essential (Dirichlet) DOF indices for specified boundary attributes.\r\n\r\nReturns the true (global) DOF indices that should be constrained for\r\nDirichlet boundary conditions on the specified boundary attributes.\r\nMultiple boundary attributes can be specified to get DOFs from several\r\nboundary regions at once.",[11634,11635],{"_19":10498,"_25":10556,"_31":6},{"_19":10662,"_25":11636,"_31":6},"- Array of boundary attributes (1-based, as defined in the mesh)",[],{"_19":11639,"_21":11640,"_23":11641,"_25":11642,"_26":11643,"_32":198,"_33":11645},"mfem.fespace.order","mfem.fespace.order(fespace)","Gets the maximum polynomial order of the finite element space.\r","Gets the maximum polynomial order of the finite element space.\r\n\r\nFor spaces with variable order (hp-adaptivity), this returns the\r\nmaximum order across all elements.",[11644],{"_19":10498,"_25":10556,"_31":6},[],{"_19":11647,"_21":11648,"_23":11514,"_25":11649,"_26":11650,"_32":11509,"_33":11655},"mfem.fespace.FiniteElementSpace.createH1","mfem.fespace.FiniteElementSpace.createH1(mesh, order, vdim?)","Creates an H1 (continuous Lagrange) finite element space.\r\n\r\nH1 spaces use continuous piecewise polynomial functions. They are the most\r\ncommon choice for scalar problems like heat transfer, and for vector problems\r\nlike elasticity.\r\n\r\n**Basis functions:**\r\n- Order 1: Linear (nodal values at vertices)\r\n- Order 2: Quadratic (nodal values at vertices and edge midpoints)\r\n- Order p: Polynomial of degree p",[11651,11652,11653],{"_19":6229,"_25":11502,"_31":6},{"_19":11504,"_25":11530,"_31":6},{"_19":11507,"_25":11654,"_31":61},"- Vector dimension (default 1 for scalar fields, 2 or 3 for vector fields)",[],{"_19":11657,"_21":11658,"_23":11659,"_25":11660,"_26":11661,"_32":198,"_33":11667},"mfem.gridfunction.computeError","mfem.gridfunction.computeError(gf, exactValue)","Computes the L2 error between a grid function and a constant exact solution.\r","Computes the L2 error between a grid function and a constant exact solution.\r\n\r\nThe L2 error is defined as:\r\n```\r\n||u - u_exact||_L2 = sqrt( ∫_Ω |u(x) - u_exact|² dx )\r\n```\r\n\r\nThis is useful for verifying solutions against known manufactured solutions\r\nor for convergence studies.",[11662,11664],{"_19":9917,"_25":11663,"_31":6},"- GridFunction (numerical solution)",{"_19":11665,"_25":11666,"_31":6},"exactValue","- The constant exact solution value",[],{"_19":11669,"_21":11670,"_23":11671,"_25":11672,"_26":11673,"_32":198,"_33":11682},"mfem.gridfunction.computeH1Error","mfem.gridfunction.computeH1Error(gf, coeffPtr?, dcoeffPtr?)","Computes the H1 error between a grid function and an exact solution.\r","Computes the H1 error between a grid function and an exact solution.\r\n\r\nThe H1 error combines the L2 error of the function and its gradient:\r\n||u - u_exact||_H1 = sqrt(||u - u_exact||²_L2 + ||∇u - ∇u_exact||²_L2)\r\n\r\nYou can provide either or both of:\r\n- The exact solution coefficient (for the L2 part)\r\n- The gradient of the exact solution (for the gradient part)",[11674,11676,11679],{"_19":9917,"_25":11675,"_31":6},"- The grid function (numerical solution)",{"_19":11677,"_25":11678,"_31":61},"coeffPtr","- Pointer to Coefficient for exact solution (or 0 to skip L2 part)",{"_19":11680,"_25":11681,"_31":61},"dcoeffPtr","- Pointer to VectorCoefficient for exact gradient (or 0 to skip gradient part)",[],{"_19":11684,"_21":11685,"_23":11686,"_25":11687,"_26":11688,"_32":198,"_33":11692},"mfem.gridfunction.computeL2ErrorCoeff","mfem.gridfunction.computeL2ErrorCoeff(gf, coeffPtr)","Computes the L2 error between a grid function and an exact solution\r","Computes the L2 error between a grid function and an exact solution\r\nrepresented as a scalar coefficient.\r\n\r\nThe L2 error is defined as:\r\n||u - u_exact||_L2 = sqrt(∫ |u(x) - u_exact(x)|² dx)",[11689,11690],{"_19":9917,"_25":11675,"_31":6},{"_19":11677,"_25":11691,"_31":6},"- Pointer to a Coefficient representing the exact solution",[],{"_19":11694,"_21":11695,"_23":11696,"_25":11697,"_26":11698,"_32":198,"_33":11704},"mfem.gridfunction.computeL2ErrorVCoeff","mfem.gridfunction.computeL2ErrorVCoeff(gf, vcoeffPtr)","Computes the L2 error between a vector grid function and an exact solution\r","Computes the L2 error between a vector grid function and an exact solution\r\nrepresented as a vector coefficient.\r\n\r\nThe L2 error is defined as:\r\n||u - u_exact||_L2 = sqrt(∫ |u(x) - u_exact(x)|² dx)\r\n\r\nwhere |·| is the Euclidean norm of the vector difference.",[11699,11701],{"_19":9917,"_25":11700,"_31":6},"- The vector grid function (numerical solution)",{"_19":11702,"_25":11703,"_31":6},"vcoeffPtr","- Pointer to a VectorCoefficient representing the exact solution",[],{"_19":11706,"_21":11707,"_23":11708,"_25":11709,"_26":11710,"_32":198,"_33":11713},"mfem.gridfunction.computeMaxError","mfem.gridfunction.computeMaxError(gf, coeffPtr)","Computes the maximum (L-infinity) error between a grid function and\r","Computes the maximum (L-infinity) error between a grid function and\r\nan exact solution represented as a coefficient.\r\n\r\nThe max error is defined as:\r\n||u - u_exact||_L∞ = max_x |u(x) - u_exact(x)|\r\n\r\nThis is useful for checking pointwise accuracy of a solution.",[11711,11712],{"_19":9917,"_25":11675,"_31":6},{"_19":11677,"_25":11691,"_31":6},[],{"_19":11715,"_21":11716,"_23":11717,"_25":11718,"_26":11719,"_32":198,"_33":11728},"mfem.gridfunction.computeW11Error","mfem.gridfunction.computeW11Error(gf, coeffPtr?, dcoeffPtr?, normType?)","Computes the W^{1,1} error between a grid function and an exact solution.\r","Computes the W^{1,1} error between a grid function and an exact solution.\r\n\r\nThe W^{1,1} norm uses L1 integrals instead of L2:\r\n||u - u_exact||_{W^{1,1}} = ∫ |u - u_exact| dx + ∫ |∇u - ∇u_exact| dx\r\n\r\nThis error measure is more robust to outliers than L2-based errors.",[11720,11721,11723,11725],{"_19":9917,"_25":11675,"_31":6},{"_19":11677,"_25":11722,"_31":61},"- Pointer to Coefficient for exact solution (or 0 to skip)",{"_19":11680,"_25":11724,"_31":61},"- Pointer to VectorCoefficient for exact gradient (or 0 to skip)",{"_19":11726,"_25":11727,"_31":61},"normType","- Which components to include (default: BOTH)",[],{"_19":11730,"_21":11731,"_23":11732,"_25":11733,"_26":11734,"_32":11739,"_33":11740},"mfem.gridfunction.fromBinary","mfem.gridfunction.fromBinary(fespace, data)","Loads a grid function from a base64-encoded binary string with an existing FE space.\r","Loads a grid function from a base64-encoded binary string with an existing FE space.\r\n\r\nThis is the inverse of . The base64 string is decoded\r\nand parsed as an MFEM format grid function. You must provide the\r\nFiniteElementSpace that matches the saved data.",[11735,11737],{"_19":10498,"_25":11736,"_31":6},"- The finite element space for the grid function",{"_19":528,"_25":11738,"_31":6},"- Base64-encoded string containing grid function data","Promise",[],{"_19":11742,"_21":11743,"_23":11744,"_25":11745,"_26":11746,"_32":11739,"_33":11750},"mfem.gridfunction.fromBinaryWithMesh","mfem.gridfunction.fromBinaryWithMesh(mesh, data)","Loads a grid function from a base64-encoded binary string with auto-detected FE space.\r","Loads a grid function from a base64-encoded binary string with auto-detected FE space.\r\n\r\nThis is the inverse of . The base64 string is decoded\r\nand parsed as an MFEM format grid function. The FE space is automatically\r\nreconstructed from the saved header information.\r\n\r\nThe returned GridFunction owns its FESpace.",[11747,11749],{"_19":6229,"_25":11748,"_31":6},"- The mesh for the grid function",{"_19":528,"_25":11738,"_31":6},[],{"_19":11752,"_21":11753,"_23":11754,"_25":11755,"_26":11756,"_32":11739,"_33":11761},"mfem.gridfunction.fromCoefficient","mfem.gridfunction.fromCoefficient(fespace, value)","Creates a new grid function initialized with a constant value.\r","Creates a new grid function initialized with a constant value.\r\n\r\nThis is a convenience function that creates a grid function and projects\r\na constant coefficient onto it. For more complex coefficients, create a\r\ngrid function manually and use projection functions.",[11757,11759],{"_19":10498,"_25":11758,"_31":6},"- The finite element space on which to define the function",{"_19":2051,"_25":11760,"_31":6},"- The constant value to project",[],{"_19":11763,"_21":11764,"_23":11765,"_25":11766,"_26":11767,"_32":11739,"_33":11771},"mfem.gridfunction.fromFunction","mfem.gridfunction.fromFunction(fespace, fn)","Creates a new grid function initialized by evaluating a function at DOF locations.\r","Creates a new grid function initialized by evaluating a function at DOF locations.\r\n\r\nThe function is evaluated at the physical coordinates of each degree of freedom\r\n(node) in the finite element space. For Lagrange elements, these are the nodal\r\ninterpolation points.\r\n\r\n**Note:** This performs nodal interpolation, not L2 projection. For smoother\r\nresults with non-smooth functions, consider using L2 projection methods.",[11768,11769],{"_19":10498,"_25":11758,"_31":6},{"_19":6033,"_25":11770,"_31":6},"- Function that takes coordinates [x, y?, z?] and returns a scalar value",[],{"_19":11773,"_21":11774,"_23":11775,"_25":11776,"_26":11777,"_32":11739,"_33":11781},"mfem.gridfunction.fromMFEM","mfem.gridfunction.fromMFEM(fespace, data)","Loads a grid function from an MFEM format string into an existing GridFunction.\r","Loads a grid function from an MFEM format string into an existing GridFunction.\r\n\r\nThe GridFunction must already have an associated FiniteElementSpace that\r\nmatches the data being loaded. Use this when you already know the FE type\r\nand have created the space.",[11778,11779],{"_19":10498,"_25":11736,"_31":6},{"_19":528,"_25":11780,"_31":6},"- MFEM format grid function string",[],{"_19":11783,"_21":11784,"_23":11785,"_25":11786,"_26":11787,"_32":11739,"_33":11790},"mfem.gridfunction.fromMFEMWithMesh","mfem.gridfunction.fromMFEMWithMesh(mesh, data)","Creates a grid function from an MFEM format string with auto-detected FE space.\r","Creates a grid function from an MFEM format string with auto-detected FE space.\r\n\r\nThis function parses the FE collection information from the saved data header\r\nand automatically creates the appropriate FiniteElementSpace. Use this when\r\nloading a solution where you don't know the FE type in advance.\r\n\r\nThe returned GridFunction owns its FESpace, which will be destroyed when\r\nthe GridFunction is destroyed.",[11788,11789],{"_19":6229,"_25":11748,"_31":6},{"_19":528,"_25":11780,"_31":6},[],{"_19":11792,"_21":11793,"_23":11794,"_25":11795,"_26":11796,"_32":11393,"_33":11801},"mfem.gridfunction.getAllNodalValues","mfem.gridfunction.getAllNodalValues(gf, vdim?)","Gets the values of a grid function at all vertices of the mesh.\r","Gets the values of a grid function at all vertices of the mesh.\r\n\r\nThis returns one value per vertex for the entire mesh, which is useful\r\nfor visualization or post-processing. For vector-valued grid functions,\r\nyou can specify which component to extract.",[11797,11799],{"_19":9917,"_25":11798,"_31":6},"- The grid function to evaluate",{"_19":11507,"_25":11800,"_31":61},"- Vector component to extract (1-based, default 1 for scalar)",[],{"_19":11803,"_21":11804,"_23":11805,"_25":11806,"_26":11807,"_32":931,"_33":11816},"mfem.gridfunction.getCurl","mfem.gridfunction.getCurl(gf, elemIdx, ip)","Computes the curl of a vector grid function at a point within an element.\r","Computes the curl of a vector grid function at a point within an element.\r\n\r\nThe curl is computed in physical coordinates:\r\n- In 3D: curl = [∂Fz/∂y - ∂Fy/∂z, ∂Fx/∂z - ∂Fz/∂x, ∂Fy/∂x - ∂Fx/∂y]\r\n- In 2D: curl is a scalar (z-component of the 3D curl)\r\n\r\nThis is typically used with H(curl) finite element spaces (Nedelec elements).",[11808,11810,11813],{"_19":9917,"_25":11809,"_31":6},"- Vector GridFunction (e.g., from H(curl) space)",{"_19":11811,"_25":11812,"_31":6},"elemIdx","- Index of the element containing the point (0-based)",{"_19":11814,"_25":11815,"_31":6},"ip","- Integration point in reference coordinates",[],{"_19":11818,"_21":11819,"_23":11820,"_25":11821,"_26":11822,"_32":62,"_33":11834},"mfem.gridfunction.getDerivative","mfem.gridfunction.getDerivative(gf, comp, derComp, destGf)","Computes the derivative of a grid function component in a specified direction\r","Computes the derivative of a grid function component in a specified direction\r\nand projects it onto another grid function.\r\n\r\nThis computes ∂u_comp/∂x_derComp where comp is the component of a\r\nvector-valued function and derComp is the spatial direction.",[11823,11825,11828,11831],{"_19":9917,"_25":11824,"_31":6},"- The source grid function",{"_19":11826,"_25":11827,"_31":6},"comp","- Component to differentiate (1-based: 1, 2, or 3)",{"_19":11829,"_25":11830,"_31":6},"derComp","- Direction of differentiation (1=x, 2=y, 3=z)",{"_19":11832,"_25":11833,"_31":6},"destGf","- Destination grid function (must be pre-created on same mesh)",[],{"_19":11836,"_21":11837,"_23":11838,"_25":11839,"_26":11840,"_32":198,"_33":11845},"mfem.gridfunction.getDivergence","mfem.gridfunction.getDivergence(gf, elemIdx, ip)","Computes the divergence of a vector grid function at a point within an element.\r","Computes the divergence of a vector grid function at a point within an element.\r\n\r\nThe divergence is computed in physical coordinates:\r\ndiv(F) = ∂Fx/∂x + ∂Fy/∂y + ∂Fz/∂z\r\n\r\nThis is typically used with H(div) finite element spaces (Raviart-Thomas elements).",[11841,11843,11844],{"_19":9917,"_25":11842,"_31":6},"- Vector GridFunction (e.g., from H(div) space)",{"_19":11811,"_25":11812,"_31":6},{"_19":11814,"_25":11815,"_31":6},[],{"_19":11847,"_21":11848,"_23":11849,"_25":11850,"_26":11851,"_32":931,"_33":11856},"mfem.gridfunction.getGradient","mfem.gridfunction.getGradient(gf, elemIdx, ip)","Computes the gradient of a scalar grid function at a point within an element.\r","Computes the gradient of a scalar grid function at a point within an element.\r\n\r\nThe gradient is computed in physical (not reference) coordinates. The result\r\nis a vector with components [∂f/∂x, ∂f/∂y, ∂f/∂z] (depending on dimension).",[11852,11854,11855],{"_19":9917,"_25":11853,"_31":6},"- Scalar GridFunction to differentiate",{"_19":11811,"_25":11812,"_31":6},{"_19":11814,"_25":11815,"_31":6},[],{"_19":11858,"_21":11859,"_23":11860,"_25":11861,"_26":11862,"_32":11868,"_33":11869},"mfem.gridfunction.getGradients","mfem.gridfunction.getGradients(gf, elemIdx, points)","Computes gradients of a grid function at multiple integration points\r","Computes gradients of a grid function at multiple integration points\r\nwithin an element.\r\n\r\nThis is more efficient than calling multiple times\r\nwhen you need gradients at many points in the same element.",[11863,11864,11866],{"_19":9917,"_25":11798,"_31":6},{"_19":11811,"_25":11865,"_31":6},"- Element index (0-based)",{"_19":9650,"_25":11867,"_31":6},"- Array of integration points in reference element coordinates","GradientsResult",[],{"_19":11871,"_21":11872,"_23":11873,"_25":11874,"_26":11875,"_32":11880,"_33":11881},"mfem.gridfunction.getHessian","mfem.gridfunction.getHessian(gf, elemIdx, ip)","Computes the Hessian matrix of a grid function at a point within an element.\r","Computes the Hessian matrix of a grid function at a point within an element.\r\n\r\nThe Hessian is the matrix of second partial derivatives:\r\n```\r\nH = | ∂²u/∂x² ∂²u/∂x∂y ∂²u/∂x∂z |\r\n | ∂²u/∂y∂x ∂²u/∂y² ∂²u/∂y∂z |\r\n | ∂²u/∂z∂x ∂²u/∂z∂y ∂²u/∂z² |\r\n```",[11876,11877,11878],{"_19":9917,"_25":11798,"_31":6},{"_19":11811,"_25":11865,"_31":6},{"_19":11814,"_25":11879,"_31":6},"- Integration point in reference element coordinates","HessianResult",[],{"_19":11883,"_21":11884,"_23":11885,"_25":11886,"_26":11887,"_32":198,"_33":11893},"mfem.gridfunction.getLaplacian","mfem.gridfunction.getLaplacian(gf, elemIdx, ip, vdim?)","Computes the Laplacian of a grid function at a point within an element.\r","Computes the Laplacian of a grid function at a point within an element.\r\n\r\nThe Laplacian is the sum of second partial derivatives:\r\nΔu = ∂²u/∂x² + ∂²u/∂y² + ∂²u/∂z²",[11888,11889,11890,11891],{"_19":9917,"_25":11798,"_31":6},{"_19":11811,"_25":11865,"_31":6},{"_19":11814,"_25":11879,"_31":6},{"_19":11507,"_25":11892,"_31":61},"- Vector component (1-based, default 1 for scalar)",[],{"_19":11895,"_21":11896,"_23":11897,"_25":11898,"_26":11899,"_32":931,"_33":11903},"mfem.gridfunction.getNodalValues","mfem.gridfunction.getNodalValues(gf, elemIdx, vdim?)","Gets the values of a grid function at the vertices of a specific element.\r","Gets the values of a grid function at the vertices of a specific element.\r\n\r\nThis is simpler than using for extracting vertex values,\r\nas it directly returns all nodal values for an element without requiring\r\nintegration point coordinates.",[11900,11901,11902],{"_19":9917,"_25":11798,"_31":6},{"_19":11811,"_25":11865,"_31":6},{"_19":11507,"_25":11800,"_31":61},[],{"_19":11905,"_21":11906,"_23":11907,"_25":11908,"_26":11909,"_32":198,"_33":11914},"mfem.gridfunction.getValue","mfem.gridfunction.getValue(gf, elemIdx, ip)","Evaluates a grid function at a point within a specific element.\r","Evaluates a grid function at a point within a specific element.\r\n\r\nThe point is specified in reference (local) coordinates of the element.\r\nFor most elements, these coordinates range from 0 to 1.",[11910,11912,11913],{"_19":9917,"_25":11911,"_31":6},"- GridFunction to evaluate",{"_19":11811,"_25":11812,"_31":6},{"_19":11814,"_25":11815,"_31":6},[],{"_19":11916,"_21":11917,"_23":11918,"_25":11919,"_26":11920,"_32":11393,"_33":11925},"mfem.gridfunction.getVectorFieldNodalValues","mfem.gridfunction.getVectorFieldNodalValues(gf, component)","Gets the values of a specific component of a vector-valued grid function\r","Gets the values of a specific component of a vector-valued grid function\r\nat all vertices of the mesh.\r\n\r\nThis is useful for extracting individual components (e.g., x-velocity,\r\ny-velocity) from a vector field for visualization or analysis.",[11921,11923],{"_19":9917,"_25":11922,"_31":6},"- The vector GridFunction to evaluate",{"_19":10874,"_25":11924,"_31":6},"- Component index (1-based: 1=x, 2=y, 3=z)",[],{"_19":11927,"_21":11928,"_23":11929,"_25":11930,"_26":11931,"_32":931,"_33":11935},"mfem.gridfunction.getVectorValue","mfem.gridfunction.getVectorValue(gf, elemIdx, ip)","Evaluates a vector-valued grid function at a point within an element.\r","Evaluates a vector-valued grid function at a point within an element.\r\n\r\nThis is the vector analog of . It returns all components\r\nof the vector field at the specified point.",[11932,11933,11934],{"_19":9917,"_25":11922,"_31":6},{"_19":11811,"_25":11865,"_31":6},{"_19":11814,"_25":11879,"_31":6},[],{"_19":11937,"_21":11938,"_23":11939,"_25":11940,"_26":11941,"_32":11945,"_33":11946},"mfem.gridfunction.getVectorValues","mfem.gridfunction.getVectorValues(gf, elemIdx, points)","Evaluates a vector-valued grid function at multiple integration points within an element.\r","Evaluates a vector-valued grid function at multiple integration points within an element.\r\n\r\nThis is more efficient than calling multiple times\r\nwhen you need values at many points in the same element.",[11942,11943,11944],{"_19":9917,"_25":11922,"_31":6},{"_19":11811,"_25":11865,"_31":6},{"_19":9650,"_25":11867,"_31":6},"VectorValuesResult",[],{"_19":11948,"_21":11949,"_23":11950,"_25":11951,"_26":11952,"_32":198,"_33":11955},"mfem.gridfunction.normH1","mfem.gridfunction.normH1(gf)","Computes the H1 norm of a grid function.\r","Computes the H1 norm of a grid function.\r\n\r\nThe H1 norm is defined as:\r\n```\r\n||u||_H1 = sqrt( ||u||²_L2 + ||∇u||²_L2 )\r\n = sqrt( ∫_Ω |u(x)|² dx + ∫_Ω |∇u(x)|² dx )\r\n```\r\n\r\nThis norm measures both the function values and their derivatives,\r\nmaking it suitable for error analysis in elliptic PDEs.\r\n\r\n**Note:** This function returns the H1 seminorm (gradient norm only).\r\nTo get the full H1 norm, combine with the L2 norm:\r\n`sqrt(normL2(gf)**2 + normH1(gf)**2)`",[11953],{"_19":9917,"_25":11954,"_31":6},"- GridFunction to compute norm of",[],{"_19":11957,"_21":11958,"_23":11959,"_25":11960,"_26":11961,"_32":198,"_33":11963},"mfem.gridfunction.normL2","mfem.gridfunction.normL2(gf)","Computes the L2 norm of a grid function.\r","Computes the L2 norm of a grid function.\r\n\r\nThe L2 norm is defined as:\r\n```\r\n||u||_L2 = sqrt( ∫_Ω |u(x)|² dx )\r\n```\r\n\r\nThis is computed using numerical quadrature over all elements in the mesh.",[11962],{"_19":9917,"_25":11954,"_31":6},[],{"_19":11965,"_21":11966,"_23":11967,"_25":11968,"_26":11969,"_32":198,"_33":11971},"mfem.gridfunction.normLinf","mfem.gridfunction.normLinf(gf)","Computes the L-infinity (maximum) norm of a grid function.\r","Computes the L-infinity (maximum) norm of a grid function.\r\n\r\nThe L-infinity norm is defined as:\r\n```\r\n||u||_∞ = max |u(x)| over all x in Ω\r\n```\r\n\r\nIn practice, this is computed as the maximum absolute value of the DOF coefficients.",[11970],{"_19":9917,"_25":11954,"_31":6},[],{"_19":11973,"_21":11974,"_23":11975,"_25":11976,"_26":11977,"_32":62,"_33":11984},"mfem.gridfunction.projectBdrCoefficient","mfem.gridfunction.projectBdrCoefficient(gf, value, bdrAttrs)","Projects a constant value onto boundary DOFs for specified boundary attributes.\r","Projects a constant value onto boundary DOFs for specified boundary attributes.\r\n\r\nThis sets the DOF values on the specified boundaries to the given constant value.\r\nIt is useful for applying Dirichlet boundary conditions where the boundary\r\nvalue is known.\r\n\r\nOnly DOFs that lie on boundary elements with the specified attributes are modified.\r\nInterior DOFs remain unchanged.",[11978,11980,11982],{"_19":9917,"_25":11979,"_31":6},"- GridFunction to modify",{"_19":2051,"_25":11981,"_31":6},"- The constant value to project on boundary",{"_19":10662,"_25":11983,"_31":6},"- Array of boundary attributes (1-based) to apply the value to",[],{"_19":11986,"_21":11987,"_23":11988,"_25":11989,"_26":11990,"_32":62,"_33":11997},"mfem.gridfunction.projectBdrVectorCoefficient","mfem.gridfunction.projectBdrVectorCoefficient(gf, vcoeffPtr, bdrAttrs)","Projects a vector coefficient onto boundary DOFs of a grid function.\r","Projects a vector coefficient onto boundary DOFs of a grid function.\r\n\r\nThis sets the values of the grid function at boundary DOFs to match\r\nthe given vector coefficient. Interior DOFs are not modified.",[11991,11993,11995],{"_19":9917,"_25":11992,"_31":6},"- The grid function to modify",{"_19":11702,"_25":11994,"_31":6},"- Pointer to a VectorCoefficient in WASM memory",{"_19":10662,"_25":11996,"_31":6},"- Array of boundary attribute markers (1 = apply, 0 = skip)",[],{"_19":11999,"_21":12000,"_23":12001,"_25":12002,"_26":12003,"_32":62,"_33":12006},"mfem.gridfunction.projectCoefficient","mfem.gridfunction.projectCoefficient(gf, value)","Projects a constant coefficient onto a grid function.\r","Projects a constant coefficient onto a grid function.\r\n\r\nThis sets all DOF values such that the grid function represents\r\nthe constant function f(x) = value everywhere in the domain.\r\nThis is equivalent to calling `gf.projectConstant(value)`.",[12004,12005],{"_19":9917,"_25":11979,"_31":6},{"_19":2051,"_25":11760,"_31":6},[],{"_19":12008,"_21":12009,"_23":12010,"_25":12011,"_26":12012,"_32":62,"_33":12019},"mfem.gridfunction.projectDiscCoefficient","mfem.gridfunction.projectDiscCoefficient(gf, coeffPtr, avgType?)","Projects a discontinuous coefficient onto a grid function with averaging.\r","Projects a discontinuous coefficient onto a grid function with averaging.\r\n\r\nWhen a coefficient has different values on different sides of an element\r\ninterface, this function uses the specified averaging type to determine\r\nthe value at shared DOFs.",[12013,12014,12016],{"_19":9917,"_25":11992,"_31":6},{"_19":11677,"_25":12015,"_31":6},"- Pointer to a Coefficient in WASM memory",{"_19":12017,"_25":12018,"_31":61},"avgType","- Averaging type for interface values (default: ARITHMETIC)",[],{"_19":12021,"_21":12022,"_23":12023,"_25":12024,"_26":12025,"_32":1947,"_33":12028},"mfem.gridfunction.projectFunction","mfem.gridfunction.projectFunction(gf, fn)","Projects a JavaScript function onto a grid function using nodal interpolation.\r","Projects a JavaScript function onto a grid function using nodal interpolation.\r\n\r\nThe function is evaluated at the physical coordinates of each degree of freedom\r\nto determine the DOF values. For standard Lagrange elements, this corresponds\r\nto interpolation at the nodal points.\r\n\r\n**Note:** This function is async because it needs to compute DOF coordinates.",[12026,12027],{"_19":9917,"_25":11979,"_31":6},{"_19":6033,"_25":11770,"_31":6},[],{"_19":12030,"_21":12031,"_23":12032,"_25":12033,"_26":12034,"_32":62,"_33":12040},"mfem.gridfunction.projectGridFunction","mfem.gridfunction.projectGridFunction(destGf, srcGf)","Projects a source grid function onto a destination grid function.\r","Projects a source grid function onto a destination grid function.\r\n\r\nThis is useful for transferring solutions between different finite element\r\nspaces on the same mesh, or for initializing a grid function from an\r\nexisting solution.",[12035,12037],{"_19":11832,"_25":12036,"_31":6},"- The destination grid function to modify",{"_19":12038,"_25":12039,"_31":6},"srcGf","- The source grid function to project from",[],{"_19":12042,"_21":12043,"_23":12044,"_25":12045,"_26":12046,"_32":546,"_33":12049},"mfem.gridfunction.save","mfem.gridfunction.save(gf)","Exports a grid function to MFEM format string.\r","Exports a grid function to MFEM format string.\r\n\r\nThe returned string can be saved to a file and later loaded back using\r\nMFEM's GridFunction constructor that takes a mesh and input stream.\r\n\r\nThe format includes the finite element collection type, ordering,\r\nand all DOF values.",[12047],{"_19":9917,"_25":12048,"_31":6},"- GridFunction to export",[],{"_19":12051,"_21":12052,"_23":12053,"_25":12054,"_26":12055,"_32":546,"_33":12058},"mfem.gridfunction.toBinary","mfem.gridfunction.toBinary(gf)","Exports a grid function to a base64-encoded binary string.\r","Exports a grid function to a base64-encoded binary string.\r\n\r\nThis provides a compact representation of the grid function suitable for\r\nstorage in JSON, localStorage, or transmission. The grid function is first\r\nserialized to MFEM format (including FE space info) and then base64-encoded.",[12056],{"_19":9917,"_25":12057,"_31":6},"- The grid function to export",[],{"_19":12060,"_21":12061,"_23":12062,"_25":12063,"_26":12064,"_32":546,"_33":12068},"mfem.gridfunction.toVTK","mfem.gridfunction.toVTK(gf, options?)","Exports a grid function to VTK format string for visualization.\r","Exports a grid function to VTK format string for visualization.\r\n\r\nThe returned string contains VTK data for the grid function values.\r\n**Note:** This exports only the field data. For complete VTK output,\r\nyou also need to export the mesh using `mesh.toVTK()`.\r\n\r\nFor visualization in ParaView or similar tools, combine the mesh\r\nand field data into a complete VTK file.",[12065,12066],{"_19":9917,"_25":12048,"_31":6},{"_19":534,"_25":12067,"_31":61},"- Export options",[],{"_19":12070,"_21":12071,"_23":12072,"_25":12073,"_26":12074,"_32":11393,"_33":12077},"mfem.gridfunction.getTrueDofs","mfem.gridfunction.getTrueDofs(gf)","Gets the true DOF values from a grid function.\r","Gets the true DOF values from a grid function.\r\n\r\nFor conforming meshes, this returns the same as `getData()`.\r\nFor non-conforming meshes, this returns only the independent DOF values,\r\nwhich may be fewer than the total number of DOFs.",[12075],{"_19":9917,"_25":12076,"_31":6},"- The grid function to query",[],{"_19":12079,"_21":12080,"_23":12081,"_25":12082,"_26":12083,"_32":198,"_33":12085},"mfem.gridfunction.getTrueVectorSize","mfem.gridfunction.getTrueVectorSize(gf)","Gets the size of the true DOF vector.\r","Gets the size of the true DOF vector.\r\n\r\nFor conforming meshes, this equals the total number of DOFs.\r\nFor non-conforming meshes, this may be smaller.",[12084],{"_19":9917,"_25":12076,"_31":6},[],{"_19":12087,"_21":12088,"_23":12089,"_25":12090,"_26":12091,"_32":62,"_33":12097},"mfem.gridfunction.setFromTrueDofs","mfem.gridfunction.setFromTrueDofs(gf, trueDofs)","Sets grid function values from true DOF values.\r","Sets grid function values from true DOF values.\r\n\r\nThis applies the prolongation operator to populate all DOFs from\r\nthe independent true DOFs. For conforming meshes, this is equivalent\r\nto `setData()`. For non-conforming meshes, this properly distributes\r\nvalues to hanging nodes.",[12092,12094],{"_19":9917,"_25":12093,"_31":6},"- The grid function to update",{"_19":12095,"_25":12096,"_31":6},"trueDofs","- Array of true DOF values",[],{"_19":12099,"_21":12100,"_23":12101,"_25":12102,"_26":12103,"_32":62,"_33":12105},"mfem.gridfunction.setTrueVector","mfem.gridfunction.setTrueVector(gf)","Extracts true DOFs from the grid function to internal storage.\r","Extracts true DOFs from the grid function to internal storage.\r\n\r\nFor conforming meshes, this is a no-op. For non-conforming meshes\r\n(with hanging nodes), this extracts the independent DOF values.\r\nCall this before solving to prepare the true DOF vector.",[12104],{"_19":9917,"_25":12093,"_31":6},[],{"_19":12107,"_21":12108,"_23":12109,"_25":12110,"_26":12111,"_32":11739,"_33":12113},"mfem.gridfunction.GridFunction.create","mfem.gridfunction.GridFunction.create(fespace)","Creates a new grid function on the specified finite element space.\r","Creates a new grid function on the specified finite element space.\r\n\r\nThe grid function is initialized with unspecified values. Use\r\n| projectConstant() or\r\n| setData() to initialize the values.",[12112],{"_19":10498,"_25":11758,"_31":6},[],{"_19":12115,"_21":12116,"_23":12117,"_25":12117,"_26":12118,"_32":11393,"_33":12121},"mfem.linalg.createDoubleArray","mfem.linalg.createDoubleArray(size)","Create a zero-initialized Float64Array.",[12119],{"_19":1105,"_25":12120,"_31":6},"- Array size",[],{"_19":12123,"_21":12124,"_23":12125,"_25":12126,"_26":12127,"_32":10706,"_33":12129},"mfem.linalg.createIntArray","mfem.linalg.createIntArray(size)","Array utility functions for creating typed arrays.\r","Array utility functions for creating typed arrays.\r\n\r\nThese are pure JavaScript utilities that don't require WASM.",[12128],{"_19":1105,"_25":12120,"_31":6},[],{"_19":12131,"_21":12132,"_23":12133,"_25":12134,"_26":12135,"_32":10706,"_33":12140},"mfem.linalg.createMarkerArray","mfem.linalg.createMarkerArray(size, markedIndices)","Create a marker array (0/1 values) with specified indices marked as 1.\r","Create a marker array (0/1 values) with specified indices marked as 1.\r\n\r\nThis is useful for creating boundary marker arrays or element selection arrays.",[12136,12137],{"_19":1105,"_25":12120,"_31":6},{"_19":12138,"_25":12139,"_31":6},"markedIndices","- Indices to mark as 1",[],{"_19":12142,"_21":12143,"_23":10573,"_25":10573,"_26":12144,"_32":10578,"_33":12146},"mfem.linalg.BlockMatrix.createSquare","mfem.linalg.BlockMatrix.createSquare(offsets)",[12145],{"_19":10576,"_25":10577,"_31":6},[],{"_19":12148,"_21":12149,"_23":10583,"_25":10583,"_26":12150,"_32":10578,"_33":12153},"mfem.linalg.BlockMatrix.create","mfem.linalg.BlockMatrix.create(rowOffsets, colOffsets)",[12151,12152],{"_19":10586,"_25":10587,"_31":6},{"_19":10589,"_25":10590,"_31":6},[],{"_19":12155,"_21":12156,"_23":10595,"_25":10596,"_26":12157,"_32":10578,"_33":12159},"mfem.linalg.BlockMatrix.fromPointer","mfem.linalg.BlockMatrix.fromPointer(ptr)",[12158],{"_19":10599,"_25":10600,"_31":6},[],{"_19":12161,"_21":12162,"_23":10605,"_25":10605,"_26":12163,"_32":10608,"_33":12165},"mfem.linalg.BlockOperator.createSquare","mfem.linalg.BlockOperator.createSquare(offsets)",[12164],{"_19":10576,"_25":10577,"_31":6},[],{"_19":12167,"_21":12168,"_23":10613,"_25":10613,"_26":12169,"_32":10608,"_33":12172},"mfem.linalg.BlockOperator.create","mfem.linalg.BlockOperator.create(rowOffsets, colOffsets)",[12170,12171],{"_19":10586,"_25":10587,"_31":6},{"_19":10589,"_25":10590,"_31":6},[],{"_19":12174,"_21":12175,"_23":10621,"_25":10622,"_26":12176,"_32":10608,"_33":12178},"mfem.linalg.BlockOperator.fromPointer","mfem.linalg.BlockOperator.fromPointer(ptr)",[12177],{"_19":10599,"_25":10625,"_31":6},[],{"_19":12180,"_21":12181,"_23":10630,"_25":10630,"_26":12182,"_32":10634,"_33":12184},"mfem.linalg.BlockVector.create","mfem.linalg.BlockVector.create(offsets)",[12183],{"_19":10576,"_25":10633,"_31":6},[],{"_19":12186,"_21":12187,"_23":10639,"_25":10640,"_26":12188,"_32":10634,"_33":12191},"mfem.linalg.BlockVector.fromPointer","mfem.linalg.BlockVector.fromPointer(ptr, offsets)",[12189,12190],{"_19":10599,"_25":10643,"_31":6},{"_19":10576,"_25":10645,"_31":6},[],{"_19":12193,"_21":12194,"_23":11444,"_25":11445,"_26":12195,"_32":11450,"_33":12198},"mfem.linalg.DenseMatrix.create","mfem.linalg.DenseMatrix.create(height, width)",[12196,12197],{"_19":9761,"_25":1864,"_31":6},{"_19":753,"_25":11449,"_31":6},[],{"_19":12200,"_21":12201,"_23":11455,"_25":11455,"_26":12202,"_32":11450,"_33":12205},"mfem.linalg.DenseMatrix.zeros","mfem.linalg.DenseMatrix.zeros(height, width)",[12203,12204],{"_19":9761,"_25":1864,"_31":6},{"_19":753,"_25":11449,"_31":6},[],{"_19":12207,"_21":12208,"_23":11463,"_25":11463,"_26":12209,"_32":11450,"_33":12211},"mfem.linalg.DenseMatrix.identity","mfem.linalg.DenseMatrix.identity(n)",[12210],{"_19":1516,"_25":11466,"_31":6},[],{"_19":12213,"_21":12214,"_23":11471,"_25":11471,"_26":12215,"_32":11450,"_33":12217},"mfem.linalg.DenseMatrix.fromArray","mfem.linalg.DenseMatrix.fromArray(data)",[12216],{"_19":528,"_25":11474,"_31":6},[],{"_19":12219,"_21":12220,"_23":11479,"_25":11480,"_26":12221,"_32":11450,"_33":12224},"mfem.linalg.DenseMatrix.fromPointer","mfem.linalg.DenseMatrix.fromPointer(ptr, ownsMemory?)",[12222,12223],{"_19":10599,"_25":11483,"_31":6},{"_19":11485,"_25":11486,"_31":61},[],{"_19":12226,"_21":12227,"_23":12228,"_25":12228,"_26":12229,"_32":12232,"_33":12233},"mfem.linalg.SparseMatrix.create","mfem.linalg.SparseMatrix.create(height, width)","Creates a new empty sparse matrix of the specified dimensions.",[12230,12231],{"_19":9761,"_25":1864,"_31":6},{"_19":753,"_25":11449,"_31":6},"Promise",[],{"_19":12235,"_21":12236,"_23":12237,"_25":12238,"_26":12239,"_32":12232,"_33":12244},"mfem.linalg.SparseMatrix.fromPointer","mfem.linalg.SparseMatrix.fromPointer(ptr, ownsMemory?)","Creates a SparseMatrix from an existing WASM pointer.\r","Creates a SparseMatrix from an existing WASM pointer.\r\nUse with caution - the caller is responsible for pointer validity.",[12240,12242],{"_19":10599,"_25":12241,"_31":6},"- WASM pointer to an existing MFEM SparseMatrix",{"_19":11485,"_25":12243,"_31":61},"- If true, destroy() will free the memory; if false, it won't",[],{"_19":12246,"_21":12247,"_23":12248,"_25":12248,"_26":12249,"_32":12252,"_33":12253},"mfem.linalg.Vector.create","mfem.linalg.Vector.create(size)","Creates a new vector of the specified size.",[12250],{"_19":1105,"_25":12251,"_31":6},"- The number of elements in the vector","Promise",[],{"_19":12255,"_21":12256,"_23":12257,"_25":12258,"_26":12259,"_32":12252,"_33":12262},"mfem.linalg.Vector.fromPointer","mfem.linalg.Vector.fromPointer(ptr)","Creates a Vector from an existing WASM pointer.\r","Creates a Vector from an existing WASM pointer.\r\nUse with caution - the caller is responsible for pointer validity.",[12260],{"_19":10599,"_25":12261,"_31":6},"- WASM pointer to an existing MFEM Vector",[],{"_19":12264,"_21":12265,"_23":12266,"_25":12266,"_26":12267,"_32":198,"_33":12270},"mfem.linear.getFinalNorm","mfem.linear.getFinalNorm(solver)","Get the final residual norm from the last solve.",[12268],{"_19":11388,"_25":12269,"_31":6},"- Iterative solver instance",[],{"_19":12272,"_21":12273,"_23":12274,"_25":12274,"_26":12275,"_32":198,"_33":12277},"mfem.linear.getNumIterations","mfem.linear.getNumIterations(solver)","Get the number of iterations from the last solve.",[12276],{"_19":11388,"_25":12269,"_31":6},[],{"_19":12279,"_21":12280,"_23":12281,"_25":12281,"_26":12282,"_32":62,"_33":12288},"mfem.linear.mult","mfem.linear.mult(solver, b, x)","Solve the linear system Ax = b.",[12283,12284,12286],{"_19":11388,"_25":12269,"_31":6},{"_19":191,"_25":12285,"_31":6},"- Right-hand side vector",{"_19":29,"_25":12287,"_31":6},"- Solution vector (modified in place)",[],{"_19":12290,"_21":12291,"_23":12292,"_25":12292,"_26":12293,"_32":62,"_33":12297},"mfem.linear.setMaxIterations","mfem.linear.setMaxIterations(solver, max)","Set maximum number of iterations for an iterative solver.",[12294,12295],{"_19":11388,"_25":12269,"_31":6},{"_19":6553,"_25":12296,"_31":6},"- Maximum iterations",[],{"_19":12299,"_21":12300,"_23":12301,"_25":12301,"_26":12302,"_32":62,"_33":12307},"mfem.linear.setPreconditioner","mfem.linear.setPreconditioner(solver, prec)","Set preconditioner for an iterative solver.",[12303,12304],{"_19":11388,"_25":12269,"_31":6},{"_19":12305,"_25":12306,"_31":6},"prec","- Preconditioner (Solver)",[],{"_19":12309,"_21":12310,"_23":12311,"_25":12311,"_26":12312,"_32":62,"_33":12317},"mfem.linear.setPrintLevel","mfem.linear.setPrintLevel(solver, level)","Set verbosity level for an iterative solver.",[12313,12314],{"_19":11388,"_25":12269,"_31":6},{"_19":12315,"_25":12316,"_31":6},"level","- Print level (0=silent, 1=summary, 2=iteration details)",[],{"_19":12319,"_21":12320,"_23":12321,"_25":12321,"_26":12322,"_32":62,"_33":12328},"mfem.linear.setTolerance","mfem.linear.setTolerance(solver, rtol, atol?)","Set convergence tolerances for an iterative solver.",[12323,12324,12326],{"_19":11388,"_25":12269,"_31":6},{"_19":77,"_25":12325,"_31":6},"- Relative tolerance",{"_19":80,"_25":12327,"_31":61},"- Absolute tolerance (optional)",[],{"_19":12330,"_21":12331,"_23":12332,"_25":12332,"_26":12333,"_32":12334,"_33":12335},"mfem.linear.BiCGSTABSolver.create","mfem.linear.BiCGSTABSolver.create()","Creates a new BiCGSTAB solver.",[],"Promise",[],{"_19":12337,"_21":12338,"_23":12339,"_25":12339,"_26":12340,"_32":12349,"_33":12350},"mfem.linear.BlockILU.create","mfem.linear.BlockILU.create(matrixPtr, blockSize?, options?)","Creates a new BlockILU preconditioner.",[12341,12344,12347],{"_19":12342,"_25":12343,"_31":6},"matrixPtr","- Pointer to SparseMatrix or Operator",{"_19":12345,"_25":12346,"_31":61},"blockSize","- Block size for ILU factorization. Default: 1",{"_19":534,"_25":12348,"_31":61},"- Optional configuration options","Promise",[],{"_19":12352,"_21":12353,"_23":12354,"_25":12354,"_26":12355,"_32":12356,"_33":12357},"mfem.linear.CGSolver.create","mfem.linear.CGSolver.create()","Creates a new CG solver.",[],"Promise",[],{"_19":12359,"_21":12360,"_23":12361,"_25":12361,"_26":12362,"_32":12365,"_33":12366},"mfem.linear.ChebyshevSmoother.create","mfem.linear.ChebyshevSmoother.create(options)","Creates a new Chebyshev smoother with explicit maximum eigenvalue.",[12363],{"_19":534,"_25":12364,"_31":6},"- Smoother configuration options","Promise",[],{"_19":12368,"_21":12369,"_23":12370,"_25":12371,"_26":12372,"_32":12365,"_33":12374},"mfem.linear.ChebyshevSmoother.createAuto","mfem.linear.ChebyshevSmoother.createAuto(options)","Creates a new Chebyshev smoother with automatic eigenvalue estimation.\r","Creates a new Chebyshev smoother with automatic eigenvalue estimation.\r\nUses power iteration to estimate the maximum eigenvalue.",[12373],{"_19":534,"_25":12364,"_31":6},[],{"_19":12376,"_21":12377,"_23":12378,"_25":12378,"_26":12379,"_32":12386,"_33":12387},"mfem.linear.DirectSubBlockSolver.create","mfem.linear.DirectSubBlockSolver.create(APtr, blockDofPtr)","Creates a new DirectSubBlockSolver.",[12380,12383],{"_19":12381,"_25":12382,"_31":6},"APtr","- Pointer to the system SparseMatrix",{"_19":12384,"_25":12385,"_31":6},"blockDofPtr","- Pointer to SparseMatrix defining block-DOF membership","Promise",[],{"_19":12389,"_21":12390,"_23":12391,"_25":12391,"_26":12392,"_32":12396,"_33":12397},"mfem.linear.DSmoother.create","mfem.linear.DSmoother.create(matrixPtr, options?)","Creates a new DSmoother.",[12393,12395],{"_19":12342,"_25":12394,"_31":6},"- Pointer to SparseMatrix",{"_19":534,"_25":12348,"_31":61},"Promise",[],{"_19":12399,"_21":12400,"_23":12401,"_25":12401,"_26":12402,"_32":12406,"_33":12407},"mfem.linear.FGMRESSolver.create","mfem.linear.FGMRESSolver.create(kdim?)","Creates a new Flexible GMRES solver.",[12403],{"_19":12404,"_25":12405,"_31":61},"kdim","- Krylov space dimension (restart parameter, default 50)","Promise",[],{"_19":12409,"_21":12410,"_23":12411,"_25":12411,"_26":12412,"_32":12414,"_33":12415},"mfem.linear.GMRESSolver.create","mfem.linear.GMRESSolver.create(kdim?)","Creates a new GMRES solver.",[12413],{"_19":12404,"_25":12405,"_31":61},"Promise",[],{"_19":12417,"_21":12418,"_23":12419,"_25":12419,"_26":12420,"_32":12427,"_33":12428},"mfem.linear.GSSmoother.create","mfem.linear.GSSmoother.create(matrixPtr, type?, iterations?)","Creates a new Gauss-Seidel smoother.",[12421,12422,12425],{"_19":12342,"_25":12394,"_31":6},{"_19":12423,"_25":12424,"_31":61},"type","- Type of GS iteration (default: SYMMETRIC)",{"_19":12426,"_25":285,"_31":61},"iterations","Promise",[],{"_19":12430,"_21":12431,"_23":12432,"_25":12432,"_26":12433,"_32":12437,"_33":12438},"mfem.linear.JacobiSmoother.create","mfem.linear.JacobiSmoother.create(matrixPtr, essentialDofs?)","Creates a new Jacobi smoother.",[12434,12435],{"_19":12342,"_25":12394,"_31":6},{"_19":10510,"_25":12436,"_31":61},"- Optional array of essential DOF indices to exclude","Promise",[],{"_19":12440,"_21":12441,"_23":12442,"_25":12442,"_26":12443,"_32":343,"_33":12444},"mfem.linear.KLUSolver.isAvailable","mfem.linear.KLUSolver.isAvailable()","Checks if KLU (SuiteSparse) is available.",[],[],{"_19":12446,"_21":12447,"_23":12448,"_25":12448,"_26":12449,"_32":12450,"_33":12451},"mfem.linear.KLUSolver.create","mfem.linear.KLUSolver.create()","Creates a new KLU solver.",[],"Promise",[],{"_19":12453,"_21":12454,"_23":12455,"_25":12455,"_26":12456,"_32":12457,"_33":12458},"mfem.linear.MINRESSolver.create","mfem.linear.MINRESSolver.create()","Creates a new MINRES solver.",[],"Promise",[],{"_19":12460,"_21":12461,"_23":12462,"_25":12462,"_26":12463,"_32":12464,"_33":12465},"mfem.linear.OrthoSolver.create","mfem.linear.OrthoSolver.create()","Creates a new orthogonalizing solver wrapper.",[],"Promise",[],{"_19":12467,"_21":12468,"_23":12469,"_25":12469,"_26":12470,"_32":12479,"_33":12480},"mfem.linear.ProductSolver.create","mfem.linear.ProductSolver.create(s0Ptr, s1Ptr, options?)","Creates a new product solver: S = S1 * S0.",[12471,12474,12477],{"_19":12472,"_25":12473,"_31":6},"s0Ptr","- Pointer to first solver (applied first)",{"_19":12475,"_25":12476,"_31":6},"s1Ptr","- Pointer to second solver (applied second)",{"_19":534,"_25":12478,"_31":61},"- Ownership options","Promise",[],{"_19":12467,"_21":12482,"_23":12469,"_25":12469,"_26":12483,"_32":12479,"_33":12490},"mfem.linear.ProductSolver.create(s0, s1, options?)",[12484,12487,12489],{"_19":12485,"_25":12486,"_31":6},"s0","- First solver (applied first)",{"_19":6877,"_25":12488,"_31":6},"- Second solver (applied second)",{"_19":534,"_25":12478,"_31":61},[],{"_19":12492,"_21":12493,"_23":12494,"_25":12494,"_26":12495,"_32":12496,"_33":12497},"mfem.linear.SLISolver.create","mfem.linear.SLISolver.create()","Creates a new SLI solver.",[],"Promise",[],{"_19":12499,"_21":12500,"_23":12501,"_25":12501,"_26":12502,"_32":343,"_33":12503},"mfem.linear.UMFPackSolver.isAvailable","mfem.linear.UMFPackSolver.isAvailable()","Checks if UMFPack (SuiteSparse) is available.",[],[],{"_19":12505,"_21":12506,"_23":12507,"_25":12507,"_26":12508,"_32":12509,"_33":12510},"mfem.linear.UMFPackSolver.create","mfem.linear.UMFPackSolver.create()","Creates a new UMFPack solver.",[],"Promise",[],{"_19":12512,"_21":12513,"_23":12514,"_25":12515,"_26":12516,"_32":62,"_33":12522},"mfem.linearForms.addBoundaryFluxIntegrator","mfem.linearForms.addBoundaryFluxIntegrator(lf, coeff, bdrAttrs?)","Add a VectorFE boundary flux integrator for H(div) spaces.\r","Add a VectorFE boundary flux integrator for H(div) spaces.\r\n\r\nComputes: ∫_∂Ω f * (v · n) ds",[12517,12518,12520],{"_19":10655,"_25":10673,"_31":6},{"_19":10336,"_25":12519,"_31":6},"- Scalar flux coefficient",{"_19":10662,"_25":12521,"_31":61},"- Optional boundary attributes to restrict to",[],{"_19":12524,"_21":12525,"_23":12526,"_25":12527,"_26":12528,"_32":62,"_33":12533},"mfem.linearForms.addBoundaryIntegrator","mfem.linearForms.addBoundaryIntegrator(lf, coeff, bdrAttrs?)","Add a boundary integrator (g, v) to the linear form.\r","Add a boundary integrator (g, v) to the linear form.\r\n\r\nComputes: ∫_∂Ω g * v ds",[12529,12530,12532],{"_19":10655,"_25":10673,"_31":6},{"_19":10336,"_25":12531,"_31":6},"- Boundary source coefficient",{"_19":10662,"_25":12521,"_31":61},[],{"_19":12535,"_21":12536,"_23":12537,"_25":12538,"_26":12539,"_32":62,"_33":12543},"mfem.linearForms.addBoundaryNormalIntegrator","mfem.linearForms.addBoundaryNormalIntegrator(lf, coeff, bdrAttrs?)","Add a boundary normal integrator (F · n, v) to the linear form.\r","Add a boundary normal integrator (F · n, v) to the linear form.\r\n\r\nComputes: ∫_∂Ω (F · n) * v ds",[12540,12541,12542],{"_19":10655,"_25":10673,"_31":6},{"_19":10336,"_25":11038,"_31":6},{"_19":10662,"_25":12521,"_31":61},[],{"_19":12545,"_21":12546,"_23":12547,"_25":12548,"_26":12549,"_32":62,"_33":12553},"mfem.linearForms.addBoundaryTangentialIntegrator","mfem.linearForms.addBoundaryTangentialIntegrator(lf, coeff, bdrAttrs?)","Add a boundary tangential integrator (F × n, v) to the linear form.\r","Add a boundary tangential integrator (F × n, v) to the linear form.\r\nFor 2D: takes the tangential component of the vector field.\r\n\r\nComputes: ∫_∂Ω (F · t) * v ds",[12550,12551,12552],{"_19":10655,"_25":10673,"_31":6},{"_19":10336,"_25":11038,"_31":6},{"_19":10662,"_25":12521,"_31":61},[],{"_19":12555,"_21":12556,"_23":12557,"_25":12558,"_26":12559,"_32":62,"_33":12567},"mfem.linearForms.addDGDirichletIntegrator","mfem.linearForms.addDGDirichletIntegrator(lf, coeff, sigma, kappa)","Add a DG Dirichlet boundary integrator for discontinuous Galerkin methods.\r","Add a DG Dirichlet boundary integrator for discontinuous Galerkin methods.\r\n\r\nNote: This integrator is not yet implemented in the WASM bindings.\r\nIt requires additional C++ support for DG-specific integrators.",[12560,12561,12563,12565],{"_19":10655,"_25":10673,"_31":6},{"_19":10336,"_25":12562,"_31":6},"- Dirichlet value coefficient",{"_19":10372,"_25":12564,"_31":6},"- Symmetry parameter (-1 for SIPG, 0 for IIPG, 1 for NIPG)",{"_19":10375,"_25":12566,"_31":6},"- Penalty parameter",[],{"_19":12569,"_21":12570,"_23":12571,"_25":12572,"_26":12573,"_32":62,"_33":12576},"mfem.linearForms.addDomainGradientIntegrator","mfem.linearForms.addDomainGradientIntegrator(lf, coeff)","Add a domain gradient integrator (F, ∇v) to the linear form.\r","Add a domain gradient integrator (F, ∇v) to the linear form.\r\n\r\nComputes: ∫ F · ∇v dx",[12574,12575],{"_19":10655,"_25":10673,"_31":6},{"_19":10336,"_25":11038,"_31":6},[],{"_19":12578,"_21":12579,"_23":12580,"_25":12581,"_26":12582,"_32":62,"_33":12586},"mfem.linearForms.addDomainIntegrator","mfem.linearForms.addDomainIntegrator(lf, coeff)","Add a domain integrator (f, v) to the linear form.\r","Add a domain integrator (f, v) to the linear form.\r\n\r\nComputes: ∫ f * v dx",[12583,12584],{"_19":10655,"_25":10673,"_31":6},{"_19":10336,"_25":12585,"_31":6},"- Source coefficient",[],{"_19":12588,"_21":12589,"_23":12590,"_25":12591,"_26":12592,"_32":62,"_33":12595},"mfem.linearForms.addVectorDomainIntegrator","mfem.linearForms.addVectorDomainIntegrator(lf, coeff)","Add a vector domain integrator (F, v) to the linear form.\r","Add a vector domain integrator (F, v) to the linear form.\r\nFor vector-valued test functions.\r\n\r\nComputes: ∫ F · v dx",[12593,12594],{"_19":10655,"_25":10673,"_31":6},{"_19":10336,"_25":11038,"_31":6},[],{"_19":12597,"_21":12598,"_23":12599,"_25":12599,"_26":12600,"_32":62,"_33":12602},"mfem.linearForms.assemble","mfem.linearForms.assemble(lf)","Assemble the linear form into a vector.",[12601],{"_19":10655,"_25":10673,"_31":6},[],{"_19":12604,"_21":12605,"_23":12606,"_25":12606,"_26":12607,"_32":11393,"_33":12609},"mfem.linearForms.getVector","mfem.linearForms.getVector(lf)","Get the assembled vector data from the linear form.",[12608],{"_19":10655,"_25":10673,"_31":6},[],{"_19":12611,"_21":12612,"_23":12613,"_25":12613,"_26":12614,"_32":12616,"_33":12617},"mfem.linearForms.create","mfem.linearForms.create(fespace)","Create a linear form on a finite element space.",[12615],{"_19":10498,"_25":10499,"_31":6},"Promise",[],{"_19":12619,"_21":12620,"_23":12621,"_25":12621,"_26":12622,"_32":12616,"_33":12624},"mfem.linearForms.LinearForm.create","mfem.linearForms.LinearForm.create(fespace)","Creates a new linear form on the specified finite element space.",[12623],{"_19":10498,"_25":10556,"_31":6},[],{"_19":12626,"_21":12627,"_23":12628,"_25":2370,"_26":12629,"_32":62,"_33":12635},"mfem.matrix.add","mfem.matrix.add(dm, alpha, other)","add",[12630,12632,12633],{"_19":12631,"_25":11402,"_31":6},"dm",{"_19":10350,"_25":198,"_31":6},{"_19":12634,"_25":11402,"_31":6},"other",[],{"_19":12637,"_21":12638,"_23":8171,"_25":2370,"_26":12639,"_32":198,"_33":12641},"mfem.matrix.cols","mfem.matrix.cols(dm)",[12640],{"_19":12631,"_25":11402,"_31":6},[],{"_19":12643,"_21":12644,"_23":12645,"_25":2370,"_26":12646,"_32":11450,"_33":12649},"mfem.matrix.create","mfem.matrix.create(rows, cols)","create_2",[12647,12648],{"_19":8168,"_25":198,"_31":6},{"_19":8171,"_25":198,"_31":6},[],{"_19":12651,"_21":12652,"_23":12653,"_25":2370,"_26":12654,"_32":198,"_33":12656},"mfem.matrix.determinant","mfem.matrix.determinant(dm)","determinant",[12655],{"_19":12631,"_25":11402,"_31":6},[],{"_19":12658,"_21":12659,"_23":12660,"_25":2370,"_26":12661,"_32":12663,"_33":12664},"mfem.matrix.eigenvalues","mfem.matrix.eigenvalues(dm)","eigenvalues",[12662],{"_19":12631,"_25":11402,"_31":6},"Promise",[],{"_19":12666,"_21":12667,"_23":12668,"_25":2370,"_26":12669,"_32":11450,"_33":12671},"mfem.matrix.fromArray","mfem.matrix.fromArray(data)","fromArray",[12670],{"_19":528,"_25":612,"_31":6},[],{"_19":12673,"_21":12674,"_23":12675,"_25":2370,"_26":12676,"_32":198,"_33":12681},"mfem.matrix.get","mfem.matrix.get(dm, i, j)","get_2",[12677,12678,12679],{"_19":12631,"_25":11402,"_31":6},{"_19":5427,"_25":198,"_31":6},{"_19":12680,"_25":198,"_31":6},"j",[],{"_19":12683,"_21":12684,"_23":12685,"_25":2370,"_26":12686,"_32":11393,"_33":12688},"mfem.matrix.getData","mfem.matrix.getData(dm)","getData",[12687],{"_19":12631,"_25":11402,"_31":6},[],{"_19":12690,"_21":12691,"_23":12692,"_25":2370,"_26":12693,"_32":11450,"_33":12695},"mfem.matrix.identity","mfem.matrix.identity(n)","identity_2",[12694],{"_19":1516,"_25":198,"_31":6},[],{"_19":12697,"_21":12698,"_23":12699,"_25":2370,"_26":12700,"_32":62,"_33":12702},"mfem.matrix.invert","mfem.matrix.invert(dm)","invert",[12701],{"_19":12631,"_25":11402,"_31":6},[],{"_19":12704,"_21":12705,"_23":12706,"_25":2370,"_26":12707,"_32":62,"_33":12712},"mfem.matrix.mult","mfem.matrix.mult(dm, x, y)","mult",[12708,12709,12711],{"_19":12631,"_25":11402,"_31":6},{"_19":29,"_25":12710,"_31":6},"Vector",{"_19":135,"_25":12710,"_31":6},[],{"_19":12714,"_21":12715,"_23":12716,"_25":2370,"_26":12717,"_32":62,"_33":12721},"mfem.matrix.multTranspose","mfem.matrix.multTranspose(dm, x, y)","multTranspose",[12718,12719,12720],{"_19":12631,"_25":11402,"_31":6},{"_19":29,"_25":12710,"_31":6},{"_19":135,"_25":12710,"_31":6},[],{"_19":12723,"_21":12724,"_23":8168,"_25":2370,"_26":12725,"_32":198,"_33":12727},"mfem.matrix.rows","mfem.matrix.rows(dm)",[12726],{"_19":12631,"_25":11402,"_31":6},[],{"_19":12729,"_21":12730,"_23":12731,"_25":2370,"_26":12732,"_32":62,"_33":12737},"mfem.matrix.set","mfem.matrix.set(dm, i, j, value)","set_2",[12733,12734,12735,12736],{"_19":12631,"_25":11402,"_31":6},{"_19":5427,"_25":198,"_31":6},{"_19":12680,"_25":198,"_31":6},{"_19":2051,"_25":198,"_31":6},[],{"_19":12739,"_21":12740,"_23":9466,"_25":2370,"_26":12741,"_32":12252,"_33":12744},"mfem.matrix.solve","mfem.matrix.solve(dm, b)",[12742,12743],{"_19":12631,"_25":11402,"_31":6},{"_19":191,"_25":12710,"_31":6},[],{"_19":12746,"_21":12747,"_23":7187,"_25":2370,"_26":12748,"_32":12663,"_33":12750},"mfem.matrix.svd","mfem.matrix.svd(dm)",[12749],{"_19":12631,"_25":11402,"_31":6},[],{"_19":12752,"_21":12753,"_23":7289,"_25":2370,"_26":12754,"_32":198,"_33":12756},"mfem.matrix.trace","mfem.matrix.trace(dm)",[12755],{"_19":12631,"_25":11402,"_31":6},[],{"_19":12758,"_21":12759,"_23":12760,"_25":2370,"_26":12761,"_32":11450,"_33":12763},"mfem.matrix.transpose","mfem.matrix.transpose(dm)","transpose_2",[12762],{"_19":12631,"_25":11402,"_31":6},[],{"_19":12765,"_21":12766,"_23":6070,"_25":2370,"_26":12767,"_32":11450,"_33":12770},"mfem.matrix.zeros","mfem.matrix.zeros(rows, cols)",[12768,12769],{"_19":8168,"_25":198,"_31":6},{"_19":8171,"_25":198,"_31":6},[],{"_19":12772,"_21":12773,"_23":11444,"_25":11445,"_26":12774,"_32":11450,"_33":12777},"mfem.matrix.DenseMatrix.create","mfem.matrix.DenseMatrix.create(height, width)",[12775,12776],{"_19":9761,"_25":1864,"_31":6},{"_19":753,"_25":11449,"_31":6},[],{"_19":12779,"_21":12780,"_23":11455,"_25":11455,"_26":12781,"_32":11450,"_33":12784},"mfem.matrix.DenseMatrix.zeros","mfem.matrix.DenseMatrix.zeros(height, width)",[12782,12783],{"_19":9761,"_25":1864,"_31":6},{"_19":753,"_25":11449,"_31":6},[],{"_19":12786,"_21":12787,"_23":11463,"_25":11463,"_26":12788,"_32":11450,"_33":12790},"mfem.matrix.DenseMatrix.identity","mfem.matrix.DenseMatrix.identity(n)",[12789],{"_19":1516,"_25":11466,"_31":6},[],{"_19":12792,"_21":12793,"_23":11471,"_25":11471,"_26":12794,"_32":11450,"_33":12796},"mfem.matrix.DenseMatrix.fromArray","mfem.matrix.DenseMatrix.fromArray(data)",[12795],{"_19":528,"_25":11474,"_31":6},[],{"_19":12798,"_21":12799,"_23":11479,"_25":11480,"_26":12800,"_32":11450,"_33":12803},"mfem.matrix.DenseMatrix.fromPointer","mfem.matrix.DenseMatrix.fromPointer(ptr, ownsMemory?)",[12801,12802],{"_19":10599,"_25":11483,"_31":6},{"_19":11485,"_25":11486,"_31":61},[],{"_19":12805,"_21":12806,"_23":12807,"_25":12808,"_26":12809,"_32":62,"_33":12815},"mfem.mesh.derefine","mfem.mesh.derefine(mesh, derefinements)","Derefines (coarsens) specified elements in a non-conforming mesh.\r","Derefines (coarsens) specified elements in a non-conforming mesh.\r\n\r\nDerefinement is the reverse of refinement - it merges previously refined\r\nelements back into their parent elements. This is useful for adaptive\r\nmesh refinement (AMR) where elements may need to be coarsened after\r\nsolution features have moved or diminished.\r\n\r\n**Requirements:**\r\n- The mesh must have NCMesh (non-conforming mesh) support enabled\r\n- The elements must have been previously refined\r\n- The derefinement indices refer to rows in the NCMesh derefinement table\r\n\r\nTo enable NCMesh support before refinement, use .",[12810,12812],{"_19":6229,"_25":12811,"_31":6},"- Mesh instance with NCMesh support",{"_19":12813,"_25":12814,"_31":6},"derefinements","- Array of derefinement table row indices",[],{"_19":12817,"_21":12818,"_23":12819,"_25":12820,"_26":12821,"_32":62,"_33":12823},"mfem.mesh.enableNCMesh","mfem.mesh.enableNCMesh(mesh)","Enables non-conforming mesh (NCMesh) support.\r","Enables non-conforming mesh (NCMesh) support.\r\n\r\nNCMesh support is required for local refinement with hanging nodes\r\nand for derefinement (coarsening). This function must be called\r\nbefore any local refinement operations if derefinement is desired later.",[12822],{"_19":6229,"_25":10703,"_31":6},[],{"_19":12825,"_21":12826,"_23":12827,"_25":12828,"_26":12829,"_32":198,"_33":12831},"mfem.mesh.getDerefTableSize","mfem.mesh.getDerefTableSize(mesh)","Gets the size of the derefinement table.\r","Gets the size of the derefinement table.\r\n\r\nThe derefinement table contains information about which element groups\r\ncan be coarsened. Each row in the table represents one possible\r\nderefinement operation.",[12830],{"_19":6229,"_25":12811,"_31":6},[],{"_19":12833,"_21":12834,"_23":12835,"_25":12835,"_26":12836,"_32":90,"_33":12838},"mfem.mesh.isNCMesh","mfem.mesh.isNCMesh(mesh)","Checks if a mesh has NCMesh (non-conforming mesh) support.",[12837],{"_19":6229,"_25":10703,"_31":6},[],{"_19":12840,"_21":12841,"_23":12842,"_25":12843,"_26":12844,"_32":62,"_33":12850},"mfem.mesh.elevateNURBSDegree","mfem.mesh.elevateNURBSDegree(mesh, relDegree)","Elevates the polynomial degree of a NURBS mesh.\r","Elevates the polynomial degree of a NURBS mesh.\r\n\r\nThis modifies the mesh in place by increasing the polynomial order of\r\nall NURBS patches. The geometry is preserved exactly while adding\r\nadditional control points.",[12845,12847],{"_19":6229,"_25":12846,"_31":6},"- NURBS mesh to elevate",{"_19":12848,"_25":12849,"_31":6},"relDegree","- Relative degree increase (e.g., 1 to go from order 2 to 3)",[],{"_19":12852,"_21":12853,"_23":12854,"_25":12855,"_26":12856,"_32":62,"_33":12861},"mfem.mesh.setNURBSOrder","mfem.mesh.setNURBSOrder(mesh, order)","Sets the NURBS order uniformly.\r","Sets the NURBS order uniformly.\r\n\r\nThis sets the curvature order of the mesh, which affects the underlying\r\nNURBS representation. Note that this may perform degree elevation or\r\nreduction depending on the current order.",[12857,12859],{"_19":6229,"_25":12858,"_31":6},"- NURBS mesh",{"_19":11504,"_25":12860,"_31":6},"- New polynomial order",[],{"_19":12863,"_21":12864,"_23":12865,"_25":12866,"_26":12867,"_32":10754,"_33":12870},"mfem.mesh.fromBinary","mfem.mesh.fromBinary(data)","Loads a mesh from a base64-encoded binary string.\r","Loads a mesh from a base64-encoded binary string.\r\n\r\nThis is the inverse of . The base64 string is decoded\r\nand parsed as an MFEM format mesh.",[12868],{"_19":528,"_25":12869,"_31":6},"- Base64-encoded string containing mesh data",[],{"_19":12872,"_21":12873,"_23":12874,"_25":12875,"_26":12876,"_32":10754,"_33":12879},"mfem.mesh.fromGmsh","mfem.mesh.fromGmsh(data)","Loads a mesh from a Gmsh format string.\r","Loads a mesh from a Gmsh format string.\r\n\r\nParses mesh data in Gmsh MSH format (versions 2.x and 4.x are supported).\r\nThis is useful for importing meshes created with the Gmsh mesh generator\r\nor exported from other tools in Gmsh format.",[12877],{"_19":528,"_25":12878,"_31":6},"- Gmsh mesh format string (MSH file contents)",[],{"_19":12881,"_21":12882,"_23":12883,"_25":12884,"_26":12885,"_32":10754,"_33":12888},"mfem.mesh.fromMFEM","mfem.mesh.fromMFEM(data)","Loads a mesh from an MFEM native format string.\r","Loads a mesh from an MFEM native format string.\r\n\r\nThis is an alias for provided for API consistency.\r\nMFEM's native mesh format is automatically detected by the parser.",[12886],{"_19":528,"_25":12887,"_31":6},"- MFEM native format mesh string (.mesh file contents)",[],{"_19":12890,"_21":12891,"_23":12892,"_25":12893,"_26":12894,"_32":10754,"_33":12897},"mfem.mesh.fromNetgen","mfem.mesh.fromNetgen(data)","Loads a mesh from a Netgen format string.\r","Loads a mesh from a Netgen format string.\r\n\r\nParses mesh data in Netgen neutral format. MFEM automatically detects\r\nthe format based on file headers:\r\n- 2D meshes typically start with \"areasmesh2\" or \"curved_areamesh2\"\r\n- 3D meshes typically start with \"NETGEN\" or \"NETGEN_Neutral_Format\"",[12895],{"_19":528,"_25":12896,"_31":6},"- Netgen format mesh string",[],{"_19":12899,"_21":12900,"_23":12901,"_25":12902,"_26":12903,"_32":10754,"_33":12906},"mfem.mesh.fromTrueGrid","mfem.mesh.fromTrueGrid(data)","Loads a mesh from a TrueGrid format string.\r","Loads a mesh from a TrueGrid format string.\r\n\r\nParses mesh data in TrueGrid format. MFEM automatically detects\r\nthe format based on file headers. TrueGrid files typically start\r\nwith \"TrueGrid\".",[12904],{"_19":528,"_25":12905,"_31":6},"- TrueGrid format mesh string",[],{"_19":12908,"_21":12909,"_23":12910,"_25":12911,"_26":12912,"_32":10754,"_33":12915},"mfem.mesh.fromVTK","mfem.mesh.fromVTK(data)","Loads a mesh from a VTK format string.\r","Loads a mesh from a VTK format string.\r\n\r\nParses mesh data in VTK legacy format (.vtk). This is useful for importing\r\nmeshes from visualization tools like ParaView or VTK-based applications.",[12913],{"_19":528,"_25":12914,"_31":6},"- VTK legacy format string (.vtk file contents)",[],{"_19":12917,"_21":12918,"_23":12919,"_25":12920,"_26":12921,"_32":612,"_33":12924},"mfem.mesh.getElementCentroids","mfem.mesh.getElementCentroids(mesh)","Computes the centroid (geometric center) of each element in the mesh.\r","Computes the centroid (geometric center) of each element in the mesh.\r\n\r\nThe centroid is the average of the element's vertex coordinates and\r\nrepresents the center of mass assuming uniform density.",[12922],{"_19":6229,"_25":12923,"_31":6},"- The mesh to compute element centroids for",[],{"_19":12926,"_21":12927,"_23":12928,"_25":12929,"_26":12930,"_32":11393,"_33":12933},"mfem.mesh.getElementVolumes","mfem.mesh.getElementVolumes(mesh)","Computes the volume (or area/length) of each element in the mesh.\r","Computes the volume (or area/length) of each element in the mesh.\r\n\r\nReturns the measure of each element according to the mesh dimension:\r\n- 1D: element lengths\r\n- 2D: element areas\r\n- 3D: element volumes\r\n\r\nThis is useful for computing integrals, checking mesh quality,\r\nor applying element-based operations.",[12931],{"_19":6229,"_25":12932,"_31":6},"- The mesh to compute element volumes for",[],{"_19":12935,"_21":12936,"_23":12937,"_25":12937,"_26":12938,"_32":11393,"_33":12946},"mfem.mesh.getNURBSKnotVector","mfem.mesh.getNURBSKnotVector(mesh, patchIdx, dir)","Gets the knot vector for a NURBS patch in a specific direction.",[12939,12940,12943],{"_19":6229,"_25":12858,"_31":6},{"_19":12941,"_25":12942,"_31":6},"patchIdx","- Patch index",{"_19":12944,"_25":12945,"_31":6},"dir","- Direction (0, 1, or 2 for x, y, z)",[],{"_19":12948,"_21":12949,"_23":12950,"_25":12950,"_26":12951,"_32":12954,"_33":12955},"mfem.mesh.getNURBSPatch","mfem.mesh.getNURBSPatch(mesh, patchIdx)","Gets full NURBS patch data including knot vectors.",[12952,12953],{"_19":6229,"_25":12858,"_31":6},{"_19":12941,"_25":12942,"_31":6},"NURBSPatch",[],{"_19":12957,"_21":12958,"_23":12959,"_25":12959,"_26":12960,"_32":12963,"_33":12964},"mfem.mesh.getNURBSPatchInfo","mfem.mesh.getNURBSPatchInfo(mesh, patchIdx)","Gets information about a NURBS patch.",[12961,12962],{"_19":6229,"_25":12858,"_31":6},{"_19":12941,"_25":12942,"_31":6},"NURBSPatchInfo",[],{"_19":12966,"_21":12967,"_23":12968,"_25":12968,"_26":12969,"_32":198,"_33":12971},"mfem.mesh.getNumNURBSPatches","mfem.mesh.getNumNURBSPatches(mesh)","Gets the number of NURBS patches in the mesh.",[12970],{"_19":6229,"_25":12858,"_31":6},[],{"_19":12973,"_21":12974,"_23":12975,"_25":12975,"_26":12976,"_32":62,"_33":12983},"mfem.mesh.insertNURBSKnot","mfem.mesh.insertNURBSKnot(mesh, direction, knot)","Inserts a single knot into a NURBS mesh.",[12977,12978,12980],{"_19":6229,"_25":12858,"_31":6},{"_19":6666,"_25":12979,"_31":6},"- Parametric direction (0=x, 1=y, 2=z)",{"_19":12981,"_25":12982,"_31":6},"knot","- Knot value to insert (must be within the parametric domain)",[],{"_19":12985,"_21":12986,"_23":12987,"_25":12987,"_26":12988,"_32":62,"_33":12994},"mfem.mesh.insertNURBSKnots","mfem.mesh.insertNURBSKnots(mesh, direction, knots)","Inserts multiple knots into a NURBS mesh in a specific direction.",[12989,12990,12991],{"_19":6229,"_25":12858,"_31":6},{"_19":6666,"_25":12979,"_31":6},{"_19":12992,"_25":12993,"_31":6},"knots","- Array of knot values to insert",[],{"_19":12996,"_21":12997,"_23":12998,"_25":12999,"_26":13000,"_32":62,"_33":13006},"mfem.mesh.uniformNURBSRefinement","mfem.mesh.uniformNURBSRefinement(mesh, refFactor?)","Performs uniform refinement on a NURBS mesh.\r","Performs uniform refinement on a NURBS mesh.\r\n\r\nThis inserts new knots uniformly within each existing span, refining\r\nthe NURBS mesh while preserving the geometry exactly.",[13001,13003],{"_19":6229,"_25":13002,"_31":6},"- NURBS mesh to refine",{"_19":13004,"_25":13005,"_31":61},"refFactor","- Refinement factor (1 = 1 new knot per span, etc.)",[],{"_19":13008,"_21":13009,"_23":13010,"_25":13011,"_26":13012,"_32":10754,"_33":13018},"mfem.mesh.makeCartesian1D","mfem.mesh.makeCartesian1D(n, sx?)","Creates a 1D Cartesian (line segment) mesh.\r","Creates a 1D Cartesian (line segment) mesh.\r\n\r\nGenerates a uniform mesh on the interval [0, sx] with `n` line segment elements.\r\nThis is useful for 1D finite element problems like ODEs, 1D heat transfer,\r\nor testing numerical methods.",[13013,13015],{"_19":1516,"_25":13014,"_31":6},"- Number of elements (must be ≥ 1)",{"_19":13016,"_25":13017,"_31":61},"sx","- Domain size / length of the interval (default 1.0)",[],{"_19":13020,"_21":13021,"_23":13022,"_25":13023,"_26":13024,"_32":10754,"_33":13038},"mfem.mesh.makeCartesian2D","mfem.mesh.makeCartesian2D(nx, ny, type?, sx?, sy?)","Creates a 2D Cartesian (rectangular) mesh.\r","Creates a 2D Cartesian (rectangular) mesh.\r\n\r\nGenerates a structured mesh on the rectangular domain [0, sx] × [0, sy]\r\nwith the specified number of elements in each direction.",[13025,13028,13031,13033,13035],{"_19":13026,"_25":13027,"_31":6},"nx","- Number of elements in the x-direction (must be ≥ 1)",{"_19":13029,"_25":13030,"_31":6},"ny","- Number of elements in the y-direction (must be ≥ 1)",{"_19":12423,"_25":13032,"_31":61},"- Element type: `'quad'` for quadrilaterals (default), `'tri'` for triangles",{"_19":13016,"_25":13034,"_31":61},"- Domain size in x-direction (default 1.0)",{"_19":13036,"_25":13037,"_31":61},"sy","- Domain size in y-direction (default 1.0)",[],{"_19":13040,"_21":13041,"_23":13042,"_25":13043,"_26":13044,"_32":10754,"_33":13056},"mfem.mesh.makeCartesian3D","mfem.mesh.makeCartesian3D(nx, ny, nz, type?, sx?, sy?, sz?)","Creates a 3D Cartesian (box) mesh.\r","Creates a 3D Cartesian (box) mesh.\r\n\r\nGenerates a structured mesh on the box domain [0, sx] × [0, sy] × [0, sz]\r\nwith the specified number of elements in each direction.",[13045,13046,13047,13049,13051,13052,13053],{"_19":13026,"_25":13027,"_31":6},{"_19":13029,"_25":13030,"_31":6},{"_19":10053,"_25":13048,"_31":6},"- Number of elements in the z-direction (must be ≥ 1)",{"_19":12423,"_25":13050,"_31":61},"- Element type: `'hex'` for hexahedra (default), `'tet'` for tetrahedra, `'wedge'` for wedges",{"_19":13016,"_25":13034,"_31":61},{"_19":13036,"_25":13037,"_31":61},{"_19":13054,"_25":13055,"_31":61},"sz","- Domain size in z-direction (default 1.0)",[],{"_19":13058,"_21":13059,"_23":13060,"_25":13061,"_26":13062,"_32":10754,"_33":13068},"mfem.mesh.makeCircle","mfem.mesh.makeCircle(npts, radius?)","Creates a 2D circular disk mesh.\r","Creates a 2D circular disk mesh.\r\n\r\nGenerates a triangulated mesh approximating a circular disk by creating a\r\nsquare mesh and applying an elliptic conformal mapping. This mapping\r\npreserves mesh quality while smoothly transforming the square to a circle.\r\n\r\nThe mesh is centered at the origin with the specified radius.",[13063,13066],{"_19":13064,"_25":13065,"_31":6},"npts","- Controls mesh density. Higher values create finer meshes (minimum 3)",{"_19":9737,"_25":13067,"_31":61},"- Radius of the circular disk (default 1.0)",[],{"_19":13070,"_21":13071,"_23":13072,"_25":13073,"_26":13074,"_32":10754,"_33":13081},"mfem.mesh.makeCylinder","mfem.mesh.makeCylinder(npts, length?, radius?)","Creates a 3D solid cy

np.arctan

Syntax

Description

Parameters

Returns