ELF>@@%$ AWAVAUATUSHdH%(H$1HHl$0Ht$0HD$8HFH1HD$DD$@H|$p4AHcH$L|$pEt IcIH$H4H$AHcHD$H$Et IcHHD$H4H|$PAHcHD$HL$PHL$Et IcHHD$D$@+D$DHE1H|$PHD$XH9t HtH$H$H9t HtH|$pHD$xH9t HtH$dH+%(mHL[]A\A]A^A_DLHgDHHQHt$DH9E~]IGH9$AD$D1HfA H $ HH9uDAt AE~ZHCH9D$NAEAD1HfDfHL$HH9uDAt EHD$HPHD$H)HAFD1HfDHL$oHL$H)\$ H9uDAt;H|$IȉH4A4HA9~LALA9~ DADHT$HLD$ Ic1EHHH9t7H $Af.ztHuDL1Hf.Ic1ED@HH9t7HL$f.ztHuDHھHIc1ED@HH9t7HL$H\$ 9 tHuHT$DHfDHHc|$ ID1HT$H|$HH9uf.D1HL$HH9uD1AH $HH9uQHHHf.AWAVAUATUSHdH%(H$1HHl$@Ht$@HD$HHFH1HD$TD$PH$4AHcH$L$Et IcIH$H4H$AHcHD$H$Et IcHHD$H4H|$`AHcHD$HL$`HL$Et IcHHD$D$P+D$THE1H|$`HtHD$hH9tH$H$H9t HtH$H$H9t HtH$dH+%(HL[]A\A]A^A_DLH]DHHGHt$DH/Ht$8HE~XIGH9$iAD$[D1HfA H $ HH9uDAt AE~ZHCH9D$AED1HfDfHL$HH9uDAt EHD$HPHD$H)HAFD1HfDHL$oHL$H)\$ H9uDAt;H|$IȉH4A4HA9~LALA9~ DADD$8HT$HLD$ Ic1E ,fHH9t!H $Af.ztH.Ic1E4f.HH9t!HL$f.ztHIc1E3f.HH9t HL$H\$ 9 tHHHc|$ ID1fHL$HH9u@D1fDAH $HH9uD1fDHT$H|$HH9uHT$DHQDL1HDHھHHHHfAWAVAUATUSHdH%(H$1HHl$@Ht$@HD$HHFH1HD$TD$PH$4AHcH$L$Et IcIH$H4H$AHcHD$H$Et IcHHD$H4H|$`AHcHD$HL$`HL$Et IcHHD$D$P+D$THE1H|$`HtHD$hH9tH$H$H9t HtH$H$H9t HtH$dH+%(HL[]A\A]A^A_DLH]DHHGHt$DH/Ht$8HE~XIGH9$iAD$[D1HfA H $ HH9uDAt AE~ZHCH9D$AED1HfDfHL$HH9uDAt EHD$HPHD$H)HAFD1HfDHL$oHL$H)\$ H9uDAt;H|$IȉH4A4HA9~LALA9~ DADD$8HT$HLD$ Ic1E ,fHH9t!H $Af.ztH.Ic1E4f.HH9t!HL$f.ztHIc1E3f.HH9t HL$H\$ 9 tHHHc|$ ID1fHL$HH9u@D1fDAH $HH9uD1fDHT$H|$HH9uHT$DHQDL1HDHھHHHHfAWAVAUATUS1HdH%(H$1HHl$ Ht$ HD$(HFH1HD$4D$0H|$@4AHcLt$@EtIcIƾH4H$AHcH$L$Et IcIH$D$0+D$4}HE1H$HtH$H9tH|$@HD$HH9t HtH$dH+%(wHL[]A\A]A^A_@DLHHt$HjDLHTHD$HHHD$7E~WIFH9AD$D1HfA  HH9uDAt AE~WIGH9$AE D1HfAH $HH9uDAt AHL$t$LLD$Ic1E,fDHH9tAf.ztHIc1E0fDHH9t!H $Af.ztHHt$HHc|$I@D$HD1fDAH $HH9u D1fDAHH9uDLHYDL1HHHDAWAVAUATUS1HdH%(H$1HHl$ Ht$ HD$(HFH1HD$4D$0H|$@4AHcLt$@EtIcIƾH4H$AHcH$L$Et IcIH$D$0+D$4}HE1H$H$H9t HtH|$@HD$HH9t HtH$dH+%(\HL[]A\A]A^A_@DLHHt$HjDLHTHt$H?Ht$H*E~ZIFH9xAD$jD1Hf.fA  HH9uDAt AE~WIGH9$AED1HfAH $HH9uDAt AD$L$LLt$D$ Ic1E 'HH9tAf.ztHIc1E,fDHH9tH $Af.ztHtkHHc|$ ID1DAH $HH9u1D1fDAHH9uDLHDL1H3HHUH@dH%(HD$81HHt$HD$HFHD$$D$ t0H|$1HT$8dH+%(uhH@]@HT$H|$H5|$HtHt+HH5HPtHuH1Huff.fHHdH%(HD$81HHt$HD$HFHD$$D$ t1H|$1HT$8dH+%(u@HHfDHt$H|$tD$HuHHfDSH0dH%(HD$(1HH4$HD$HFHD$D$t*H111HT$(dH+%(u1H0[fDfH~I1MufHnff.AWAVAUATUSHdH%(H$HFHHl$PHt$PHD$XHHD$hHD$`H$4AHcH$L$EH4H$AHcHD$H$EaH4H|$pAHcHD$HL$pHL$ED$`+D$d!HE1H|$pHD$xH9t HtH$H$H9t HtH$H$H9tHt H$dH+%(2HL[]A\A]A^A_@H$dH+%(HHH[H=]A\A]A^A_fDH5E1zf.IcHHD$D$`+D$dHt$8HHt$@HHt$HHDLHDHHHt$DHnE~YIGH9$AD$D1H@fAH $HH9uDAt AE~ZHCH9D$&AED1HfDf$HL$$HH9uDAt EHD$HPHD$H)HAFD1HfDHL$o,HL$,H)l$ H9uDAt;H|$IH 4A4PA9~TAT A9~ DAD HT$T$HHLL$@D$8D$ Ic1E0fDHH9t!H $Af.ztHTIc1E4f.HH9t!HL$f.ztH,Ic1E3f.HH9t HL$H\$ 9 tHHHc|$ IIcHHD$IcIH$:D1HL$HH9uD1AH $HH9uD1HT$H|$HH9uiHT$DH0DLHDHھHHHHff.AWAVAUATUSHhdH%(H$X1HHl$`H|$`HD$hHGHHD$tD$pH$4AHcH$H$Et IcHH$H4H$AHcH$HD$HL$ Et IcHHD$H4H$ AHcH$ HD$HT$(Et IcHHD$H4H$AHcH$HD$HL$0Et IcHHD$D$p+D$tHE1H$H$H9t HtH$ H$(H9t HtH$HtH$H9tH$H$H9t HtH$XdH+%(HhL[]A\A]A^A_fDHt$@H:Ht$HH%Ht$PHHt$XHDHHHt$ DHHt$(DHHt$0DHE~]H $HCH9AD$zD1Hf$$HH9uDAtH$E~iHL$ Ht$HAH9AED1Hf,,HH9uDAtHT$ HT$E~kHL$(Ht$HAH9dAFWD1Hf.f44HH9uDAtHT$(HT$EHL$0Ht$HQHH)HAGD1HfDo<<HH9uDAt=H|$0LD$H4A4HA9~LALA9~ DADHL$0HT$(HHt$ \$XT$PL$HD$@D$HH D1AH<$HH9uD1f.AHH9uQDLH[DLH HHf.ATL%H \HH5LuLHLA\ATIUHHt HH5LHtHmtH]A\HH]A\SolveQuadraticTartagliaCardanSolveFerrariSolveLinBairstowSolveFilterRootsSafeDownCastvtkObjectBaseSetDivisionToleranceGetDivisionToleranceSolveCubicp_voidSturmBisectionSolveHabichtBisectionSolveIsTypeOfIsANewInstanceSolveLineardddPPP *d *d *iH|$PHD$XH9t HtH$H$H9t HtH|$pHD$xH9t HtHH|$`HD$hH9t HtH$H$H9t HtH$H$H9t HtHH|$`HD$hH9t HtH$H$H9t HtH$H$H9t HtHH$H$H9t HtH|$@HD$HH9t HtHH$H$H9t HtH|$@HD$HH9t HtHH|$pHtHD$xH9tH$H$H9t HtH$H$H9t HtHH$H$H9t HtH$ H$(H9t HtH$H$H9t HtH$H$H9t HtHH$HtH$H9tH$H$H9t HtH|$pHD$xH9t HtHH$H$H9t HtH$HtH$H9tH|$pHtHD$xH9tHH$H$H9t HtH$H$H9t HtH|$pHtHD$xH9tHH$HtH$H9tH$H$H9t HtH|$pHD$xH9t HtHH$H$H9t HtH$HtH$H9tH|$pHtHD$xH9tHH$H$H9t HtH$H$H9t HtH|$pHtHD$xH9tHH|$@HD$HH9t HtH|$`HD$hH9t HtHT   TT   ZT   ZV;V;"n    ZS qMz 7ZqMz 7ZA  5vtkPolynomialSolversUnivariatevtkPolynomialSolversUnivariate - polynomial solvers Superclass: vtkObject vtkPolynomialSolversUnivariate provides solvers for univariate polynomial equations with real coefficients. The Tartaglia-Cardan and Ferrari solvers work on polynomials of fixed degree 3 and 4, respectively. The Lin-Bairstow and Sturm solvers work on polynomials of arbitrary degree. The Sturm solver is the most robust solver but only reports roots within an interval and does not report multiplicities. The Lin-Bairstow solver reports multiplicities. For difficult polynomials, you may wish to use FilterRoots to eliminate some of the roots reported by the Sturm solver. FilterRoots evaluates the derivatives near each root to eliminate cases where a local minimum or maximum is close to zero. @par Thanks: Thanks to Philippe Pebay, Korben Rusek, David Thompson, and Maurice Rojas for implementing these solvers. vtkCommonMathPython.vtkPolynomialSolversUnivariateV.IsTypeOf(string) -> int C++: static vtkTypeBool IsTypeOf(const char *type) Return 1 if this class type is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. V.IsA(string) -> int C++: vtkTypeBool IsA(const char *type) override; Return 1 if this class is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. V.SafeDownCast(vtkObjectBase) -> vtkPolynomialSolversUnivariate C++: static vtkPolynomialSolversUnivariate *SafeDownCast( vtkObjectBase *o) V.NewInstance() -> vtkPolynomialSolversUnivariate C++: vtkPolynomialSolversUnivariate *NewInstance() V.HabichtBisectionSolve([float, ...], int, [float, ...], [float, ...], float) -> int C++: static int HabichtBisectionSolve(double *P, int d, double *a, double *upperBnds, double tol) V.HabichtBisectionSolve([float, ...], int, [float, ...], [float, ...], float, int) -> int C++: static int HabichtBisectionSolve(double *P, int d, double *a, double *upperBnds, double tol, int intervalType) V.HabichtBisectionSolve([float, ...], int, [float, ...], [float, ...], float, int, bool) -> int C++: static int HabichtBisectionSolve(double *P, int d, double *a, double *upperBnds, double tol, int intervalType, bool divideGCD) Finds all REAL roots (within tolerance tol) of the d -th degree polynomial\[ P[0] X^d + ... + P[d-1] X + P[d]\] in ] a[0] ; a[1]] using the Habicht sequence (polynomial coefficients are REAL) and returns the count nr. All roots are bracketed in the r first ] upperBnds[i] - tol ; upperBnds[i]] intervals. Returns -1 if anything went wrong (such as: polynomial does not have degree d, the interval provided by the other is absurd, etc.). * intervalType specifies the search interval as follows: * 0 = 00 = ]a,b[ * 1 = 10 = [a,b[ * 2 = 01 = ]a,b] * 3 = 11 = [a,b] * This defaults to 0. * The last non-zero item in the Habicht sequence is the gcd of P and P'. The * parameter divideGCD specifies whether the program should attempt to divide * by the gcd and run again. It works better with polynomials known to have * high multiplicities. When divideGCD != 0 then it attempts to divide by the * GCD, if applicable. This defaults to 0. * Compared to the Sturm solver the Habicht solver is slower, * although both are O(d^2). The Habicht solver has the added benefit * that it has a built in mechanism to keep the leading coefficients of the * result from polynomial division bounded above and below in absolute value. * This will tend to keep the coefficients of the polynomials in the sequence * from zeroi ... [Truncated] V.SturmBisectionSolve([float, ...], int, [float, ...], [float, ...], float) -> int C++: static int SturmBisectionSolve(double *P, int d, double *a, double *upperBnds, double tol) V.SturmBisectionSolve([float, ...], int, [float, ...], [float, ...], float, int) -> int C++: static int SturmBisectionSolve(double *P, int d, double *a, double *upperBnds, double tol, int intervalType) V.SturmBisectionSolve([float, ...], int, [float, ...], [float, ...], float, int, bool) -> int C++: static int SturmBisectionSolve(double *P, int d, double *a, double *upperBnds, double tol, int intervalType, bool divideGCD) Finds all REAL roots (within tolerance tol) of the d -th degree polynomial P[0] X^d + ... + P[d-1] X + P[d] in ] a[0] ; a[1]] using Sturm's theorem ( polynomial coefficients are REAL ) and returns the count nr. All roots are bracketed in the r first ] upperBnds[i] - tol ; upperBnds[i]] intervals. Returns -1 if anything went wrong (such as: polynomial does not have degree d, the interval provided by the other is absurd, etc.). * intervalType specifies the search interval as follows: * 0 = 00 = ]a,b[ * 1 = 10 = [a,b[ * 2 = 01 = ]a,b] * 3 = 11 = [a,b] * This defaults to 0. * The last non-zero item in the Sturm sequence is the gcd of P and P'. The * parameter divideGCD specifies whether the program should attempt to divide * by the gcd and run again. It works better with polynomials known to have * high multiplicities. When divideGCD != 0 then it attempts to divide by the * GCD, if applicable. This defaults to 0. * Constructing the Sturm sequence is O(d^2) in both time and space. * Warning: it is the user's responsibility to make sure the upperBnds * array is large enough to contain the maximal number of expected roots. * Note that nr is smaller or equal to the actual number of roots in * ] a[0] ; a[1]] since roots within \tol are lumped in the same bracket. * array is large enough to contain the ma ... [Truncated] V.FilterRoots([float, ...], int, [float, ...], int, float) -> int C++: static int FilterRoots(double *P, int d, double *upperBnds, int rootcount, double diameter) This uses the derivative sequence to filter possible roots of a polynomial. First it sorts the roots and removes any duplicates. If the number of sign changes of the derivative sequence at a root at upperBnds[i] == that at upperBnds[i] - diameter then the i^th value is removed from upperBnds. It returns the new number of roots. V.LinBairstowSolve([float, ...], int, [float, ...], float) -> int C++: static int LinBairstowSolve(double *c, int d, double *r, double &tolerance) Seeks all REAL roots of the d -th degree polynomial c[0] X^d + ... + c[d-1] X + c[d] = 0 equation Lin-Bairstow's method ( polynomial coefficients are REAL ) and stores the nr roots found ( multiple roots are multiply stored ) in r.tolerance is the user-defined solver tolerance; this variable may be relaxed by the iterative solver if needed. Returns nr. Warning: it is the user's responsibility to make sure the r array is large enough to contain the maximal number of expected roots. V.FerrariSolve([float, ...], [float, ...], [int, ...], float) -> int C++: static int FerrariSolve(double *c, double *r, int *m, double tol) Algebraically extracts REAL roots of the quartic polynomial with REAL coefficients X^4 + c[0] X^3 + c[1] X^2 + c[2] X + c[3] and stores them (when they exist) and their respective multiplicities in the r and m arrays, based on Ferrari's method. Some numerical noise can be filtered by the use of a tolerance tol instead of equality with 0 (one can use, e.g., VTK_DBL_EPSILON). Returns the number of roots. Warning: it is the user's responsibility to pass a non-negative tol. V.TartagliaCardanSolve([float, ...], [float, ...], [int, ...], float) -> int C++: static int TartagliaCardanSolve(double *c, double *r, int *m, double tol) Algebraically extracts REAL roots of the cubic polynomial with REAL coefficients X^3 + c[0] X^2 + c[1] X + c[2] and stores them (when they exist) and their respective multiplicities in the r and m arrays. Some numerical noise can be filtered by the use of a tolerance tol instead of equality with 0 (one can use, e.g., VTK_DBL_EPSILON). The main differences with SolveCubic are that (1) the polynomial must have unit leading coefficient, (2) complex roots are discarded upfront, (3) non-simple roots are stored only once, along with their respective multiplicities, and (4) some numerical noise is filtered by the use of relative tolerance instead of equality with 0. Returns the number of roots. In memoriam Niccolo Tartaglia (1500 - 1559), unfairly forgotten. V.SolveCubic(float, float, float, float) -> (float, ...) C++: static double *SolveCubic(double c0, double c1, double c2, double c3) V.SolveCubic(float, float, float, float, [float, ...], [float, ...], [float, ...], [int, ...]) -> int C++: static int SolveCubic(double c0, double c1, double c2, double c3, double *r1, double *r2, double *r3, int *num_roots) Solves a cubic equation c0*t^3 + c1*t^2 + c2*t + c3 = 0 when c0, c1, c2, and c3 are REAL. Solution is motivated by Numerical Recipes In C 2nd Ed. Return array contains number of (real) roots (counting multiple roots as one) followed by roots themselves. The value in roots[4] is a integer giving further information about the roots (see return codes for int SolveCubic() ). V.SolveQuadratic(float, float, float) -> (float, ...) C++: static double *SolveQuadratic(double c0, double c1, double c2) V.SolveQuadratic(float, float, float, [float, ...], [float, ...], [int, ...]) -> int C++: static int SolveQuadratic(double c0, double c1, double c2, double *r1, double *r2, int *num_roots) V.SolveQuadratic([float, ...], [float, ...], [int, ...]) -> int C++: static int SolveQuadratic(double *c, double *r, int *m) Solves a quadratic equation c0*t^2 + c1*t + c2 = 0 when c0, c1, and c2 are REAL. Solution is motivated by Numerical Recipes In C 2nd Ed. Return array contains number of (real) roots (counting multiple roots as one) followed by roots themselves. Note that roots[3] contains a return code further describing solution - see documentation for SolveCubic() for meaning of return codes. V.SolveLinear(float, float) -> (float, ...) C++: static double *SolveLinear(double c0, double c1) V.SolveLinear(float, float, [float, ...], [int, ...]) -> int C++: static int SolveLinear(double c0, double c1, double *r1, int *num_roots) Solves a linear equation c0*t + c1 = 0 when c0 and c1 are REAL. Solution is motivated by Numerical Recipes In C 2nd Ed. Return array contains number of roots followed by roots themselves. V.SetDivisionTolerance(float) C++: static void SetDivisionTolerance(double tol) Set/get the tolerance used when performing polynomial Euclidean division to find polynomial roots. This tolerance is used to decide whether the coefficient(s) of a polynomial remainder are close enough to zero to be neglected. V.GetDivisionTolerance() -> float C++: static double GetDivisionTolerance() Set/get the tolerance used when performing polynomial Euclidean division to find polynomial roots. This tolerance is used to decide whether the coefficient(s) of a polynomial remainder are close enough to zero to be neglected. vtkObjectUH=Hu]ÐHH=tH]HHHD!!GCC: (Ubuntu 11.4.0-1ubuntu1~22.04) 11.4.0GNUzRx  0 zPLRx P$6FBB B(A0A8G 8D0A(B BBBD xYP^FBB B(A0A8G 8D0A(B BBBH _P^FBB B(A0A8G 8D0A(B BBBH h_PFBB B(A0A8I' 8D0A(B BBBE @PFBB B(A0A8I' 8D0A(B BBBE X@ EDPa AE HPa G ED@W AG hBFBB B(A0A8G 8D0A(B BBBE ^ 8G0H(B BBBK L_PpLBGB B(A0A8G 8D0A(B BBBG ,(RED`H AF  DE LFBB B(A0A8G[ 8D0A(B BBBC hLFBB B(A0A8G[ 8D0A(B BBBC @<EY B W(`EAD`j AAJ 0^FAA D`  AABH gFD@ EE ED`e AA LFBB B(A0A8GQ 8A0A(B BBBH :|MFF0OFDD n ABA DDBN   26 v YP^ Y_R ^ _ @` W@ pg B`, _r L `'RL( zP8% rGH^0Jg!KeL :?w |  $ 1 B N [ i ~            2 " n !      7 W      u   5 x    4 n    & 5 q    (g>W"<EWm%QMO^sQO(@Uj}_ZL42PyvtkPolynomialSolversUnivariate_StaticNewv_ZL50PyvtkPolynomialSolversUnivariate_SolveQuadratic_s3P7_objectS0__ZL50PyvtkPolynomialSolversUnivariate_SolveQuadratic_s3P7_objectS0_.cold_ZL53PyvtkPolynomialSolversUnivariate_TartagliaCardanSolveP7_objectS0__ZL53PyvtkPolynomialSolversUnivariate_TartagliaCardanSolveP7_objectS0_.cold_ZL45PyvtkPolynomialSolversUnivariate_FerrariSolveP7_objectS0__ZL45PyvtkPolynomialSolversUnivariate_FerrariSolveP7_objectS0_.cold_ZL49PyvtkPolynomialSolversUnivariate_LinBairstowSolveP7_objectS0__ZL49PyvtkPolynomialSolversUnivariate_LinBairstowSolveP7_objectS0_.cold_ZL44PyvtkPolynomialSolversUnivariate_FilterRootsP7_objectS0__ZL44PyvtkPolynomialSolversUnivariate_FilterRootsP7_objectS0_.cold_ZL45PyvtkPolynomialSolversUnivariate_SafeDownCastP7_objectS0__ZL53PyvtkPolynomialSolversUnivariate_SetDivisionToleranceP7_objectS0__ZL53PyvtkPolynomialSolversUnivariate_GetDivisionToleranceP7_objectS0__ZL47PyvtkPolynomialSolversUnivariate_SolveQuadraticP7_objectS0__ZL55PyvtkPolynomialSolversUnivariate_SolveQuadratic_Methods_ZL47PyvtkPolynomialSolversUnivariate_SolveQuadraticP7_objectS0_.cold_ZL46PyvtkPolynomialSolversUnivariate_SolveCubic_s2P7_objectS0_.constprop.0_ZL46PyvtkPolynomialSolversUnivariate_SolveCubic_s2P7_objectS0_.constprop.0.cold_ZL43PyvtkPolynomialSolversUnivariate_SolveCubicP7_objectS0__ZL52PyvtkPolynomialSolversUnivariate_SturmBisectionSolveP7_objectS0__ZL52PyvtkPolynomialSolversUnivariate_SturmBisectionSolveP7_objectS0_.cold_ZL54PyvtkPolynomialSolversUnivariate_HabichtBisectionSolveP7_objectS0__ZL54PyvtkPolynomialSolversUnivariate_HabichtBisectionSolveP7_objectS0_.cold_ZL41PyvtkPolynomialSolversUnivariate_IsTypeOfP7_objectS0__ZL36PyvtkPolynomialSolversUnivariate_IsAP7_objectS0__ZL44PyvtkPolynomialSolversUnivariate_NewInstanceP7_objectS0__ZL50PyvtkPolynomialSolversUnivariate_SolveQuadratic_s1P7_objectS0__ZL44PyvtkPolynomialSolversUnivariate_SolveLinearP7_objectS0__ZL44PyvtkPolynomialSolversUnivariate_SolveLinearP7_objectS0_.cold_ZL37PyvtkPolynomialSolversUnivariate_Type_ZL40PyvtkPolynomialSolversUnivariate_Methods_GLOBAL__sub_I_vtkPolynomialSolversUnivariatePython.cxx.LC0.LC2.LC4.LC6.LC8.LC10.LC11.LC12.LC13.LC14.LC15.LC17.LC19.LC20.LC21.LC22.LC23.LC25.LC28.LC27.LC29.LC30.LC31.LC32.LC34_ZN30vtkPolynomialSolversUnivariate3NewEv_ZNK30vtkPolynomialSolversUnivariate19NewInstanceInternalEvDW.ref.__gxx_personality_v0_ZN13vtkPythonArgs10GetArgSizeEi_ZN13vtkPythonArgs5ArrayIdEC1El_ZN13vtkPythonArgs5ArrayIiEC1El_ZN13vtkPythonArgs13ArgCountErrorEii_ZdaPv_ZN13vtkPythonArgs8GetArrayEPdi_ZN13vtkPythonArgs8GetArrayEPii_ZN30vtkPolynomialSolversUnivariate14SolveQuadraticEPdS0_PiPyErr_Occurred_ZN13vtkPythonArgs8SetArrayEiPKdi_ZN13vtkPythonArgs8SetArrayEiPKiiPyLong_FromLong__stack_chk_fail_Unwind_Resume_ZN13vtkPythonArgs8GetValueERd_ZN30vtkPolynomialSolversUnivariate20TartagliaCardanSolveEPdS0_Pid_ZN30vtkPolynomialSolversUnivariate12FerrariSolveEPdS0_Pid_ZN13vtkPythonArgs8GetValueERi_ZN30vtkPolynomialSolversUnivariate16LinBairstowSolveEPdiS0_Rd_ZN13vtkPythonArgs11SetArgValueEid_ZN30vtkPolynomialSolversUnivariate11FilterRootsEPdiS0_id_ZN13vtkPythonArgs17GetArgAsVTKObjectEPKcRb_ZN13vtkPythonUtil20GetObjectFromPointerEP13vtkObjectBase_ZN30vtkPolynomialSolversUnivariate20SetDivisionToleranceEd_GLOBAL_OFFSET_TABLE__Py_NoneStruct_ZN30vtkPolynomialSolversUnivariate20GetDivisionToleranceEvPyFloat_FromDouble_ZN17vtkPythonOverload10CallMethodEP11PyMethodDefP7_objectS3__ZN13vtkPythonArgs13ArgCountErrorEiPKc_ZN30vtkPolynomialSolversUnivariate14SolveQuadraticEdddPdS0_Pi_ZN30vtkPolynomialSolversUnivariate10SolveCubicEddddPdS0_S0_Pi_ZN30vtkPolynomialSolversUnivariate10SolveCubicEdddd_ZN13vtkPythonUtil13ManglePointerEPKvPKcPyUnicode_FromString_ZN30vtkPolynomialSolversUnivariate19SturmBisectionSolveEPdiS0_S0_di_ZN13vtkPythonArgs8GetValueERb_ZN30vtkPolynomialSolversUnivariate19SturmBisectionSolveEPdiS0_S0_dib_ZN30vtkPolynomialSolversUnivariate19SturmBisectionSolveEPdiS0_S0_d_ZN30vtkPolynomialSolversUnivariate21HabichtBisectionSolveEPdiS0_S0_di_ZN30vtkPolynomialSolversUnivariate21HabichtBisectionSolveEPdiS0_S0_dib_ZN30vtkPolynomialSolversUnivariate21HabichtBisectionSolveEPdiS0_S0_d_ZN30vtkPolynomialSolversUnivariate3IsAEPKcstrcmp_ZN13vtkObjectBase8IsTypeOfEPKc_ZN13vtkPythonArgs8GetValueERPc_ZN13vtkPythonArgs19GetSelfFromFirstArgEP7_objectS1_PyVTKObject_CheckPyVTKObject_GetObjectPyVTKObject_SetFlag_ZN30vtkPolynomialSolversUnivariate14SolveQuadraticEddd_ZN30vtkPolynomialSolversUnivariate11SolveLinearEdd_ZN30vtkPolynomialSolversUnivariate11SolveLinearEddPdPiPyvtkPolynomialSolversUnivariate_ClassNewPyVTKClass_AddPyvtkObject_ClassNewPyType_ReadyPyVTKAddFile_vtkPolynomialSolversUnivariatePyDict_SetItemString_Py_DeallocPyType_TypePyVTKObject_DeletePyVTKObject_ReprPyVTKObject_StringPyObject_GenericGetAttrPyObject_GenericSetAttrPyVTKObject_AsBufferPyVTKObject_TraversePyVTKObject_GetSetPyVTKObject_NewPyObject_GC_Del;-eIxJIJIKAL]M|MMNNOPQR Q%R\QvSQTU{.IJIJ-I@KLMMM"N8NPOeXY Q] Q Q Q TO Sd R| R U / I JH I^ J I K L M" MA M N N O XJZ}QQQ QTSRRU=0gIzJIJLM,MjN[NX\QQQ Q T?]RRU 17IJJhI~JLMM:NO[eNz[Xk^QQQTXRjRtU2L 3_+4:QG`SQ_U5LXaQ *cU<6fLdQeU-7/IEJkIJIKLM5MTM,-gX+X@XVNlNOhMQQQQTSURR< 8d Iz J I J I!J;!IQ!K!L!M!M!M"MY"Xn"X"X"X"N"N"N"O%iH%Q%Q%Q&Q&Q#&T&U&S&R 'R#'R'8'g'8'9'X'X (X(X@(jH(Q`(:e(km(l(*c(U);)gC);[)7p)I)J)I)J)I)JD*LS*;k*<*I*J*I*J*I +JT+Lv+M+;+=+I+J,I%,JL,Ib,J,L,M,M-M-N-[-N-N.X'.[/m/Q/Q80QF0QY0Tr0N0[0N0N0X0[0nB2oy2Q2Q2Q3Q3T23NG3[]3Nu3N3X4p5QX5Q5Q5Q5Te6R6U6R6R6R~7R7R7R7R7R8>8g8>879I9J79IM9Jt9I9J9L9>9<:I#:JG:I]:J:I:J:L;M;;>S;=h;I{;J;I;J;I;JA<Lc<M<M<MJ=N_=[u=N=N=X=[?qI?Q?Q?Q?Q?T@N@[-@NE@NZ@Xo@[@nAr BQHBQBQBQBTBNB[BNCNCXpDsDQDQ(EQ6EQIETERHFUXFRrFRFRGR#GR8GRPGRjGRG?:HLmHw}H4HuH@HuHQHTHvHUHAVILIxIwI*tI4IuI@IuIQITJv*JURJBJLJxJ*GJFK4KQ$K`8KyHKzeK{tKQKUK-KLLX/LX@LX[L|cLQwL:|LkLlL*cLULCLg+MCIMD[MXlMXM}MQM:MkMlMCM9MINJ#NI6NKkNLNMNMNXNXON&OO4P~iPQPQPQPTP*cHQS`QRjQUQ+Q4Q,QQ+QQ+QQQ4 RF*46B  U n 2Srf4'O@'0L'X'77v88S8'8438?8K8r{GGGGpGGQG0GGvQQ+RFM4MMMUWnMMMWMM MW2MKMSWrMMWMMMWM0MOMnMvWMMMWMM,M4WSMrMMWMMMWM0MIMQWpMMMWMMW4u&@+u8vE+)0X8@G (H8@NHX`h0JxpP8(Bh1`$  (P8X@H`'X!`hx#L0'ip(~ *K(8V 4SHhqP#4Y=>X aFai$-~HQWp $- ,`'\(ezoP8x )D dGH0JK L\e QQ).symtab.strtab.shstrtab.rela.text.data.bss.rela.text._ZNK30vtkPolynomialSolversUnivariate19NewInstanceInternalEv.rodata.str1.1.rela.text.unlikely.gcc_except_table.rodata.str1.8.rodata._ZN30vtkPolynomialSolversUnivariate3IsAEPKc.str1.1.rela.text._ZN30vtkPolynomialSolversUnivariate3IsAEPKc.rela.text.startup.rela.init_array.rela.data.rel.rela.data.rel.local.rodata.cst8.rela.data.rel.local.DW.ref.__gxx_personality_v0.comment.note.GNU-stack.note.gnu.property.rela.eh_frame.group@ "GL "tX "H p/R@0"&R,R6R 1@0"x2RS@H" X2ZI+2 <@Xx"3P.@0"FhA@"W R@ "f ` a@8"v(@"0,܊ @("  #F x