Cider Isn't Darwin Emulation, Really
Something went wrong. Try again.
133 kB · 4872 lines
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851285228532854285528562857285828592860286128622863286428652866286728682869287028712872287328742875287628772878287928802881288228832884288528862887288828892890289128922893289428952896289728982899290029012902290329042905290629072908290929102911291229132914291529162917291829192920292129222923292429252926292729282929293029312932293329342935293629372938293929402941294229432944294529462947294829492950295129522953295429552956295729582959296029612962296329642965296629672968296929702971297229732974297529762977297829792980298129822983298429852986298729882989299029912992299329942995299629972998299930003001300230033004300530063007300830093010301130123013301430153016301730183019302030213022302330243025302630273028302930303031303230333034303530363037303830393040304130423043304430453046304730483049305030513052305330543055305630573058305930603061306230633064306530663067306830693070307130723073307430753076307730783079308030813082308330843085308630873088308930903091309230933094309530963097309830993100310131023103310431053106310731083109311031113112311331143115311631173118311931203121312231233124312531263127312831293130313131323133313431353136313731383139314031413142314331443145314631473148314931503151315231533154315531563157315831593160316131623163316431653166316731683169317031713172317331743175317631773178317931803181318231833184318531863187318831893190319131923193319431953196319731983199320032013202320332043205320632073208320932103211321232133214321532163217321832193220322132223223322432253226322732283229323032313232323332343235323632373238323932403241324232433244324532463247324832493250325132523253325432553256325732583259326032613262326332643265326632673268326932703271327232733274327532763277327832793280328132823283328432853286328732883289329032913292329332943295329632973298329933003301330233033304330533063307330833093310331133123313331433153316331733183319332033213322332333243325332633273328332933303331333233333334333533363337333833393340334133423343334433453346334733483349335033513352335333543355335633573358335933603361336233633364336533663367336833693370337133723373337433753376337733783379338033813382338333843385338633873388338933903391339233933394339533963397339833993400340134023403340434053406340734083409341034113412341334143415341634173418341934203421342234233424342534263427342834293430343134323433343434353436343734383439344034413442344334443445344634473448344934503451345234533454345534563457345834593460346134623463346434653466346734683469347034713472347334743475347634773478347934803481348234833484348534863487348834893490349134923493349434953496349734983499350035013502350335043505350635073508350935103511351235133514351535163517351835193520352135223523352435253526352735283529353035313532353335343535353635373538353935403541354235433544354535463547354835493550355135523553355435553556355735583559356035613562356335643565356635673568356935703571357235733574357535763577357835793580358135823583358435853586358735883589359035913592359335943595359635973598359936003601360236033604360536063607360836093610361136123613361436153616361736183619362036213622362336243625362636273628362936303631363236333634363536363637363836393640364136423643364436453646364736483649365036513652365336543655365636573658365936603661366236633664366536663667366836693670367136723673367436753676367736783679368036813682368336843685368636873688368936903691369236933694369536963697369836993700370137023703370437053706370737083709371037113712371337143715371637173718371937203721372237233724372537263727372837293730373137323733373437353736373737383739374037413742374337443745374637473748374937503751375237533754375537563757375837593760376137623763376437653766376737683769377037713772377337743775377637773778377937803781378237833784378537863787378837893790379137923793379437953796379737983799380038013802380338043805380638073808380938103811381238133814381538163817381838193820382138223823382438253826382738283829383038313832383338343835383638373838383938403841384238433844384538463847384838493850385138523853385438553856385738583859386038613862386338643865386638673868386938703871387238733874387538763877387838793880388138823883388438853886388738883889389038913892389338943895389638973898389939003901390239033904390539063907390839093910391139123913391439153916391739183919392039213922392339243925392639273928392939303931393239333934393539363937393839393940394139423943394439453946394739483949395039513952395339543955395639573958395939603961396239633964396539663967396839693970397139723973397439753976397739783979398039813982398339843985398639873988398939903991399239933994399539963997399839994000400140024003400440054006400740084009401040114012401340144015401640174018401940204021402240234024402540264027402840294030403140324033403440354036403740384039404040414042404340444045404640474048404940504051405240534054405540564057405840594060406140624063406440654066406740684069407040714072407340744075407640774078407940804081408240834084408540864087408840894090409140924093409440954096409740984099410041014102410341044105410641074108410941104111411241134114411541164117411841194120412141224123412441254126412741284129413041314132413341344135413641374138413941404141414241434144414541464147414841494150415141524153415441554156415741584159416041614162416341644165416641674168416941704171417241734174417541764177417841794180418141824183418441854186418741884189419041914192419341944195419641974198419942004201420242034204420542064207420842094210421142124213421442154216421742184219422042214222422342244225422642274228422942304231423242334234423542364237423842394240424142424243424442454246424742484249425042514252425342544255425642574258425942604261426242634264426542664267426842694270427142724273427442754276427742784279428042814282428342844285428642874288428942904291429242934294429542964297429842994300430143024303430443054306430743084309431043114312431343144315431643174318431943204321432243234324432543264327432843294330433143324333433443354336433743384339434043414342434343444345434643474348434943504351435243534354435543564357435843594360436143624363436443654366436743684369437043714372437343744375437643774378437943804381438243834384438543864387438843894390439143924393439443954396439743984399440044014402440344044405440644074408440944104411441244134414441544164417441844194420442144224423442444254426442744284429443044314432443344344435443644374438443944404441444244434444444544464447444844494450445144524453445444554456445744584459446044614462446344644465446644674468446944704471447244734474447544764477447844794480448144824483448444854486448744884489449044914492449344944495449644974498449945004501450245034504450545064507450845094510451145124513451445154516451745184519452045214522452345244525452645274528452945304531453245334534453545364537453845394540454145424543454445454546454745484549455045514552455345544555455645574558455945604561456245634564456545664567456845694570457145724573457445754576457745784579458045814582458345844585458645874588458945904591459245934594459545964597459845994600460146024603460446054606460746084609461046114612461346144615461646174618461946204621462246234624462546264627462846294630463146324633463446354636463746384639464046414642464346444645464646474648464946504651465246534654465546564657465846594660466146624663466446654666466746684669467046714672467346744675467646774678467946804681468246834684468546864687468846894690469146924693469446954696469746984699470047014702470347044705470647074708470947104711471247134714471547164717471847194720472147224723472447254726472747284729473047314732473347344735473647374738473947404741474247434744474547464747474847494750475147524753475447554756475747584759476047614762476347644765476647674768476947704771477247734774477547764777477847794780478147824783478447854786478747884789479047914792479347944795479647974798479948004801480248034804480548064807480848094810481148124813481448154816481748184819482048214822482348244825482648274828482948304831483248334834483548364837483848394840484148424843484448454846484748484849485048514852485348544855485648574858485948604861486248634864486548664867486848694870487148724873// -*- C++ -*-//===-------------------------- valarray ----------------------------------===////// The LLVM Compiler Infrastructure//// This file is dual licensed under the MIT and the University of Illinois Open// Source Licenses. See LICENSE.TXT for details.////===----------------------------------------------------------------------===//#ifndef _LIBCPP_VALARRAY#define _LIBCPP_VALARRAY/* valarray synopsisnamespace std{template<class T>class valarray{public: typedef T value_type; // construct/destroy: valarray(); explicit valarray(size_t n); valarray(const value_type& x, size_t n); valarray(const value_type* px, size_t n); valarray(const valarray& v); valarray(valarray&& v) noexcept; valarray(const slice_array<value_type>& sa); valarray(const gslice_array<value_type>& ga); valarray(const mask_array<value_type>& ma); valarray(const indirect_array<value_type>& ia); valarray(initializer_list<value_type> il); ~valarray(); // assignment: valarray& operator=(const valarray& v); valarray& operator=(valarray&& v) noexcept; valarray& operator=(initializer_list<value_type> il); valarray& operator=(const value_type& x); valarray& operator=(const slice_array<value_type>& sa); valarray& operator=(const gslice_array<value_type>& ga); valarray& operator=(const mask_array<value_type>& ma); valarray& operator=(const indirect_array<value_type>& ia); // element access: const value_type& operator[](size_t i) const; value_type& operator[](size_t i); // subset operations: valarray operator[](slice s) const; slice_array<value_type> operator[](slice s); valarray operator[](const gslice& gs) const; gslice_array<value_type> operator[](const gslice& gs); valarray operator[](const valarray<bool>& vb) const; mask_array<value_type> operator[](const valarray<bool>& vb); valarray operator[](const valarray<size_t>& vs) const; indirect_array<value_type> operator[](const valarray<size_t>& vs); // unary operators: valarray operator+() const; valarray operator-() const; valarray operator~() const; valarray<bool> operator!() const; // computed assignment: valarray& operator*= (const value_type& x); valarray& operator/= (const value_type& x); valarray& operator%= (const value_type& x); valarray& operator+= (const value_type& x); valarray& operator-= (const value_type& x); valarray& operator^= (const value_type& x); valarray& operator&= (const value_type& x); valarray& operator|= (const value_type& x); valarray& operator<<=(const value_type& x); valarray& operator>>=(const value_type& x); valarray& operator*= (const valarray& v); valarray& operator/= (const valarray& v); valarray& operator%= (const valarray& v); valarray& operator+= (const valarray& v); valarray& operator-= (const valarray& v); valarray& operator^= (const valarray& v); valarray& operator|= (const valarray& v); valarray& operator&= (const valarray& v); valarray& operator<<=(const valarray& v); valarray& operator>>=(const valarray& v); // member functions: void swap(valarray& v) noexcept; size_t size() const; value_type sum() const; value_type min() const; value_type max() const; valarray shift (int i) const; valarray cshift(int i) const; valarray apply(value_type f(value_type)) const; valarray apply(value_type f(const value_type&)) const; void resize(size_t n, value_type x = value_type());};class slice{public: slice(); slice(size_t start, size_t size, size_t stride); size_t start() const; size_t size() const; size_t stride() const;};template <class T>class slice_array{public: typedef T value_type; const slice_array& operator=(const slice_array& sa) const; void operator= (const valarray<value_type>& v) const; void operator*= (const valarray<value_type>& v) const; void operator/= (const valarray<value_type>& v) const; void operator%= (const valarray<value_type>& v) const; void operator+= (const valarray<value_type>& v) const; void operator-= (const valarray<value_type>& v) const; void operator^= (const valarray<value_type>& v) const; void operator&= (const valarray<value_type>& v) const; void operator|= (const valarray<value_type>& v) const; void operator<<=(const valarray<value_type>& v) const; void operator>>=(const valarray<value_type>& v) const; void operator=(const value_type& x) const; slice_array() = delete;};class gslice{public: gslice(); gslice(size_t start, const valarray<size_t>& size, const valarray<size_t>& stride); size_t start() const; valarray<size_t> size() const; valarray<size_t> stride() const;};template <class T>class gslice_array{public: typedef T value_type; void operator= (const valarray<value_type>& v) const; void operator*= (const valarray<value_type>& v) const; void operator/= (const valarray<value_type>& v) const; void operator%= (const valarray<value_type>& v) const; void operator+= (const valarray<value_type>& v) const; void operator-= (const valarray<value_type>& v) const; void operator^= (const valarray<value_type>& v) const; void operator&= (const valarray<value_type>& v) const; void operator|= (const valarray<value_type>& v) const; void operator<<=(const valarray<value_type>& v) const; void operator>>=(const valarray<value_type>& v) const; gslice_array(const gslice_array& ga); ~gslice_array(); const gslice_array& operator=(const gslice_array& ga) const; void operator=(const value_type& x) const; gslice_array() = delete;};template <class T>class mask_array{public: typedef T value_type; void operator= (const valarray<value_type>& v) const; void operator*= (const valarray<value_type>& v) const; void operator/= (const valarray<value_type>& v) const; void operator%= (const valarray<value_type>& v) const; void operator+= (const valarray<value_type>& v) const; void operator-= (const valarray<value_type>& v) const; void operator^= (const valarray<value_type>& v) const; void operator&= (const valarray<value_type>& v) const; void operator|= (const valarray<value_type>& v) const; void operator<<=(const valarray<value_type>& v) const; void operator>>=(const valarray<value_type>& v) const; mask_array(const mask_array& ma); ~mask_array(); const mask_array& operator=(const mask_array& ma) const; void operator=(const value_type& x) const; mask_array() = delete;};template <class T>class indirect_array{public: typedef T value_type; void operator= (const valarray<value_type>& v) const; void operator*= (const valarray<value_type>& v) const; void operator/= (const valarray<value_type>& v) const; void operator%= (const valarray<value_type>& v) const; void operator+= (const valarray<value_type>& v) const; void operator-= (const valarray<value_type>& v) const; void operator^= (const valarray<value_type>& v) const; void operator&= (const valarray<value_type>& v) const; void operator|= (const valarray<value_type>& v) const; void operator<<=(const valarray<value_type>& v) const; void operator>>=(const valarray<value_type>& v) const; indirect_array(const indirect_array& ia); ~indirect_array(); const indirect_array& operator=(const indirect_array& ia) const; void operator=(const value_type& x) const; indirect_array() = delete;};template<class T> void swap(valarray<T>& x, valarray<T>& y) noexcept;template<class T> valarray<T> operator* (const valarray<T>& x, const valarray<T>& y);template<class T> valarray<T> operator* (const valarray<T>& x, const T& y);template<class T> valarray<T> operator* (const T& x, const valarray<T>& y);template<class T> valarray<T> operator/ (const valarray<T>& x, const valarray<T>& y);template<class T> valarray<T> operator/ (const valarray<T>& x, const T& y);template<class T> valarray<T> operator/ (const T& x, const valarray<T>& y);template<class T> valarray<T> operator% (const valarray<T>& x, const valarray<T>& y);template<class T> valarray<T> operator% (const valarray<T>& x, const T& y);template<class T> valarray<T> operator% (const T& x, const valarray<T>& y);template<class T> valarray<T> operator+ (const valarray<T>& x, const valarray<T>& y);template<class T> valarray<T> operator+ (const valarray<T>& x, const T& y);template<class T> valarray<T> operator+ (const T& x, const valarray<T>& y);template<class T> valarray<T> operator- (const valarray<T>& x, const valarray<T>& y);template<class T> valarray<T> operator- (const valarray<T>& x, const T& y);template<class T> valarray<T> operator- (const T& x, const valarray<T>& y);template<class T> valarray<T> operator^ (const valarray<T>& x, const valarray<T>& y);template<class T> valarray<T> operator^ (const valarray<T>& x, const T& y);template<class T> valarray<T> operator^ (const T& x, const valarray<T>& y);template<class T> valarray<T> operator& (const valarray<T>& x, const valarray<T>& y);template<class T> valarray<T> operator& (const valarray<T>& x, const T& y);template<class T> valarray<T> operator& (const T& x, const valarray<T>& y);template<class T> valarray<T> operator| (const valarray<T>& x, const valarray<T>& y);template<class T> valarray<T> operator| (const valarray<T>& x, const T& y);template<class T> valarray<T> operator| (const T& x, const valarray<T>& y);template<class T> valarray<T> operator<<(const valarray<T>& x, const valarray<T>& y);template<class T> valarray<T> operator<<(const valarray<T>& x, const T& y);template<class T> valarray<T> operator<<(const T& x, const valarray<T>& y);template<class T> valarray<T> operator>>(const valarray<T>& x, const valarray<T>& y);template<class T> valarray<T> operator>>(const valarray<T>& x, const T& y);template<class T> valarray<T> operator>>(const T& x, const valarray<T>& y);template<class T> valarray<bool> operator&&(const valarray<T>& x, const valarray<T>& y);template<class T> valarray<bool> operator&&(const valarray<T>& x, const T& y);template<class T> valarray<bool> operator&&(const T& x, const valarray<T>& y);template<class T> valarray<bool> operator||(const valarray<T>& x, const valarray<T>& y);template<class T> valarray<bool> operator||(const valarray<T>& x, const T& y);template<class T> valarray<bool> operator||(const T& x, const valarray<T>& y);template<class T> valarray<bool> operator==(const valarray<T>& x, const valarray<T>& y);template<class T> valarray<bool> operator==(const valarray<T>& x, const T& y);template<class T> valarray<bool> operator==(const T& x, const valarray<T>& y);template<class T> valarray<bool> operator!=(const valarray<T>& x, const valarray<T>& y);template<class T> valarray<bool> operator!=(const valarray<T>& x, const T& y);template<class T> valarray<bool> operator!=(const T& x, const valarray<T>& y);template<class T> valarray<bool> operator< (const valarray<T>& x, const valarray<T>& y);template<class T> valarray<bool> operator< (const valarray<T>& x, const T& y);template<class T> valarray<bool> operator< (const T& x, const valarray<T>& y);template<class T> valarray<bool> operator> (const valarray<T>& x, const valarray<T>& y);template<class T> valarray<bool> operator> (const valarray<T>& x, const T& y);template<class T> valarray<bool> operator> (const T& x, const valarray<T>& y);template<class T> valarray<bool> operator<=(const valarray<T>& x, const valarray<T>& y);template<class T> valarray<bool> operator<=(const valarray<T>& x, const T& y);template<class T> valarray<bool> operator<=(const T& x, const valarray<T>& y);template<class T> valarray<bool> operator>=(const valarray<T>& x, const valarray<T>& y);template<class T> valarray<bool> operator>=(const valarray<T>& x, const T& y);template<class T> valarray<bool> operator>=(const T& x, const valarray<T>& y);template<class T> valarray<T> abs (const valarray<T>& x);template<class T> valarray<T> acos (const valarray<T>& x);template<class T> valarray<T> asin (const valarray<T>& x);template<class T> valarray<T> atan (const valarray<T>& x);template<class T> valarray<T> atan2(const valarray<T>& x, const valarray<T>& y);template<class T> valarray<T> atan2(const valarray<T>& x, const T& y);template<class T> valarray<T> atan2(const T& x, const valarray<T>& y);template<class T> valarray<T> cos (const valarray<T>& x);template<class T> valarray<T> cosh (const valarray<T>& x);template<class T> valarray<T> exp (const valarray<T>& x);template<class T> valarray<T> log (const valarray<T>& x);template<class T> valarray<T> log10(const valarray<T>& x);template<class T> valarray<T> pow(const valarray<T>& x, const valarray<T>& y);template<class T> valarray<T> pow(const valarray<T>& x, const T& y);template<class T> valarray<T> pow(const T& x, const valarray<T>& y);template<class T> valarray<T> sin (const valarray<T>& x);template<class T> valarray<T> sinh (const valarray<T>& x);template<class T> valarray<T> sqrt (const valarray<T>& x);template<class T> valarray<T> tan (const valarray<T>& x);template<class T> valarray<T> tanh (const valarray<T>& x);template <class T> unspecified1 begin(valarray<T>& v);template <class T> unspecified2 begin(const valarray<T>& v);template <class T> unspecified1 end(valarray<T>& v);template <class T> unspecified2 end(const valarray<T>& v);} // std*/#include <__config>#include <cstddef>#include <cmath>#include <initializer_list>#include <algorithm>#include <functional>#include <new>#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)#pragma GCC system_header#endif_LIBCPP_PUSH_MACROS#include <__undef_macros>_LIBCPP_BEGIN_NAMESPACE_STDtemplate<class _Tp> class _LIBCPP_TEMPLATE_VIS valarray;class _LIBCPP_TEMPLATE_VIS slice{ size_t __start_; size_t __size_; size_t __stride_;public: _LIBCPP_INLINE_VISIBILITY slice() : __start_(0), __size_(0), __stride_(0) {} _LIBCPP_INLINE_VISIBILITY slice(size_t __start, size_t __size, size_t __stride) : __start_(__start), __size_(__size), __stride_(__stride) {} _LIBCPP_INLINE_VISIBILITY size_t start() const {return __start_;} _LIBCPP_INLINE_VISIBILITY size_t size() const {return __size_;} _LIBCPP_INLINE_VISIBILITY size_t stride() const {return __stride_;}};template <class _Tp> class _LIBCPP_TEMPLATE_VIS slice_array;class _LIBCPP_TYPE_VIS gslice;template <class _Tp> class _LIBCPP_TEMPLATE_VIS gslice_array;template <class _Tp> class _LIBCPP_TEMPLATE_VIS mask_array;template <class _Tp> class _LIBCPP_TEMPLATE_VIS indirect_array;template <class _Tp>_LIBCPP_INLINE_VISIBILITY_Tp*begin(valarray<_Tp>& __v);template <class _Tp>_LIBCPP_INLINE_VISIBILITYconst _Tp*begin(const valarray<_Tp>& __v);template <class _Tp>_LIBCPP_INLINE_VISIBILITY_Tp*end(valarray<_Tp>& __v);template <class _Tp>_LIBCPP_INLINE_VISIBILITYconst _Tp*end(const valarray<_Tp>& __v);template <class _Op, class _A0>struct _UnaryOp{ typedef typename _Op::result_type result_type; typedef typename _A0::value_type value_type; _Op __op_; _A0 __a0_; _LIBCPP_INLINE_VISIBILITY _UnaryOp(const _Op& __op, const _A0& __a0) : __op_(__op), __a0_(__a0) {} _LIBCPP_INLINE_VISIBILITY result_type operator[](size_t __i) const {return __op_(__a0_[__i]);} _LIBCPP_INLINE_VISIBILITY size_t size() const {return __a0_.size();}};template <class _Op, class _A0, class _A1>struct _BinaryOp{ typedef typename _Op::result_type result_type; typedef typename _A0::value_type value_type; _Op __op_; _A0 __a0_; _A1 __a1_; _LIBCPP_INLINE_VISIBILITY _BinaryOp(const _Op& __op, const _A0& __a0, const _A1& __a1) : __op_(__op), __a0_(__a0), __a1_(__a1) {} _LIBCPP_INLINE_VISIBILITY value_type operator[](size_t __i) const {return __op_(__a0_[__i], __a1_[__i]);} _LIBCPP_INLINE_VISIBILITY size_t size() const {return __a0_.size();}};template <class _Tp>class __scalar_expr{public: typedef _Tp value_type; typedef const _Tp& result_type;private: const value_type& __t_; size_t __s_;public: _LIBCPP_INLINE_VISIBILITY explicit __scalar_expr(const value_type& __t, size_t __s) : __t_(__t), __s_(__s) {} _LIBCPP_INLINE_VISIBILITY result_type operator[](size_t) const {return __t_;} _LIBCPP_INLINE_VISIBILITY size_t size() const {return __s_;}};template <class _Tp>struct __unary_plus : unary_function<_Tp, _Tp>{ _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x) const {return +__x;}};template <class _Tp>struct __bit_not : unary_function<_Tp, _Tp>{ _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x) const {return ~__x;}};template <class _Tp>struct __bit_shift_left : binary_function<_Tp, _Tp, _Tp>{ _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const {return __x << __y;}};template <class _Tp>struct __bit_shift_right : binary_function<_Tp, _Tp, _Tp>{ _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const {return __x >> __y;}};template <class _Tp, class _Fp>struct __apply_expr : unary_function<_Tp, _Tp>{private: _Fp __f_;public: _LIBCPP_INLINE_VISIBILITY explicit __apply_expr(_Fp __f) : __f_(__f) {} _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x) const {return __f_(__x);}};template <class _Tp>struct __abs_expr : unary_function<_Tp, _Tp>{ _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x) const {return abs(__x);}};template <class _Tp>struct __acos_expr : unary_function<_Tp, _Tp>{ _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x) const {return acos(__x);}};template <class _Tp>struct __asin_expr : unary_function<_Tp, _Tp>{ _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x) const {return asin(__x);}};template <class _Tp>struct __atan_expr : unary_function<_Tp, _Tp>{ _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x) const {return atan(__x);}};template <class _Tp>struct __atan2_expr : binary_function<_Tp, _Tp, _Tp>{ _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const {return atan2(__x, __y);}};template <class _Tp>struct __cos_expr : unary_function<_Tp, _Tp>{ _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x) const {return cos(__x);}};template <class _Tp>struct __cosh_expr : unary_function<_Tp, _Tp>{ _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x) const {return cosh(__x);}};template <class _Tp>struct __exp_expr : unary_function<_Tp, _Tp>{ _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x) const {return exp(__x);}};template <class _Tp>struct __log_expr : unary_function<_Tp, _Tp>{ _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x) const {return log(__x);}};template <class _Tp>struct __log10_expr : unary_function<_Tp, _Tp>{ _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x) const {return log10(__x);}};template <class _Tp>struct __pow_expr : binary_function<_Tp, _Tp, _Tp>{ _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const {return pow(__x, __y);}};template <class _Tp>struct __sin_expr : unary_function<_Tp, _Tp>{ _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x) const {return sin(__x);}};template <class _Tp>struct __sinh_expr : unary_function<_Tp, _Tp>{ _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x) const {return sinh(__x);}};template <class _Tp>struct __sqrt_expr : unary_function<_Tp, _Tp>{ _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x) const {return sqrt(__x);}};template <class _Tp>struct __tan_expr : unary_function<_Tp, _Tp>{ _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x) const {return tan(__x);}};template <class _Tp>struct __tanh_expr : unary_function<_Tp, _Tp>{ _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x) const {return tanh(__x);}};template <class _ValExpr>class __slice_expr{ typedef typename remove_reference<_ValExpr>::type _RmExpr;public: typedef typename _RmExpr::value_type value_type; typedef value_type result_type;private: _ValExpr __expr_; size_t __start_; size_t __size_; size_t __stride_; _LIBCPP_INLINE_VISIBILITY __slice_expr(const slice& __sl, const _RmExpr& __e) : __expr_(__e), __start_(__sl.start()), __size_(__sl.size()), __stride_(__sl.stride()) {}public: _LIBCPP_INLINE_VISIBILITY result_type operator[](size_t __i) const {return __expr_[__start_ + __i * __stride_];} _LIBCPP_INLINE_VISIBILITY size_t size() const {return __size_;} template <class> friend class _LIBCPP_TEMPLATE_VIS valarray;};template <class _ValExpr>class __mask_expr;template <class _ValExpr>class __indirect_expr;template <class _ValExpr>class __shift_expr{ typedef typename remove_reference<_ValExpr>::type _RmExpr;public: typedef typename _RmExpr::value_type value_type; typedef value_type result_type;private: _ValExpr __expr_; size_t __size_; ptrdiff_t __ul_; ptrdiff_t __sn_; ptrdiff_t __n_; static const ptrdiff_t _Np = static_cast<ptrdiff_t>( sizeof(ptrdiff_t) * __CHAR_BIT__ - 1); _LIBCPP_INLINE_VISIBILITY __shift_expr(int __n, const _RmExpr& __e) : __expr_(__e), __size_(__e.size()), __n_(__n) { ptrdiff_t __neg_n = static_cast<ptrdiff_t>(__n_ >> _Np); __sn_ = __neg_n | static_cast<ptrdiff_t>(static_cast<size_t>(-__n_) >> _Np); __ul_ = ((__size_ - __n_) & ~__neg_n) | ((__n_ + 1) & __neg_n); }public: _LIBCPP_INLINE_VISIBILITY result_type operator[](size_t __j) const { ptrdiff_t __i = static_cast<ptrdiff_t>(__j); ptrdiff_t __m = (__sn_ * __i - __ul_) >> _Np; return (__expr_[(__i + __n_) & __m] & __m) | (value_type() & ~__m); } _LIBCPP_INLINE_VISIBILITY size_t size() const {return __size_;} template <class> friend class __val_expr;};template <class _ValExpr>class __cshift_expr{ typedef typename remove_reference<_ValExpr>::type _RmExpr;public: typedef typename _RmExpr::value_type value_type; typedef value_type result_type;private: _ValExpr __expr_; size_t __size_; size_t __m_; size_t __o1_; size_t __o2_; _LIBCPP_INLINE_VISIBILITY __cshift_expr(int __n, const _RmExpr& __e) : __expr_(__e), __size_(__e.size()) { __n %= static_cast<int>(__size_); if (__n >= 0) { __m_ = __size_ - __n; __o1_ = __n; __o2_ = __n - __size_; } else { __m_ = -__n; __o1_ = __n + __size_; __o2_ = __n; } }public: _LIBCPP_INLINE_VISIBILITY result_type operator[](size_t __i) const { if (__i < __m_) return __expr_[__i + __o1_]; return __expr_[__i + __o2_]; } _LIBCPP_INLINE_VISIBILITY size_t size() const {return __size_;} template <class> friend class __val_expr;};template<class _ValExpr>class __val_expr;template<class _ValExpr>struct __is_val_expr : false_type {};template<class _ValExpr>struct __is_val_expr<__val_expr<_ValExpr> > : true_type {};template<class _Tp>struct __is_val_expr<valarray<_Tp> > : true_type {};template<class _Tp>class _LIBCPP_TEMPLATE_VIS valarray{public: typedef _Tp value_type; typedef _Tp result_type;private: value_type* __begin_; value_type* __end_;public: // construct/destroy: _LIBCPP_INLINE_VISIBILITY valarray() : __begin_(0), __end_(0) {} inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY explicit valarray(size_t __n); _LIBCPP_INLINE_VISIBILITY valarray(const value_type& __x, size_t __n); valarray(const value_type* __p, size_t __n); valarray(const valarray& __v);#ifndef _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY valarray(valarray&& __v) _NOEXCEPT; valarray(initializer_list<value_type> __il);#endif // _LIBCPP_CXX03_LANG valarray(const slice_array<value_type>& __sa); valarray(const gslice_array<value_type>& __ga); valarray(const mask_array<value_type>& __ma); valarray(const indirect_array<value_type>& __ia); inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY ~valarray(); // assignment: valarray& operator=(const valarray& __v);#ifndef _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY valarray& operator=(valarray&& __v) _NOEXCEPT; _LIBCPP_INLINE_VISIBILITY valarray& operator=(initializer_list<value_type>);#endif // _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY valarray& operator=(const value_type& __x); _LIBCPP_INLINE_VISIBILITY valarray& operator=(const slice_array<value_type>& __sa); _LIBCPP_INLINE_VISIBILITY valarray& operator=(const gslice_array<value_type>& __ga); _LIBCPP_INLINE_VISIBILITY valarray& operator=(const mask_array<value_type>& __ma); _LIBCPP_INLINE_VISIBILITY valarray& operator=(const indirect_array<value_type>& __ia); template <class _ValExpr> _LIBCPP_INLINE_VISIBILITY valarray& operator=(const __val_expr<_ValExpr>& __v); // element access: _LIBCPP_INLINE_VISIBILITY const value_type& operator[](size_t __i) const {return __begin_[__i];} _LIBCPP_INLINE_VISIBILITY value_type& operator[](size_t __i) {return __begin_[__i];} // subset operations: _LIBCPP_INLINE_VISIBILITY __val_expr<__slice_expr<const valarray&> > operator[](slice __s) const; _LIBCPP_INLINE_VISIBILITY slice_array<value_type> operator[](slice __s); _LIBCPP_INLINE_VISIBILITY __val_expr<__indirect_expr<const valarray&> > operator[](const gslice& __gs) const; _LIBCPP_INLINE_VISIBILITY gslice_array<value_type> operator[](const gslice& __gs);#ifndef _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY __val_expr<__indirect_expr<const valarray&> > operator[](gslice&& __gs) const; _LIBCPP_INLINE_VISIBILITY gslice_array<value_type> operator[](gslice&& __gs);#endif // _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY __val_expr<__mask_expr<const valarray&> > operator[](const valarray<bool>& __vb) const; _LIBCPP_INLINE_VISIBILITY mask_array<value_type> operator[](const valarray<bool>& __vb);#ifndef _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY __val_expr<__mask_expr<const valarray&> > operator[](valarray<bool>&& __vb) const; _LIBCPP_INLINE_VISIBILITY mask_array<value_type> operator[](valarray<bool>&& __vb);#endif // _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY __val_expr<__indirect_expr<const valarray&> > operator[](const valarray<size_t>& __vs) const; _LIBCPP_INLINE_VISIBILITY indirect_array<value_type> operator[](const valarray<size_t>& __vs);#ifndef _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY __val_expr<__indirect_expr<const valarray&> > operator[](valarray<size_t>&& __vs) const; _LIBCPP_INLINE_VISIBILITY indirect_array<value_type> operator[](valarray<size_t>&& __vs);#endif // _LIBCPP_CXX03_LANG // unary operators: valarray operator+() const; valarray operator-() const; valarray operator~() const; valarray<bool> operator!() const; // computed assignment: _LIBCPP_INLINE_VISIBILITY valarray& operator*= (const value_type& __x); _LIBCPP_INLINE_VISIBILITY valarray& operator/= (const value_type& __x); _LIBCPP_INLINE_VISIBILITY valarray& operator%= (const value_type& __x); _LIBCPP_INLINE_VISIBILITY valarray& operator+= (const value_type& __x); _LIBCPP_INLINE_VISIBILITY valarray& operator-= (const value_type& __x); _LIBCPP_INLINE_VISIBILITY valarray& operator^= (const value_type& __x); _LIBCPP_INLINE_VISIBILITY valarray& operator&= (const value_type& __x); _LIBCPP_INLINE_VISIBILITY valarray& operator|= (const value_type& __x); _LIBCPP_INLINE_VISIBILITY valarray& operator<<=(const value_type& __x); _LIBCPP_INLINE_VISIBILITY valarray& operator>>=(const value_type& __x); template <class _Expr> typename enable_if < __is_val_expr<_Expr>::value, valarray& >::type _LIBCPP_INLINE_VISIBILITY operator*= (const _Expr& __v); template <class _Expr> typename enable_if < __is_val_expr<_Expr>::value, valarray& >::type _LIBCPP_INLINE_VISIBILITY operator/= (const _Expr& __v); template <class _Expr> typename enable_if < __is_val_expr<_Expr>::value, valarray& >::type _LIBCPP_INLINE_VISIBILITY operator%= (const _Expr& __v); template <class _Expr> typename enable_if < __is_val_expr<_Expr>::value, valarray& >::type _LIBCPP_INLINE_VISIBILITY operator+= (const _Expr& __v); template <class _Expr> typename enable_if < __is_val_expr<_Expr>::value, valarray& >::type _LIBCPP_INLINE_VISIBILITY operator-= (const _Expr& __v); template <class _Expr> typename enable_if < __is_val_expr<_Expr>::value, valarray& >::type _LIBCPP_INLINE_VISIBILITY operator^= (const _Expr& __v); template <class _Expr> typename enable_if < __is_val_expr<_Expr>::value, valarray& >::type _LIBCPP_INLINE_VISIBILITY operator|= (const _Expr& __v); template <class _Expr> typename enable_if < __is_val_expr<_Expr>::value, valarray& >::type _LIBCPP_INLINE_VISIBILITY operator&= (const _Expr& __v); template <class _Expr> typename enable_if < __is_val_expr<_Expr>::value, valarray& >::type _LIBCPP_INLINE_VISIBILITY operator<<= (const _Expr& __v); template <class _Expr> typename enable_if < __is_val_expr<_Expr>::value, valarray& >::type _LIBCPP_INLINE_VISIBILITY operator>>= (const _Expr& __v); // member functions: _LIBCPP_INLINE_VISIBILITY void swap(valarray& __v) _NOEXCEPT; _LIBCPP_INLINE_VISIBILITY size_t size() const {return static_cast<size_t>(__end_ - __begin_);} _LIBCPP_INLINE_VISIBILITY value_type sum() const; _LIBCPP_INLINE_VISIBILITY value_type min() const; _LIBCPP_INLINE_VISIBILITY value_type max() const; valarray shift (int __i) const; valarray cshift(int __i) const; valarray apply(value_type __f(value_type)) const; valarray apply(value_type __f(const value_type&)) const; void resize(size_t __n, value_type __x = value_type());private: template <class> friend class _LIBCPP_TEMPLATE_VIS valarray; template <class> friend class _LIBCPP_TEMPLATE_VIS slice_array; template <class> friend class _LIBCPP_TEMPLATE_VIS gslice_array; template <class> friend class _LIBCPP_TEMPLATE_VIS mask_array; template <class> friend class __mask_expr; template <class> friend class _LIBCPP_TEMPLATE_VIS indirect_array; template <class> friend class __indirect_expr; template <class> friend class __val_expr; template <class _Up> friend _Up* begin(valarray<_Up>& __v); template <class _Up> friend const _Up* begin(const valarray<_Up>& __v); template <class _Up> friend _Up* end(valarray<_Up>& __v); template <class _Up> friend const _Up* end(const valarray<_Up>& __v);};_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS valarray<size_t>::valarray(size_t))_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS valarray<size_t>::~valarray())_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void valarray<size_t>::resize(size_t, size_t))template <class _Op, class _Tp>struct _UnaryOp<_Op, valarray<_Tp> >{ typedef typename _Op::result_type result_type; typedef _Tp value_type; _Op __op_; const valarray<_Tp>& __a0_; _LIBCPP_INLINE_VISIBILITY _UnaryOp(const _Op& __op, const valarray<_Tp>& __a0) : __op_(__op), __a0_(__a0) {} _LIBCPP_INLINE_VISIBILITY result_type operator[](size_t __i) const {return __op_(__a0_[__i]);} _LIBCPP_INLINE_VISIBILITY size_t size() const {return __a0_.size();}};template <class _Op, class _Tp, class _A1>struct _BinaryOp<_Op, valarray<_Tp>, _A1>{ typedef typename _Op::result_type result_type; typedef _Tp value_type; _Op __op_; const valarray<_Tp>& __a0_; _A1 __a1_; _LIBCPP_INLINE_VISIBILITY _BinaryOp(const _Op& __op, const valarray<_Tp>& __a0, const _A1& __a1) : __op_(__op), __a0_(__a0), __a1_(__a1) {} _LIBCPP_INLINE_VISIBILITY value_type operator[](size_t __i) const {return __op_(__a0_[__i], __a1_[__i]);} _LIBCPP_INLINE_VISIBILITY size_t size() const {return __a0_.size();}};template <class _Op, class _A0, class _Tp>struct _BinaryOp<_Op, _A0, valarray<_Tp> >{ typedef typename _Op::result_type result_type; typedef _Tp value_type; _Op __op_; _A0 __a0_; const valarray<_Tp>& __a1_; _LIBCPP_INLINE_VISIBILITY _BinaryOp(const _Op& __op, const _A0& __a0, const valarray<_Tp>& __a1) : __op_(__op), __a0_(__a0), __a1_(__a1) {} _LIBCPP_INLINE_VISIBILITY value_type operator[](size_t __i) const {return __op_(__a0_[__i], __a1_[__i]);} _LIBCPP_INLINE_VISIBILITY size_t size() const {return __a0_.size();}};template <class _Op, class _Tp>struct _BinaryOp<_Op, valarray<_Tp>, valarray<_Tp> >{ typedef typename _Op::result_type result_type; typedef _Tp value_type; _Op __op_; const valarray<_Tp>& __a0_; const valarray<_Tp>& __a1_; _LIBCPP_INLINE_VISIBILITY _BinaryOp(const _Op& __op, const valarray<_Tp>& __a0, const valarray<_Tp>& __a1) : __op_(__op), __a0_(__a0), __a1_(__a1) {} _LIBCPP_INLINE_VISIBILITY value_type operator[](size_t __i) const {return __op_(__a0_[__i], __a1_[__i]);} _LIBCPP_INLINE_VISIBILITY size_t size() const {return __a0_.size();}};// slice_arraytemplate <class _Tp>class _LIBCPP_TEMPLATE_VIS slice_array{public: typedef _Tp value_type;private: value_type* __vp_; size_t __size_; size_t __stride_;public: template <class _Expr> typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator=(const _Expr& __v) const; template <class _Expr> typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator*=(const _Expr& __v) const; template <class _Expr> typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator/=(const _Expr& __v) const; template <class _Expr> typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator%=(const _Expr& __v) const; template <class _Expr> typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator+=(const _Expr& __v) const; template <class _Expr> typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator-=(const _Expr& __v) const; template <class _Expr> typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator^=(const _Expr& __v) const; template <class _Expr> typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator&=(const _Expr& __v) const; template <class _Expr> typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator|=(const _Expr& __v) const; template <class _Expr> typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator<<=(const _Expr& __v) const; template <class _Expr> typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator>>=(const _Expr& __v) const; _LIBCPP_INLINE_VISIBILITY const slice_array& operator=(const slice_array& __sa) const; _LIBCPP_INLINE_VISIBILITY void operator=(const value_type& __x) const;private: _LIBCPP_INLINE_VISIBILITY slice_array(const slice& __sl, const valarray<value_type>& __v) : __vp_(const_cast<value_type*>(__v.__begin_ + __sl.start())), __size_(__sl.size()), __stride_(__sl.stride()) {} template <class> friend class valarray; template <class> friend class sliceExpr;};template <class _Tp>inlineconst slice_array<_Tp>&slice_array<_Tp>::operator=(const slice_array& __sa) const{ value_type* __t = __vp_; const value_type* __s = __sa.__vp_; for (size_t __n = __size_; __n; --__n, __t += __stride_, __s += __sa.__stride_) *__t = *__s; return *this;}template <class _Tp>template <class _Expr>inlinetypename enable_if< __is_val_expr<_Expr>::value, void>::typeslice_array<_Tp>::operator=(const _Expr& __v) const{ value_type* __t = __vp_; for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) *__t = __v[__i];}template <class _Tp>template <class _Expr>inlinetypename enable_if< __is_val_expr<_Expr>::value, void>::typeslice_array<_Tp>::operator*=(const _Expr& __v) const{ value_type* __t = __vp_; for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) *__t *= __v[__i];}template <class _Tp>template <class _Expr>inlinetypename enable_if< __is_val_expr<_Expr>::value, void>::typeslice_array<_Tp>::operator/=(const _Expr& __v) const{ value_type* __t = __vp_; for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) *__t /= __v[__i];}template <class _Tp>template <class _Expr>inlinetypename enable_if< __is_val_expr<_Expr>::value, void>::typeslice_array<_Tp>::operator%=(const _Expr& __v) const{ value_type* __t = __vp_; for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) *__t %= __v[__i];}template <class _Tp>template <class _Expr>inlinetypename enable_if< __is_val_expr<_Expr>::value, void>::typeslice_array<_Tp>::operator+=(const _Expr& __v) const{ value_type* __t = __vp_; for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) *__t += __v[__i];}template <class _Tp>template <class _Expr>inlinetypename enable_if< __is_val_expr<_Expr>::value, void>::typeslice_array<_Tp>::operator-=(const _Expr& __v) const{ value_type* __t = __vp_; for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) *__t -= __v[__i];}template <class _Tp>template <class _Expr>inlinetypename enable_if< __is_val_expr<_Expr>::value, void>::typeslice_array<_Tp>::operator^=(const _Expr& __v) const{ value_type* __t = __vp_; for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) *__t ^= __v[__i];}template <class _Tp>template <class _Expr>inlinetypename enable_if< __is_val_expr<_Expr>::value, void>::typeslice_array<_Tp>::operator&=(const _Expr& __v) const{ value_type* __t = __vp_; for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) *__t &= __v[__i];}template <class _Tp>template <class _Expr>inlinetypename enable_if< __is_val_expr<_Expr>::value, void>::typeslice_array<_Tp>::operator|=(const _Expr& __v) const{ value_type* __t = __vp_; for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) *__t |= __v[__i];}template <class _Tp>template <class _Expr>inlinetypename enable_if< __is_val_expr<_Expr>::value, void>::typeslice_array<_Tp>::operator<<=(const _Expr& __v) const{ value_type* __t = __vp_; for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) *__t <<= __v[__i];}template <class _Tp>template <class _Expr>inlinetypename enable_if< __is_val_expr<_Expr>::value, void>::typeslice_array<_Tp>::operator>>=(const _Expr& __v) const{ value_type* __t = __vp_; for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) *__t >>= __v[__i];}template <class _Tp>inlinevoidslice_array<_Tp>::operator=(const value_type& __x) const{ value_type* __t = __vp_; for (size_t __n = __size_; __n; --__n, __t += __stride_) *__t = __x;}// gsliceclass _LIBCPP_TYPE_VIS gslice{ valarray<size_t> __size_; valarray<size_t> __stride_; valarray<size_t> __1d_;public: _LIBCPP_INLINE_VISIBILITY gslice() {} _LIBCPP_INLINE_VISIBILITY gslice(size_t __start, const valarray<size_t>& __size, const valarray<size_t>& __stride) : __size_(__size), __stride_(__stride) {__init(__start);}#ifndef _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY gslice(size_t __start, const valarray<size_t>& __size, valarray<size_t>&& __stride) : __size_(__size), __stride_(move(__stride)) {__init(__start);} _LIBCPP_INLINE_VISIBILITY gslice(size_t __start, valarray<size_t>&& __size, const valarray<size_t>& __stride) : __size_(move(__size)), __stride_(__stride) {__init(__start);} _LIBCPP_INLINE_VISIBILITY gslice(size_t __start, valarray<size_t>&& __size, valarray<size_t>&& __stride) : __size_(move(__size)), __stride_(move(__stride)) {__init(__start);}#endif // _LIBCPP_CXX03_LANG// gslice(const gslice&) = default;// gslice(gslice&&) = default;// gslice& operator=(const gslice&) = default;// gslice& operator=(gslice&&) = default; _LIBCPP_INLINE_VISIBILITY size_t start() const {return __1d_.size() ? __1d_[0] : 0;} _LIBCPP_INLINE_VISIBILITY valarray<size_t> size() const {return __size_;} _LIBCPP_INLINE_VISIBILITY valarray<size_t> stride() const {return __stride_;}private: void __init(size_t __start); template <class> friend class gslice_array; template <class> friend class valarray; template <class> friend class __val_expr;};// gslice_arraytemplate <class _Tp>class _LIBCPP_TEMPLATE_VIS gslice_array{public: typedef _Tp value_type;private: value_type* __vp_; valarray<size_t> __1d_;public: template <class _Expr> typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator=(const _Expr& __v) const; template <class _Expr> typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator*=(const _Expr& __v) const; template <class _Expr> typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator/=(const _Expr& __v) const; template <class _Expr> typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator%=(const _Expr& __v) const; template <class _Expr> typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator+=(const _Expr& __v) const; template <class _Expr> typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator-=(const _Expr& __v) const; template <class _Expr> typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator^=(const _Expr& __v) const; template <class _Expr> typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator&=(const _Expr& __v) const; template <class _Expr> typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator|=(const _Expr& __v) const; template <class _Expr> typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator<<=(const _Expr& __v) const; template <class _Expr> typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator>>=(const _Expr& __v) const; _LIBCPP_INLINE_VISIBILITY const gslice_array& operator=(const gslice_array& __ga) const; _LIBCPP_INLINE_VISIBILITY void operator=(const value_type& __x) const;// gslice_array(const gslice_array&) = default;// gslice_array(gslice_array&&) = default;// gslice_array& operator=(const gslice_array&) = default;// gslice_array& operator=(gslice_array&&) = default;private: gslice_array(const gslice& __gs, const valarray<value_type>& __v) : __vp_(const_cast<value_type*>(__v.__begin_)), __1d_(__gs.__1d_) {}#ifndef _LIBCPP_CXX03_LANG gslice_array(gslice&& __gs, const valarray<value_type>& __v) : __vp_(const_cast<value_type*>(__v.__begin_)), __1d_(move(__gs.__1d_)) {}#endif // _LIBCPP_CXX03_LANG template <class> friend class valarray;};template <class _Tp>template <class _Expr>inlinetypename enable_if< __is_val_expr<_Expr>::value, void>::typegslice_array<_Tp>::operator=(const _Expr& __v) const{ typedef const size_t* _Ip; size_t __j = 0; for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) __vp_[*__i] = __v[__j];}template <class _Tp>template <class _Expr>inlinetypename enable_if< __is_val_expr<_Expr>::value, void>::typegslice_array<_Tp>::operator*=(const _Expr& __v) const{ typedef const size_t* _Ip; size_t __j = 0; for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) __vp_[*__i] *= __v[__j];}template <class _Tp>template <class _Expr>inlinetypename enable_if< __is_val_expr<_Expr>::value, void>::typegslice_array<_Tp>::operator/=(const _Expr& __v) const{ typedef const size_t* _Ip; size_t __j = 0; for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) __vp_[*__i] /= __v[__j];}template <class _Tp>template <class _Expr>inlinetypename enable_if< __is_val_expr<_Expr>::value, void>::typegslice_array<_Tp>::operator%=(const _Expr& __v) const{ typedef const size_t* _Ip; size_t __j = 0; for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) __vp_[*__i] %= __v[__j];}template <class _Tp>template <class _Expr>inlinetypename enable_if< __is_val_expr<_Expr>::value, void>::typegslice_array<_Tp>::operator+=(const _Expr& __v) const{ typedef const size_t* _Ip; size_t __j = 0; for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) __vp_[*__i] += __v[__j];}template <class _Tp>template <class _Expr>inlinetypename enable_if< __is_val_expr<_Expr>::value, void>::typegslice_array<_Tp>::operator-=(const _Expr& __v) const{ typedef const size_t* _Ip; size_t __j = 0; for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) __vp_[*__i] -= __v[__j];}template <class _Tp>template <class _Expr>inlinetypename enable_if< __is_val_expr<_Expr>::value, void>::typegslice_array<_Tp>::operator^=(const _Expr& __v) const{ typedef const size_t* _Ip; size_t __j = 0; for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) __vp_[*__i] ^= __v[__j];}template <class _Tp>template <class _Expr>inlinetypename enable_if< __is_val_expr<_Expr>::value, void>::typegslice_array<_Tp>::operator&=(const _Expr& __v) const{ typedef const size_t* _Ip; size_t __j = 0; for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) __vp_[*__i] &= __v[__j];}template <class _Tp>template <class _Expr>inlinetypename enable_if< __is_val_expr<_Expr>::value, void>::typegslice_array<_Tp>::operator|=(const _Expr& __v) const{ typedef const size_t* _Ip; size_t __j = 0; for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) __vp_[*__i] |= __v[__j];}template <class _Tp>template <class _Expr>inlinetypename enable_if< __is_val_expr<_Expr>::value, void>::typegslice_array<_Tp>::operator<<=(const _Expr& __v) const{ typedef const size_t* _Ip; size_t __j = 0; for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) __vp_[*__i] <<= __v[__j];}template <class _Tp>template <class _Expr>inlinetypename enable_if< __is_val_expr<_Expr>::value, void>::typegslice_array<_Tp>::operator>>=(const _Expr& __v) const{ typedef const size_t* _Ip; size_t __j = 0; for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) __vp_[*__i] >>= __v[__j];}template <class _Tp>inlineconst gslice_array<_Tp>&gslice_array<_Tp>::operator=(const gslice_array& __ga) const{ typedef const size_t* _Ip; const value_type* __s = __ga.__vp_; for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_, __j = __ga.__1d_.__begin_; __i != __e; ++__i, ++__j) __vp_[*__i] = __s[*__j]; return *this;}template <class _Tp>inlinevoidgslice_array<_Tp>::operator=(const value_type& __x) const{ typedef const size_t* _Ip; for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i) __vp_[*__i] = __x;}// mask_arraytemplate <class _Tp>class _LIBCPP_TEMPLATE_VIS mask_array{public: typedef _Tp value_type;private: value_type* __vp_; valarray<size_t> __1d_;public: template <class _Expr> typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator=(const _Expr& __v) const; template <class _Expr> typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator*=(const _Expr& __v) const; template <class _Expr> typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator/=(const _Expr& __v) const; template <class _Expr> typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator%=(const _Expr& __v) const; template <class _Expr> typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator+=(const _Expr& __v) const; template <class _Expr> typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator-=(const _Expr& __v) const; template <class _Expr> typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator^=(const _Expr& __v) const; template <class _Expr> typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator&=(const _Expr& __v) const; template <class _Expr> typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator|=(const _Expr& __v) const; template <class _Expr> typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator<<=(const _Expr& __v) const; template <class _Expr> typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator>>=(const _Expr& __v) const; _LIBCPP_INLINE_VISIBILITY const mask_array& operator=(const mask_array& __ma) const; _LIBCPP_INLINE_VISIBILITY void operator=(const value_type& __x) const;// mask_array(const mask_array&) = default;// mask_array(mask_array&&) = default;// mask_array& operator=(const mask_array&) = default;// mask_array& operator=(mask_array&&) = default;private: _LIBCPP_INLINE_VISIBILITY mask_array(const valarray<bool>& __vb, const valarray<value_type>& __v) : __vp_(const_cast<value_type*>(__v.__begin_)), __1d_(static_cast<size_t>(count(__vb.__begin_, __vb.__end_, true))) { size_t __j = 0; for (size_t __i = 0; __i < __vb.size(); ++__i) if (__vb[__i]) __1d_[__j++] = __i; } template <class> friend class valarray;};template <class _Tp>template <class _Expr>inlinetypename enable_if< __is_val_expr<_Expr>::value, void>::typemask_array<_Tp>::operator=(const _Expr& __v) const{ size_t __n = __1d_.size(); for (size_t __i = 0; __i < __n; ++__i) __vp_[__1d_[__i]] = __v[__i];}template <class _Tp>template <class _Expr>inlinetypename enable_if< __is_val_expr<_Expr>::value, void>::typemask_array<_Tp>::operator*=(const _Expr& __v) const{ size_t __n = __1d_.size(); for (size_t __i = 0; __i < __n; ++__i) __vp_[__1d_[__i]] *= __v[__i];}template <class _Tp>template <class _Expr>inlinetypename enable_if< __is_val_expr<_Expr>::value, void>::typemask_array<_Tp>::operator/=(const _Expr& __v) const{ size_t __n = __1d_.size(); for (size_t __i = 0; __i < __n; ++__i) __vp_[__1d_[__i]] /= __v[__i];}template <class _Tp>template <class _Expr>inlinetypename enable_if< __is_val_expr<_Expr>::value, void>::typemask_array<_Tp>::operator%=(const _Expr& __v) const{ size_t __n = __1d_.size(); for (size_t __i = 0; __i < __n; ++__i) __vp_[__1d_[__i]] %= __v[__i];}template <class _Tp>template <class _Expr>inlinetypename enable_if< __is_val_expr<_Expr>::value, void>::typemask_array<_Tp>::operator+=(const _Expr& __v) const{ size_t __n = __1d_.size(); for (size_t __i = 0; __i < __n; ++__i) __vp_[__1d_[__i]] += __v[__i];}template <class _Tp>template <class _Expr>inlinetypename enable_if< __is_val_expr<_Expr>::value, void>::typemask_array<_Tp>::operator-=(const _Expr& __v) const{ size_t __n = __1d_.size(); for (size_t __i = 0; __i < __n; ++__i) __vp_[__1d_[__i]] -= __v[__i];}template <class _Tp>template <class _Expr>inlinetypename enable_if< __is_val_expr<_Expr>::value, void>::typemask_array<_Tp>::operator^=(const _Expr& __v) const{ size_t __n = __1d_.size(); for (size_t __i = 0; __i < __n; ++__i) __vp_[__1d_[__i]] ^= __v[__i];}template <class _Tp>template <class _Expr>inlinetypename enable_if< __is_val_expr<_Expr>::value, void>::typemask_array<_Tp>::operator&=(const _Expr& __v) const{ size_t __n = __1d_.size(); for (size_t __i = 0; __i < __n; ++__i) __vp_[__1d_[__i]] &= __v[__i];}template <class _Tp>template <class _Expr>inlinetypename enable_if< __is_val_expr<_Expr>::value, void>::typemask_array<_Tp>::operator|=(const _Expr& __v) const{ size_t __n = __1d_.size(); for (size_t __i = 0; __i < __n; ++__i) __vp_[__1d_[__i]] |= __v[__i];}template <class _Tp>template <class _Expr>inlinetypename enable_if< __is_val_expr<_Expr>::value, void>::typemask_array<_Tp>::operator<<=(const _Expr& __v) const{ size_t __n = __1d_.size(); for (size_t __i = 0; __i < __n; ++__i) __vp_[__1d_[__i]] <<= __v[__i];}template <class _Tp>template <class _Expr>inlinetypename enable_if< __is_val_expr<_Expr>::value, void>::typemask_array<_Tp>::operator>>=(const _Expr& __v) const{ size_t __n = __1d_.size(); for (size_t __i = 0; __i < __n; ++__i) __vp_[__1d_[__i]] >>= __v[__i];}template <class _Tp>inlineconst mask_array<_Tp>&mask_array<_Tp>::operator=(const mask_array& __ma) const{ size_t __n = __1d_.size(); for (size_t __i = 0; __i < __n; ++__i) __vp_[__1d_[__i]] = __ma.__vp_[__1d_[__i]]; return *this;}template <class _Tp>inlinevoidmask_array<_Tp>::operator=(const value_type& __x) const{ size_t __n = __1d_.size(); for (size_t __i = 0; __i < __n; ++__i) __vp_[__1d_[__i]] = __x;}template <class _ValExpr>class __mask_expr{ typedef typename remove_reference<_ValExpr>::type _RmExpr;public: typedef typename _RmExpr::value_type value_type; typedef value_type result_type;private: _ValExpr __expr_; valarray<size_t> __1d_; _LIBCPP_INLINE_VISIBILITY __mask_expr(const valarray<bool>& __vb, const _RmExpr& __e) : __expr_(__e), __1d_(static_cast<size_t>(count(__vb.__begin_, __vb.__end_, true))) { size_t __j = 0; for (size_t __i = 0; __i < __vb.size(); ++__i) if (__vb[__i]) __1d_[__j++] = __i; }public: _LIBCPP_INLINE_VISIBILITY result_type operator[](size_t __i) const {return __expr_[__1d_[__i]];} _LIBCPP_INLINE_VISIBILITY size_t size() const {return __1d_.size();} template <class> friend class valarray;};// indirect_arraytemplate <class _Tp>class _LIBCPP_TEMPLATE_VIS indirect_array{public: typedef _Tp value_type;private: value_type* __vp_; valarray<size_t> __1d_;public: template <class _Expr> typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator=(const _Expr& __v) const; template <class _Expr> typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator*=(const _Expr& __v) const; template <class _Expr> typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator/=(const _Expr& __v) const; template <class _Expr> typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator%=(const _Expr& __v) const; template <class _Expr> typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator+=(const _Expr& __v) const; template <class _Expr> typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator-=(const _Expr& __v) const; template <class _Expr> typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator^=(const _Expr& __v) const; template <class _Expr> typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator&=(const _Expr& __v) const; template <class _Expr> typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator|=(const _Expr& __v) const; template <class _Expr> typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator<<=(const _Expr& __v) const; template <class _Expr> typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator>>=(const _Expr& __v) const; _LIBCPP_INLINE_VISIBILITY const indirect_array& operator=(const indirect_array& __ia) const; _LIBCPP_INLINE_VISIBILITY void operator=(const value_type& __x) const;// indirect_array(const indirect_array&) = default;// indirect_array(indirect_array&&) = default;// indirect_array& operator=(const indirect_array&) = default;// indirect_array& operator=(indirect_array&&) = default;private: _LIBCPP_INLINE_VISIBILITY indirect_array(const valarray<size_t>& __ia, const valarray<value_type>& __v) : __vp_(const_cast<value_type*>(__v.__begin_)), __1d_(__ia) {}#ifndef _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY indirect_array(valarray<size_t>&& __ia, const valarray<value_type>& __v) : __vp_(const_cast<value_type*>(__v.__begin_)), __1d_(move(__ia)) {}#endif // _LIBCPP_CXX03_LANG template <class> friend class valarray;};template <class _Tp>template <class _Expr>inlinetypename enable_if< __is_val_expr<_Expr>::value, void>::typeindirect_array<_Tp>::operator=(const _Expr& __v) const{ size_t __n = __1d_.size(); for (size_t __i = 0; __i < __n; ++__i) __vp_[__1d_[__i]] = __v[__i];}template <class _Tp>template <class _Expr>inlinetypename enable_if< __is_val_expr<_Expr>::value, void>::typeindirect_array<_Tp>::operator*=(const _Expr& __v) const{ size_t __n = __1d_.size(); for (size_t __i = 0; __i < __n; ++__i) __vp_[__1d_[__i]] *= __v[__i];}template <class _Tp>template <class _Expr>inlinetypename enable_if< __is_val_expr<_Expr>::value, void>::typeindirect_array<_Tp>::operator/=(const _Expr& __v) const{ size_t __n = __1d_.size(); for (size_t __i = 0; __i < __n; ++__i) __vp_[__1d_[__i]] /= __v[__i];}template <class _Tp>template <class _Expr>inlinetypename enable_if< __is_val_expr<_Expr>::value, void>::typeindirect_array<_Tp>::operator%=(const _Expr& __v) const{ size_t __n = __1d_.size(); for (size_t __i = 0; __i < __n; ++__i) __vp_[__1d_[__i]] %= __v[__i];}template <class _Tp>template <class _Expr>inlinetypename enable_if< __is_val_expr<_Expr>::value, void>::typeindirect_array<_Tp>::operator+=(const _Expr& __v) const{ size_t __n = __1d_.size(); for (size_t __i = 0; __i < __n; ++__i) __vp_[__1d_[__i]] += __v[__i];}template <class _Tp>template <class _Expr>inlinetypename enable_if< __is_val_expr<_Expr>::value, void>::typeindirect_array<_Tp>::operator-=(const _Expr& __v) const{ size_t __n = __1d_.size(); for (size_t __i = 0; __i < __n; ++__i) __vp_[__1d_[__i]] -= __v[__i];}template <class _Tp>template <class _Expr>inlinetypename enable_if< __is_val_expr<_Expr>::value, void>::typeindirect_array<_Tp>::operator^=(const _Expr& __v) const{ size_t __n = __1d_.size(); for (size_t __i = 0; __i < __n; ++__i) __vp_[__1d_[__i]] ^= __v[__i];}template <class _Tp>template <class _Expr>inlinetypename enable_if< __is_val_expr<_Expr>::value, void>::typeindirect_array<_Tp>::operator&=(const _Expr& __v) const{ size_t __n = __1d_.size(); for (size_t __i = 0; __i < __n; ++__i) __vp_[__1d_[__i]] &= __v[__i];}template <class _Tp>template <class _Expr>inlinetypename enable_if< __is_val_expr<_Expr>::value, void>::typeindirect_array<_Tp>::operator|=(const _Expr& __v) const{ size_t __n = __1d_.size(); for (size_t __i = 0; __i < __n; ++__i) __vp_[__1d_[__i]] |= __v[__i];}template <class _Tp>template <class _Expr>inlinetypename enable_if< __is_val_expr<_Expr>::value, void>::typeindirect_array<_Tp>::operator<<=(const _Expr& __v) const{ size_t __n = __1d_.size(); for (size_t __i = 0; __i < __n; ++__i) __vp_[__1d_[__i]] <<= __v[__i];}template <class _Tp>template <class _Expr>inlinetypename enable_if< __is_val_expr<_Expr>::value, void>::typeindirect_array<_Tp>::operator>>=(const _Expr& __v) const{ size_t __n = __1d_.size(); for (size_t __i = 0; __i < __n; ++__i) __vp_[__1d_[__i]] >>= __v[__i];}template <class _Tp>inlineconst indirect_array<_Tp>&indirect_array<_Tp>::operator=(const indirect_array& __ia) const{ typedef const size_t* _Ip; const value_type* __s = __ia.__vp_; for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_, __j = __ia.__1d_.__begin_; __i != __e; ++__i, ++__j) __vp_[*__i] = __s[*__j]; return *this;}template <class _Tp>inlinevoidindirect_array<_Tp>::operator=(const value_type& __x) const{ typedef const size_t* _Ip; for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i) __vp_[*__i] = __x;}template <class _ValExpr>class __indirect_expr{ typedef typename remove_reference<_ValExpr>::type _RmExpr;public: typedef typename _RmExpr::value_type value_type; typedef value_type result_type;private: _ValExpr __expr_; valarray<size_t> __1d_; _LIBCPP_INLINE_VISIBILITY __indirect_expr(const valarray<size_t>& __ia, const _RmExpr& __e) : __expr_(__e), __1d_(__ia) {}#ifndef _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY __indirect_expr(valarray<size_t>&& __ia, const _RmExpr& __e) : __expr_(__e), __1d_(move(__ia)) {}#endif // _LIBCPP_CXX03_LANGpublic: _LIBCPP_INLINE_VISIBILITY result_type operator[](size_t __i) const {return __expr_[__1d_[__i]];} _LIBCPP_INLINE_VISIBILITY size_t size() const {return __1d_.size();} template <class> friend class _LIBCPP_TEMPLATE_VIS valarray;};template<class _ValExpr>class __val_expr{ typedef typename remove_reference<_ValExpr>::type _RmExpr; _ValExpr __expr_;public: typedef typename _RmExpr::value_type value_type; typedef typename _RmExpr::result_type result_type; _LIBCPP_INLINE_VISIBILITY explicit __val_expr(const _RmExpr& __e) : __expr_(__e) {} _LIBCPP_INLINE_VISIBILITY result_type operator[](size_t __i) const {return __expr_[__i];} _LIBCPP_INLINE_VISIBILITY __val_expr<__slice_expr<_ValExpr> > operator[](slice __s) const {return __val_expr<__slice_expr<_ValExpr> >(__expr_, __s);} _LIBCPP_INLINE_VISIBILITY __val_expr<__indirect_expr<_ValExpr> > operator[](const gslice& __gs) const {return __val_expr<__indirect_expr<_ValExpr> >(__expr_, __gs.__1d_);} _LIBCPP_INLINE_VISIBILITY __val_expr<__mask_expr<_ValExpr> > operator[](const valarray<bool>& __vb) const {return __val_expr<__mask_expr<_ValExpr> >(__expr_, __vb);} _LIBCPP_INLINE_VISIBILITY __val_expr<__indirect_expr<_ValExpr> > operator[](const valarray<size_t>& __vs) const {return __val_expr<__indirect_expr<_ValExpr> >(__expr_, __vs);} _LIBCPP_INLINE_VISIBILITY __val_expr<_UnaryOp<__unary_plus<value_type>, _ValExpr> > operator+() const { typedef _UnaryOp<__unary_plus<value_type>, _ValExpr> _NewExpr; return __val_expr<_NewExpr>(_NewExpr(__unary_plus<value_type>(), __expr_)); } _LIBCPP_INLINE_VISIBILITY __val_expr<_UnaryOp<negate<value_type>, _ValExpr> > operator-() const { typedef _UnaryOp<negate<value_type>, _ValExpr> _NewExpr; return __val_expr<_NewExpr>(_NewExpr(negate<value_type>(), __expr_)); } _LIBCPP_INLINE_VISIBILITY __val_expr<_UnaryOp<__bit_not<value_type>, _ValExpr> > operator~() const { typedef _UnaryOp<__bit_not<value_type>, _ValExpr> _NewExpr; return __val_expr<_NewExpr>(_NewExpr(__bit_not<value_type>(), __expr_)); } _LIBCPP_INLINE_VISIBILITY __val_expr<_UnaryOp<logical_not<value_type>, _ValExpr> > operator!() const { typedef _UnaryOp<logical_not<value_type>, _ValExpr> _NewExpr; return __val_expr<_NewExpr>(_NewExpr(logical_not<value_type>(), __expr_)); } operator valarray<result_type>() const; _LIBCPP_INLINE_VISIBILITY size_t size() const {return __expr_.size();} _LIBCPP_INLINE_VISIBILITY result_type sum() const { size_t __n = __expr_.size(); result_type __r = __n ? __expr_[0] : result_type(); for (size_t __i = 1; __i < __n; ++__i) __r += __expr_[__i]; return __r; } _LIBCPP_INLINE_VISIBILITY result_type min() const { size_t __n = size(); result_type __r = __n ? (*this)[0] : result_type(); for (size_t __i = 1; __i < __n; ++__i) { result_type __x = __expr_[__i]; if (__x < __r) __r = __x; } return __r; } _LIBCPP_INLINE_VISIBILITY result_type max() const { size_t __n = size(); result_type __r = __n ? (*this)[0] : result_type(); for (size_t __i = 1; __i < __n; ++__i) { result_type __x = __expr_[__i]; if (__r < __x) __r = __x; } return __r; } _LIBCPP_INLINE_VISIBILITY __val_expr<__shift_expr<_ValExpr> > shift (int __i) const {return __val_expr<__shift_expr<_ValExpr> >(__shift_expr<_ValExpr>(__i, __expr_));} _LIBCPP_INLINE_VISIBILITY __val_expr<__cshift_expr<_ValExpr> > cshift(int __i) const {return __val_expr<__cshift_expr<_ValExpr> >(__cshift_expr<_ValExpr>(__i, __expr_));} _LIBCPP_INLINE_VISIBILITY __val_expr<_UnaryOp<__apply_expr<value_type, value_type(*)(value_type)>, _ValExpr> > apply(value_type __f(value_type)) const { typedef __apply_expr<value_type, value_type(*)(value_type)> _Op; typedef _UnaryOp<_Op, _ValExpr> _NewExpr; return __val_expr<_NewExpr>(_NewExpr(_Op(__f), __expr_)); } _LIBCPP_INLINE_VISIBILITY __val_expr<_UnaryOp<__apply_expr<value_type, value_type(*)(const value_type&)>, _ValExpr> > apply(value_type __f(const value_type&)) const { typedef __apply_expr<value_type, value_type(*)(const value_type&)> _Op; typedef _UnaryOp<_Op, _ValExpr> _NewExpr; return __val_expr<_NewExpr>(_NewExpr(_Op(__f), __expr_)); }};template<class _ValExpr>__val_expr<_ValExpr>::operator valarray<__val_expr::result_type>() const{ valarray<result_type> __r; size_t __n = __expr_.size(); if (__n) { __r.__begin_ = __r.__end_ = static_cast<result_type*>(_VSTD::__allocate(__n * sizeof(result_type))); for (size_t __i = 0; __i != __n; ++__r.__end_, ++__i) ::new (__r.__end_) result_type(__expr_[__i]); } return __r;}// valarraytemplate <class _Tp>inlinevalarray<_Tp>::valarray(size_t __n) : __begin_(0), __end_(0){ resize(__n);}template <class _Tp>inlinevalarray<_Tp>::valarray(const value_type& __x, size_t __n) : __begin_(0), __end_(0){ resize(__n, __x);}template <class _Tp>valarray<_Tp>::valarray(const value_type* __p, size_t __n) : __begin_(0), __end_(0){ if (__n) { __begin_ = __end_ = static_cast<value_type*>(_VSTD::__allocate(__n * sizeof(value_type)));#ifndef _LIBCPP_NO_EXCEPTIONS try {#endif // _LIBCPP_NO_EXCEPTIONS for (; __n; ++__end_, ++__p, --__n) ::new (__end_) value_type(*__p);#ifndef _LIBCPP_NO_EXCEPTIONS } catch (...) { resize(0); throw; }#endif // _LIBCPP_NO_EXCEPTIONS }}template <class _Tp>valarray<_Tp>::valarray(const valarray& __v) : __begin_(0), __end_(0){ if (__v.size()) { __begin_ = __end_ = static_cast<value_type*>(_VSTD::__allocate(__v.size() * sizeof(value_type)));#ifndef _LIBCPP_NO_EXCEPTIONS try {#endif // _LIBCPP_NO_EXCEPTIONS for (value_type* __p = __v.__begin_; __p != __v.__end_; ++__end_, ++__p) ::new (__end_) value_type(*__p);#ifndef _LIBCPP_NO_EXCEPTIONS } catch (...) { resize(0); throw; }#endif // _LIBCPP_NO_EXCEPTIONS }}#ifndef _LIBCPP_CXX03_LANGtemplate <class _Tp>inlinevalarray<_Tp>::valarray(valarray&& __v) _NOEXCEPT : __begin_(__v.__begin_), __end_(__v.__end_){ __v.__begin_ = __v.__end_ = nullptr;}template <class _Tp>valarray<_Tp>::valarray(initializer_list<value_type> __il) : __begin_(0), __end_(0){ size_t __n = __il.size(); if (__n) { __begin_ = __end_ = static_cast<value_type*>(_VSTD::__allocate(__n * sizeof(value_type)));#ifndef _LIBCPP_NO_EXCEPTIONS try {#endif // _LIBCPP_NO_EXCEPTIONS for (const value_type* __p = __il.begin(); __n; ++__end_, ++__p, --__n) ::new (__end_) value_type(*__p);#ifndef _LIBCPP_NO_EXCEPTIONS } catch (...) { resize(0); throw; }#endif // _LIBCPP_NO_EXCEPTIONS }}#endif // _LIBCPP_CXX03_LANGtemplate <class _Tp>valarray<_Tp>::valarray(const slice_array<value_type>& __sa) : __begin_(0), __end_(0){ size_t __n = __sa.__size_; if (__n) { __begin_ = __end_ = static_cast<value_type*>(_VSTD::__allocate(__n * sizeof(value_type)));#ifndef _LIBCPP_NO_EXCEPTIONS try {#endif // _LIBCPP_NO_EXCEPTIONS for (const value_type* __p = __sa.__vp_; __n; ++__end_, __p += __sa.__stride_, --__n) ::new (__end_) value_type(*__p);#ifndef _LIBCPP_NO_EXCEPTIONS } catch (...) { resize(0); throw; }#endif // _LIBCPP_NO_EXCEPTIONS }}template <class _Tp>valarray<_Tp>::valarray(const gslice_array<value_type>& __ga) : __begin_(0), __end_(0){ size_t __n = __ga.__1d_.size(); if (__n) { __begin_ = __end_ = static_cast<value_type*>(_VSTD::__allocate(__n * sizeof(value_type)));#ifndef _LIBCPP_NO_EXCEPTIONS try {#endif // _LIBCPP_NO_EXCEPTIONS typedef const size_t* _Ip; const value_type* __s = __ga.__vp_; for (_Ip __i = __ga.__1d_.__begin_, __e = __ga.__1d_.__end_; __i != __e; ++__i, ++__end_) ::new (__end_) value_type(__s[*__i]);#ifndef _LIBCPP_NO_EXCEPTIONS } catch (...) { resize(0); throw; }#endif // _LIBCPP_NO_EXCEPTIONS }}template <class _Tp>valarray<_Tp>::valarray(const mask_array<value_type>& __ma) : __begin_(0), __end_(0){ size_t __n = __ma.__1d_.size(); if (__n) { __begin_ = __end_ = static_cast<value_type*>(_VSTD::__allocate(__n * sizeof(value_type)));#ifndef _LIBCPP_NO_EXCEPTIONS try {#endif // _LIBCPP_NO_EXCEPTIONS typedef const size_t* _Ip; const value_type* __s = __ma.__vp_; for (_Ip __i = __ma.__1d_.__begin_, __e = __ma.__1d_.__end_; __i != __e; ++__i, ++__end_) ::new (__end_) value_type(__s[*__i]);#ifndef _LIBCPP_NO_EXCEPTIONS } catch (...) { resize(0); throw; }#endif // _LIBCPP_NO_EXCEPTIONS }}template <class _Tp>valarray<_Tp>::valarray(const indirect_array<value_type>& __ia) : __begin_(0), __end_(0){ size_t __n = __ia.__1d_.size(); if (__n) { __begin_ = __end_ = static_cast<value_type*>(_VSTD::__allocate(__n * sizeof(value_type)));#ifndef _LIBCPP_NO_EXCEPTIONS try {#endif // _LIBCPP_NO_EXCEPTIONS typedef const size_t* _Ip; const value_type* __s = __ia.__vp_; for (_Ip __i = __ia.__1d_.__begin_, __e = __ia.__1d_.__end_; __i != __e; ++__i, ++__end_) ::new (__end_) value_type(__s[*__i]);#ifndef _LIBCPP_NO_EXCEPTIONS } catch (...) { resize(0); throw; }#endif // _LIBCPP_NO_EXCEPTIONS }}template <class _Tp>inlinevalarray<_Tp>::~valarray(){ resize(0);}template <class _Tp>valarray<_Tp>&valarray<_Tp>::operator=(const valarray& __v){ if (this != &__v) { if (size() != __v.size()) resize(__v.size()); _VSTD::copy(__v.__begin_, __v.__end_, __begin_); } return *this;}#ifndef _LIBCPP_CXX03_LANGtemplate <class _Tp>inlinevalarray<_Tp>&valarray<_Tp>::operator=(valarray&& __v) _NOEXCEPT{ resize(0); __begin_ = __v.__begin_; __end_ = __v.__end_; __v.__begin_ = nullptr; __v.__end_ = nullptr; return *this;}template <class _Tp>inlinevalarray<_Tp>&valarray<_Tp>::operator=(initializer_list<value_type> __il){ if (size() != __il.size()) resize(__il.size()); _VSTD::copy(__il.begin(), __il.end(), __begin_); return *this;}#endif // _LIBCPP_CXX03_LANGtemplate <class _Tp>inlinevalarray<_Tp>&valarray<_Tp>::operator=(const value_type& __x){ _VSTD::fill(__begin_, __end_, __x); return *this;}template <class _Tp>inlinevalarray<_Tp>&valarray<_Tp>::operator=(const slice_array<value_type>& __sa){ value_type* __t = __begin_; const value_type* __s = __sa.__vp_; for (size_t __n = __sa.__size_; __n; --__n, __s += __sa.__stride_, ++__t) *__t = *__s; return *this;}template <class _Tp>inlinevalarray<_Tp>&valarray<_Tp>::operator=(const gslice_array<value_type>& __ga){ typedef const size_t* _Ip; value_type* __t = __begin_; const value_type* __s = __ga.__vp_; for (_Ip __i = __ga.__1d_.__begin_, __e = __ga.__1d_.__end_; __i != __e; ++__i, ++__t) *__t = __s[*__i]; return *this;}template <class _Tp>inlinevalarray<_Tp>&valarray<_Tp>::operator=(const mask_array<value_type>& __ma){ typedef const size_t* _Ip; value_type* __t = __begin_; const value_type* __s = __ma.__vp_; for (_Ip __i = __ma.__1d_.__begin_, __e = __ma.__1d_.__end_; __i != __e; ++__i, ++__t) *__t = __s[*__i]; return *this;}template <class _Tp>inlinevalarray<_Tp>&valarray<_Tp>::operator=(const indirect_array<value_type>& __ia){ typedef const size_t* _Ip; value_type* __t = __begin_; const value_type* __s = __ia.__vp_; for (_Ip __i = __ia.__1d_.__begin_, __e = __ia.__1d_.__end_; __i != __e; ++__i, ++__t) *__t = __s[*__i]; return *this;}template <class _Tp>template <class _ValExpr>inlinevalarray<_Tp>&valarray<_Tp>::operator=(const __val_expr<_ValExpr>& __v){ size_t __n = __v.size(); if (size() != __n) resize(__n); value_type* __t = __begin_; for (size_t __i = 0; __i != __n; ++__t, ++__i) *__t = result_type(__v[__i]); return *this;}template <class _Tp>inline__val_expr<__slice_expr<const valarray<_Tp>&> >valarray<_Tp>::operator[](slice __s) const{ return __val_expr<__slice_expr<const valarray&> >(__slice_expr<const valarray&>(__s, *this));}template <class _Tp>inlineslice_array<_Tp>valarray<_Tp>::operator[](slice __s){ return slice_array<value_type>(__s, *this);}template <class _Tp>inline__val_expr<__indirect_expr<const valarray<_Tp>&> >valarray<_Tp>::operator[](const gslice& __gs) const{ return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(__gs.__1d_, *this));}template <class _Tp>inlinegslice_array<_Tp>valarray<_Tp>::operator[](const gslice& __gs){ return gslice_array<value_type>(__gs, *this);}#ifndef _LIBCPP_CXX03_LANGtemplate <class _Tp>inline__val_expr<__indirect_expr<const valarray<_Tp>&> >valarray<_Tp>::operator[](gslice&& __gs) const{ return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(move(__gs.__1d_), *this));}template <class _Tp>inlinegslice_array<_Tp>valarray<_Tp>::operator[](gslice&& __gs){ return gslice_array<value_type>(move(__gs), *this);}#endif // _LIBCPP_CXX03_LANGtemplate <class _Tp>inline__val_expr<__mask_expr<const valarray<_Tp>&> >valarray<_Tp>::operator[](const valarray<bool>& __vb) const{ return __val_expr<__mask_expr<const valarray&> >(__mask_expr<const valarray&>(__vb, *this));}template <class _Tp>inlinemask_array<_Tp>valarray<_Tp>::operator[](const valarray<bool>& __vb){ return mask_array<value_type>(__vb, *this);}#ifndef _LIBCPP_CXX03_LANGtemplate <class _Tp>inline__val_expr<__mask_expr<const valarray<_Tp>&> >valarray<_Tp>::operator[](valarray<bool>&& __vb) const{ return __val_expr<__mask_expr<const valarray&> >(__mask_expr<const valarray&>(move(__vb), *this));}template <class _Tp>inlinemask_array<_Tp>valarray<_Tp>::operator[](valarray<bool>&& __vb){ return mask_array<value_type>(move(__vb), *this);}#endif // _LIBCPP_CXX03_LANGtemplate <class _Tp>inline__val_expr<__indirect_expr<const valarray<_Tp>&> >valarray<_Tp>::operator[](const valarray<size_t>& __vs) const{ return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(__vs, *this));}template <class _Tp>inlineindirect_array<_Tp>valarray<_Tp>::operator[](const valarray<size_t>& __vs){ return indirect_array<value_type>(__vs, *this);}#ifndef _LIBCPP_CXX03_LANGtemplate <class _Tp>inline__val_expr<__indirect_expr<const valarray<_Tp>&> >valarray<_Tp>::operator[](valarray<size_t>&& __vs) const{ return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(move(__vs), *this));}template <class _Tp>inlineindirect_array<_Tp>valarray<_Tp>::operator[](valarray<size_t>&& __vs){ return indirect_array<value_type>(move(__vs), *this);}#endif // _LIBCPP_CXX03_LANGtemplate <class _Tp>valarray<_Tp>valarray<_Tp>::operator+() const{ valarray<value_type> __r; size_t __n = size(); if (__n) { __r.__begin_ = __r.__end_ = static_cast<value_type*>(_VSTD::__allocate(__n * sizeof(value_type))); for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n) ::new (__r.__end_) value_type(+*__p); } return __r;}template <class _Tp>valarray<_Tp>valarray<_Tp>::operator-() const{ valarray<value_type> __r; size_t __n = size(); if (__n) { __r.__begin_ = __r.__end_ = static_cast<value_type*>(_VSTD::__allocate(__n * sizeof(value_type))); for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n) ::new (__r.__end_) value_type(-*__p); } return __r;}template <class _Tp>valarray<_Tp>valarray<_Tp>::operator~() const{ valarray<value_type> __r; size_t __n = size(); if (__n) { __r.__begin_ = __r.__end_ = static_cast<value_type*>(_VSTD::__allocate(__n * sizeof(value_type))); for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n) ::new (__r.__end_) value_type(~*__p); } return __r;}template <class _Tp>valarray<bool>valarray<_Tp>::operator!() const{ valarray<bool> __r; size_t __n = size(); if (__n) { __r.__begin_ = __r.__end_ = static_cast<bool*>(_VSTD::__allocate(__n * sizeof(bool))); for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n) ::new (__r.__end_) bool(!*__p); } return __r;}template <class _Tp>inlinevalarray<_Tp>&valarray<_Tp>::operator*=(const value_type& __x){ for (value_type* __p = __begin_; __p != __end_; ++__p) *__p *= __x; return *this;}template <class _Tp>inlinevalarray<_Tp>&valarray<_Tp>::operator/=(const value_type& __x){ for (value_type* __p = __begin_; __p != __end_; ++__p) *__p /= __x; return *this;}template <class _Tp>inlinevalarray<_Tp>&valarray<_Tp>::operator%=(const value_type& __x){ for (value_type* __p = __begin_; __p != __end_; ++__p) *__p %= __x; return *this;}template <class _Tp>inlinevalarray<_Tp>&valarray<_Tp>::operator+=(const value_type& __x){ for (value_type* __p = __begin_; __p != __end_; ++__p) *__p += __x; return *this;}template <class _Tp>inlinevalarray<_Tp>&valarray<_Tp>::operator-=(const value_type& __x){ for (value_type* __p = __begin_; __p != __end_; ++__p) *__p -= __x; return *this;}template <class _Tp>inlinevalarray<_Tp>&valarray<_Tp>::operator^=(const value_type& __x){ for (value_type* __p = __begin_; __p != __end_; ++__p) *__p ^= __x; return *this;}template <class _Tp>inlinevalarray<_Tp>&valarray<_Tp>::operator&=(const value_type& __x){ for (value_type* __p = __begin_; __p != __end_; ++__p) *__p &= __x; return *this;}template <class _Tp>inlinevalarray<_Tp>&valarray<_Tp>::operator|=(const value_type& __x){ for (value_type* __p = __begin_; __p != __end_; ++__p) *__p |= __x; return *this;}template <class _Tp>inlinevalarray<_Tp>&valarray<_Tp>::operator<<=(const value_type& __x){ for (value_type* __p = __begin_; __p != __end_; ++__p) *__p <<= __x; return *this;}template <class _Tp>inlinevalarray<_Tp>&valarray<_Tp>::operator>>=(const value_type& __x){ for (value_type* __p = __begin_; __p != __end_; ++__p) *__p >>= __x; return *this;}template <class _Tp>template <class _Expr>inlinetypename enable_if< __is_val_expr<_Expr>::value, valarray<_Tp>&>::typevalarray<_Tp>::operator*=(const _Expr& __v){ size_t __i = 0; for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i) *__t *= __v[__i]; return *this;}template <class _Tp>template <class _Expr>inlinetypename enable_if< __is_val_expr<_Expr>::value, valarray<_Tp>&>::typevalarray<_Tp>::operator/=(const _Expr& __v){ size_t __i = 0; for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i) *__t /= __v[__i]; return *this;}template <class _Tp>template <class _Expr>inlinetypename enable_if< __is_val_expr<_Expr>::value, valarray<_Tp>&>::typevalarray<_Tp>::operator%=(const _Expr& __v){ size_t __i = 0; for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i) *__t %= __v[__i]; return *this;}template <class _Tp>template <class _Expr>inlinetypename enable_if< __is_val_expr<_Expr>::value, valarray<_Tp>&>::typevalarray<_Tp>::operator+=(const _Expr& __v){ size_t __i = 0; for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i) *__t += __v[__i]; return *this;}template <class _Tp>template <class _Expr>inlinetypename enable_if< __is_val_expr<_Expr>::value, valarray<_Tp>&>::typevalarray<_Tp>::operator-=(const _Expr& __v){ size_t __i = 0; for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i) *__t -= __v[__i]; return *this;}template <class _Tp>template <class _Expr>inlinetypename enable_if< __is_val_expr<_Expr>::value, valarray<_Tp>&>::typevalarray<_Tp>::operator^=(const _Expr& __v){ size_t __i = 0; for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i) *__t ^= __v[__i]; return *this;}template <class _Tp>template <class _Expr>inlinetypename enable_if< __is_val_expr<_Expr>::value, valarray<_Tp>&>::typevalarray<_Tp>::operator|=(const _Expr& __v){ size_t __i = 0; for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i) *__t |= __v[__i]; return *this;}template <class _Tp>template <class _Expr>inlinetypename enable_if< __is_val_expr<_Expr>::value, valarray<_Tp>&>::typevalarray<_Tp>::operator&=(const _Expr& __v){ size_t __i = 0; for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i) *__t &= __v[__i]; return *this;}template <class _Tp>template <class _Expr>inlinetypename enable_if< __is_val_expr<_Expr>::value, valarray<_Tp>&>::typevalarray<_Tp>::operator<<=(const _Expr& __v){ size_t __i = 0; for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i) *__t <<= __v[__i]; return *this;}template <class _Tp>template <class _Expr>inlinetypename enable_if< __is_val_expr<_Expr>::value, valarray<_Tp>&>::typevalarray<_Tp>::operator>>=(const _Expr& __v){ size_t __i = 0; for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i) *__t >>= __v[__i]; return *this;}template <class _Tp>inlinevoidvalarray<_Tp>::swap(valarray& __v) _NOEXCEPT{ _VSTD::swap(__begin_, __v.__begin_); _VSTD::swap(__end_, __v.__end_);}template <class _Tp>inline_Tpvalarray<_Tp>::sum() const{ if (__begin_ == __end_) return value_type(); const value_type* __p = __begin_; _Tp __r = *__p; for (++__p; __p != __end_; ++__p) __r += *__p; return __r;}template <class _Tp>inline_Tpvalarray<_Tp>::min() const{ if (__begin_ == __end_) return value_type(); return *_VSTD::min_element(__begin_, __end_);}template <class _Tp>inline_Tpvalarray<_Tp>::max() const{ if (__begin_ == __end_) return value_type(); return *_VSTD::max_element(__begin_, __end_);}template <class _Tp>valarray<_Tp>valarray<_Tp>::shift(int __i) const{ valarray<value_type> __r; size_t __n = size(); if (__n) { __r.__begin_ = __r.__end_ = static_cast<value_type*>(_VSTD::__allocate(__n * sizeof(value_type))); const value_type* __sb; value_type* __tb; value_type* __te; if (__i >= 0) { __i = _VSTD::min(__i, static_cast<int>(__n)); __sb = __begin_ + __i; __tb = __r.__begin_; __te = __r.__begin_ + (__n - __i); } else { __i = _VSTD::min(-__i, static_cast<int>(__n)); __sb = __begin_; __tb = __r.__begin_ + __i; __te = __r.__begin_ + __n; } for (; __r.__end_ != __tb; ++__r.__end_) ::new (__r.__end_) value_type(); for (; __r.__end_ != __te; ++__r.__end_, ++__sb) ::new (__r.__end_) value_type(*__sb); for (__te = __r.__begin_ + __n; __r.__end_ != __te; ++__r.__end_) ::new (__r.__end_) value_type(); } return __r;}template <class _Tp>valarray<_Tp>valarray<_Tp>::cshift(int __i) const{ valarray<value_type> __r; size_t __n = size(); if (__n) { __r.__begin_ = __r.__end_ = static_cast<value_type*>(_VSTD::__allocate(__n * sizeof(value_type))); __i %= static_cast<int>(__n); const value_type* __m = __i >= 0 ? __begin_ + __i : __end_ + __i; for (const value_type* __s = __m; __s != __end_; ++__r.__end_, ++__s) ::new (__r.__end_) value_type(*__s); for (const value_type* __s = __begin_; __s != __m; ++__r.__end_, ++__s) ::new (__r.__end_) value_type(*__s); } return __r;}template <class _Tp>valarray<_Tp>valarray<_Tp>::apply(value_type __f(value_type)) const{ valarray<value_type> __r; size_t __n = size(); if (__n) { __r.__begin_ = __r.__end_ = static_cast<value_type*>(_VSTD::__allocate(__n * sizeof(value_type))); for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n) ::new (__r.__end_) value_type(__f(*__p)); } return __r;}template <class _Tp>valarray<_Tp>valarray<_Tp>::apply(value_type __f(const value_type&)) const{ valarray<value_type> __r; size_t __n = size(); if (__n) { __r.__begin_ = __r.__end_ = static_cast<value_type*>(_VSTD::__allocate(__n * sizeof(value_type))); for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n) ::new (__r.__end_) value_type(__f(*__p)); } return __r;}template <class _Tp>voidvalarray<_Tp>::resize(size_t __n, value_type __x){ if (__begin_ != nullptr) { while (__end_ != __begin_) (--__end_)->~value_type(); _VSTD::__libcpp_deallocate(__begin_); __begin_ = __end_ = nullptr; } if (__n) { __begin_ = __end_ = static_cast<value_type*>(_VSTD::__allocate(__n * sizeof(value_type)));#ifndef _LIBCPP_NO_EXCEPTIONS try {#endif // _LIBCPP_NO_EXCEPTIONS for (; __n; --__n, ++__end_) ::new (__end_) value_type(__x);#ifndef _LIBCPP_NO_EXCEPTIONS } catch (...) { resize(0); throw; }#endif // _LIBCPP_NO_EXCEPTIONS }}template<class _Tp>inline _LIBCPP_INLINE_VISIBILITYvoidswap(valarray<_Tp>& __x, valarray<_Tp>& __y) _NOEXCEPT{ __x.swap(__y);}template<class _Expr1, class _Expr2>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, __val_expr<_BinaryOp<multiplies<typename _Expr1::value_type>, _Expr1, _Expr2> >>::typeoperator*(const _Expr1& __x, const _Expr2& __y){ typedef typename _Expr1::value_type value_type; typedef _BinaryOp<multiplies<value_type>, _Expr1, _Expr2> _Op; return __val_expr<_Op>(_Op(multiplies<value_type>(), __x, __y));}template<class _Expr>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr>::value, __val_expr<_BinaryOp<multiplies<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >>::typeoperator*(const _Expr& __x, const typename _Expr::value_type& __y){ typedef typename _Expr::value_type value_type; typedef _BinaryOp<multiplies<value_type>, _Expr, __scalar_expr<value_type> > _Op; return __val_expr<_Op>(_Op(multiplies<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));}template<class _Expr>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr>::value, __val_expr<_BinaryOp<multiplies<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >>::typeoperator*(const typename _Expr::value_type& __x, const _Expr& __y){ typedef typename _Expr::value_type value_type; typedef _BinaryOp<multiplies<value_type>, __scalar_expr<value_type>, _Expr> _Op; return __val_expr<_Op>(_Op(multiplies<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));}template<class _Expr1, class _Expr2>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, __val_expr<_BinaryOp<divides<typename _Expr1::value_type>, _Expr1, _Expr2> >>::typeoperator/(const _Expr1& __x, const _Expr2& __y){ typedef typename _Expr1::value_type value_type; typedef _BinaryOp<divides<value_type>, _Expr1, _Expr2> _Op; return __val_expr<_Op>(_Op(divides<value_type>(), __x, __y));}template<class _Expr>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr>::value, __val_expr<_BinaryOp<divides<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >>::typeoperator/(const _Expr& __x, const typename _Expr::value_type& __y){ typedef typename _Expr::value_type value_type; typedef _BinaryOp<divides<value_type>, _Expr, __scalar_expr<value_type> > _Op; return __val_expr<_Op>(_Op(divides<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));}template<class _Expr>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr>::value, __val_expr<_BinaryOp<divides<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >>::typeoperator/(const typename _Expr::value_type& __x, const _Expr& __y){ typedef typename _Expr::value_type value_type; typedef _BinaryOp<divides<value_type>, __scalar_expr<value_type>, _Expr> _Op; return __val_expr<_Op>(_Op(divides<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));}template<class _Expr1, class _Expr2>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, __val_expr<_BinaryOp<modulus<typename _Expr1::value_type>, _Expr1, _Expr2> >>::typeoperator%(const _Expr1& __x, const _Expr2& __y){ typedef typename _Expr1::value_type value_type; typedef _BinaryOp<modulus<value_type>, _Expr1, _Expr2> _Op; return __val_expr<_Op>(_Op(modulus<value_type>(), __x, __y));}template<class _Expr>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr>::value, __val_expr<_BinaryOp<modulus<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >>::typeoperator%(const _Expr& __x, const typename _Expr::value_type& __y){ typedef typename _Expr::value_type value_type; typedef _BinaryOp<modulus<value_type>, _Expr, __scalar_expr<value_type> > _Op; return __val_expr<_Op>(_Op(modulus<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));}template<class _Expr>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr>::value, __val_expr<_BinaryOp<modulus<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >>::typeoperator%(const typename _Expr::value_type& __x, const _Expr& __y){ typedef typename _Expr::value_type value_type; typedef _BinaryOp<modulus<value_type>, __scalar_expr<value_type>, _Expr> _Op; return __val_expr<_Op>(_Op(modulus<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));}template<class _Expr1, class _Expr2>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, __val_expr<_BinaryOp<plus<typename _Expr1::value_type>, _Expr1, _Expr2> >>::typeoperator+(const _Expr1& __x, const _Expr2& __y){ typedef typename _Expr1::value_type value_type; typedef _BinaryOp<plus<value_type>, _Expr1, _Expr2> _Op; return __val_expr<_Op>(_Op(plus<value_type>(), __x, __y));}template<class _Expr>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr>::value, __val_expr<_BinaryOp<plus<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >>::typeoperator+(const _Expr& __x, const typename _Expr::value_type& __y){ typedef typename _Expr::value_type value_type; typedef _BinaryOp<plus<value_type>, _Expr, __scalar_expr<value_type> > _Op; return __val_expr<_Op>(_Op(plus<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));}template<class _Expr>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr>::value, __val_expr<_BinaryOp<plus<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >>::typeoperator+(const typename _Expr::value_type& __x, const _Expr& __y){ typedef typename _Expr::value_type value_type; typedef _BinaryOp<plus<value_type>, __scalar_expr<value_type>, _Expr> _Op; return __val_expr<_Op>(_Op(plus<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));}template<class _Expr1, class _Expr2>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, __val_expr<_BinaryOp<minus<typename _Expr1::value_type>, _Expr1, _Expr2> >>::typeoperator-(const _Expr1& __x, const _Expr2& __y){ typedef typename _Expr1::value_type value_type; typedef _BinaryOp<minus<value_type>, _Expr1, _Expr2> _Op; return __val_expr<_Op>(_Op(minus<value_type>(), __x, __y));}template<class _Expr>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr>::value, __val_expr<_BinaryOp<minus<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >>::typeoperator-(const _Expr& __x, const typename _Expr::value_type& __y){ typedef typename _Expr::value_type value_type; typedef _BinaryOp<minus<value_type>, _Expr, __scalar_expr<value_type> > _Op; return __val_expr<_Op>(_Op(minus<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));}template<class _Expr>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr>::value, __val_expr<_BinaryOp<minus<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >>::typeoperator-(const typename _Expr::value_type& __x, const _Expr& __y){ typedef typename _Expr::value_type value_type; typedef _BinaryOp<minus<value_type>, __scalar_expr<value_type>, _Expr> _Op; return __val_expr<_Op>(_Op(minus<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));}template<class _Expr1, class _Expr2>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, __val_expr<_BinaryOp<bit_xor<typename _Expr1::value_type>, _Expr1, _Expr2> >>::typeoperator^(const _Expr1& __x, const _Expr2& __y){ typedef typename _Expr1::value_type value_type; typedef _BinaryOp<bit_xor<value_type>, _Expr1, _Expr2> _Op; return __val_expr<_Op>(_Op(bit_xor<value_type>(), __x, __y));}template<class _Expr>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr>::value, __val_expr<_BinaryOp<bit_xor<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >>::typeoperator^(const _Expr& __x, const typename _Expr::value_type& __y){ typedef typename _Expr::value_type value_type; typedef _BinaryOp<bit_xor<value_type>, _Expr, __scalar_expr<value_type> > _Op; return __val_expr<_Op>(_Op(bit_xor<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));}template<class _Expr>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr>::value, __val_expr<_BinaryOp<bit_xor<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >>::typeoperator^(const typename _Expr::value_type& __x, const _Expr& __y){ typedef typename _Expr::value_type value_type; typedef _BinaryOp<bit_xor<value_type>, __scalar_expr<value_type>, _Expr> _Op; return __val_expr<_Op>(_Op(bit_xor<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));}template<class _Expr1, class _Expr2>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, __val_expr<_BinaryOp<bit_and<typename _Expr1::value_type>, _Expr1, _Expr2> >>::typeoperator&(const _Expr1& __x, const _Expr2& __y){ typedef typename _Expr1::value_type value_type; typedef _BinaryOp<bit_and<value_type>, _Expr1, _Expr2> _Op; return __val_expr<_Op>(_Op(bit_and<value_type>(), __x, __y));}template<class _Expr>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr>::value, __val_expr<_BinaryOp<bit_and<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >>::typeoperator&(const _Expr& __x, const typename _Expr::value_type& __y){ typedef typename _Expr::value_type value_type; typedef _BinaryOp<bit_and<value_type>, _Expr, __scalar_expr<value_type> > _Op; return __val_expr<_Op>(_Op(bit_and<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));}template<class _Expr>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr>::value, __val_expr<_BinaryOp<bit_and<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >>::typeoperator&(const typename _Expr::value_type& __x, const _Expr& __y){ typedef typename _Expr::value_type value_type; typedef _BinaryOp<bit_and<value_type>, __scalar_expr<value_type>, _Expr> _Op; return __val_expr<_Op>(_Op(bit_and<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));}template<class _Expr1, class _Expr2>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, __val_expr<_BinaryOp<bit_or<typename _Expr1::value_type>, _Expr1, _Expr2> >>::typeoperator|(const _Expr1& __x, const _Expr2& __y){ typedef typename _Expr1::value_type value_type; typedef _BinaryOp<bit_or<value_type>, _Expr1, _Expr2> _Op; return __val_expr<_Op>(_Op(bit_or<value_type>(), __x, __y));}template<class _Expr>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr>::value, __val_expr<_BinaryOp<bit_or<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >>::typeoperator|(const _Expr& __x, const typename _Expr::value_type& __y){ typedef typename _Expr::value_type value_type; typedef _BinaryOp<bit_or<value_type>, _Expr, __scalar_expr<value_type> > _Op; return __val_expr<_Op>(_Op(bit_or<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));}template<class _Expr>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr>::value, __val_expr<_BinaryOp<bit_or<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >>::typeoperator|(const typename _Expr::value_type& __x, const _Expr& __y){ typedef typename _Expr::value_type value_type; typedef _BinaryOp<bit_or<value_type>, __scalar_expr<value_type>, _Expr> _Op; return __val_expr<_Op>(_Op(bit_or<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));}template<class _Expr1, class _Expr2>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, __val_expr<_BinaryOp<__bit_shift_left<typename _Expr1::value_type>, _Expr1, _Expr2> >>::typeoperator<<(const _Expr1& __x, const _Expr2& __y){ typedef typename _Expr1::value_type value_type; typedef _BinaryOp<__bit_shift_left<value_type>, _Expr1, _Expr2> _Op; return __val_expr<_Op>(_Op(__bit_shift_left<value_type>(), __x, __y));}template<class _Expr>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr>::value, __val_expr<_BinaryOp<__bit_shift_left<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >>::typeoperator<<(const _Expr& __x, const typename _Expr::value_type& __y){ typedef typename _Expr::value_type value_type; typedef _BinaryOp<__bit_shift_left<value_type>, _Expr, __scalar_expr<value_type> > _Op; return __val_expr<_Op>(_Op(__bit_shift_left<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));}template<class _Expr>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr>::value, __val_expr<_BinaryOp<__bit_shift_left<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >>::typeoperator<<(const typename _Expr::value_type& __x, const _Expr& __y){ typedef typename _Expr::value_type value_type; typedef _BinaryOp<__bit_shift_left<value_type>, __scalar_expr<value_type>, _Expr> _Op; return __val_expr<_Op>(_Op(__bit_shift_left<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));}template<class _Expr1, class _Expr2>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, __val_expr<_BinaryOp<__bit_shift_right<typename _Expr1::value_type>, _Expr1, _Expr2> >>::typeoperator>>(const _Expr1& __x, const _Expr2& __y){ typedef typename _Expr1::value_type value_type; typedef _BinaryOp<__bit_shift_right<value_type>, _Expr1, _Expr2> _Op; return __val_expr<_Op>(_Op(__bit_shift_right<value_type>(), __x, __y));}template<class _Expr>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr>::value, __val_expr<_BinaryOp<__bit_shift_right<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >>::typeoperator>>(const _Expr& __x, const typename _Expr::value_type& __y){ typedef typename _Expr::value_type value_type; typedef _BinaryOp<__bit_shift_right<value_type>, _Expr, __scalar_expr<value_type> > _Op; return __val_expr<_Op>(_Op(__bit_shift_right<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));}template<class _Expr>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr>::value, __val_expr<_BinaryOp<__bit_shift_right<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >>::typeoperator>>(const typename _Expr::value_type& __x, const _Expr& __y){ typedef typename _Expr::value_type value_type; typedef _BinaryOp<__bit_shift_right<value_type>, __scalar_expr<value_type>, _Expr> _Op; return __val_expr<_Op>(_Op(__bit_shift_right<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));}template<class _Expr1, class _Expr2>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, __val_expr<_BinaryOp<logical_and<typename _Expr1::value_type>, _Expr1, _Expr2> >>::typeoperator&&(const _Expr1& __x, const _Expr2& __y){ typedef typename _Expr1::value_type value_type; typedef _BinaryOp<logical_and<value_type>, _Expr1, _Expr2> _Op; return __val_expr<_Op>(_Op(logical_and<value_type>(), __x, __y));}template<class _Expr>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr>::value, __val_expr<_BinaryOp<logical_and<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >>::typeoperator&&(const _Expr& __x, const typename _Expr::value_type& __y){ typedef typename _Expr::value_type value_type; typedef _BinaryOp<logical_and<value_type>, _Expr, __scalar_expr<value_type> > _Op; return __val_expr<_Op>(_Op(logical_and<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));}template<class _Expr>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr>::value, __val_expr<_BinaryOp<logical_and<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >>::typeoperator&&(const typename _Expr::value_type& __x, const _Expr& __y){ typedef typename _Expr::value_type value_type; typedef _BinaryOp<logical_and<value_type>, __scalar_expr<value_type>, _Expr> _Op; return __val_expr<_Op>(_Op(logical_and<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));}template<class _Expr1, class _Expr2>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, __val_expr<_BinaryOp<logical_or<typename _Expr1::value_type>, _Expr1, _Expr2> >>::typeoperator||(const _Expr1& __x, const _Expr2& __y){ typedef typename _Expr1::value_type value_type; typedef _BinaryOp<logical_or<value_type>, _Expr1, _Expr2> _Op; return __val_expr<_Op>(_Op(logical_or<value_type>(), __x, __y));}template<class _Expr>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr>::value, __val_expr<_BinaryOp<logical_or<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >>::typeoperator||(const _Expr& __x, const typename _Expr::value_type& __y){ typedef typename _Expr::value_type value_type; typedef _BinaryOp<logical_or<value_type>, _Expr, __scalar_expr<value_type> > _Op; return __val_expr<_Op>(_Op(logical_or<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));}template<class _Expr>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr>::value, __val_expr<_BinaryOp<logical_or<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >>::typeoperator||(const typename _Expr::value_type& __x, const _Expr& __y){ typedef typename _Expr::value_type value_type; typedef _BinaryOp<logical_or<value_type>, __scalar_expr<value_type>, _Expr> _Op; return __val_expr<_Op>(_Op(logical_or<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));}template<class _Expr1, class _Expr2>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, __val_expr<_BinaryOp<equal_to<typename _Expr1::value_type>, _Expr1, _Expr2> >>::typeoperator==(const _Expr1& __x, const _Expr2& __y){ typedef typename _Expr1::value_type value_type; typedef _BinaryOp<equal_to<value_type>, _Expr1, _Expr2> _Op; return __val_expr<_Op>(_Op(equal_to<value_type>(), __x, __y));}template<class _Expr>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr>::value, __val_expr<_BinaryOp<equal_to<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >>::typeoperator==(const _Expr& __x, const typename _Expr::value_type& __y){ typedef typename _Expr::value_type value_type; typedef _BinaryOp<equal_to<value_type>, _Expr, __scalar_expr<value_type> > _Op; return __val_expr<_Op>(_Op(equal_to<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));}template<class _Expr>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr>::value, __val_expr<_BinaryOp<equal_to<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >>::typeoperator==(const typename _Expr::value_type& __x, const _Expr& __y){ typedef typename _Expr::value_type value_type; typedef _BinaryOp<equal_to<value_type>, __scalar_expr<value_type>, _Expr> _Op; return __val_expr<_Op>(_Op(equal_to<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));}template<class _Expr1, class _Expr2>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, __val_expr<_BinaryOp<not_equal_to<typename _Expr1::value_type>, _Expr1, _Expr2> >>::typeoperator!=(const _Expr1& __x, const _Expr2& __y){ typedef typename _Expr1::value_type value_type; typedef _BinaryOp<not_equal_to<value_type>, _Expr1, _Expr2> _Op; return __val_expr<_Op>(_Op(not_equal_to<value_type>(), __x, __y));}template<class _Expr>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr>::value, __val_expr<_BinaryOp<not_equal_to<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >>::typeoperator!=(const _Expr& __x, const typename _Expr::value_type& __y){ typedef typename _Expr::value_type value_type; typedef _BinaryOp<not_equal_to<value_type>, _Expr, __scalar_expr<value_type> > _Op; return __val_expr<_Op>(_Op(not_equal_to<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));}template<class _Expr>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr>::value, __val_expr<_BinaryOp<not_equal_to<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >>::typeoperator!=(const typename _Expr::value_type& __x, const _Expr& __y){ typedef typename _Expr::value_type value_type; typedef _BinaryOp<not_equal_to<value_type>, __scalar_expr<value_type>, _Expr> _Op; return __val_expr<_Op>(_Op(not_equal_to<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));}template<class _Expr1, class _Expr2>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, __val_expr<_BinaryOp<less<typename _Expr1::value_type>, _Expr1, _Expr2> >>::typeoperator<(const _Expr1& __x, const _Expr2& __y){ typedef typename _Expr1::value_type value_type; typedef _BinaryOp<less<value_type>, _Expr1, _Expr2> _Op; return __val_expr<_Op>(_Op(less<value_type>(), __x, __y));}template<class _Expr>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr>::value, __val_expr<_BinaryOp<less<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >>::typeoperator<(const _Expr& __x, const typename _Expr::value_type& __y){ typedef typename _Expr::value_type value_type; typedef _BinaryOp<less<value_type>, _Expr, __scalar_expr<value_type> > _Op; return __val_expr<_Op>(_Op(less<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));}template<class _Expr>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr>::value, __val_expr<_BinaryOp<less<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >>::typeoperator<(const typename _Expr::value_type& __x, const _Expr& __y){ typedef typename _Expr::value_type value_type; typedef _BinaryOp<less<value_type>, __scalar_expr<value_type>, _Expr> _Op; return __val_expr<_Op>(_Op(less<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));}template<class _Expr1, class _Expr2>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, __val_expr<_BinaryOp<greater<typename _Expr1::value_type>, _Expr1, _Expr2> >>::typeoperator>(const _Expr1& __x, const _Expr2& __y){ typedef typename _Expr1::value_type value_type; typedef _BinaryOp<greater<value_type>, _Expr1, _Expr2> _Op; return __val_expr<_Op>(_Op(greater<value_type>(), __x, __y));}template<class _Expr>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr>::value, __val_expr<_BinaryOp<greater<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >>::typeoperator>(const _Expr& __x, const typename _Expr::value_type& __y){ typedef typename _Expr::value_type value_type; typedef _BinaryOp<greater<value_type>, _Expr, __scalar_expr<value_type> > _Op; return __val_expr<_Op>(_Op(greater<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));}template<class _Expr>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr>::value, __val_expr<_BinaryOp<greater<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >>::typeoperator>(const typename _Expr::value_type& __x, const _Expr& __y){ typedef typename _Expr::value_type value_type; typedef _BinaryOp<greater<value_type>, __scalar_expr<value_type>, _Expr> _Op; return __val_expr<_Op>(_Op(greater<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));}template<class _Expr1, class _Expr2>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, __val_expr<_BinaryOp<less_equal<typename _Expr1::value_type>, _Expr1, _Expr2> >>::typeoperator<=(const _Expr1& __x, const _Expr2& __y){ typedef typename _Expr1::value_type value_type; typedef _BinaryOp<less_equal<value_type>, _Expr1, _Expr2> _Op; return __val_expr<_Op>(_Op(less_equal<value_type>(), __x, __y));}template<class _Expr>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr>::value, __val_expr<_BinaryOp<less_equal<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >>::typeoperator<=(const _Expr& __x, const typename _Expr::value_type& __y){ typedef typename _Expr::value_type value_type; typedef _BinaryOp<less_equal<value_type>, _Expr, __scalar_expr<value_type> > _Op; return __val_expr<_Op>(_Op(less_equal<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));}template<class _Expr>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr>::value, __val_expr<_BinaryOp<less_equal<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >>::typeoperator<=(const typename _Expr::value_type& __x, const _Expr& __y){ typedef typename _Expr::value_type value_type; typedef _BinaryOp<less_equal<value_type>, __scalar_expr<value_type>, _Expr> _Op; return __val_expr<_Op>(_Op(less_equal<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));}template<class _Expr1, class _Expr2>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, __val_expr<_BinaryOp<greater_equal<typename _Expr1::value_type>, _Expr1, _Expr2> >>::typeoperator>=(const _Expr1& __x, const _Expr2& __y){ typedef typename _Expr1::value_type value_type; typedef _BinaryOp<greater_equal<value_type>, _Expr1, _Expr2> _Op; return __val_expr<_Op>(_Op(greater_equal<value_type>(), __x, __y));}template<class _Expr>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr>::value, __val_expr<_BinaryOp<greater_equal<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >>::typeoperator>=(const _Expr& __x, const typename _Expr::value_type& __y){ typedef typename _Expr::value_type value_type; typedef _BinaryOp<greater_equal<value_type>, _Expr, __scalar_expr<value_type> > _Op; return __val_expr<_Op>(_Op(greater_equal<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));}template<class _Expr>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr>::value, __val_expr<_BinaryOp<greater_equal<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >>::typeoperator>=(const typename _Expr::value_type& __x, const _Expr& __y){ typedef typename _Expr::value_type value_type; typedef _BinaryOp<greater_equal<value_type>, __scalar_expr<value_type>, _Expr> _Op; return __val_expr<_Op>(_Op(greater_equal<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));}template<class _Expr>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr>::value, __val_expr<_UnaryOp<__abs_expr<typename _Expr::value_type>, _Expr> >>::typeabs(const _Expr& __x){ typedef typename _Expr::value_type value_type; typedef _UnaryOp<__abs_expr<value_type>, _Expr> _Op; return __val_expr<_Op>(_Op(__abs_expr<value_type>(), __x));}template<class _Expr>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr>::value, __val_expr<_UnaryOp<__acos_expr<typename _Expr::value_type>, _Expr> >>::typeacos(const _Expr& __x){ typedef typename _Expr::value_type value_type; typedef _UnaryOp<__acos_expr<value_type>, _Expr> _Op; return __val_expr<_Op>(_Op(__acos_expr<value_type>(), __x));}template<class _Expr>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr>::value, __val_expr<_UnaryOp<__asin_expr<typename _Expr::value_type>, _Expr> >>::typeasin(const _Expr& __x){ typedef typename _Expr::value_type value_type; typedef _UnaryOp<__asin_expr<value_type>, _Expr> _Op; return __val_expr<_Op>(_Op(__asin_expr<value_type>(), __x));}template<class _Expr>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr>::value, __val_expr<_UnaryOp<__atan_expr<typename _Expr::value_type>, _Expr> >>::typeatan(const _Expr& __x){ typedef typename _Expr::value_type value_type; typedef _UnaryOp<__atan_expr<value_type>, _Expr> _Op; return __val_expr<_Op>(_Op(__atan_expr<value_type>(), __x));}template<class _Expr1, class _Expr2>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, __val_expr<_BinaryOp<__atan2_expr<typename _Expr1::value_type>, _Expr1, _Expr2> >>::typeatan2(const _Expr1& __x, const _Expr2& __y){ typedef typename _Expr1::value_type value_type; typedef _BinaryOp<__atan2_expr<value_type>, _Expr1, _Expr2> _Op; return __val_expr<_Op>(_Op(__atan2_expr<value_type>(), __x, __y));}template<class _Expr>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr>::value, __val_expr<_BinaryOp<__atan2_expr<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >>::typeatan2(const _Expr& __x, const typename _Expr::value_type& __y){ typedef typename _Expr::value_type value_type; typedef _BinaryOp<__atan2_expr<value_type>, _Expr, __scalar_expr<value_type> > _Op; return __val_expr<_Op>(_Op(__atan2_expr<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));}template<class _Expr>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr>::value, __val_expr<_BinaryOp<__atan2_expr<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >>::typeatan2(const typename _Expr::value_type& __x, const _Expr& __y){ typedef typename _Expr::value_type value_type; typedef _BinaryOp<__atan2_expr<value_type>, __scalar_expr<value_type>, _Expr> _Op; return __val_expr<_Op>(_Op(__atan2_expr<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));}template<class _Expr>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr>::value, __val_expr<_UnaryOp<__cos_expr<typename _Expr::value_type>, _Expr> >>::typecos(const _Expr& __x){ typedef typename _Expr::value_type value_type; typedef _UnaryOp<__cos_expr<value_type>, _Expr> _Op; return __val_expr<_Op>(_Op(__cos_expr<value_type>(), __x));}template<class _Expr>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr>::value, __val_expr<_UnaryOp<__cosh_expr<typename _Expr::value_type>, _Expr> >>::typecosh(const _Expr& __x){ typedef typename _Expr::value_type value_type; typedef _UnaryOp<__cosh_expr<value_type>, _Expr> _Op; return __val_expr<_Op>(_Op(__cosh_expr<value_type>(), __x));}template<class _Expr>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr>::value, __val_expr<_UnaryOp<__exp_expr<typename _Expr::value_type>, _Expr> >>::typeexp(const _Expr& __x){ typedef typename _Expr::value_type value_type; typedef _UnaryOp<__exp_expr<value_type>, _Expr> _Op; return __val_expr<_Op>(_Op(__exp_expr<value_type>(), __x));}template<class _Expr>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr>::value, __val_expr<_UnaryOp<__log_expr<typename _Expr::value_type>, _Expr> >>::typelog(const _Expr& __x){ typedef typename _Expr::value_type value_type; typedef _UnaryOp<__log_expr<value_type>, _Expr> _Op; return __val_expr<_Op>(_Op(__log_expr<value_type>(), __x));}template<class _Expr>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr>::value, __val_expr<_UnaryOp<__log10_expr<typename _Expr::value_type>, _Expr> >>::typelog10(const _Expr& __x){ typedef typename _Expr::value_type value_type; typedef _UnaryOp<__log10_expr<value_type>, _Expr> _Op; return __val_expr<_Op>(_Op(__log10_expr<value_type>(), __x));}template<class _Expr1, class _Expr2>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, __val_expr<_BinaryOp<__pow_expr<typename _Expr1::value_type>, _Expr1, _Expr2> >>::typepow(const _Expr1& __x, const _Expr2& __y){ typedef typename _Expr1::value_type value_type; typedef _BinaryOp<__pow_expr<value_type>, _Expr1, _Expr2> _Op; return __val_expr<_Op>(_Op(__pow_expr<value_type>(), __x, __y));}template<class _Expr>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr>::value, __val_expr<_BinaryOp<__pow_expr<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >>::typepow(const _Expr& __x, const typename _Expr::value_type& __y){ typedef typename _Expr::value_type value_type; typedef _BinaryOp<__pow_expr<value_type>, _Expr, __scalar_expr<value_type> > _Op; return __val_expr<_Op>(_Op(__pow_expr<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));}template<class _Expr>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr>::value, __val_expr<_BinaryOp<__pow_expr<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >>::typepow(const typename _Expr::value_type& __x, const _Expr& __y){ typedef typename _Expr::value_type value_type; typedef _BinaryOp<__pow_expr<value_type>, __scalar_expr<value_type>, _Expr> _Op; return __val_expr<_Op>(_Op(__pow_expr<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));}template<class _Expr>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr>::value, __val_expr<_UnaryOp<__sin_expr<typename _Expr::value_type>, _Expr> >>::typesin(const _Expr& __x){ typedef typename _Expr::value_type value_type; typedef _UnaryOp<__sin_expr<value_type>, _Expr> _Op; return __val_expr<_Op>(_Op(__sin_expr<value_type>(), __x));}template<class _Expr>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr>::value, __val_expr<_UnaryOp<__sinh_expr<typename _Expr::value_type>, _Expr> >>::typesinh(const _Expr& __x){ typedef typename _Expr::value_type value_type; typedef _UnaryOp<__sinh_expr<value_type>, _Expr> _Op; return __val_expr<_Op>(_Op(__sinh_expr<value_type>(), __x));}template<class _Expr>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr>::value, __val_expr<_UnaryOp<__sqrt_expr<typename _Expr::value_type>, _Expr> >>::typesqrt(const _Expr& __x){ typedef typename _Expr::value_type value_type; typedef _UnaryOp<__sqrt_expr<value_type>, _Expr> _Op; return __val_expr<_Op>(_Op(__sqrt_expr<value_type>(), __x));}template<class _Expr>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr>::value, __val_expr<_UnaryOp<__tan_expr<typename _Expr::value_type>, _Expr> >>::typetan(const _Expr& __x){ typedef typename _Expr::value_type value_type; typedef _UnaryOp<__tan_expr<value_type>, _Expr> _Op; return __val_expr<_Op>(_Op(__tan_expr<value_type>(), __x));}template<class _Expr>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_val_expr<_Expr>::value, __val_expr<_UnaryOp<__tanh_expr<typename _Expr::value_type>, _Expr> >>::typetanh(const _Expr& __x){ typedef typename _Expr::value_type value_type; typedef _UnaryOp<__tanh_expr<value_type>, _Expr> _Op; return __val_expr<_Op>(_Op(__tanh_expr<value_type>(), __x));}template <class _Tp>inline _LIBCPP_INLINE_VISIBILITY_Tp*begin(valarray<_Tp>& __v){ return __v.__begin_;}template <class _Tp>inline _LIBCPP_INLINE_VISIBILITYconst _Tp*begin(const valarray<_Tp>& __v){ return __v.__begin_;}template <class _Tp>inline _LIBCPP_INLINE_VISIBILITY_Tp*end(valarray<_Tp>& __v){ return __v.__end_;}template <class _Tp>inline _LIBCPP_INLINE_VISIBILITYconst _Tp*end(const valarray<_Tp>& __v){ return __v.__end_;}_LIBCPP_END_NAMESPACE_STD_LIBCPP_POP_MACROS#endif // _LIBCPP_VALARRAY