What's new in Maple: Release 9.5 Michael Monagan (CECM) and Allan Wittkopf (Maplesoft) Presented at CECM day '04, July 29th, 2004, SFU, Burnaby, British ColumbiaPrepared from Maple 9* and Maple 9.5 ISSAC presentation worksheets of Juergen Gerhard.

GMP library for fast arbitrary precision arithmetic 3^1000000;Maple 8: 2.05 Karatsuba Maple 9: 0.41 FFTnextprime(10^1000);Maple 8: 242.6 Maple 9: 10.95 f := 3^100000: h := irem(5^80000,f): gcd(f,h);Maple 8: 16.3 Euclidean algorithm Maple 9: 0.36 Binary Lehmer algorithm

In general an optimization problem is of the form NiMqJiUkbWluRyIiIi0lImZHNiMlInhHRiU= for NiNJInhHNiI= in NiMpJSJSRyUibkc= subject to NiMxLSYlImNHNiMlImlHNiMlInhHIiIh, dj(x) = 0The optimization package handles several types of objective and constraint functions.with(Optimization);

For a first example we have a simple two dimensional linear programming problem: NiMsKCUkbWluRyIiIiomIiIjRiUlInhHRiUhIiIlInlHRik= subject to NiMxSSJ5RzYiLCYqJi1JJkZsb2F0R0kqcHJvdGVjdGVkR0YqNiQiI1YhIiIiIiJJInhHRiVGLkYuKiZGLkYuIiIjRi1GLg==, NiMxJSJ5RywmKiYiIiYiIiIlInhHRighIiIiIiNGKA==, NiMxIiIhJSJ4Rw==, NiMxIiIhJSJ5Rw==obj := -2*x-y; consts := [y<=4.3*x+1/2,y<=-5*x+2,x>=0,y>=0];The plot below shows the feasible region and the contours of the objective function. The location of the optimal solution is indicated by a blue circle.p1 := plots[inequal](consts, x=-0.5..1, y=-0.5..2, optionsexcluded=(color=white), optionsfeasible=(color=yellow)): p2 := plots[contourplot](obj, x=-0.5..1, y=-0.5..2): p3 := plots[pointplot]({[.1612903225806451,1.193548387096774]}, symbolsize=15, color=blue, symbol=circle): plots[display](p1,p2,p3);The LPSolve command returns the optimal function values as well as the point at which the optimal value occurs.LPSolve(obj,consts);The first element of the solution is the minimum value that the objective function obtains while satisfying the constraints. The second element indicates a point where the minimum is reached. This point is not necessarily unique.We can also run the commands using arbitrary precision, which is not possible using Matlab or pure NAG routines. Digits := 50; LPSolve(obj,consts[1..2],assume=nonnegative); Digits := 10:

For a first example of a quadratic program we will use: min NiMsKiomIiIlIiIiKiQlInhHIiIjRiZGJiUieUchIiJGKEYmIiImRiY= subject to NiMxLCQiIzYhIiIsKCUieEciIiIlInlHRikqJiIiKEYpRihGKUYm, NiMxLCYqKCIjNiIiIiIiIyEiIiUieEdGJ0YnJSJ5R0YnIiIh, NiMxLCQiIiUhIiIlInhH obj := 4*x^2-y+x+5; consts := [x+y-7*x>=-11,11/2*x+y<=0,x>=-4];The plot below shows the feasible region and the contours of the objective function. The blue circle indicates the optimal point.p1 := plots[contourplot](obj, x=-4..4, y=-10..10, contours=30): p2 := plots[inequal](consts, x=-4..4, y=-10..10, optionsexcluded=(color=white), optionsfeasible=(color=yellow)): p3 := plots[pointplot]({[-0.8125,4.486]}, symbolsize=15, color=blue, symbol=circle): plots[display](p1,p2,p3);The QPSolve command returns the optimal function values as well as the point at which the optimal value occurs.QPSolve(obj, consts);

LSSolve([x^3-2,x^2-6,x^2-9]);

Non-linear optimization finds local minima of a wide range of univariate and multivariate functions. For our first example, we will minimize f := sin(x);on NiMvSSJ4RzYiOyIiIiIjNQ== using the commandNLPSolve(f,x=1..10);Below we can see a plot of the function and a blue circle at the above point.p1 := plot(f,x=1..10): p2 := plots[pointplot]([[4.7123,-1]], color=blue, symbolsize=15, symbol=circle): plots[display](p1,p2);The next function, which can be evaluated using evalhf, can be minimized quickly.f := x*erf(x)*cos(x);s := NLPSolve(f,x=1..20);p1 := plot(f,x=1..20): p2 := plots[pointplot]([[rhs(s[2][1]),s[1]]], color=blue, symbol=circle, symbolsize=15): plots[display](p1,p2);We can see that this has only found a local minimum and not the global minimum. f := (x-1)^2 + (x-y)^2 + (y-z)^4;consts := {x*(1+y^2)+z^4=8.24264};r := NLPSolve(f, consts, assume=nonnegative);

f := 1+(x-1)^2+(y-3)^2;Optimization[Interactive](f);

DAE problems are ODE system problems that are coupled with algebraic problems in the differential variables. Maple now has three DAE solvers:The Modified Extended Backward Differentiation Formula Implicit solver (mebdfi), for solution of implicit DAE systems, and two modified standard solvers rkf45_dae and rosenbrock_dae, for stiff and non-stiff problems respectively.Car Axis Problem: This problem models the behavior of car suspension when travelling over a rough road. There are 4 differential equations and 2 difficult (high index) constraints.MFNWtKUb<ob<R=MDLCdNNZIk:dY>D:;R^OtI?]ZRLCTJcDXoXuuvXcTOiXaIxUGggmfKUVMAw<Ub@]F]=Ce;HEyD@[td;g[of\\WV?OijeGGer`KbPyRTOSM=rOITU[HS=G]Ovb;hTCV\\mT[]cRot<OUUcBTQCbKfp?t_;WwEtJ]f>Gw^KEPUIWocmYeuwFamsVmUQWyvsvVysaycuoGqIXhIvVgiqyxqiuygyr=w;YbAk@SSmyHVM:ew:>bg]JWA^tHZo<JbZN]J;J:PE:[thwDdWgeWETKEF?X`KXTKXl[d[>duv[MQuTQuLQtlfhdad]^mF`m@WiuWqVP\\?A;Pus]khqwhQj<PjOTOP=MaalLXlMhvN`v>AOCCNxVb`of`kIxky]vKxRFdXPMXDMX\\]l^BduvSKcDOc\\Of\\_cpmTlMSlMVRYaJs=[TQuTAuRAUEGAuCKXDMX\\exoixNkN:lj_=kSmSnhn_hNv\\QvxveiKGdKquwXiqquwX`QY]qrEXeUWeikUtPTQuTqnTIMfyobXnCytQaoSUnXELMqXZAr;hsUxPqYxgDQkDQwHQmmvJmm:>vgau\\qsWXaIgaoadIGhtxiyqy<ijEVlMXlUV]UvuswvWpkHp[sYx]ykynap_wRAfyOnsHqSo]_YwcHocPuBWckfgcIwciyyGdH_cHwk<a:;fpmwlWVAqcXwGDwCMaEOYVIgIP]UV]gxaYnItAUv]YvOYwuoXgQYbIfA_eSwFZkfJ]wZuTQuTF]SFAsKWFosSSWdMWHZIfteIw>rZ^[kvwcXkffbAwbewiPitOioTgpDgaQQy[fjr@qrFivOxCy^A^aZPaTysxoxmFaHplZ^awOynOcDOsZw[?Jvhma=YVqk``Y_eV_EV[EVwtQPAtJAlPpl`av;dWpIvjLU<ySWlPlLPl=pAP:KomAkkXlAAkB@kXxWceuUpStirvayveWr\\SMUTM]SF]k`mv@dXb>Z:PuGNmFasFqiXiqtgxdOf\\On`gxTXmUhbq`tmQuTU\\arCoSxQSauVagsxCg:eySQtLQhnEwLewWqYHctyIw;>OaD]yrIwikUv@oyOOtLQtSSH`=ufYcamEukXFUs[iXquXEyFOOxO]TN=ufYCTMwy?ieuth_f^_FGmCoacTcHDUYhsbOSHaGyvoUIcfJweMWt]?P:<PflnSdnLlLPlTYuUy@X[QRgil[YrAxr?ircDLLdvudXdaltmQf=ujdw]ePodP\\IyVlKoAw]xkTaww`lwTq_dR]TodPoDTKETj=XjiiuuxN`mSEMuoQYbdsSMMjElQ>ZZoaoX\\sFsEYsMvu`hhmn_nXnw?byn[MWfAqkWfZ?fZ\\Qt@p[WNooYhhHp]`nkx^m_wbV`aNx`h^gQiw^llPloghogyIwaAjyEPGuS`@kVMSDMkETKnEkEUQl]vBpUY`WpItOPmcUtbQwdQmkTV@ppsmUKETKqjGTM@\\QN`mLpP?E:;gWWi>ir?iexcYt=TeyGamV`mdQwdqaUl]wtixeiIagsWqiwUUxMF^[F>qViQEGwcIwtqeXpQYbCISCI_cHIs[j^_Ifar?x:abaXuTQutOwNIoXWagfmaHqsHeVPfiXl>idqqfUWeU?eR?mmVlG^tBG]`Ym=B@sr^UWc?ch?cHcHn[HrWhwEymssvStQYUtaRZAbBIWFGEmkBcWJ:PusmM]asiqXAEX;<J:ylviKQ@:;O:>Zbh=Nga_cDV[EvthheEiwABJUIeSSWMWdMw^IsMGiwAJJUQeTSWER;EjUXlpA:Ou[cX:;::Zq>adN_d^bdQtLQtP_oRGrgv:^_Bghogh<Ob<@cWqwWYqohqkE:;RgaG_cXkGhk?SW;:_t;n\\aY`UwphghmA\\uwxhikCHksYsYoylynyfycquwXiIvavApK^n?Fo=j@xJp]ysiwiuYudVDalWTQp=Wi`N`lN@uRAujAxjydxNYTwaW`tjNI:aHduhyuyxeHlwisGisqrGLEufIueHuSIutx;FdWHamK]mrFHmjDV<xKpqQ?Mw:>jAhthhpohdXVj=XjgoxwFrOXlMfveqwhqlq`bvQgdOgdV_eVxmYxOyv]Of\\Ov\\Qv`_sRH^pxcNxs]Qg>`t;jmQWQIuSIOIPNWmKiXkLAOkYUr@X[`ySitOitNadwhqwHpkHdYyvsvhhaumxfIqf`ofDpyGp]wNa^^^^IxAy]AOw:BjkdTiuwWYQmEA[wY_DGSemsVH_ICmSHmsHqsPeYXwTioUOCgmaTHyCcWB:luLUqTPmTDtaHrdXk`UyptWXaoXEXmtvQQuTQmKHl[tV<`t;rmQWQEUSEinEwLuxIYrW_eY_YR]G]_ICisGiRdAB:xjOqoeXoeppppPeTOEYpaaPb`mYQyoYwYyYyiyIqYpYpAxKYlx;AjIC>[eTixo[R?YhnYdmYcB?cRyiyuitAu^GSM_yxssI;JR=TgaRo]WH]KKExfLmgYyIGyYXipawCHkCH\\C^whqwpYyvvAnnTIk;Q\\kHxEOof@pj@`]V^]^`n^pn`pNWdlvaHYx=>:QhduTQuTaKD\\yDcWweUWPuiFYx=^_eph\\QnDQsDQsEYsGX^ogakIrvvA<USewNQm[MVF`KedXwDxraQyBR]UgatJcdJ?dJShBeUyKyaUFayZdwteNvA`gpqo<wuV@g?gb?@cW@ehh\\endrGwa^mFIy?pj@pkTf`dF_cFkhwCHUr=w;YjAlowUXgQuoxUvQvQTpmXpw=XPpRRUJMUssiquqwuxMx=y[isUNgigf`of@ob@okSV``N^\\NjKq_:b__iWmYxmYCESC=bBeegwRHySVwugYuqwwXiiUUTMUfqmYkCHkSSQoGOmhIoWI=J`qTuDPtLxblW@Yva\\tTQudxMOLVRimGlMqXNI]RyarZQscuuthXehn_hvlivEqK]hU`tSX`MPlL@AWQ<Z`YduPtLQds_lP^u]y^N`mV`qmwvHg`g?r>WmraacwbWpx;YjAfphwstPqt`tNadgYfMonFG[DN[TXaqo_sva:r>KWacwr_hTqEqSGGcCGchogh\\?XOeTOMxaGYqYgm=EgQfiYxVwHimeXayKWx=;BjkgTiEsKX^?fZ?r]yV]KWaoeBosSawWAbP;uios[wsMqRHyC:HONqSGYOIlKHlxfIoBpJbYQwaj>`j>TSp@y^ay:<JF=npmUTAwapohps[iLKUqdPoddlFTpj\\vvAZRFdgqwXiqeWx>qbyf[Gf[dAd=qjGVkB@kbN?OYxmFpkHpqsWWI;cvf=ssIJj\\jTISEYmR@mbqSYTnRylgTUp`lOhloYxSDWDYv]Yv]Pn\\PJsdY?msI>jYathPplPdTndq_nHO]_apn`pEx\\incWPaOoesAv=x[@ikUvnw?nZ@n:_tNVp\\akxIlmYZ:>xDPuCxpbhoghsDQslGyafrOIaFnpvitipi_WpqAvC@\\xQxQxqVHamo^qnrC?ssI:kUKUIqsbb_Hn[HNgdOGSm]gCeerWDOyRqYtYoynitQuUOCG?ewVmbVwM:tsbhmTeR?ivHIPo\\O?UxPdr?ircDOcDPkDPd=ODMTLMtKYnAEqelM;`mYroehuivisYS[DN[vcoBkYfIoILwrVauVMXEmiQyIlmY:dpeYlmtVHaqjQrElOyqmTYwvHqsHUSYqitYsYslAyayQyIUwXO@qOtLQTXq\\YMBIy;^thxh>yZBYvnIwMiexiqcXdap^`n^hiuuxdGPdKgcaWiuWqGqqYWgSGeSob@oZqgri>lmY:txy`PodPCYnn`Xhay^YwixqhlO;mmv`xLYS\\lYcEWcuLh\\UrAy]yk?ySN\\LN<osDKZyUBIi:@jPWq@qr@GivowsxvVaxJvdipeWQp_WsnHgMaxixlN`l^v^aVhE_c[xi^aY;hlOuCGCMwrkWVAQisYg\\;YAucXcTesbOytQyWUqhgQuoWWMsFH]vx=e?KXx=BZeVoWinEwL_hVmetiWOIWcccZ?gWyrYsYFisjsG^ay:;rtKWacgRuRAurQyixiXIWi>SuaWxjAr<;dmYJ`qTuXxaysEYn>`vXhQ=DW]QLMTL_hMNms:\\OixY^kJQWaPlpmGhlbAwbYVAqkkUP<\\JlmI[hTiyhyXyWEx[YrYtIuIgIxM?d`agpohpWiuWex_g:[bVwMjllTiYnItAUMp\\WjqrC=o?lTTUUUEkYYJVLXxsmOuCGxdSGeSGisGqqrC]b>_bBYvGWEq;Tu;wYuyBIy;twdhmnPPTHKmqREpN[PyOYoQEMbPJwYv^msI=UypYwQj?TK^`rD]O?upa>hPgw^hcKacRx`BXkEXl@VkuIZ=PnQamYIoMwnpyiDPyROf\\Ofn_hnVnWCNqWZMuTQuNGCmQts]sRGH=ueOGBjEfA?ReYxFYsEYhSyhTAdbcSDowcYtagEtgI?iEHGEmkbhuS:[tHIdEydisV`mVtuwv[EpMB<;xNWxMwFemtfGwhqwheWgeDkYgcGgc_gf_sIysQueCGcCGcEWcM?VEGth;BbguyAFgWRCESCwxHYVNAgKmH@Kg:wtJUuEEwugIUOeTOuUYuUSEUcxWOCmuvHiIumxf_BpMfy]vv\\JVPuChvLxrkTV@AYiaQNujLPwidJjqP\\HVd=oEMXlMXpmXppPTiR^pWDalcLYwYNayJJ<RduxMymxat`uuR]yxiyuquE<YQhOUmxwxwwuWGQmo\\uO<xkLmgYuvHYmpL[IlmYJB<QoXMkLV>=Xj=pqxJsHsKqkVDQLQuTQS]LJ@DtyTMsta;fnpWofAiu>vGocHouphgUioUwpJWaj^\\^ay:NZ?gwvW\\jQo]Vc]NrWGZ]VbHy[:akv^xZIr=vkV>s]FZiQuoXgy\\dhZLFZFOkxX[^`of`smheZBrIUgQYg?xd;vgAwbAinEwLWH;sW[EV[EXkEhRgRh]CRUBAoGJOuTQUoQIssQxlVBxlHXwTANq@vZAVcmK>qNL@x:TW:msI\\K<eXoexjHV=qnHemd]pMTWb=WrxYyqqDqKRPtUIqP<xHMmnDwDileTYpawsQxQxqF=rEllAiph<L:Hr\\dwgIoMunFTQyXon`pNMvvtWquwuyRgaMJQJXEogIQsDQ>\\qJ<vtyRHyKvTwhLpmXpmPpl`kfyMl`wrexFdK[pXtMlLPl@mkVDqbEt\\LJX=nKPNayJhYTKETk\\WRAPY\\XOLq=eXoexwYyqiqtHwUAL]hyIYN@]krIvItYRxmYxs<qLJ<vJXx=tkJ]TN]xpYuiUMvaN]Pn\\pUvEx?EK]aqQdqSlSgqrGXMquwXiqPplP@pj@PgiRPlp:<VXxMrpvS`nj<MyhQNXPNXxfxoixxXxJo\\mTiR@mRDYv?XKQ\\xduR:YKZAJeUY<XPBXXJ@qaxveiLOdLlAOKQlR`JsAjrtJsYtGqKIEx[LtHTSC\\t@XrBHQs<XZAjP]RuyRHURHqP:`thlPplTXdR:AKrEJV=tyLq:=RIimutX`usXhuMAxcpVJMK=aysYxmP`C?uNOeTO_G?oEYtWhnBIkNIsk_vbOulwr\\it^>xlOdgavN`qtFuTAhdw^di\\N^\\NAtJAb:Y[ZQ`nGj:PbhwxDilef]X_lL@nFOjNXlTQuTGpnOxv?yjIv\\^dhvyJ@[U@uCfv`vbH`]cHaEgyjViaosPYieGgGF`ZiwKvcpoyvIi<ne:v[@FlnGj:dJyvsyvYwtFAbvkR>]RBYfUWv[cvZKTFaf;gCESCMQeJExRCGcCG@CyAicboXMyfIuIsMx^wHP]T[;v?;fE[bJyRumGqcU\\YEI_hiMwZKV^[fSat^ehf_gfsHqsDoWwMcHJefdOgDmW=CBi;bIaxIoGJ?R=mWk]Yv]iAsCReUWeyLYSiCgaQv_[fFAEa;SlkgTIcYQxpOuK;x<;iViBLKETKId]tb_f^_F\\?R]SdSGeSysuOX=erQ=WP]wMwSxCTGKU[EV[Ow>_dbyUxay]yEyAw^MIGMV]gSUoHcwvgcGgSSQfai@ob@_iv_QPh\\fn?okSwdQw^XxoaWvSyySQeJgwXpitIgUhiLNZ;v_rQ\\c@lqqwWYuqxgYgggggYWgFFc:^^OidhOiPodPHxQynjQgQ>suxwxXuSIucxk<fncPlJgd\\@bOPr[`bSFjkYvAYswQtAQ^_hn_PdBinWV\\Yn^yoZ?fZcxt?GjN_iMAtJA\\V^]Vf]WfmJ@ljIvAx]XqqwWiTapcOmTIkbn_T_pbWv@ikLo]toyVpfK_no`_hn_Pqjw@c;HsBAsJXlKfsMVakAt=w[CymHNgavvcv]B^_oXpSY`aOy?VrB>i;yZBimOP_tIxAy=oXLqfqQYiaf<MufYWtIYoEc]SF]At?KFOCRTUruwXiQSeIgi?CL;DB]UiOW;CTZwECSCESgiwgQyDQIv=ybE=bhChWAwKYf?AuWEileROOWsETYuDDOcDOCDKCXshMYHrYDw_wOew>IhWOIoMSH;G;WfNYFOITaoChcF>MS?OIMoU]GSK]rb?gb?bMUiicYcYSausXgDucVRQS<=reES^kXcYWSUBUyfumfRqIgaWAcTK[TcodP]SdKb>WCqoWWQWcEWs_YsQh=uvyavCYd_QuLIyiYV>uIlQxlaxgEw<UIwaY?ewD[tQABMCiWQfUMWlMYI]v`QgcgvlIBkIYTiiPWVxAvAsIJQIpSY\\sVbkvLIsSGYPOTuCXDYupgWMOe]mDi]R:YWG[FZcTGCb=uvIOiaOtLUgSygnwtwEx^gEO;CX[Ir=TEOB_GFEeSGetxkH_MsN?fZ?fsWXaQt?Kvg]fKGSCESS[wD_UdmrmAVEIyTiheeF`GTduFPAX=qbGKyqUxmYxikUv?uQyX_aCwgIQErZOWQKDLKteUc==rEkIZwt[ITdSgkWXaqSioFLiG@WRayix[BVwHimEW=FxGFhkGHMU[CHsmsAwtOgdOgyNWXsgddWd=IrVgXpmXdgXU]rRirAyreixOmi\\Gi@qUGgucYtaXPqhuS\\KqXvIprFHMm\\r@DYOAutYKw=rexu=ak:xty@S?`TLpndemx=LT`ulHT]pRwmymymYLQn=WsEYs=r`dwvlY;Iw<DxGlmWisO]rfxtd<npewKusAdTA]YmXmeAL=quXDkA]ncINZiNZixSdSGeSLaqTaw=Au>ijeYJIqkHpKshVdEvCdxS<nE\\r>=soUlE<uJAtJyluPMNdYcDmeURNhvf`nCXx;imoloTIkNYw=iq:DojaJvpY>UUyeQr<QrdPodxZIr=PwoEX[QwoePneKIiwwpLS`mYxxj\\wfEMI@KjHqOqWnAwKqPuuKL=nOpV<lUyExbYnIPwEqmTlr`tty=wJIndiXCxQBMuKiJ<lN?AqduPd]tbTmSxJd@LjQmEDtpHv=yjexvDmuNAlZEKo\\pZ@UTIuLPlLloOdUZ<jTIYrhlQxrTQuTuohiuH=rELKC<Nn`jVPOueMWdMY`YlIkpduOeNgqNH]]egbQ>[ZphXnfSQp_GupOhlOh\\`wZVi>^qXOvtixeQuTA\\dQynxpqXcf@nWW_O`peihU>gZX[^>nb^_f^lbPbE_g]phX>v?y\\Y_ymymyaaeotff_RW\\SY\\exvm`o`FZi?vjIrAv]byyNvfVAuRAoYW]COmHGqh_ZD^h;@^oO\\:_\\N^\\RpwFikuvuHwcqwhqgqWfdFgrc`oTgpdOoWN[YXxjvsixt\\hdSGecPu;QlLPlCWl`FoywiQqoWc_UsN=GZoTEoUx_YsMV\\MVDMSDke:awJiB\\qiNIYdMwXKWaagfISJmFQcUDAGlwv`ebQ?bqasSWH>[iJ;bbYi:]hwgSbQBk?eNIeIewnQhQwdQwxWywxuTwIyfYhIQSKaUv?QDdN;tO:dUZ<SWhXNqSKeUWewjdJD]QDYSidq^Yj?=WB<YC<Y;pOJ@JcQJk@jNImXewntmQuUYuUOeTohXeqTw`wwUwUuu\\eQ=MJX=Jt@RVIn\\Pn\\DN[DR<auWYqqUmtyylPjTWcpanOnuxhiuVjS?[rGZbQZkgkdQwdAuRAeE>cWhtNqs;oxVnrjo_R?p:pmqNZX?:DJbdXPhTudqfiTPmTPxlQXojXOkDPkDOcDkfpM;t?NcdaoiphtQlaFtPp^uO\\UGc=Xi\\arCNw^FZi>ZW?^Pxlt@ZLWaGPlLPlgYuqXcuYayoyvymwawa_t:OZX?:llQPq:QTuDTrhquglLg^qGhMqnG?aCNZX[<^bdQZ?gwtXquxkYvax`isQhc?bmPpl@mP@b:Y[:w\\B?bCge:?oW`uy`kF`kTQuTamV`mN`lNNyAaoK>xDVwQyoY?pZGrbIt]Xb<Obrho:w\\BXmW?^PqltVkehmNxkVauVG_SFkCHk\\>iFQqm`c?xaoOwNqywYyoygCi_HpkHpfnX[JiZ\\QeQ>k_inHQpdw^GQvthheqkVFa\\WpIVcS_qrG`Sw]EVaypppppMynIWwWxmNOusVh`akSV`@pgI?nE^f:q_JFtHav^avanmrOvgypYqpjWdcGboX_b>_BQsDQ\\;YmyvixYeigq?WfQ>^nwhqWc_hltveMWdMGeSGeUWeepeIHkCHkEXkUH`]oZ]he:p_JpmW?^DOw^IccGgchpUWcEGoWilevdXGi_i\\k`v;Gb;WuphgMywS_[;>eaYmTPmTYuUY]UV]oIiHHqmwvXhauo`mV`M_xI`mY^Zrw\\B_b>_r;YjAv]x?y[yxXYiIQx@Ar\\NgaFhwYmioqshiuqhsoqtgxdaqv`a<?ibIe[yoXgqdNdQItKIhcQt_py=nEQdbYi:]rvIWOCFJKi:]gZoXAycYsUqoWW_RhCdKGd?gb?OtlET`GrW?bQ_eY;UXOitOirAyrIX]qrgeutgxiwYwYg=uDBasSWHysysysU]Wwic[kfxSYwAWNgIumxv_ylYsRMIjMda]wBYdoSWPAI^aynGRh]vvArL?ScuTuctwgxPYUDqE^sFasVauVeeUZKxtyVxSxSScwyt`kTuOv\\QvN_dNCYl_VCQdqkurUFf[GFORFkg[KH`_rIegv`mY<UUMw>Uu@hKUlN?`u[xx<Uo?DwcIw?dJ?<oWxyK@J^UsPhO_eV_ER;ERuqxgYUp`WSdNR\\QB@WRamsTXtmJvPNoUT``SKYwYDQy<P]`tSQyWDjctmKxrZAvZ]tHymnuXquqmqsuDocHokDPkdv_ivfHJ@lQ:UKruPimufhrUMUHySgInb@NayJ`ultDnmXpMmM_<j=ewvqjxeKjhXeqtK`R;tydymG`mY<mDQOB`tCUySeTOety=OpuxhiUs]pX=q`mKoXtiHJpexdiTt`k:AQJXx=TTBeuqxqwiW_dXdxlxxM^lWMplPQYkImC\\thPn\\P^<CIMsEYs_;U`kR@SF=msI[cccXsIysqsBeeJEUSEinEwLUwWuB]QgW_rBYUqoWwCX\\arGYeqcF\\kSGeS_CD<kf=_eYtlNIS=YOP<PeTOEdpmimYXlr@UhLy>IkMd]M@ZF_nyo`loiZi]^`bcGtLAf_ps`gu[N_@_dufyHVvAp[WNnAxZf^[sBvkSlMXlqsWWI?UuV=dtSew=i`gsDWRN]c_oXtiE@IeW=B;;CssIjUd@ob@OuTQuRAuRQXuSbOOI[yDy?y?=TJ=d_SiM[c\\oXfAHH;v:CIy;X;ewNYDoKhIibn;d>oTi[ijQb_sGHwyOqSySiZQv?YcfAHH;tyoySAssIRYcWcWeUaeWUipeSXsfIueHOusmEgmX;SIFWBFKClmYZARWeUWWreChkGh=OhqMTr]vkKHlKDoWx^KuTudcEWcEESCEnui:;i=CIy?BnMXLsuVyiyuUXWSVSHoMwNQf\\OfXwEMCruWXaqcMgCfOTu[iWwrZegE=BiURHysTadPodhsUx_UyQsfIumwYxYxYWwYED=uEYsEYcDOcvvueSibEsD^IXVAik=gWwBZegE=ByKwYgcVTxM=UR=OhEnZ@n:]WtPwQpQqmwVaoSUpnXmrPWOQOgio;EXcWcmqvGYpdihmimTIpPi^:HbZvvaoeTN]T^bda]tgrnFoUHAGGXiuo?H?TjHpkHxoyeiKWaQFlbNdnhwHimuN>gcooG;[cACIySD[kUVmw<oUdahOmixEyEyUD_wCicmeW^UysYxaivkKF\\KBoWXKWFAmcbgE@iFH]dJ_BcWBj;I^ayF_SWeUWMTLMdpyVf]WfeXoehryWCSTNYGduiXsDJESuSgHCTkibTiR@mRxSyfYhYMyLydlYxmiFN]dQMXlMX>UxRwTA;VhcymGdmYH:siyiyiixymyAyYvyRb=WbwRPCXxiuiqYq[YrAxj?hj[tHiR>etTOeT_vCqwWYieiwb?uJefLufTIf>SBRgBaSXxMt>scTcHD]UBcuXoe_EwLifAucXcTU=dEsbHcELWGfCVA_uHChZqHuaW>stH_yKyRYcWRAh;QrQowmS]Oy`y`xSysxo`^^^>ObyxwvwvuFxkIx]nbF@urHh]Gf[GvcYtaxytytyPsAnmrS<OfF;VtCxMOYWCDKCHimuvCWF]fOkY[ibQkFImevUypxMx=y[Il]tRx=y=yMxYxytymqpgUuxQxQxqnmXpMktLk;@rsIqFYrItaUwutqdN_dNYtIwagviH`]sNdh^wUygyhq^GsLhmuvhHx]ynyOxdXGh[Ap\\GuQ_oRGxTYgiHo=QvgaaPga`AuSwphgmlWidgpUfvpq\\f>e:OZ:>r^@a^ay>Wu>oxhquwXeMWd]xhxOdSir]@_UyBIIbkfHeeT=TJ=dJ?dZgs:=UsOX__UUEYvCYlavOYgQeUu[WeUWeWIx?tN[InAv;YBywe>_bOKv>itDgupSyrwg^_f^CX;?sX;bO?d`cxPigUeGgcGQwGYmtLkYpSybuDkWb[EV[]cpEXLoemWsy?y?yGXGImmVLafCmgW;TgKvbkXVQrM_SFChAKb>mXEcwvoytYwoeXoMFuMw@McqscGgcwEy_ydCcy:[G:Ydp]tfub=wBIKWMeE^oteydmkelcVD=TJ=tVIimEssix?MXlMxmysysgg_EpyfycyC]E<UUUUeEQWasuoGuaQfZiwveSQuTQ_T:WBAkCV?IkMr`uE@IE_uBSYBj_FHcYXWx`isMsf\\giUGeSGESCEskVFAeB?cBkVrwxDmTPmT_eV__UwstxoipewTEXAOunkBvgeiAd<cgVqUoeXooHFWt@aw?;BEOxrgEsMFooUoGi^ay@cbVUDsOSLAVHkX=UI?mYxmqLPLeuU\\HN@tQytjkaOFqU:<KFeyMGys^sjw^ayfmxkXGcF_cFYsEYh;gwNat?FpHAoWxycyiRv^lxZZGiBIyG>s@h[U^tLQ_=h\\vPtLQdsCV=RgaS]SYFqU:;CJ[E`=iu[vvax`yGjMXxMtjKi`uw^;WJ?D;QxGwvJSdXwhXmxNaw?cFu]sX>tZvvaqnwXal_vBGb;Gj_YsCA\\mxy=^sX?Z:pyoy_jOhxo_RYaovov>ar>ulin<Anm>\\VIjSY[:>tINyVxeSGeSpxth`loi\\_w^>tiPodPhL?xTN]TnnGWmP>[uokHFpXyq>aw?>ZbyZewvvqZewwNq[;GjJPySNf[yyGHuEBF;EVSUisvaOhqMV[eekWWlyWDOI@KRQytJSsyybFqU:;BQgxIacssib?gbCWYqCYkIfasTAGOgdOOf\\IbjuVA_BHEF`mx<>eFAaIycTQqf`of`j>`jOX_Qoxyo^\\_feWgegalH]fNga_hSYfpQ:ks]mdV@qr@qaumwmXxaysythhUeynQPpmXpMOkvVnpotQhqXwfi>ccomjFf<P]LI;[xDGdmmYlYDUkHf=SEUSu[YrdqAdX:]YdhOjljb`JtPucYSgPlwHumnuxhiuWhmWxRIp]Gqf>ZZqkxIyqvvqPh_QsiyiyYyAn[V>laficYwOYoQgbCXZ^ohPNgqyqBPrgiuux`yvaYO[\\YiiiqAqlTCrGcyUXxMf[uwywyx_EmOhlOToeipaRHaFhkGh`uH\\thyYpmSylYvAylivEiN@IOitOiYoR?ZjwZYyvvavaavJgbr>fSVa:BB;RLCTJcTKETigsT_HweV_eVLAw[oX;CRoeXomR@mRgeWgmSHmSDMSDSE?MJY<vm`mY]Yv]YYUyXIooTr@ukXdkTIUPDOOEqsHqyxywywY@Y\\IKctJCHkCxLilU^mtW<JRtRyaQOXxeyVceLo\\R_\\N^\\JoXp`dLOdLLMl>ascxQEMSDmLilUFQLT@JZ=Ov<mmYweUV>pppNc_GduVo[hk=G[Gf[OG^Lob@oZMWW;Hxkw^aytQhqMvTcv=IbmeC=KRgahk=GDuv^[DTyhiuE]GT:;rF?iJWxuyby=yAwDY]YKIrXISbyULMT<OuSuBg]EDAykYvimuvGeMWdmoWWQItoG;hToyoi`mYQwOYoYUYgiPOXxMtKZtoBhJ>ewf@jTdk\\DlHPwEqmpdWTIoMunR@SA<JPqnQamYeR?ejvtXRuT?]VIdpmdQlUWMLLL\\tmEqSiv_ivkEXk=Ut<JB\\Pn`mYyMxAxAxRYdYnYmYay`iuuxXOUxRIuSIMrTVQ\\ObpX\\hWUmpfEOeTOEdKGdqsUx`mV`mn>XPFpR;<j:tN_dN?]RhYQYIyH@OYYjAtK<dwYyyFqtgXUgTxIaXquXQdLOdOR=pZYKY=y<qvGYmiuuxhyHYQiaoXeqt]rBHLN\\X:<KjmrHhMUEUSEykyrYtsUxPi<JyiYeAYudyd@Od]MDqnGUmbtu:<JDtvqiq=YuS\\lhpoh`wfawi]Y]YMIiQqaukXVAqLilUvIuIqYPPlG<J:hqmpkqXt@UnjlK?<J:TYaePoXLytNh`x>IkM\\k=EJ:<XXDX?DPkDPAx[fpf`XnpobqYhdgoEIkMv^PgdOgxVgwN>:[wWGcOqSywvdIf=ubROGH;BZQewWCIsCqquI=Ejmb=GWNqcwsT;;BvcViqHh]ubgW?SbqWHJ[wsOC:;v;MdMWd?aI>[ty_yJGra]teUWWmF`kFD?vkhT:<J]HTR=URPmTPOg`pntt@hMj<WbuWahsh<VIiT:nrn^^UopfGsIysqnypQ`@fdufggXcpaE<MpHnXeqteXgeWgHO@QTRlSgQquXqYIYaiMkdrFpR;<Jj\\OdxwGMMdYoQuoTPVr]qk`thxvTulNDO:<J]HYL`wfawWTQp]n_hngquwXufdKoHTNqSyLM?aOKPJ:<RZHtTQutQwexoPhlOhlN`l^t^pFtSX]<gwRWwL>Z:AyNwdQwr@qr@ar>aev@iKah]^vwaopwthheUWqpgwSYpaGeeQ\\:BfKuBOCmqcV[xmOuW_IsMT^oSX_IpAu]uhheuTCIl]F@qC:HnJqnS\\LN\\Lf@UkPr^honxmOqWMqnGUl`dSdxoixSIuSQuo^av^ar?irkTkV>jK>gb?gRAp[WjSonS^x=HdPQdKVmVwgAGsX_cF_sdhdepnTInnHZ:>y?PtLQt_YsQX]vGlNVhrWaGFp@YhfaoUwpHGsXOgdO_lxZ:>vivZ\\pnS^f`of`gf_GeZvr^?qSivwYsXQj?V[RFs<>ZZidWX\\KXy;y[x?tKIt[gn_naFpqd^pt`xOhL_UnayvaYsYTvcXLMTLacSSHJgI:;BIQtTQutWXaqSc]W=UR=ucVCI\\efHeHM;gWoRQuTQeUWee`SYEmdfCcGgcwbSkrC;BZqIdeHeCY\\KbqsVHaEEgyqmVLUIACuu;XZArCWDa[WpIVVGTp=dw<JhHVDhUu]u[=kStStIhynqJqk>O^Fqe:>ZjWty>m_wtX@jMWaGvjka_Fqe:B@cbimXgIdYEikUv@ygxexeOtLQtyQyiwydMWdMRgaU;GuE;JV=ruUqpAkY]LCUWiuWi]Wf]ukXVApygxlXMYCtWaiUSYVpQJ:<j<YvupxBIJUUUUer:IkjmMulXF]s\\pxPmV`mvjIv=YSDMSXlYrIvV`mVtYGxYkdvbdl;eu:pUauOF`MsLThESr=YrTJU=JZ<tjathhQl]mUuphepn`pVmqvEUoHpDDTJIsMxNAhj?hSR@P;]Q@HR@yqR]UgaxpPUyTY[GmmvsWXaaWfvv^:^ZRNuhhasGisWjDQxb`uU@y>Xpawsp_hn_et`hCWiE_lfNatNevYrMwcwfniI\\o^tryl:GdupmlxtXquxVgPa_@Yh<>b:@`RieuOyDiqGYmqvwFImmFmSHmmnFkRIoEWKDLKxrYvIwxdocx;EyQbTiC\\qxmkeM;B<<ny<vhhQQxOYmqZuRT`ry\\y[yK\\=vnxp@\\tptJnHxitjHdMlawryLNqKSYZJYawgwTY^L>_hfwqvqsiknfiavcX`tygfxaysyEoxocGqqHbohNYh]yUJUIYOsXSvsCB:afbyXgIEsKX^OEsCUMUTmyGyQxicWgeWTyr>IbCWYuYyywyuyvXWYhKItKuowulatryDNqsQQhAQWNABZMw@]SSagOSGP=c@GcAWtI_eNkm<YKmmvFIkB@kJDYmmnyMpy]UXty<PuSdJAHh_NZLVGgFtCJRTLcep^<RQYqqpq@mSt]RPuJoly?yOFDnF]KBppftvfIumxpiuuXauVaQp]wRmOE<JRDmYqypyp\\dXexTipUt`XcXx]XSVUx=TJHxY;ewFUjb\\uXiquevpMS^QxXYYiIM^=kK<J:uUf@p]iwYEwe]yELWamQ>InYtQx]YsQx_IPkDPPMu@yL:<rG]pkyOqmwVIPxAj@\\thxQNqu@PLp`v^av^`n^@YcxM:<J:aXp<RGxYCasFasDQsldrT]TbhUiaXoeX_qv`Qsw`ljhv\\irE`stXJ:<TttNGTvIlYjYjHpkHTXouX[pXw@wVQqoUwH`MsLNIYSDMSPt?E[:^gpIwnWaqowFysIy[Gf[ofmG>bgqyYfZ?fZ\\Qs??x`ysYxyPYeiG`op[:>b[P`uNx^PodPsYWqpAnpo]ZQsOX_i`qlQkVqsZ@nZFkV_t@Ai:>ZZ>]^wtX^tHi_tXQyHYaYmUypiwlaYoQwOIYsEYneU<;Bb[CoWWIKWaQIAycYsduytPqtPCESCG;YcEYg=IB:;UISfgQu=Ous?Ej?W]GTpawSYxlYsiSVcAB:[HngUumgXeidEb_cH<[TgQcEWcMMTL]vCQd_SSXAY]icj?hjKSp;B:OrjWipAfpUbmkvUmhfEGeSON\\LnxWYWsPh_]`f=>Zb?]swtX^TmHTETe_XmoBR;B:ugbUipAUieTGGF;WXEcho;rFeIf?C:;reoY:AsuoxZoXwIfYUBFQEsoT:;BIwhMofRihAcheYDokfBmeNwdQwr?ir[Ew:<QZMnW?NuGkMsPigUuSV?IkUx`isFasFEx`ag;kB:;tMSXgQu=OMnYXSIuSQLa`SV@QKaneIq;<JrUMmlwTYfXNijAv;hfxI]wq[]Ympfg\\fbABnQSeUWeAykYvw;Y:ySxCy>YStEGGSyGWEqkgXeitYfYcybyhygygiuuwX=KuUIh=AI:;bmaXpmXtmx:gdOgdXOWrUitOiTOeTxpqxPplPDhxNqUYHQmmVAuRA@wnXWwloP=TulXRtJ:<MNlMYXSQhmWhwlAS:EpeLn[Ms:iMulXFMMmewg`sFasS:c]B@_n?ir?ygXeqPZKgwRIfV>Z:i`v>m@QghogPf]T^lwX\\sW\\WQgcKxNhxoixpxtOeTOudhdePr<Qr`^cR@vZPgDIsBxvmgw^fcfphTaw<nhRvZ:>x]vsvVxF@mjPn\\Pnx`tHWswhmwVipXn]XvLinEOuUOvOOhlOh>__YPidIo;vZU?kPn`pbhggamVDehMqtt_hdaey=J`QNxlQxurHhMOitOQWR\\YYEqqHqmuvD`tcYyatJOXYT`QsMXkEXk=RrUQPQq><Jj<NKEd>?xlPplplfFeLychisGIhOFr;Irl_fKPdQnk]o^oXfgXc:>Z]ATWYusXhaUyCiqsHsMwcwf^IxpiwUqdOUIPQi>vqrVluWuqxgYAx[YrIn]v>w_XhJOucQuNXaM>oWVgWO:kYkGE=gswgCUkHfkHpkTEqus]Ecuy?EUeMWd]UBUVSKUgqgWUipo`_nkZgoE?:YurCIiigYoU>IIp]RJ_vrkUlmF]kRF?sEYsEqsHqhNOuW_IsM<VfI<CaRVa:>ZINv<aqqpysqrqnqkQvEx_D@^wpxTYgXAa[Ih]qrWYqqwcv@tMycyfgWfpUapcWt^HcMPweYwMYtMiteFasFakGhk_s\\vZ:>h;pohpoUypiweypiwaustxiyuixieCdmuUuIf_UsOXAqcWsynySyah[Ur@sWrYdBAsBEYvsqsUSchm`YkQioUuTiuRCqUF]SF`JWTTgATvEJ:Ly;UMWMTQuTQmTPmnyUWwQyoYKP\\OjAsVAJwtovf<Gv[YrAWTMUTwkyiar@qrDYVMUTMAVy?WHGHSODZ<lwdXKDlw<J:tJNuv^UYuUYoeXopqmMTVYU;ER;=Xj=pUpwGIMuuxwywyuYIqmwluJUQKevZ@^Qv_X_p`PusF_uO\\^@`LhZ:NZGfgnGcGgcGgf_gnpNq>O]@g`t`b^icTqbYhku?lYN\\QAmKHl[nxH_lIYvAymlffDijEv\\fnopgqDqmViulQxlg^uO\\v`^_f^Ciu?ox:>rL@gsx`oF`ZouvHiaosVHtXi\\sWurHh]AmkVF^yrH^F`m=ocHokVpmq^thOynIwavcX`]fQkdnnYIxA_fiGnWxtYwiwpohpc^wgsQx_QxtQl_Vc\\Wf]wexGy_ojkOZ:HucY_qq^hvvmwmuamiOyavZUQ`axnaXiCqucHjdfdOgd\\wg<>cga`>_voQpq?v:IjQ_wB_iKffAFu=>Zm@vqauUHlgimRqds_\\eW]ZPgQYdpanN@`uGZ:^c;Htlwg@opqGf[GflAaRatWA\\EvlXnfi>Z:H`kfbhisMoxH?xrhqMX_`xebX`JitHWki>mw@Z:niAahsx`I``yXwQyoYqqwWqAydHamoVgP`rANfBhmqVq=OZa@okVi;>ZvGk?NhiowmhgUqpYay`y`_hn_pmOWq?WkPFsKhvDVayGZA`ZZG\\V>hpQrBIl]f^xQ[Iv[a?fE>ZrvkoQhio][f^_f^[F^[Wt`dAcfw[F^[RXcvLUfpmsDqUiWhQkVHaesmwVIIUgYZUC]II;;fQMB^sx`qIkEXkMfqybIsEpEV]Qbx?dEMGAaDUMvvqtySRbKhpoEmwD>mx>quGQeoSks>jX@ZFiqs_rQ_f_gfChqU_pbGl>@[dirbAwbw`=@ZcWl_q_rvys_thxhSYdyO`XX\\Z>r[vx`I_uw`kOv>Gg<gxinlNDCIsCqGYSX@aKnYYFQnpmw@`NFxv><Kb<swHY=XJAlKVuqxeUX`Ut`XcMx^Is\\Ax>qlCXuuAv=xKptWXawTIPAukXdoVqpMHt@LWaIJSYVvtN:HS[tx`YJ>qLaxnaxlOhlgQuoXwbIt]PnpMoQdov`qV]JiLOdLsoHvTXn@eklhK`=nDLWaQqfIpTdP:HM[thAAkw>cEWcUOqnGw=y[y^_lqplgvDghggbjavoGiQi`oXdGhgUWeUXlYxbgaeQhqXwrmOsW_mjFf<IkMv^tgyP`bBxswvxVoeXo]WA^:na=`uUxisnhfAmR_fUhauw^QIioQwOi`of`di_KIqwWypIqVIms`gSQpiiiiYieotfHbgai;p`jhfpawSYuqxgQ@pk_wRIpwgir_sRH`Ap[WNlZPd>vkVDZiFBiiSCuRuRAuRuMwbEv[IvAmcVCduewFufTKWaIeuyhqhqLTPDXOyuwwxxtIKLtqpipihqyqyuySvDx>apcUtlMXlmtgXUAeY=<XMLXimJaEwLin\\QoMXlMhNlAlyTkDPknxp^iXsut_YNEIPqhWUqN@iMoXx?=Ks]yrIx_YsQXSFAUXmUx<vvtrZAvZEYVYpauSLMTL`YE]KxlNI<ro@LM`uUHUBPkDPSIuSymysyvqewTiN;yjpUTdLOd\\r^\\TOeTs`Y^eXbpxpqXamQFPuspk>eNSDMSdpohp\\QtLMTL]mCTM_PyCYVAuRA`j^Tl`dSTQp_UK`tK:IMBiqSxlsTX`AkaqTuEtc`LW@y>DxsEKCDKLQysHqxmVTMUT@YtuV`iw[pXhlxV`v`qvdXyqEx\\iRaisSPpUyXiquOETCYuiuqGHs=<wOLXimT\\qywYyT]X\\hqbqvfQX?avCYlEXkEHxpmUKIQkIVAmkVDTqPWkQv?Yjd`WlIVsHuLUYOuma`yCHs=<pKXYm`XNQxgyWyUUmXvlaRGXvmuY_AP?@utEk>`nvaKr]PNqWJ\\LN\\L^OsLXstvixayqputWsoHooOhIhrCIwYGhjFiAp[WNn=oZ<FZlwg;p^oOrDilefaU>te`xJ`jD?oWDh_UsOxDYGi_TQuTAcB?CsWWTmKsWUFv[IVMFKsbG=COGsU?IkMv@gCU[v=kGroR:Sv=mwg;thuxewgxOgIWVNUUaIuYEtawbJUIqUVMwHYaYmhwUiFQoWymRlo\\DlXuP[\\mtdXdYyiyqy=v:OflanxyqxQyeatv?`ugx[vxP>mN_dN_^^^^rAvA`]LYbbhmE`]ynivguthhggggGlKHl?hj?p]S`\\cptpW_gf_WQqoWgixhhWx`iskGhk?mv>`]NeaavuxwxXy[yjYnuvHiMWiE`uU?b[FhF`ukwjwN[nYbN_aBwsnA\\dw`B^x]HdpawSYxlYsiViDOh^pmAfZ?fy\\y\\y@waY`R`ajFdGGgdOgdkeHt_LueIn[HnL<uwpxTYWnyS@lNlurmXpmxTh`UcDTupx\\=UR=mqlYexd[^tHI_DXkEXdLOd^IsLh^EourWvGvkYIncVd``mvFil?buokCYZ=NnoocDHjM@jTWwV`dhig@akSVnAwkHF[CFrwHjGqaq@eXVodPoHwmxfabhqbqZ?PutynQaxJNgQy^GisGYep`gcrDarxewUyhiEulgVXAyOGwMyfEOuw=x;LySETmxTMxlUXmEqME<vu]tbQlPplPXsQxOeyRQ`n_hngPUoPS<IrCTL`<TlDnaDYsEYLAXchY]mlhdUTAtJAvGxUK@wDqv>qty<oWyy?]oiaqmqSdMWdXle=jsXR^]V^`QXxQymY:epMYmvDQ_dP_hMAxJXqksaloUQuGeChsifet`nwh^gvdHocH?ir?aWXlj>^OitOQvV^p?Hrvxpwix]ykyn_gqpN@uxYug_thyiiQkppZRx[`yhA_b>?s]Wf]WnmIaUG__VipawKvjqGv<iZPge;vsLydhighausP^o_xIo[B@ePNo^wa@qsAvq_niZpohpoyysFFnXXge?jC?gZYmjgd_NZ?wp@fxgndWGZInx^?luWxZflOhl\\yhcxkHF\\:puRIiUF_nXZ`iZ=NegapSF^_iv_Q\\T>yl@pHYmqvcYIb^a^ffoCn_=owGYivIxIxiv>hZAjEYeLPeLFgZ`i`_wfwmH^dcoghowAIp>NnTIkYXuthheIkMbUwHiMS^SeTOedYyDmGdcX`asSGBA_spab_gH;IEBiisAenaxnEcRGcxch\\yFHUSV]bIqYKes]mwy=fD=rcgerIifaoohpoXLalSNtlgYpJYr;dltXlM<yDyTxPv<ytkDYJYP@XNqqvYmPf=ujYlY`y>Xse\\Mx\\YrlN`lR^yuauqb`MEUUUUUytmC<NoXtiAPhyxOxl?UWgmx;POhVaFo]JXimN]lW[@okVFyZIr=@Zyp[?fZ?NsRIy`HaLQqk^nCwuqxgYQmoVg<NegqZuXrrx[BpkHp]x^iripewtVaaHVya^ZN^vXakIGf[Gfyf[h?^nnpAn;krIwEiiI]utQuH@asSWHysysysA[hqWX[ubkueoYYBUh_qyk=uyCr<iiK[vXaSAMWdMWj=XjGD<MWy?TSEUsYwYuyTMCgwBU?FIeX]=USewVmu[]uq;g[Shh[CNEwOkdPah@Ec_sx`EBLKDL[yrkF:yi@qGuSIUMCdWyGwcqKik[GeoXTaw<SrteEastpUENGs]EWGUtooC^qufCSf]Wf=BDkeTatcAt[WR@aw@AhZOucUWWMSN;dKGd[=unkbmSR`EHsmt=_uUgxbIIiGUT;WFgeKQikkbR]wlUyfegEuxkmVBaG`ss<ChQCiq?B^;BaMeqyWfacJic[eEoWxkQUQoE;mWm_BrqUt;iXav?ob@Os]_yVKeaiWBii?;V:UFgmSNge[WRAoB`iRbitRIEgWE]=coKuQsuigXcID\\SF]cR>oCX[Ibif]YW`sSxeRDQfRYC`IfuUfXWduUC^mekWDZyD[oixoUDmyQyixixWUipEEpWE=axduvAihhcua]sRGHpGbPqXmAcCYipewTOSaMHIcu];duUBbIuGGF_yuBiuRsCSwX`yingHYay`yHIaesSvighhcILyB\\CxHYEi]ikQueugsqr??Wm_wkCY=OiGey^qMAuRMXY=xyeMTYLYBeQkpu\\POwaX]=KLqkGymytuBiuRlNpqXapSWPLcXlatkwF`C^pAokVFgtvq\\fw]?dJ?lEVm[>q@VkGHqV^pd>swHZWA]wVqknewgxOGi?y`[Vi:PoWqnGWm^HvhxoixcIwcQwoBWxgOq_?sqxgYq_@axYwyoyewG_k`obfwv?tDpp;fuRnpxXhio[U^l]phXQfHh]kRwgE_SYkCHkKDn]IuawmwYuyhyUWviGPSb=WbOGejiVEMcCYhKWY=;x>uH@wGq;GqUdA_gNIifCDtoUpaHE;yOygxeHdKGDAegGiDeusYW[UHwmFIQueKSMWY=suoOg@kSWIYpWE=]cWGcPeck_tfQXKYHwWuecGgcdRgYigEsuHeSGE]VIAWwoXDiIViiuulh@mOuTNpNq?rUiuRn^lnhpVohXlcHsXqwWYqIgmtfxpYuiwyryrynspX^gVyditexmyoysWjBqmVPoNvlTPmTvah`y\\gk?qrBiq;>orvwpiwUytixeyvhhauxiyuuUmeWwxPAtJAVP_KeToWpUEmlTIlL<N`XUC_[uNhmxqoioigcoXvYYlFpkHplPIuiy\\DakEhkKXi=>pcQadYwdQw>Gjnyggxeypi;Qj?nuBfx^htlFlkXp?nsXivlWmW^fiy[y?y=OgdOogYtKg_L?^vitfNkt@kKFxNqtyn\\pFixV[TGZFG\\aipqxpEWg`xkman\\^\\N^\\>vZAViuP^Bpqdh[DicnGtXN[^ii_ibZO_eV__qjcPv\\fZ_F_cFg@akSnaPhao>d?Adeomo^`n>kCY\\GnxuHsmYcJQ[Zqg=QwcIJotKuUMUT]otYmTiWSjoEQsDacgP?sU_HVmIeOgSEUSMXTKDVSebcsy[FJWS^_uagbp]r>AS]MGlwFXor`uukiUf]bn?hxGIGsGgey]qC\\wE\\edHkEvdUJtUh=O[yxZhL:AQWAMd]kOaqsUxNQSTLkFasFikUtPHHMmlN\\LN<yOkmmNaR_]wFiP\\hWBdJEqViyvNYsXIj=tJHimutNGqoi]SX`yt`JbMNhpyWQnbxOQdn`]Jtet[uxO\\pdHt_lQHLU;\\KOEJa`SSPxsxswGh<gac@pLQbHx]ynevfnspojNgQYkfIcKPakOv>@aFvmoGgDGqKP^hYvZIdxGx<ijEvqxixixinYnYFwYQxdXkl>iJQ[ZY`FOuGH^[FonN]\\Ps`X[:GdupeJg^FOc[xsxGdV^knfyXq]bPh_U_aysYx\\?X\\Qf^;dNYiqwgxexeWCP[GjQdEOHE=tD;Rqkr:wy<WxU[d]oX`AFgcGG]sAMXlMhimYh]xbItdktmaWSKt<wrqoutUwwyxYytygx<YCi[R@mRDgbtQsQmi\\IXQcRh\\JrtKX\\QJUJO]vK]p;QPWAMwyWJmkTImLHsMxNQtLQTyfyvvdPJeni@vk<Ob^]soyvIyLgp`xcYp_yi];W_:xrKyh]?giNkNIe]X]=at@q[oXwMF_NPt^WyfGp`glZ^geWgU^tq`yOXZ]vx@>`Zw`@puaIe]ymofpkXbgQy>OviFiNp`WyfgipB`r_YsQxZO^atQ`Anbhi[Z?dWA]TaluVsvYv`p`p?oWAZ`WsQXkovb@obhvex`yZIr=psAvkXgtRNhi?ZnWfb_tQytUPuRInpgi\\Yy?Qm_psbV[_NbeylV>]sx`:v[pWfbyZd@eZX`Mggq?fdAZQfpeYlKV^@?sGn\\mqwUxmEN[DNlAatNatYxyvyvx>[XF[TGZbqrjO\\MfgJokTIq<AqkWvhiuuxhgQuoxnYpiTyZyv^OIc>vwixiwY_sx`:vo<w`@Xg@qs>WuW>npWj]N`lNdXvsYxaiY]oXpsG^G?cJQ[:w`@nrHfpU>jRAuRGifOgdO^bgZjv\\nWfZ_wJWq;?^;peJ?dJirEx\\CNe;^[HfuR>]u^tHi_^N\\v@h[QZ;W_:JQ<t@hV\\]wJUQ]XPwMynYla^xSQkd^Zg@ZP`w@A`ca^>pj@pZEA]u^th?ZNAbOFqSQyo?jBNe;>WKB;WVAqcSmrRIfpUBZCf\\_ID=IciIoWFqqB:uP]mRULW=PXEayA=oWuY>hj?Hs]xrMuX>do:BFks[YrAgv@=ehUbl]thwlfIx:hmcQVppOWMq>=tD<RqlR:LMuTO?PMrUq;\\rimtfHULuNATqe@Q;UO:duRlqAMvcIV=qjGemtdtGYvvMxCyNXPPpeKGdKqywYyP<Mxi<XOqoyuTaHkYQn?UkphWUqPZqo\\QUgpYqiuquQvAx=YmqtWL\\p<=J<uP@uspmraUlJ\\vTXYDuT>uO_LTqAsSEs[POdLO^auvqOr=YuHZY?cB?kvnjAxju^i`XoeXocHoCOgoPwPHtXw[Gf[Wf`d_tewowpbJQ[;@ZWA]@FbT_ntQytisUx`U>xVq\\h^erXgQq_yxjuAoWAZ\\y^qxbdiodXrTHjEwcIwty?eOQwKYnAWknNvXArTAtGHvTnuXPhQodPolJ@lZ?uyweHiob@oByq\\_a^>fEomGIk[N_dXe`Y[Y?y<@apFoOQs[IgNgdOgcR@`;OvPw^IpZZOdMAbqnjkywKIwMynQaoSWfRY`NPvkhfEq\\yqoNIjqXw_>gwVipuKIt[AHNSHasFA]tHIeTecrIbcGttsF_oGVSIp]Seae^WE=AhNitOiF_cFS[y^cvFcvvcYpwIpKWqyibCGdYGbeeusXh?SWoTkwywyuyiYxaysQv>YyLIIasJ[pS<HVKeuRdOgdOQxOYmtIpOCUSEUUoPWO=UR=mdqrZQRSTlTPmThnEulpaYwPn\\PRXdNdEUp`WSAsKXNendDym=qjGVhs?rB`lMFggVuTQunv]cFpKIj=vZVHw\\`mrFh\\`ZI?oWHn=pdsQkvNsq`mfYo;_y:aqWA]CHkCpsqWf:HbJ@fwf`ofpa`t?ob@OcFP^qPxOydYgcCGcKfncf_gfsHqspggvhnnxm\\fhl?lf`ofFgOfdnYdYweYpmXpwFPuGf]t^dHYdxg]oX`h?tdpuO@h@i]YFkrIjYFhlX]=pyCWx\\AtBHsWvtX_i^IlAOsDQslN@CYx[YrAXKQoVlLOdLCYUHmpyLNfEtKItlaRTXTkMkdiRsmO[IlmtRmYYjaVSepelOhlulhVEpU\\`pZhTG`Ut<YjAnmyRUPP_MsIxYvo]COZqYdj`psGaBx]rinUVZFOwNYiwgeUX]XIuSIguahTflxX^KomEHsmoiK>fo^tPOsO@m>fgDGscYtahroNo]Hc[WywywywaZIutYcpa_ephYfinIlBgutixey\\f>EwUkWb<ObhquwWwGWx>]y:AIWAEZEEnisWixeyt__CnQI_IhlOhLMk;eMM]JLMn_ds;MkSXsGisOuYD]UOYWtAtZ<UPewx`y_yOUaw]@jtmv]eUJtk_TSP`xfqLqinlINx=tmlR`tx@lPaLYBTySur>]SymUXmuZpYHmkpQtEuOcxvGeSGEPkDPT=K_tRMQqCeUxTUNqs?QLJquXqwKXn?tJATo:mrQhQy<kY<w[tx`MTvUpr=mp\\W>IjhqwhEPtQmxDScLy^YlI]tadtBhs@TQQx_fvmkof;hcsNu`hcU`tmqlPp\\GascXnohpoh\\Pn\\XIqmwbDWn=AxEg`Vy[iwvO^rvXcu@lV`mfqy[`^@olAYuqxguIpWFbvQZGNhi?v^NdXNauVaoQgqXgQq_s_uvHimPmo?`d_tbfxtpi@YmNX_kofCHkCPd>`bepnGWm`hcGQen@gKqrGX]uggvfpvB?Whr?ioKELWI:tJs`N\\@^\\gsFIsKatuPhnFa<AsKTAohBmsJmsMchmQCMwFImdUGteOGFkTL[TkKxLMwHCx=cYvYShiC@Sc>oIQygYutuShkWVAqYjIrAKf[MDLcdQwdYOIoMGr;Ir=ujGVtiWGKtMYtEMSDMyDodpiwUyteOu_qv`QsKaFBSiquwX_RZEdKGddiXC;snWfCgYngxbaCMWHNQDx=gWwbKWiesH=YFWycI_IlAc>aGocHokYVOEC?ySuCluWZID\\Wf]WTMUToQv^aVYotmysysgX?wAsVDUbcsYdoeCqU=uYoKIWmIZsUKyFgQSEUSOYx]sRH?uxyyBEE[AwKYf?cB?;gWwTbihuIt_qvXMsM_BikVsyuKsI]MRhiGJGxXQrJQTT]rqYij;iYeDmob@LTTtwVwf:ysiheuphlavCQcgQkDPkp^gRAnywhbAt[PoJXke_qrGx\\XbZw^G?_u?^rW[IqhyNcNh_;YsZwpogbvQZVNhi?vUnewgX]va=TduTXmUhgVWaRdaxw[v\\?U=qbGSwS=euSIusVIqeg_cW]Yv]ix=ga?sUmWhmw]ucwkF_gUXWIFPNyhn`hv[^q<xfux]OXdV>hUwd>y[Biq;xwK@jcN_dNc>?ssqvhGnWpeYQwoGy`GgKgrFiujX^yOafppkftHwoAWlmPlmWxu?caGxOXr@_kRFlQxlahoFqvHQ`WOgJWlmYo_O^xGZ<Fqq>`BNvnPoeXoUN]T^mS@cj>nJnxoY\\=haN`mIXaeAd]pHtPh]uwXYqqoWUqpaxMySuxMtdr>arBUn`=u;POBxmi=Nq_kf>i@Wa_vx_x\\oXhDf`tnxvIymQcgauf?n]Qv\\arZyZTgy;_yBiq;>e:Vkehef_gfhsx`qGxbHp^gQm>Qx`f]bPjri[DNhi?ZbhmS@ljWab>_BIff^oEAcBvgmPs:g\\>ycIFqq>ZNqsnacSP`_Qr?X[pvcfa^apZd`lPpl@gb?GklI]axaTFxU^_^qu:>duVokfitaxMx^IOowh[WIn[Hn[wvHimlafUqpgOeNymKHl;pvSPbvAswDbge?IT=cTdOgd_ucMT?Mw`gSUodPodPOeTOGg]x;YbASeUWeqqwWYGikxVwRCkBKsIluOZ<jNqO\\LN<mMUTMUdmYQnqxN\\Qw^HkViquuxkYvAylitUhLWqasmtsBymdio]xRIPTL`yhlY\\uuiuuxhYwQyoYXaqsgyuyxUyqLsxP:<pxPuC=KitkddXaQpkXOeTOuNwOybXFi^_sRH`pxcqVmQxaqfgTa^g?oAonmOjENvahkhFoeXoMXi^xyvxnphoA>ZNEGSx`isuCYlafEYSlOgOoHOwFBKK^tkYiyhyXy]x]xMcuOTLWa<NEYkYeXoeXuUYu@QfuJqqTJ=TJ\\MV\\kuUJ:@rOUqSUp`emsTX@YNAPQv=yjhsx`REdRAyPbUnEMPmTPeTOeTWeUWOaMDeKklXImQsavJIn=elqXVsUP:<KVepU]pbEtphWUatPQqh<n`HuWEqleVlavCqPuALxdW[is`qv`ew=<vxLUhiSG]KJTThxKM]vDyWVAqk]sRN^\\N^tywV`fsW`:>[>gpEF[CFpsHpZXhr?irasSX`O`tCNmNIkgAuuxhiOf\\O^CWaq?wevxpffDumueuaeMgyM_GimB:;gWWwEKIEgtrIuIqYpwWYqIocIe[Hn[TUysQes:=sIysqat<eG;WbT?EJquXqUWeUgweR;v;auUKvA;B;?gpMgoUY\\Ica[evaiRohtQytYtawSeyTSAD@qcWSGxsSYQImCuHIseIgluWocHoKGqqfXudJ[RGawPCYuMxCyFwwhtAG\\yB:SR<svYeXRCfXycmAEykYvusQiRUqcXcITAtJAf@=VlOXRuI@?u]Ciqsw;?y;;fpmt>MegchRKcTwFQyyAgr^]TOeTs[CvYDNqHmAGVugr]FqqvAQv;?y;B[=TuscIIemsfa?v?ir?ITV]xH;uUIiq[rI;BJUi;UfPWRfUWePuQin?tK^iQgaW@<swHNx=J:PuSqJfuk^HPTmpfEuqqqqWgPaoS>xeNvQ_rRin_hn_>ukhZXwZ`HxmwG>npgqMn]Xni^AsKF`bfyiViiHcWqwWYq?IoNgdOgZBqpxnnHiqSFevAdx>ZNqsahwKOhlOxphgUqgWQqOykTIaBgmGqm=Y_gf_o`vOHpjowGFx=>j:ixpOo[ql@iusGoM?e`W[n@jGiq[ni:>fksVKENCTlor@qRkCYHYSWGY[sx`MWkYRECBJUIQIevCYlEXkEh?gfH_uUgV>yC];EZyXV;TushJohxohpoTFucXisnohpoV^]V^kF`KeKMwBii[kY:;bTIIpsBLaxEYvgYuqgHoWDo?TWSesGisofJOIluWBwE\\yB:OuG;bTsW\\gWokgCeUcEWcGHAOfJWY=[rI;BoWEneeQsrM?eR?Gh?W[Qr?obOOIluW:?ySug[KBNqkEaUHmSHIp]urXAY]ikwTYpaj@pjTDRdAswHJ\\yJ:Pus=mjAxjQUuLxvXn]XriLTAmgZnIKWaiutsg^gVUqhguyrycyAwUOIImwG;Dy;BNqsagXx?hj?HocHOqv>QGIqWPIYluW:?y;;nvYjLPQKMm\\Qv\\Et[tsPIYluW:@y;<npmJLPqoTWPausXXA]OQXyomU^TlVYMZ>\\y>bgak<gb?gjBgeTOeTQkOV_^ycKPnWVap?qJwv_Aa\\@hiqquqotY`v^aVwyhgdOg\\sx`:;ly[PqtPQ[DN;uq@lvbIt]hWpatTuyWUkWeUWeSGeSgiwgikGhkdiLoXpe=Wb=otYpv`qVexIMoDmQamsVLwv<Nx=[qy_W>npooBgeIivXxbGP]_vkqngVAhJWagOf:@]rXfAqkcgmMp`uAsCGh>P^MH^[F^=hhi_ts?n?vn\\>ZdwveGomhitpiRWeUWmgYtKi^gf_gjivkhFligoTgpd^_f^g<ajCVZHIs]ps=>dKNysy`;fpmYjNI_PyOyDN[DbGuBKc>ar>aeV_ejAxjuxAsSLuv;;gB;bTxqNIKyuxquYqxYyqYqMyadqKuvo@PJPQI<kYdL;<TutX_pSRaVAAvomMkYJ>ykD@JbhmeQTAemA<n\\<JdujNImZPrMuv;Dx]PN:=jdhmSinHDx=<pdeRZpT\\pXXTnohpoTN]TNkDPKQPLujrIJJEL:BDeeTibvsHqsHjmt__fHYBR[i\\;HSqCoWxD_tSCVQKXdaI:cD;;Tu[fHOII;R?=BNLTAemAj_ithPqtPYRAp[UJhQOhHtSIus<OcXWb=WrxYyqqpXT;dXXPQI\\T>LO<LWayJ]ptLQtlpVGQMw@QWuqxeYrAx[QwIijEtLt\\Y?]Xkpn`pnQeTeixEPxsQkDPKKaT>tkttKZYpD@RGERgqyIpwhqw<Pj<`of`OwPVWTQp]OuTQUeycLOoXWQqoGYmqTQ]=vtIy\\@OY`yCqme@kY<jqXO<TJlDTupUb`of`kIxkQySX<ujHV=mUXmmpynb`lB<U<MR<AjuXLF<y?EYX]TN]vF@X<LvA<v`eR:\\thyy[LxmqxUyWeiySeWgeoTYXOUNhlOhyvytysuyduvFyL_IsPhOUMqtPqjxXBxM:dL;dpmiMOid]Xn]hx@qwhiuuppIwxVgtmGylivxy[_avQVlLPldQwdQi`NZ;PaI>B;TusWKQtLQDXkEhwY_quwWYwoYlsIysyZIr=gyVKsCyGH]erCxRIh]=gWcXX;rueD;IyHaSdKRZ?gWieusX`usXggyefkGhKih=EIsir[WRAowRIh=UECQBBwMIQvJ=mc@KbhuyAN<YplevDuUxQv:XRW=JkYJZPNZbMCESCw=wGpsHqSFu]ts=Bd\\tHyWbUL=iMB]SF]xLyL;PQI<R?=RgaYGAwKYngmxOiTnYnetygyuxiOxlQXYjY]rRITaI:[tHyX^mV`MIvOHoHokDPktpheuLaReXquXQytQyQwOYowyMDIsiLkVLX]IomAJXMrehrIPkZMVoXMylYvikUtPV\\mPqsWXQEUSEep?dOeTOedRNdpIaXoeXgLUn@W]qrGPWI\\Jayqb@wfawfIOk@jrIJJ?npoe^^_f^oxpqXIfpYmBitjHFgUuoXcUTkaxe?WdkxgYuQYTgaesQvoYoIAmkTjtMRWxRvAjD@LrdL;yyduLOdLOxlQxtWiugxUHer`uwP`weuxYxrYtYvpn`pn\\Pn\\xtqUysQn\\AwKYn?dJ?\\TFLwvLvA\\T>@rc@KxyTuDLs`lN`LkxXxHuBxnsHqsLQtLm?MPcXxBxMrUJ]toAdMZiL;AL]MP]Qv\\QpmXp?avs<uupYbQwdQMp\\WRXKyhTXmUhLvDem>]yJtQjlSkTn\\\\JDPuC@s_pn`pqmqsuLyWaUuyrohVWXOdLO>UTklX:@y;\\JTeRjLsvUqatmvMPf\\OfHn[HnyalUpjELTatJQTQBqr_AjrIJ><V?=PJawluWeAlMPQD<jrIje=UrULQUKN]j[\\LJ=Jipts]lIPX<eRjLr_ERgAJJtQ:TwExMduJ:@IMeUWeIsEx[EYsEYcDOcrOAHleR:ew:;Dy;XWwVXGY`ubWkG?GreKBduB:?y;wbSiheuTV]M@mrSLo\\<np=JBxMrhR`mV`XjqXSIuSiPodPvDAMdPNZZjA`\\fhFgwoNe??bg=CSsEYsKTa=rD?bTIBZkYZIHDKCD[UREwC[iKEDJUATKayLuiJYtT>\\tHZZn^`nvavasI[QIrjh<e?[jA<sEYs]uYOTN=Pu;<>Xq^av^APupsy`KR]XKUQ:\\rIDxmUkAqMu]WWQqo]UA\\qW<JZlYPmNhlOhIlAmM[QQZph:FxmP`nIfTPnbQnpCZkY:wh=;B:]y:AurSTRATu;B:^qW>Z:NvA>oW>Z:J]yLp\\tH<JJtQ:Yu;<JriTvallINx=v`]W>Pu;<J\\yJrUQ:<J>yKJUAGRNwCkYf>?fp=B:?y;kuH;B:Cx=SD\\ayjiUNqC:;LB^qW>:>O<:GxiIGduJb=OKtQvh=Fxm^^=Pe[o[oXZ:>bvAxp?:;Fx=gW;B:KNkYPxiU:ew:<JJtQvh=;DySvk;uG=DKUI:;B>yCi>ZZnibh]:>:TjYuPNq;?y[iw:;B:CxmkE=gE\\ObTIB:;Fx=Yu;B:;RvATujS\\yydRgAJ:RZ?Iy[tH;B:CP`DxmEVBPKduJ:<ZE>[ayjTIZ:>joirIfp=>Z:V`Cxmewq<Pu;ZWx]dwZ:>Z`H\\yvt@@oZph:B>[bmYRgAZyVkYx[Nx[oX:HW>ys_eU>ew:<::gx?ZFG_x?oWJJvyYy\\lXsY>Z:>eXxq[Q\\:>Z:NgA>:;fp=J:<Tu<Z:>oW>:;bTBrgsyUblYU[wG`CCocB:;B:;RLEdMCde?DR?4>PDEtools[declare](prime=t,quiet): # Constants l := 1: eps := 1/100: h := 1/5: w := 10: l0 := 1/2: M := 10: tau := Pi/5: r := 1/10: # Aux. variables s := eps^2*M/2: ll := sqrt(xl(t)^2+yl(t)^2): yb := r*sin(w*t): xb := sqrt(l^2-yb^2): lr := sqrt((xr(t)-xb)^2+(yr(t)-yb)^2): eqns := { # Differential Equations: s*diff(xl(t),t,t) = (l0/ll-1)*xl(t)+lam1(t)*xb+2*lam2(t)*(xl(t)-xr(t)), s*diff(yl(t),t,t) = (l0/ll-1)*yl(t)+lam1(t)*yb+2*lam2(t)*(yl(t)-yr(t))-s, s*diff(xr(t),t,t) = (l0/lr-1)*(xr(t)-xb) -2*lam2(t)*(xl(t)-xr(t)), s*diff(yr(t),t,t) = (l0/lr-1)*(yr(t)-yb) -2*lam2(t)*(yl(t)-yr(t))-s, # Algebraic Constraints: 0 = xl(t)*xb+yl(t)*yb, 0 = (xl(t)-xr(t))^2+(yl(t)-yr(t))^2-l^2 }: # Initial conditions and problem variables ics := { xl(0)=0, yl(0)=1/2, xr(0)=1, yr(0)=1/2, D(xl)(0)=-1/2, D(yl)(0)=0, D(xr)(0)=-1/2, D(yr)(0)=0, lam1(0)=0, lam2(0)=0 }: vars := [xl(t),yl(t),xr(t),yr(t),lam1(t),lam2(t)]: The problem type is detected automatically for problems with algebraic constraints:sol := dsolve(eqns union ics, numeric);We can plot the physical variables in phase space:plots[odeplot](sol,[xl(t),yl(t)],0..3,numpoints=1000);plots[odeplot](sol,[xr(t),yr(t)],0..3,numpoints=1000);Also built into the interactive ODE analyzer.

New package for root finding problems beyond fsolve, Maple's standard numerical solver, e.g., finding all roots of a non-polynomial analytic function or finding all isolated roots of a system of polynomial equationswith(RootFinding): unprotect('AXESLABELS'):f := 1+2^(-z)+3^(-z)+5^(-z); AXESLABELS:=()->NULL:Analytic(f, z, re=-1..1, im=-100..100, plot);

restart; Exp := proc( x::numeric, n::integer ) local s, t, i; t := 1.0; s := t; for i to n do t := t*x/i; s := s+t; od; s; end: CodeGeneration[C]( Exp );CodeGeneration[Fortran]( Exp );CodeGeneration[Java]( Exp);New:CodeGeneration[VisualBasic]( Exp );CodeGeneration[Matlab]( Exp );

Soliton Exampleeq := diff(u(x,t),t)+6*u(x,t)*diff(u(x,t),x)+diff(u(x,t),x,x,x);ibc := {u(22, t) = 0, u(0, t) = 0, u(x, 0) = 12*(3+4*cosh(2*x-18)+cosh(4*x-12)) /(3*cosh(x+3)+cosh(3*x-15))^2, D[1](u)(0, t) = D[1](u)(22, t)};sol := pdsolve(eq,ibc,numeric,spacestep=22/512,timestep=1/128):sol[animate](t=0..1,frames=100);sol[plot3d](t=0..1, grid=[65,65], style=PATCHNOGRID);

with(DiscreteTransforms);New transform routines very fast, and implement specialized codes for radix 2,3,4,5,6,7,8,9, and 16, (as well as a standard code for prime radix). f := proc(n,x,y) local i: for i to n do x[i] := sin(i/10): y[i] := cos(i/10): end do: end proc: n := 2^20; X1 := Vector(n,datatype=float[8]): Y1 := Vector(n,datatype=float[8]): evalhf(f(n,var(X),var(Y))):tt := time(): FourierTransform(X1,Y1): time()-tt;n := 3*5*2^12*19; X2 := Vector(n,datatype=float[8]): Y2 := Vector(n,datatype=float[8]): evalhf(f(n,var(X),var(Y))):tt := time(): FourierTransform(X2,Y2): time()-tt;

with(ArrayTools);ComplexAsFloat allows data type aliasing - useful for evalhfM := Matrix(3,3,(i,j)->i-j*I,datatype=complex[8],order=C_order);Mr := ComplexAsFloat(M);M[1,1];Mr[1,1] := 0: M[1,1];Alias allows a reformat of the same data in a different structureV := Vector[row](9,i->i);Vm := Alias(V,[3,3],C_order);Vm[3,3] := 0: V[9];

f := GAMMA(a,x);df := diff(f,a);convert(df,hypergeom);

Improved handling of unknown functionsf := diff(u(x),x)*exp(v(x))*ln(w(x)) +u(x)*diff(v(x),x)*exp(v(x))*ln(w(x)) +u(x)*exp(v(x))*diff(w(x),x)/w(x) +sin(x);int(f,x);

complete replacement of the top-level command NiNJJHN1bUc2JEkqcHJvdGVjdGVkR0YlSShfc3lzbGliRzYimore powerful and returns nicer resultsextension mechanism for users to add their own summation coderestart;Sum(Psi(x)^2,x) = sum(Psi(x)^2,x);Sum(binomial(n,4*k),k=0..infinity) = simplify(sum(binomial(n,4*k),k=0..infinity)) assuming n::posint;drastic efficiency improvement for rational functionsf := (x^2+2000*x+1001000)/((x+1001)*(x+1000)*x);Sum(f,x) = sum(f,x);

restart;

Riccati type ODEsPDEtools[declare]((y,F,G)(x), prime=x);diff(y(x),x) = G(x)*y(x)^2 - (diff(F(x),x)+2*G(x)*F(x)^2)/F(x)*y(x) + (2*F(x)*diff(F(x),x)+G(x)*F(x)^3)/F(x);dsolve(%, y(x));Heun type ODEsode := 2*x*(x-1)*diff(y(x),x,x) + (2*x-1)*diff(y(x),x)+(mu*x+nu)*y(x) = 0;dsolve(ode, y(x));2nd order ODEs admitting hypergeometric solutionsdiff(y(x),x,x) = -(x^2+1)/x/(x-1)/(x+1)*diff(y(x),x)+1/(x-1)/(x+1)*y(x);dsolve(%);

sys := [x*diff(diff(f(x,y,z),x),x)+(y+1)*diff(diff(f(x,y,z),x),y)+z*diff(diff(f(x,y,z),x),z), x*diff(diff(f(x,y,z),x),y)+(y+1)*diff(diff(f(x,y,z),y),y)+z*diff(diff(f(x,y,z),y),z), x*diff(diff(f(x,y,z),x),z)+(y+1)*diff(diff(f(x,y,z),y),z)+z*diff(diff(f(x,y,z),z),z)]:pdsolve(%);

Solutions of the differential equationrestart; DE := diff(y(x),x,x)+(a-2*q*cos(2*x))*y(x) = 0;Diff(MathieuC(a,q,x),x,x) = diff(MathieuC(a,q,x),x,x); Diff(MathieuS(a,q,x),x,x) = diff(MathieuS(a,q,x),x,x);MathieuC(a,0,x),MathieuS(a,0,x);MathieuCE(n,q,x) = MathieuCE(n,q,0)*MathieuC(MathieuA(n,q),q,x); MathieuSE(n,q,x) = MathieuSEPrime(n,q,0)*MathieuS(MathieuB(n,q),q,x);MathieuCE(n,q,x+2*Pi),MathieuSE(n,q,x+2*Pi);series(MathieuA(1,q),q); series(MathieuCE(1,q,x),q,3);plot([seq(MathieuSE(n,1,z), n=1..4)], z=0..Pi, title="Odd periodic Mathieu functions, q=1", legend = [seq(se||n, n=1..4)]);

restart; with(plots): setoptions(thickness=2):f := y^2=x^3-x;implicitplot( f, x=-2..2, y=-2..2, grid=[50,50] );f := y^2=x*(x^2-D);animate( implicitplot, [ f, x=-2..2, y=-2..2, grid=[50,50] ], D=-1..1, frames=50 );

sin(x+2*y)*exp(-(x^2+y^2)/2); Context menu interactive plot builder 3D plot controls: rotation, scaling and panning

restart; with(plots): f := 1-y^2-exp(y)*x^2-1/2*x^2;p := plot3d( f, x=-1..1, y=-1..1, style=patchcontour ): T := plot3d( 1, x=-1..1, y=-1..1, color=red ): display({p,T},axes=box); transparency=0.5

"I like to program in Fortran. God programs in Fortran." David Collinette, 2004.

?OpenMapleAn interface that allows C (and now Java and Visual Basic) programs to call Maple?OpenMaple,Java

For formulae and commands but not programs.MmaTranslator:-FromMma("Exp[x] EllipticPi[a,z,b]");MmaTranslator:-FromMma("Integrate[Cos[x],{x,0,1}]");Open Mathematica Notebooks

with(linalg): Unwith(linalg):

mod5 := module() option package; export `+`,`*`,expand,factor; `+` := proc(x,y) option overload; modp(:-`+`(x,y),5); end proc: `*` := proc(x,y) option overload; modp(:-`*`(x,y),5); end proc: expand := proc() option overload; modp(Expand(args),5); end proc: factor := proc() option overload; modp(Factor(args),5); end proc: end module;with(mod5);3+23*8;expand((x-1)^5) = factor(x^5-1);unwith(mod5);3+23*8;expand((x-1)^5) <> factor(x^5-1);

StringOperations := module() option package; export `+`; `+` := proc(x::string,y::string) option overload; cat(x,y) end proc: end module;with(StringOperations);"2"+"b"+"3";2+b+3;unwith(StringOperations);"2"+"b"+"3";

You can now iterate over the entries of objects of type array, table, vector, matrix, rtable, Array, Vector, Matrix as well as list, set, and using the in syntax. B := Vector([x,1-x,1+x] );for p in B do p od;mul( p, p in B );

New package NiNJLENvbnRleHRNZW51RzYi supercedes NiNJKGNvbnRleHRHNiI=Support for creating new context menus and modifying and adding to existing ones on the flysin(A-2*B);ContextMenu:-CurrentContext:-Entries:-Add( "Combine", "combine(%EXPR)", 'algebraic'):save and restore: ContextMenu:-Save, ContextMenu:-Install

interface(elisionthreshold=100); interface(elisiondigitsbefore=5,elisiondigitsafter=3);1000!;interface(termelisionthreshold=50); interface(elisiontermsbefore=3,elisiontermsafter=1);sort(euler(150,x),x);

LinearType LinearA and hit tab. Facility also works for user-defined functions and packages

Open the tools menu and select Spellcheck ...

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cWRGXXNGU0NHXUNGdXRQX1NGY0NFY1NGYVNRcWRGWnFmZVVPQGJGXVNRcWRGWm9mZVVPQGpWcG9nRD1WYG1mZVU7dmBXV0VQTVBMTVQ8bWhoP0pUcG9nRF1wXl9uXmBxZmVVO1BtUnBvZ3JHU0NHZUNHdXRQOmtTUXFkRkpVRG1oaE9TOmdTUXFkRmpVPG1oaD9nW3FWYFdXRVA9aWNHdXRQOmlTUTE6cWRGX1NGU1NHXVNHdXRQX1NGbUNFZVNGa1NRcWRGWE1QUE1TQG1oaE9TZmBmZmBsXmBXV2VsQkdTU0dfc0d1dFBfS1NsbFRITVJwb2dETVJgTVBQbVNIbWhoT1N2YGZmYG1mYFczOw==cWRGW2NHU1NHXXNHdXRQX0NGa0NFZWNGW1NRcWRGXUNGU1NHX0NHdXRQX0tTbGxURG1VcG9nUkdTU0dhQ0Z1dFA+YWZmYG1OYFdXZWxOYGpeX29WYG9mZVVPQF9DRWVzRmtTUXFkRkxNUFBNVEBtaGhPU2ZgZmZgbjU6cWRGYVNGU1NHYWNGdXRQX3NGW0NFZXNGZVNRcWRGWnNmZVVPQF1bbk5gV1dFUE1QUE1UOmlDRWVzRlpyXl9vVmBwZmVVT0BpO2FTUXFkRkxNUFBtU0Q9RkBIPTE6cXRGaUNIU3NGYUNGdXRQYXNHSlRwb2dIXXNeX21WYHFmZVVXQEJHXVNRcXRGa0NGU3NGY2NHdXRQYTtQTVJwb2c6TG1oaD9dQ0VhU0dpU1FxPG5gbGZlVVdAalVwb2c6aVNGdXRQOmVTUXF0RkpWPG1oaD9KVHBvZzpcXG1oaG9TWnNOYFdXRVpxZmVVO2NDRl1TUXE8Ukd1dFA+YGZeYGpGYVdXZW06XXNGdXRQYTt2YFdXRUpTQG1oaF9xSlRETVRwb2c6XFxtaGg/ckZfU1FxPGJHdXRQWm4+YFdXRVpuZmVVOz5hV1dFalREbWhoP0pVcG9nOmdDRnV0UDpjU1FxPEJIdXRQWnFOYFdXRVpwZmVVOz5hVzM7cWRGXUNHU0NHXWNGdXRQX1NGW0NFY1NGSlJUTVBMbVI6YUNFY1NGXVNRcVRGbVNIU0NHXTtmYGZeYGs6QE1QTG1SWnJ2YGZeYGs6SE1QTD1KUmxMVD5gV1dla3Zgb15fbjo+YGZeQEpVWE1QTE1SYG1oaG9SVmBmXmBqOmVTSFNDR1s7XmBmXmBqOjxNUExNUlpubmBmXmBqOkRNUExNUlptPmFmXmBqOkxNUEw9SlJsTFQ6X3NHU0NHXTtOYGZeYGs6XUNIU0NHXTteYGZSRlpqXj9dOzxNVWxcXGs6SE1QRmBralZgTVBGQFJHUztSRlM7PmFxXj9abV4/alVcXE1QTD1CR1NDR1prXl9uQkZuYHFeP1ptXj9abF5fbjY6cVRGX0NFYVNIYVNRcVRGY0NFYVNIZ1NRcVRGZ0NFYVNIbVNRcVRGa0NFY0NGX1NRcVRGbUNFY0NGZVNRcWRGX0NFY0NGaVNRcWRGOjE6cWRGaUNFYVNIZVNRcWRGZ0NFYVNIbVNRcWRGYUNFY0NGY1NRcWRGW0NFY0NGa1NRcVRGbUNFY1NGXVNRcVRGaUNFY1NGY1NRcVRGZ0NFY1NGaVNRcVRGZUNFY1NGMzo=cWRGZ0NFY1NGXVNRcWRGZUNFY1NGY1NRcWRGY0NFY1NGaVNRcWRGZVtsPmBXV2VsRmFmXmBsWm1OYGZeYGtGYVdXZW1WYGZeYGtuYFdXZW1eYGZeQGFTUXF0Rl1DRWNTRl07a0NFY1NGW1NRcWRGalIzOg==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cWRHXUNIU2NGaUNGdXRQZ1NGbUNFX2NHaVNRcWRHVE1QRE1VUG1oaE9VVmBmTmBwdkBSRlNjRmlTRnV0UGdLUmxMU1hNVHBvZ1Q9Qkh1dFBnQ0ZtQ0VfQ0hdU1FxXFxyXl9sPmFuZmVVOz5hV1dFalZEbWhoT1U6Z1NRcWRHckZbQ0Z1dFA6Y1NRcVxccV5fbT5gcWZlVTs+YVczOw==cVRHbXNHU3NGW0NGdXRQZ0NGW0NFX1NIbVNRcWRHUE1QRG1WXFxtaGhPVT5hZk5gc3ZgV1dlcEZgbF5fbEZhcGZlVW9AZ0NFX1NIWnNeX2xGYW9mZVVvYGxOYGZOQDM6cWRHYVNHU2NGZ2NGdXRQZ3NGZ0NFX2NHZVNRcWRHSE1QRE1VWG1oaE9VTmBmTmBxPmBXV2VwQkZTY0Zpc0Z1dFBnY0ZtQ0Vfc0djU1ExOg==cWRHY0NHU2NGZ2NHdXRQZ0NHckdbU1FxZEdETVBEbVVMbWhoT1VGYGZOYHF2YFdXZXBCRlNjRmtTRnV0UGdzRm1DRV9DSGNTUXFcXHJeX2w+YXFmZVU7YG1ScG9nOlBtaGhPVUxtUlJIaVNRcVxcbmpWYG1oaE9ValM8TVJwNT8=cWRHZ3NHU2NGaXNGdXRQZ2NHZ0NFX3NHZ1NRcWRHUE1QRG1VYG1oaE9VTmBmTmByTmBXV2VwZmByXl9sPmFwZmVVa1RsTFNcXE1WcG9nVF1tXl9sRmFrZmVVb0BfQ0VfU0hhU1ExOg==cWRHZUNGU2NGaUNIdXRQZ1NHYUNFX0NIW1NRcWRHVE1QRE1WQG1oaE9VRmFmTmByVmBXV2VwbmBsXl9sPmFwZmVVb0BlQ0VfQ0hrU1FxXFxyXl9sRmFqZmVVc0ddQ0VfU0hdU1FxXFxuXl9sRmFtZmVVa1NsTFNgPTE6cWRHa0NHU2NGa1NHdXRQZ0NIYUNFX0NIa1NRcWRHRE1QRG1WQG1oaE9VVkBgTVRwb2dUXXBeX2xGYW9mZVVrVmxMU2BtU3BvZ1RtVkRNUERdamZlVW9AYUNFX0NIaVNRcWRHPE1QRE1WUD1cXE1VQkhabToyOg==cWRHbWNGU2NGZ3NGdXRQZ1NIZUNFX2NHY1NRcWRHXFxNUERNVVBtaGhvVTxNUmxMU1RNVnBvZ1hda15fbHZga2ZlVXdAX0NFX3NHY1NRcXRHSE1QRG1VXFxtaGg/Y0NFX0NIXVNRcVxcb15fbD5hb2ZlVWtVbExTXFxNVnBvZzptY0Z1dFBpO25gV1dlcWJHU2NGbVNIdXRQaUtUVmBqTmBXV0VAXW0+YG1mZVVrVmxsUzw9MTo=cWRGX1NGU0NHbVNGdXRQX2NGZUNFY1NIalM8TVBMbVY6YUNFY1NIX1NRcWRGWE1QTG1WWm5OYGZeYHM6WE1QTD1SR11DRWM7UkdTQ0c6bUNFY1NIYVNRcWRGZ1NGU0NHNDo=cWRGX0NHU0NHa2NHdXRQX2NGXUNFY0NIbVNRcWRGXUNIU0NHbVNGdXRQX2NGW0NFY1NIY1NRcWRGSE1QTG1WUG1oaE9TbmBmXmBzdmBXV2VsQkhTQ0c0Og==cXRGYUNGU0NHbXNHdXRQYXNGZUNFY1NIWnNeX25GQUJHYUNFY1NIWnJeX25GQVJHYUNFYztyR1NDR207VG1SbExUYE1WcG9nSF1wXl9uRkFqVmxMVHZAdmBtXl9uOm5gZl5AZ1NRcXRGSD1MbWhob1M+YGZeQGFTUXF0RmdDSFNDR0RtaDI6cXRGaWNHU0NHbUNIdXRQYXNHY0NFZUNGXVNRcXRGQE1QUE1STG1oaG9TVG1WbGxUPG1VcG9nSF1wXl9vPmBzZmVVV0A6MTo=cXRGa1NGU1NHXVNIdXRQYXNHbUNFZWNGX1NRcXRGVE1QUE1TTG1oaG9TRmBmZmBsPmFXV2VtbmBxXl9vVmBrZmVVV0BhQ0Vlc0ZjU1FxXFxqXl9vVmBwZmVVV0BqVXA1Pw==cXRGZ3NHU1NHX0NGdXRQYXNHXUNFZWNGX1NRcXRGTE1QUE1TTG1oaG9TbmBmZmBsdmBXV2VtPmFqXl9vVmBqZmVVa1NsbFRITVNwb2dCR1NTR2FzRnU0PA==cXRGbUNHU1NHX0NIdXRQYVNIXUNFZXNGW1NRcXRGWm5mZVVXQGNbbWZgV1dlbXJHU1NHYUNHalZsbFRIbVJwb2dIXXBeX29WYGo6YUNFZWNGbVNRcXRGOjI6cURHW3NHU1NHXVNIdXRQY0NGa0NFZWNGX1NRcURHXUNGU1NHX1NHdXRQYztGYVdXRUBNUFBtU0RtaGg/alNwNT8=cURHW3NGU1NHX2NHdXRQY0NGZ0NFZWNGZVNRcURHXUNGU1NHXztWYGZmQGNTUXFER1BNUFBNUzQ6cURHY2NGU1NHXUNIdXRQY3NGbUNFZVNGaVNRcURHVE1QUG1SVG1oaE9UVmBmZmBrZmBXV2VuTmBzXl9vOmZgZmZga3ZAYkZTU0dfQ0Z1dFBja1NsbFREbVNwb2dMXXBeX29OYG9mZVVrVmJGaVNRcWxTRE1QUF1zZmVVX0BlQ0Vlc0ZbU1FxXFxyXl9vVmBtZmVVQ0dbQ0Vlc0ZnU1FxbFNYTVBQbVNcXG1oaD9hW206XzthOz5hZmZAZVNRcVxcc1psZmVVX2BtTkBIbVJwb2dMPUJGMjo=cURHZUNHU1NHX2NHdXRQY1NHXUNFZWNGa1NRcURHY0NIU1NHYVNGdXRQY0tUbGxUSE1TcG9nTF1rXl9vVmBuZmVVX0A6MTo=cURHY1NGU1NHX3NHdXRQY0NHY0NFZWNGa1NRcURHWE1QUG1TPG1oaE9UUE1SbGxUSG1ScG9nTF1tXl9vVmBuZmVVX0BnQ0Vlc0ZlU1FxREdcXE1QUG1TVG1oMjo=cXRGa1NGU3NGZVNIdXRQYUNIY0NFYVNHa1NRcXRGXFxNUEhtVFpzTmBmVmBvOlBNUEhtVGA9RmFmVmBvWm4+YG1eX21mQEpVbGxTVE1ScG9nTG1SPE1QSE1VOmNDRWFjR1pyXl9tbkBiRl9DRWFjR1puXl9tNjo=cURHXXNHU3NGZVNHdXRQY2NGW0NFYVNHZ1NRcURHTE1QSG1UWG1oaE9UdmBmVkBrU1FxREdhQ0ZTc0ZnQ0Z1dFBjY0ZtQ0VhY0dhU1FxREdUTVBITVVMbWhoT1RWYGZWYHBuYFdXRVpxZjZFcVRHZVNIU0NIaVNRcVRHZVNHU0NIaTtATVBcXE1WcG9nUE1UXFxNUGBNUnBvZ1Bdb15fc1ZgV1dlb0JHU1NIZ1NRcVRHRE1QYG1WcG9nUD1ATVJIbWhoP2pVcG9nOl1TRnV0UGVrUmxsUkBNVHBvZ1Bdal5fa0ZgcWZlVXNGbUNFXWNGXVNRcTxSR3V0UGVLVmxsUkQ9MTo=cVRHYUNHU1NGW0NIdXRQZXNGa0NFXUNGSlRETVBATVI6Z0NFXUNGZ1NRcVRHZUNGU1NGWzs6Mzo=cVRHaVNGU1NIXVNRcVRHZ0NIU1NIY1NRcVRHVE1QYG1VcG9nUF1uXl9rPmBqZmVVZ0BfQ0VdQ0ZjU1FxXFxqXl9rPmBxZmVVU0dtQ0VdU0ZbU1FxPEJHdXRQOmtTUXFUR2dTRlNTRl9TRnV0UE5ARE1TcDU/cVRHa3NGU1NIbVNRcVRHa2NGU1NGW2NGdXRQZXNHbUNFXUNGZ1NRcVRHVE1QQE1SYG1oaD9fQ0VdU0ZhU1FxVEdnQ0hTU0ZdY0d1dFBuYGZGYGt2YFczOw==cVRHZ1NIU1NGW2NHdXRQZXNHX0NFXUNGaVNRcVRHUE1QQG1SPG1oaG9UdmBmRmBrVmBXV2VvUkhTU0ZdY0d1dFBcXE1TbGxSQG1VcG9nOjQ6cVRHa1NIU0NIXVNRcVRHbUNGU0NIY1NRcVRHRE1QXFxtVXBvZ1BdbV5fcz5gV1dlb1JHU1NIY1NRcVxccF5fc3ZgV1dFUkZbU0Z1dFA6ZVNRcVRHUF1rPmBzZmVVZ0Bha1JATVNwb2dQXWxSRl1TR3V0UFxcPV1TRmtTUXFUR1RNUEBNUzxtaGg/YUNFXWNGYVNRcVRHPE1QQE1TTG1oaD86MTo=cURHY0NGU3NGZXNGdXRQY0NHYUNFYVNHZ1NRcURHVE1QSG1UYG1oaE9UPmFmVmBwTmBXV2VuZmBqXl9tbmBvZmVVX0BfQ0VhY0dpU1ExOg==cURHZ0NGU3NGZWNGdXRQY2NHalVwb2dMbVRYTVBITVVAbWhoT1RmYGZWYHBeYFdXZW5iRlNzRmdTSHV0UGNDR21DRWFzR19TUXFcXHFeX212YG9mZVVfQGdDRWFzR2tTUXFER1BNUEhtVWBtaDI6cURHZVNHU3NGaUNGdXRQY1NHSlRwb2dMXW5eX212YHFmZVVfQGlDRWFzR2tTUXFER2dDRlNzRmlzR2pTbGxTWE1VcG9nTF1wXl9tdmBuOmlDRWFrUnBvZ0xdbl5fbUJGSlI6ZkBiRnV0UGM7NTo=cURHa2NHU3NGZWNHdXRQY0NIaUNFYWNHW1NRcURHWm9mZVVfQHJHW1NRcVxccGpVTG1oaE9UOmdTUTE6cURHa2NGU3NGZ2NHdXRQY0NIaUNFYWNHalZATVBITVU6ZUNFYWNHWnJeX21uYG9mZVVfQG1DRWFjRzM6cWRGa2NHU0NHa1NIdXRQX0NIUkhhU1FxZEZacWZlVU9AZmBqRmBXV2VsUkdTU0dbQ0d1dFBfO0ZhV1dFTE1QUG1SRG1oaE9TVmBmZmBrZmBXV2VsOmBtaGg/alQ6UkZ1dFBeQDxNVnBvZ0Rdb1pvZmVVS1ZsbFQ8TVRqVkBNUFBNUkhtaGg/Y0NFZUtTcG9nckdTU0dbc0ZKVmxsVG5gV1dlbFJIU1NHW1NIVmBqPmBmZmBrTkBIPWJHdXRQYWtSbGxUQG1WOjY6cVRHW1NIU3NGY3NHdXRQZVNGX0NFYVNHW1NRcVRHWm9mZVVnQGFDRWFTR21TUXFUR0xNUEhNVUxtaGhvVGZgZlZgcHZgV1dFalVAbWhob1RuYGZWYHFmYFdXRVprOmJHWnJeX21uYG5abEZgZlZgcE5gV1dlb1JHU3NGZzs+YWZWQGFTUXFUR2FDRlNzRmdjR3V0UGVrUmxsU0ZhV1dFalVIbWhoP19DRWFzRzM6cVRHaVNGU3NGY0NHdXRQZXNHW0NFYUNHXVNRcVRHZ0NIU3NGYUNIdXRQZWtUbGxTSE1VcG9nUF1rXl9tVmBxZmVVZ2BvdmBmVmBtPkFCR1NzRmFTSHV0UGVLUmxsUz5gV1dlb15gcV5fbV5gazpjQ0VhQ0dhU1FxVEdITVBITVRUbWhoP1JHW1NRcTxCR3V0UF5AUG1VcG9nOmdTRnV0UG5gZlZgcF5gV1dFWnJmZVVrVXJHXVNRcTxiRnU0PA==cVRHYVNIU3NGZUNIdXRQZUNHYUNFYVNHWnBeX21mYHFmZVVnYG8+YGZWYG86TE1QSG1UOmlDRWFTRzM6cVRHaVNIU3NGY2NGdXRQZXNHaUNFYUNHZ1NRcVRHTE1QSE1UYG1oaG9URmBmVmBvTmBXV0VnU0hTc0ZlQ0d1NDw=cVRHbUNGU3NGY2NGdXRQZUNIa0NFYUNHZVNRcVRHUE1QSE1UXFxtaGhvVE5gZlZgb0ZgV1dlb3Zgc15fbWZgb2ZlVWtVbGxTUE1WcG9nUkdTc0ZnU0Z1dFBeYGZWYHBeYFdXZW9yRlNzRmdzR3V0UGVLVHJHW1NRcVRHUD1pc0Z1dFBla1VyR2dTUXFUR2A9aXNHdTQ8cWRHW0NHU3NGZXNGdXRQZ0NGXUNFYVNHZ1NRcVRHbUNIU3NGZVNIdXRQZUtUbGxTVG1TcG9nUF1qXl9tbmBwZmVVQ0hpQ0VhY0dtU1FxXFxuXl9tdmBrZmVVZ0BKU3A1Pw==cVRHa0NIU3NGZVNIdXRQZVNIXUNFYWNHXVNRcVRHTE1QSE1VTG1oaG9UdmBmVmBwbmBXV2VwPmBrXl9tUkh1dFBnS1RsbFNYbVJwb2dUXXFeX212YGxmZVVvQGtDRWFzR2FTUTE6cWRHXXNGU3NGZ2NGdXRQZ1NGZUNFYWNHZVNRcWRHVE1QSE1VXFxtaGhPVXZgZlZgcUZgV1dlcE5gal5fbXZgamZlVW9AX0NFYWNHaVNRcWRHTE1QSE1VTG1oaE9VZmBmVkBdU1FxXFxtXl9tZmByZmVVU0ZtQ0VhU0dacFpqZmVVa1NiR187Wm40Og==cWRHX1NGU3NGY1NGdXRQZ2NGY0NFYUNHX1NRcWRHWE1QSE1USG1oaE9VSE1SbGxTTE1UcG9nVF1tXl9tXmBwZmVVb0BnQ0VhQ0drU1FxZEdcXE1QSG1UQG1oaD9qVHBvZ1Q9Ukh1dFBnO1RtU3BvZ3JHU3NGZ2NHdXRQbkBUbVZwb2dyRnZgbGZlVUtSckdlU1FxTFNqVVRtaGg/Z0NFYXNHaVNRMTo=cVRGW2NGU0NHZVNRcVRGW0NHU0NHbVNRcVRGUE1QUE1UcG9nQD1GYVdXRWJHZVNRcVxcbmJHa1NRcVRGckdfU1FxVEZqVXBvZ0A9XFxtUnBvZ0A9NTo=cVRGW3NGU0NHYVNRcVRGW0NIU0NHYTtdY0ZTQ0djU1FxVEZcXE1QTE1USlNETVBMbVRwb2dAXXBeX25mQFJIU0NHZTU7cVRGW3NGU2NHW1NRcVRGW0NIU2NHWztdY0ZTY0dbO1hNUFRNUkpTQE1QVE1SWm5eX3A+QDE6cVRGW0NHU3NHY1NRcVRGW3NHU3NHZVNRcVRGXVNGU3NHZTtUTVBYbVRKU0RNUFhtVFpyXl9xbmBXV2VrVmBsXl9xbkByRlNzR2c1Ow==cVRGYUNIU2NHYVNRcVRGYVNIU2NHZ1NRcVRGckdbU1FxVEZjY0ZTc0dfU1FxVEZQTVBYbVJwb2dAXXFeX3A+YVdXZWtmYGpeX3BeYFdXZWtSRlNjR11TUXFcXG5eX3A+YFdXRVBNUFRtU1pwXl9wbkByR1NjR21TUXFURnJHWzU7cVRGZ1NHU0NHX1NRcVRGZ2NHU0NHZ1NRcVRGUkdbU1FxVEZYTVBQbVNwb2dAPXZgV1dla1pwRmBXV2VrYkdUbVRwb2dAXW9iR21TUXFURnJHYVNRcVxcbl5fcVZAMTo=cVRGaUNIU2NHaVNRcVRGa1NGU2NHa1NRcVRGTE1QVG1VWnFeX3BmYFdXZWtCSFNjR19TUXFURlhdb0ZhV1dla3JGU2NHW1NRcVRGPE1QVE1TalVqVFpwXl9wPkFacU5gV1dFYE1QWG1TcG9nQE1WRE1QWE1UcG9nQF1vXl9xVkBSSFNzRzo1Og==cVRGbXNGU2NHXVNRcVRGbUNHU2NHY1NRcVRGVE1QVG1VcG9nQD1YbVJwb2dyR1NzR2NTUXE8PmBXV2VrWnBmYFdXZWtSSFNjR19TUXFkRltjRlNjR1tTUXFkRlBNUFBtVnBvZ0Rdcl5fcD5AOjM6cWRGX0NGU2NHYVNRcWRGXWNHU2NHYTtITVBUbVRwb2dEXWteX3A+YVdXZWxyRlhtUnBvZ0RdcHJHX1NRcWRGWE1QWG1UcG9nQkdTc0dnU1FxZEY8TVBYTVVKUmBNUFhNVTM6cWRGZXNGU0NHZVNRcWRGZTtnU1ExOg==cWRGZWNGU0NHY1NRcWRGZUNHU0NHa1NRcWRGUkdfU1FxZEZQTVBQTVVwb2dEXXBeX3A+YFdXZWxyR1NjR2NTUXE8PmFXV0VyR19TUXE8bmBXV0VKUzpUPTphU1FxZEZSR21TUXFkRlxcTVBQTVRwb2dSSFNTR11TUXFkRmdTRlNDR2s7TE1QTE1VcG9nckdTQ0dlU1FxZEZpQ0ZTQ0dpU1FxZEZATVBQTVJwb2dyRlNTR2M7YkdbO0pVcG9nWnFGYFdXRWpUcG9nOm1TUXFcXG9eX3FuQGJHU3NHYVNRcVxccV5fcD5BUkhTY0dhO2tDRlNjR1s7QE1QUG1VcG9nckZTU0dab15fb0ZAQkhTQ0dtU1FxbFY8TVBQTVNabF5fb25AckZTY0dbO0xNUFRtUzp2YFdXRXJHXTtQTVBYPTprU1ExOg==cXRGW2NHU2NHZ1NRcXRGXUNGU2NHZztMTVBUTVVacV5fcGZgV1dlbU5gal5fcE5gV1dlbVpvPmFXV2VtRmByXl9vZmBXV0VITVBQbVRaalJHZ1NRcUxSWE1QUE1WWnBqUnBvZ0hdbl5fcF5gV1dlbXJGU2NHaVNRcXRGTF1xRmBXV0VYXXFWYFdXZW1GYGteX3FWQEJHWE1TcG9nYkdTc0dfNTs=cXRGYUNGU0NHYVNRcXRGYVNGU0NHZ1NRcXRGRE1QUE1ScG9nSD1eYFdXZW1SRlBNVnBvZ0hdamJHXVNRcXRGX1NIU2NHY1NRcVxccl5fcHZgV1dlbVpxRmBXV0VUTVBYbVIzOg==cXRGX0NHU2NHXVNRcXRGX0NIU2NHXTthY0ZTY0ddO0hNUFRtUjM6cXRGY3NGU0NHX1NRcXRGYztnU1FxdEZSR19TUXFcXGxeX29mYFdXZW1CRlNjR1tTUXF0RmFDSFNjR2FTUXF0RkxNUFRtVXBvZ0hdbF5fcT5gV1dFPE1QWG1TcG9nYkY6UE1QVG1VWnJKVXBvZ15ga15fcF5gV1dlbUJHU2NHYTtYTVBUbVVac15fcT5AZmBrXl9xVkByRlNzR2dTUXFcXG5eX3F2YFczOw==cXRGZ0NIU2NHX1NRcXRGZ1NHU2NHZVNRcXRGRE1QVG1VcG9nSF1rXl9xPmBXV2VtYkZYTVRwb2dIXW9yR2dTUXF0RlxcXXF2YFdXRWlTRlNzR2c7TE1QWG1UcG9nYkdTc0dfU1FxXFxyXl9wRmFXV2VtOmU7UE1QVG1TcG9nSF1rYkdhOzxNUFRtVDM6cXRGbWNHU2NHZ1NRcXRGbWNGU2NHaVNRcXRGa1NIU2NHbVNRcXRGVE1QWG1ScG9nSF1vXl9xXmBXV2VtYkd2YFdXRWBdcT5hV1dlbUZBWG1UcG9nSF1vXl9xRkByR1NjR2lbbj5gal5fcFZgV1dlbmJGU1NHbVNRcURHSE1QUE1UcG9nTF1uXl9uRmFXV0VQTVBMbVRwb2dMXW5KU3BvZ0w9dmBXV0VSR11TUXFER2pVcG9nckZUTVJwb2dMPW5ATD1YbVI6bmBXV0VMXXE+QTE6

Maplets for tutorialsVisuals for teaching

restart; with(Student[Precalculus]);LinearInequalitiesTutor();CompositionTutor(sin(x),1/x);LimitTutor(sin(x)/x,x=0);StandardFunctionsTutor();

restart; with(Student[Calculus1]);f := (2-x^3)/x;FunctionChart(f,x=-2..2);VolumeOfRevolutionTutor();IntTutor(2*cos(ln(x))/x);NewtonsMethodTutor(cos(x),0.1);MeanValueTheoremTutor(cos(x),x=0..Pi);CurveAnalysisTutor();

restart; with(Student[LinearAlgebra]); infolevel[Student[LinearAlgebra]] := 1:

Linear systems of equationsLinearSystemPlot( {x+y+z=1, 1-2*y+z=3, x-y=0} ); Linear transformationsM := <<1,1/2>|<-1/3,3/5>>;ApplyLinearTransformPlot(M, output=animation, iterations=20, trace=4); Least squares approximationLeastSquaresPlot([[2,2],[3,2.2], [4,2.8],[5,4.1],[6,7.2]], [x,y], curve=a*x^2+b*x+c);LeastSquaresPlot([1,2,2,3,3,3], [1,1,2,1,2,3], [2.5,3.3,3.4,4.1,5.1,5.8], boxoptions=[color=blue]); Eigenvalues and eigenvectorsEigenPlot(<<1,1>|<1,0>>, showunitvectors, numvectors=25);

M := <<1,3,-1>|<2,0,4>|<0,1,1>>;InverseTutor(M);GaussEliminationTutor(M);LinearSystemPlotTutor(M);

Tools for teaching and learning multivariate calculus (Rn to R)with(Student[MultivariateCalculus]);f := 1-x^2-y^3-2*x*y;TaylorApproximation(f, [x,y]=[0,0], 2 );TaylorApproximation(f, [x,y]=[0,0], 1, output=plot, view=[-2..2,-2..2,-3..3]);Student[MultivariateCalculus][CrossSectionTutor]();

The most depressing word in Mathematics is: "RECALL". David Collinette, 2004.

Over 5000 mathematical definitions.?abs?dihedral_group

FunctionAdvisor( definition, arctanh );FunctionAdvisor( special_values, arctanh );FunctionAdvisor( branch_cuts, arctanh(z) );FunctionAdvisor( DE, BesselJ(v,z) );alias(J=BesselJ): FunctionAdvisor(identities, J(v,x));FunctionAdvisor(relate, sin, BesselJ );?FunctionAdvisor

Global Optimization ToolboxDatabase Integration Toolbox

- Numeric linear algebra speedups- Linear inequality solvers- Numeric Elliptic function evaluation enhancements- QDifferenceEquations enhancements- LinearFunctionalSystems enhancements- LRETools enhancements - PolynomialTools enhancements- diffalg enhancements- simplify enhancements- FunctionAdvisor enhancements- OpenMaple: Java and VisualBasic- Sparse distributed multivariate polynomials- remember table enhancements- Soft vs. hard interrupt- Debug button- New single file library archive format- Object constructors: appliable modules- Enhanced palettes?updates,Maple9?updates,Maple9_5