From 9b051edb11995712dee860bbadafd3f7461f78cd Mon Sep 17 00:00:00 2001 From: That_One_Nerd <78499572+That-One-Nerd@users.noreply.github.com> Date: Thu, 17 Jun 2021 13:59:27 -0400 Subject: [PATCH] new version --- Nerd_STF.dll | Bin 44032 -> 62976 bytes Scripts/{Filesaving.cs => Files.cs} | 447 +++--- Scripts/General.cs | 114 +- Scripts/Interfaces.cs | 16 - Scripts/Lists.cs | 1515 +++++++++++------- Scripts/Mathematics.cs | 2243 +++++++-------------------- changelog.md | 136 +- 7 files changed, 2008 insertions(+), 2463 deletions(-) rename Scripts/{Filesaving.cs => Files.cs} (53%) delete mode 100644 Scripts/Interfaces.cs diff --git a/Nerd_STF.dll b/Nerd_STF.dll index c1bd85b260424e74237a163ec03c511d77f577f2..3218a2da14dcd981f358fe1baadbf7642dc4a4ee 100644 GIT binary patch literal 62976 zcmeEv37i$hwSHA~-|oJ5_CaO?ilxe%AQMB{EWq9H~DF_`#_8j~1e%>O&5s=M!<8CH|`UjDx~%IW$} zojP^u)Y?_ueaFqXN?1Y&8~^_C4-9K54==`n^=ZkI87mt2Wp7G+*Qx`O( z%ND1S^HX(;%I4NJH6@$N<|N8eOPk6Xn#x8@m{PVVS)ZuL%ZnXjR8Jf!#2L~O?_d7q zJ$`QQif&~&vX2lSg5zm!d5#pK4B;|dg(&2((smPr?B~DPhzFnkEHV4*Buf8>R|AQK zzc*u2OrQYtb`F#f!~6}AA{W8eqf$)uc?WYX3ruHe4|q&Qx{Bt+xy`_Reh-2;E~~K{ zi2urjm|c-dr{)5&ZLm=|03UI5K!%{YDpHBYBm~J;0h`$ep9LZu7$U^5Y>p5)Ha?~M_qg1k!5V7*U@gs3j$<73zp*SWojo^t<*^V>p=mCTcZE#63?w&NTAdelH#GEp$18tZl|6a=(>K=@3RU*d zij!`ffq?2-SigS;3_F@LHil){MKNF5uDumu9nf&VYCo^cRA(gUrHbw)>$kR zC#Htz=paHu^viW{UHw>mAoww-{6-argMy5N=-)1zvu)Uyc6mwpMS+fO!}}ElK!`6R zC0|MioSezCTk735tfk(5!&z^O{QC`WDYs3_jc;X@EN{Vs##TJoC(94UFa2Bi4J3I_uk`dmPA=58|FNBsqO}Cx()PSt`3DmYu)fHiJ^`rFV1|v8s zLpokT!ZQ@NxOi`X)Mzwq?os7uYqk}~1f0pIc592lXh)bPi>wU|rPWtJkBpV%^laz2 zmU|@`!Z~ktORIBSi1huf18SH~{4Nw(+y2#c-SdprD#)@xUKZE znoP?KBSRML%Z_M`RH`*_w8D6AiPK3R{;ZPH_&tbOSSalvs3Jko$`9E#Ms})HWv`+N zQ;}6vGb-O+MRh=Pvn?iRwOFEZ{rh@!I$hBLkCo`^4S1|kS8Bl1+V!~n0`#L{XO7F^ z5SNjtmeX-<)C71>vk1K6_7ZU%!a+3aO7$c)X=3D2sHX&%CkBscR8JDz)W~oDuH~ZX$&C~Bm`0iEF7)qQE}AOc zI8l#jl&LNk79`Y+))O%cl8hlJb#zzwCYTs0g&0+WdLNY z_E@#9g6mCEKb4=rmkq>pjZ|ZrCGXIc6w{S-8nG-xYBCK02n_)U4XMdC#82fX@MQxr zZAgtVgs!BRuB6k5Wf?Lf(-45r5P;B-8QF&Tsr&@KY#^o$nPCi}D=DTc=`>;*c%FC@j!K`d^3KylM!>%`@1C223g ztuTV5o2)^Q49MbIw2WhcO01LuD|n@JY)MH;`Wh-!|B@0egGS}xm!z+yh*6rK5jnkV zH3}ONUjd64b)z)MNY%fTQ~23wP-@a@X%jb{QAo6m)~E$FhnE!0NPiQSu0f?KxXoHc z6@sM!c>+rVauY2LsN}TFwIezWl}@MmhO%BWiC#0QUh|W^rqk(ha1Y9TICK7ZGv||q z+*}s=lRk6E(1rf2&m6LOp+D_2hpbj^m@)_4|9{F%s|8c$AgEUlrpy6Xml^8_ zYGmt)gzE@uSr#`}T1QaZvY663f?Aiwl-3c{zAUExIwDYakn0G_E8Z9Lf7Y~4c^YoU ztWJ3wZpNfeHfZj_tRuK=ywBY#L(8yRX}(gT3~XpE;`o@#Daq}b>w25=oM?5- zE3MA;=w#<3+ILmrxPy~b8yXhQ#8&n?%kH0(T7^}7x(eO)JZ1Nf*oC5}tE_&OMJ8Nt z*_GK63;R3vLdZmwwXmOUA*dR74*<&=fmLylD%lh(&FL9)l)GtWjQ2E~kl{JLjZ_|A z4x6C)5Oez5pqaA2)8%PPwx3NoWa!P1HGWz>ILl8nTKTD$v4MO&n6_d)N6pYWmo2mw z#<#-deLu8HdV4J4kh31S6Fn?KCpHnre6?NBM|6SD~z#@du#Cnt}5T4(;1d zHJRlxbs0xKXfs80E>VQ$5`PNH=qN&n`1=U<^7r501b}@fYcU8sI}9Uu2(d+HXF$ZN z44AdwzpwmuwUHn8`yU3IH{+ijmL}^sj4h-fj7=sEpRFu5oQ+FA1JN}YV-;Gx=Gz&( zzRHT&H8WRHnb8IK-gSTb=cI@o)N22nG;B8e=WGV+!bz3C7vEwh{(zcjm7xn{?D`72 zX!h2+FmY4P>xr0&yGfVGswgx8cHB%4hCukAYr~8~u^|xt=h~qAhOUb?{i_?uOzmdh;6t#1r?(fVLv!eP9l~({hxq7& zVrj}_Kx_?+41w%+%I6^5{4n~^2?vGsIS6w#=5r7&rO!cFiqAnpDShO@=J7cQ$7m+o zr_Vu%tIt6U6F1PI4t?a&LWgFy(4o&k3=`)dq=QbSc|f^9onH*hha>QIzu{P5wF4tj zn#NNkPWdu0w+&Y-Nhp32I6AsC{YQ!&g;=5Y;*ES$q!*4|_qoHRn|Vcn`^~;D@ttWa zX}%RDd(6P9Z$gdv|AV&B(5!ck|L1M_A=^UK*n$zBT)&=(8R5UF8-=Bt#;K6)g?lh^ zti==^i1%`Xbb4sNFZC+Mb6tsFmSDM~lKn8Yr`}>NCFgC}_=z;&Z^;n0D7}**r}s{^ z;KnRt`a&?%lNX=+d>Xa5zGmR9FK7U1|9%d*+Bg-)Ko7Mkd zlJ+EGnL!6&SbKzw3yE=I$S_?^Gfp!r4@PTp;YbWv)~X}mL3B7g;1R4n&N)!u>c)MG zRIH@rx<@f2HDQn1q4#>U4EH0B&pgf1w&_0oug^E^GylE$hW*2@izVc)^+ZhfxIp{T zVvo}91i8v$>i3KwiS8NKr+&+QfZWS{AoT~vlrXDLgkri2WXNUq2|T_-sh*dmIeH{fbA#I<{EaEI?NKGx|(cteq6xT>gbl7(inD@I#?2_n~|-~j|ge{E(ik@P+dS%-ygZ-~_1mmU?Vnw#3d3Die822?dZOya z%qpQL20}CS^v_wAX3O=dd_JaI&ih*mmLD|#hm!>1OT-2jr>&0YXW{bqh{l-2^z>5+>pFq_m`oCh%$ z%^bw^X0$FOY@_|>|0Ont1D@VI{@-Y0I5_IfUTq^*5L9dHiI^es0bPd{*CcJ{Qk_^# zX~3jvv6%V;W}rY1m{c$0sX5}WvwtQ`gCm~_Q(fy5U7QKiNV=s5&V(ro!|jy%J9BX+ zOj&8J-a(~0j|9(dw5{75-L_Qjvs-94Y^^@4;23?was!0LuGXGA&$!7K^ksr*?LgXl zB}H^49VR*}FAU9LUI1ZUHQ9Ojg1$@;t@EO>oD|WObeQO@yfAKuc>#oZ&B)Hn7xZO< zXq^`g^rVQcq{BpK<%K~#%nKmQYi4#{zMwA?MC-h079d4*B^@T3X9GMGYGwlp(QJ@q zLjSDxOLIeL1nv?`vZecFNz+V`Ax$&I&olc*|IV4^qj@8g*7F7%SDKxwUsfubMZ#2i z7BQ*j=!XaNZm&Mh)?UM0LJI^vO{L4p0gw%+7kwVAW$Dqe%t?k}dLpIasEnD0q6TL~ zWlT2|bzvBlIp-h>vkWUtg`08yl9>2w@@e*&gR@nZ4HM`HK6Gu#JP-2{7sy`4C)|-$ ze8i1|S~}#`^V18+_;Ai!{b#JmEcTjz+{z5f&OdEs24(CYwlae($U18^&sdSYW){;* zcox&iImiiHPiW>DD|R7`o&T=oYB>p-XRQA1%hht?G|yOZxiEcFn^;f8OrIa=MrCo+ zqO(zI3>H(GOsPFsOldNuCSfu4C(}Tko=nlksZG>VFT-E(j8!n7Qmbn{pHiN|d>U0W z%VIvIybZT=s+75S#)@pnoMqd5#wsg6e=^OOz`2mT0lcM0r&LyszI2N$v!-4gz)?Z8 z(=d~UJ_86{1`v9zT8}!{o1}g!KY=eBi22HOUC?|?is?!^jaZf;m}Wym0763mLPKh@ z4e?X?34GZ=OdCRzG-;<2ta5EKxoL!Y(xB1ega=M5YvXx^iJC8N{Z=9I*k}l_tR+R;+sDT z(R82H-}-0uH=6uI3u*EXP2|ZxD{a55w6qim)6!BPBP}fj&@Yu3uDhj~NOUp!muEVO z773vqS|o&e^df56wxW&pSJz*$_(u_$I6dYwiO>hq5f*+KwPbx>CG!T{9|O_!mzJ~>61y) z#KrM)S5MR$%0!|^AUI0J2O)TZtKvBJis2;cSRJ{cq5L!z#};Nxak5pE0*W-t(hzSR zv4nL6<*9izW?G^Ob%R~bqSgW>v7UHuinKY}RHw8W$I8sXUFq&}aU|;Ybfm{#kV#(> zvywP1jOFyqag$iF#g3&!ZW3Dsu@nC5og#N>N4$NL>tRDYiPc$br*cAz;J6{+l?w?Y zl_(IU#|rHC!(iky3Rm1hW#oe>ozGANvh#_#y&P9(;GB??;TL2vjI+qh1Gn!&1Rmn@ zX%A7`g((8FO%V>{zHCpu`Wf34;_wEa@lvlm?HjIzs`jdsOV*>r;(FE^wM0xg zye|;c1&+W=b(HJ4+)6kNpRz-=?=BsQpjK9{eS*eC_7!QL$M8lI`}|hYo11=;?GcZH2V7Z3OH2 zsc_!UO75cM^ll-Qa2`->p8n)?ff6M zUq8o!-dR)<)8^7cFU79+kQasbeS2)G4nWQLJ6e^6ULG#ew8Z)O-r{hI3hE7%sP z{Aq?!&_z1?;);2Czx_YM_q&QM-6NxB9KdwhBK^VFW410!kS-bz4yPW2k;2$@dZ_EG z)nkTYsz)qY4$(%`W0npjFw*-v4#zgsW2lho@I>gtj#d#btTM);&i)|a4<@b?P139! zj3@5|;|V6OHg&{(9c>LHt@OPXj3uNG3mapTozt`2^h`Z(>z-L`mPv+3rtwUp`!FW- z=L3D?Tk1PW3%UF3od;C@C@H5p#gg*yZH-iNp-B%0^lUwcZDXYJX&6U3$&b|MeV3Hh z9NZvR6LU&>XAU6HLv4lp*izpiH$qmPJ(zq&TkU_Pt#}B# z!j@)neGj2}I_&z+9v8;7q3duAE$N*x;E+zV%dcQ39Qm)Y6Ald(8$12+`jF~5Lkrcj zKVBbxJ%K0QBI3R$}igMHJ9IJk?uIN%-QGY*GkDt?fLm+e&sSi z$5$)^c9=5!+OiCGPuTRyPJ3uJM=D>TXZbC00`ySd%$#rc z*->~NL}Nu7YOl18Xqool8ZIm1hI=?R*uDQrHrTxb8~nbCF>imx=d3gPD&!Bk$ef*- zkdm0JV%WXoZ6yZHxV=1*>*QGYHC#)g{gmuu-Dp?7ulr#{G$9SPfBpNKL)l5P`u;|n zVd?!m3$L&EI})DbmDcc$B=1P@LfUUCeRuLW5)n5eZ?yR$JB`&=%wLczyaD4R=^nZ| z+{?p`f!WdW%tAZV3p?;IjM)mYqSaWuPe5uG;D=tcw!ZIJMlC-1&`ldtWaCQ@nww#* z|0##S;MdBhV;^E7l(O43ADgJeoz#kpHXaenQ8w%m`}Z30$q=J`kBR9i2;l>6>8ZGu zxXEd_B&QQO6J%92h^e*cN&@-@otOO4FP$22(lbDkGePwI39IOPyK<6efu}bHPgXE( z7GV5r5NzK9Vv08qwo(6~u^?c8t2Y#WPj6F@-OQrkKF4TsscrEfs&ISp0 z53vI%X}gaM+28IV#IPNtuq)fOSGZ4`p}X#%shd4A2O2XRG&g|SKSNsj=P1|eYrA&k z0e$plmXGKxaUgVsd%L`28@6uRzOC8Uo^4HzThjYCct|~75BumVYtV&{3+gMqdLDv# znP5HvIzFJCMLqV~{Efq-P*GxDl|sQO<1P~oqX^u1=w4a!=xCeV9axb38} z(fXNm8jaj{E3jc#N^6PMin(_lP;q}eAWy?Wd;wXH(qojO;*`W2C_sJeZsgk)`5x&% z@AOOTchU1sY+X*Vow&eq;O`r03_X>Cn`*kc6K^idntpqJvKNwK?SiNGD)jd+YICVdUuA=#TZ1*M+DLtVOui zw2g)O5Q=R~q9ne7d;AlqobYfCgPd-IxuSF2*Q>-SD1R%xMHzZ^e>5fkZJUaHy9AzXm`SqYwHQ?vg{-2WM-PWPh%2*|)x-oup|-$KYm` zTn%mI8}=b$am&#%5A!opsMI5^9u2#b%BwfKD&_r6xSwn(9co3xnCz19jx zefm}?w@Y|JbZ=STrCIetXEwd;(wuj?80Wm_*G|TvZ%Mgp&J1%!chk1o^>GBvX~Vx{j{nTi03nsS$rb7YTWV|`?wWudmOSahun`z+Qh;-916awY{n2=h3(Bz+0&>Y-L$+D5r) zlBAC^QmIV)jqo(f_gQ4yvASJVVJ60n3D+;TbJq%|<4ivHo4#+fYG;p`c2)$PJP%pn z1aui$5iH>FRK_>Ju#!aMms6a-D#8OHWI;)CJ#o4H{RsMKZDb9+2O<8dG*%4*t^&X! zry8q0O5w829{0_>eXU~RWsr<{nJKt5r8O0~PU>Y$az=taU(iab@3pSx@hq&<(5gzO zF~=BW3&#(x{l`E4;gsw5;Hd1$E2v1cFrWY}20EoT5DR6#5?AvO3}$*l!BZ~;GM;)N zXr6k32l%O%t8vv&y-;MUr(TGe@ze{$;F%7+a%UdhM^(Y8G|pr{^Fql zGcR-eG0+-=`V64s;Gr{&BL;;X{_c#Z4Tv zm;;={b2|SHj&DjbA1=W;{5};Q;2b_o7d$Hvvb2o{I)^`G+YWFJPx{*K6B)kW&pEuG z{^0BJ0O#(^&;YkOr7xZ&)?al~gm(Y}^GI3~2eLGHlk@S(m#?jQ#|hYxih zOecZ5>_cwqW9Y-<{dE905?%Jgv9;xaH}zw>f21{rIiEcUcV?SN_Mu()I{q1E@j7z| zbkexxcY#Bz?{Kgp`)D7rrLMyCJ#AN4srtJvqL z({fF~Z9C)f0BU@mr4u5!g`}gqX z9DZMU@8cZ);PO0_b9mB-wZs0;;YlcS&T4UNZglMT9G+F|v&FQn@L>J5c2b@P+d2ae)8bH?z`hrs z+)-Ika0Y&Y86Ps|fc@Ff_Bs4v*s$+&crHW6J(X|uKF;9}uE_p5JV^)V@Bui$IXuak zei^JA`5c}Ok*`IhIa($;bF}=eR$LtZQ9K=N&{c1D_<+y*d@zs1g1sYJpJbo?ZA5(L z*&mzd_jzq+%lpUR?2ppYBd6JCf2=V{H0$gyTXFI_#2-*Go&9ZsVEo%4!7dk_{asIt z{h$4j1^?=^KPuEAo&B-PaP~(#T3jd!e1{4{2Vpt@4t5r~){-|+fOfq|*gqO0G5=^R z2%A*C3?-y6T1pw-;-d^#aR3aQ0ci#Yf>*lY7b?7NHr?z*+3{6?Xp_w4b`wYcK91IS zY5WA3qdKO)i%eqa8$ok=xK8qW2qY<$liZ9T@;ri-U~7}th)Ao`$1i|TR&r&Mv%E>p zX|VT8zvYEJHA>SVBTGlc&j%}c6S6WXP_`{PV`~)$z_{6Ga3Cz~EyNECdn+Ic%Uo*D zG?wYI-bOK5#`9hJo;|6y#SGZVCxZ=#amp!<+a7ZK6O0KBuSaL+=}qRsY>4u$XUQt%T7NKKyH_`&V_&QUX-Jf|A{z7 zKQQ7u*U88Y4>XqGu_8Y=U2He`Af!zd`ePZ^x@dFc6+ENC?!&vm4*{|n*h=l;T9q-^ zva5UBAb1&&WNA%A9%Vo3lRxeH*UBH&M(LXCp~aIAL$<_(sfv=15ZMfZ^5Fc(7H8s$ zHiI=cs**~@{+wh@JV=K^kPP#6%TVmrH3uCW!q5kAU8M6jWwIL zG8w)i8T6Z<;G#1{el#yt;EI1}LzJDab+%k5Ngf4mtcO#AM}D#@o$7o((gt--$=Od- z=b`EQ>qOSX1A3~>HZZGJw}Ee%a^ahm&r-R{h>(}LB|L`!w*)SFTag%be@a3$=Ww7e ze`7Qje}TA&ebJBQ08Xz?B}RF-UlfcTqGqTWD>Wd??7*kT6rmw z<+{Cc+|r8kN@Bl6uNSI4o1#2Ee@m`}#Hv?8RM)?AM9;KZNtoZfb zzR+S==MfHH&~0a{BAX|JRX-!aQkFw~k5*lE8k3?uVo!KN7fl_ZwdyQ6X0-BFScON}%EX^YefS<}k+_1*v91_N#!nk;5*DX2Ge1N^O zieBKO+)u$jD)))__aubQfzBd?VK3b`3N$`$W5u{q#xRE+hVxiX@8BB2KeRzpn&&-T zDo1$EO*xMEF4Onzrkn!t1jHOMG;*Emh_%kns3Y!=5FN_l*EyVGdL`31^Y_{$6UiF{ znr9Pz-X_h9S@T&AaS~CYpKz*PB40VMmgw15GS?BG$B3R|k<4g8^lY)fi{Ys|lIa~G zP8n-1ijd|RktR?XohkFhqp{BmibWTBcR`659=*H35gXj@pu0HVAGw2~#aIp94Vj}M zQ!MhC?f}OTzv8^?80o)*b3cv4Hy046p2L&a^6#-F%UGs@`DZbWSu-Wd4oe(yBRHMJ zOU&tjFkCLa#?Gdev<6N3m7FnhAi^3QuQbZzxNW%_<%{Uig<^^rBfo|oP{3%5Rg?2I z)MI-_zl#xa#AHVAID}$iHEa33Taz;or~6wu?&&;=D-sVg8k<9?SbWUrV?pQ$VM)r* zk%US_4@T`7brfUeO(??#L7xonBAOVjF=&aDWre7rhjRxaZYiS&7#$`4$mn)PUByv~ zB%igOatDesaXzDy1)*+Y9izJu*B{TIT*c@ypp$`aRBMoK2umI#?odkNcLHsJz1w5O z57kBR=S0{w5cB*Gl?8-oMh~-ODN9y}?Hor3^aJts%68RXd>lK~?k{@g_K5TsPe)I+ zrMOo88UF0%9v^YU_#C2dayVB}IL35*PA}#Y%~eEWpwm~6lE;I_J)*q}NM7stDB2t0 zuHZXjBlE8=Y#F|0ADq)6Z;9_0%)u|UKbJe!(qSnsP`hC5or-L}05-P{JI;^fCN+Ka z^G+4)S!)x$x`61|Jfd@$u8LK`s`CmqDPMkL!AT@pcv3`)AK07V>U;Bd*^cO(`=TYq zW8zoH@i(9o%iv_OQQVg|7?RZnb&(??N-PM_>9GD`gWgaRBewX&pyR}d2*#tM1^zao zU!D#-CL44#w76n+fKHEi;y#1&5f>GY2k7)jOcZz1T6REZjwlPz>5*K~Y|!^((;|7| zOGa0B7?v|5k}po`PU+TpFXt{nPZ@2{7tTtc35+iG9Ct5JwT|mBC}%HvVjZK6-txS& zBZcCe05wF4M6;IkrmN;iv3Qoz`_We&LSLA;r=2C}ea9T5bDyIKjb!wG^kkRNR10FbQ`_Tqu+^i65RuIOQf^t8=$R`qr^~yUW8U0@T;Zu z0ooclMx+heQ}CV0vEq^d-4cn5jRD#kDHpdI^bmCR5)TFFmPmzoHb7e=eZ-pv9ap$5 z(pS6}pzV=<;`af1664jM461_U06ZD2%U4ynJ#w-r2+)&}LG)BAm;IdRw#ccXSAe!h zhKQ2_^kih17-rB4NRAMb1GGIdO3Vt-laVoEfkA`4ZIRQ&MFH9#IYV3*peG~a#a4r+ zL2{yaCP3RGlf^Fr^kihJ_}HN3c|VOz7oP{{l?d)jkEb%M^FBe(sTRcseG{#`S{!ZA zrYNB*gGQrQRf~}Zy@=jXE$R)rg(ZK-XrtHL`*{SbCt5I~h3s(%(N|CiT^b`)Y0%fB zghm^*sesTdgEnwn+907Q?lObUun2w6pdF0vH)t?RK5x+dHc7r`&@j&7FO1fqZ~g*t zxjo4;Lcfm86!jX3fu193#Z!!^Km0CID{jDT9s0W*SMa;YY|(szM)yX47pW6x;C4|6 z-5ckKT1M0xKaI>4-!XC2|LVm(22ua37iGBB@cUoAxRw$1s?Q?{@p6EqGhh5UKvAbb zbis0+{P`jz7mDftNoSF`FhEf!DQ+`pPr>JrCE~pRNhdA5O08v2LDX3)dK>f*bS@X? z1V}n7#MJ?cVl;oypyLXQoK@n-22}xFC|)*bVO~dP4fd^c4$Je(oQnkgju=_JJnuN? zVlkSLZi8#ZWP_*;t`)NkqBgizEHH@L;98M3h}z&GT|Mo!H5U+F-4-Nt6ztI6@1Y z>&2-7TI}2)5(d2p$s5Jy04;Dfi=PB&v9m>dWYC_1TIUvVJm2YIWGGnR+$JUlXt8sL zSZ>fm(D?&#Uw{@kTg6)eTI}2<_(cO)c3k1P&OIV_vbM7d=sr4p(2tG^)Kqhf$T;|kV0 zkBNGN?v1W@9v4>`^n1iTA+{UzQf#yHWAT|mFRM$Or$qNbTIb8^Hs@*4+n|T@wmLr% z0}T2icfIqhn9YdRJ@-1#iEA0H^M3Cw5zmR6O&qOso)h<(xGJn|o)b?PMC+I5#4ASf z1edhfU!&Y<{X!_0(MIpr-UC1#4Eod}bc{hwF+zP9QA@rc@|+kGphujain9Xri^vP2 zkrB1sC!CkXg9eQ&c*1!_*x2ULZTAW1RWXi{Zo99E*^H>|ZixI$oFAa)oY%#ABS|g! z4RNDE)RNy2_ZvxC&AcIAVMJ~BW#{MOivaC#c8K_3%AMlgb>0?J4SErhJMk%B9rt2% zhx3lu8lZQbcf}5a_7uGA{94#UwB(+G9nNmiCqVBy?~AhxdI&oAh)V;s!}*=q7NB>X z55=zxI<9b!^O5)&t@-q<|D)6__t1A51`Lieu&|jR-#W4n* z6W!zN75xJAvGau(9H75AUy9QVS^-HRX9VbDN6AEh{^Hnju|b0|r#tc+0s7eSm|eeC4RT><)wQz$<-XnEe3PO;<{CQzc~dA8e5dc&xE>%94P%soQV zH~I)IR)j_|+UPaK3V^D099rZNK+OT_?3T*)jHnHEcRR@r!$}K`pWWRf?{F6a10(Fx| zj-(uDPr)>IsN52uv)$qHp#aTuN6J?WdI&m4%TEGywmVjOW3??0 zMd!Jv%dQ3;SJ>o^lgArW1vEkSH|U&blRHUHH)sXW6uHcx!CsR)P2OnGG@vu(GX^cs zTjtitw*s`vogqIoXlUVDccxUQX%KQ)D)w*5sY-*&Xi{b=n>~Exi~<- zh@34iWkfZ7nOi4&olZGWO<(5Dk*^qZZ}c*Eu3T~k#p#-^muneOO<(OMf0 z${?!gd9rLArPC{jd2$sas@v<_`SQ*HZFU>vPXly^yHI{$(2I~1f9b}(L3B#@&tp9 zE4;_OP@ZH^70??JM?T4j zTEW}y4e}o*j#|NYp12T5uL-<4|_=~nPv`8gwM1@F2y%BpE3N$3N2vz!s2PuwkX zjX^I$@)o&0Kp(ib$z1{Z#JxktrfV&G3f^^pAV&u119z)z4A3X;UGf@(9)iw$$IKptyQ70`pS%Aj+ie{~<0^lb-{TmiIQZZ&AI_gD8( z`GrB#fF75pS8K_IdD8o_JSRY&_oSqcLy(q*c?I56lEUy{q?1+RJsqHN1ts1y0lGI@ z;{C)&d9ULB>)8O&nlD5rxS4Td8Ey3QE1YdTE5FNVomU#2CZCnJ8B`WM%6m@U6U2>I z&&x-HxS8?=`JzGJvfs8|l5ZPyN#PRllKjA+KVvoelKjk|r5s1!x}aG*&$||Jg&Ltn zIzZh6G+(|X`vypgm*toM&6KamO9OPdd`*5Fpe^!ea_S7u0XoaA*X06@#3?x4ctfrY z&|V;WCQFKL*5&f&vN}Lp~8Z<9=ul%L#FiWSKm%CHGBhNDE(fn)0ujEw$+OB>jcLZpfd{_25Tc_LM?G^9I zYJ+~N%DrF9O#wR5+a-4gXppyC_NmqBeyYZJ@5@UAG|}55UkK1F@AtB7wwAm;uiX1c z&JNIt-XG-F01fg!mY)Y`jQ6RWSm&pk=zS)y4bUv_FLJj*mv~dvUKyXGB`@*js=vu| z12oV3LOvUyW!{(an7O{>MV?TN0lLPs)Z+%dn_rG!11_xBlJDl9=((yfK!ZF_Z4b~G zFQz&qe94Jkt~x6~v%CUzk3n~!?8WMf0G;TyQ`Pfyx;yd)c}J*Q0yM@eQGBqEIqr_U ziCzaaV!kgq%R5qCYtXcU?dmA?LV%{puBvc>mYi0w*(+0H0(7U>O|1{mecmx@dw?GG zj#FP4R9kSdDp$Q4w3ga}mw*-rXs7C_9uLqnUN7}=fL``aQ2oyF)4k*MR%-+Ffmf-v z2I!AomD&>^E81W6S*X)BqC^8#V}Pc~lhw8WZT3!49|!18?`vv6qo3|RZ?IYrphvx7 z>Q+YY%Zi+Ja-_PC(R^mf zSDvm0256@|LrpYjElyd-sh=4%-QB9jsb2?ZFTU&jS%9RNpavzi&MUpGYNFZ{puJ*} z`plpY^0zAd;L2hx`9c0(F-09=P*1BzbgG(dP_6BV>FQR4uD1yNhe0 zdPdMZJwx4T5Y5vw)HWk|uiM_5q3GpdJu_d3pAA?Mpi$9T>f!)hW!I`J0yHyPr#2b% zVsue-u6jK{tD*_T2j-aLUW{&t&R5lGox_XK3+)Cq$Drd1cUcS7!T@cFE>g__x;vUw zs|>1wRSQ2JGxZe#E52@yR7Bv8H3XDTCrTcWzZHz@0)ZB3%5s?tIu^D z&qvEuyqWz8)B|zn256bJLOr7q=FOyazIw%=vgk7F0<}{k%sEd-*Qm8iS&NvDbL)%M z&H(KN>bJ~~n=jX@*#RoIzOJ?zv=QmnsW$_(7wB&RnlCR=<;%5}jk4UjRGn$iK<|y{ zWvbbra(kz|T)l444z$+ws>8WD-H!bE@(MLEK;_m3wK_n*h+e6#GKl7?tJKE<`c3pI zWv$R!HpsiIt5uFcxp_&Tt^xW(^cvO2psn89)<$(zfIg3IRG%3{W5IRGI#27I?)HdY zr%DYf%v)xCTlF&NhnNj-P^%ej6j$b1vG1zyGSa={d+IhLS(*DsYqNUD#8D5pNj+f@ z^?;kyD@Kxfz)kAgD=Bwc0p`cHs4WIn0o|hRGH7ApQL)?9{fub!G+y1No-~NoM7OI~ z45BsB?dn$s(VFOX^*e)TO?12Z!XR1`;e%i2bJ@8K-mW?ZXuiB1&&c|55~uWo0yI;8 zU#$$#7I~+-RwF?xkFDy30PU3jp$b>A7D2Unml_eE?dmSIK0wpt-RfO~XsvOND!V|Z z`>8t7yH_;^XpncGdN4p^yltxRLSJ&C_kfxjpjqBS>JEcwt+8G03DAk&k5s?aI^Fe{ zZy!~w12o2aTFz3&#HR@G*>;R#6?>25^tXOQ#CO_%e)uV z)&O1Py`(-1&^6wxYRttt9j!H9SDONKqW6aSEI@<2pQ{mTeaSK24z)Qz6TP?9?f}j5 zeyIk0T}#qh<6X5jKqq?dsdoc3$osYGwa%9uXiW9>3yt@xYSQ~pZBR65uiuCKdH3_(OTnkwJks|0ev2zo$9Y@ z%w<|jZNW3%UUhDOUiSW`wg>1P@9!%28@}WR-ak~o0R7RE*5UwJQQLaZAX;m<)@K2l zCOvD=pu+yLF_nWXHYqYaYW~A2|?W{8xtrN7? zXlGqu5UnTLTh|6?r!294;3Lf1rPh50$%417QtL5;Xr3;$UNDH}@KWn7MtWQ-wRW30 znzcJv1Fp~|s?7bn)zP{-K(5`%`W_=aYaeOdZV-)GM_Tt7NgA_`v=(k4Ei`5w7wc>_ z2k4~OQP!#ejfj<5>jE?>*3G&yKy|TWtW5@0LCdk$Ede?y7PsyR(1=*MwLL(SV!fF7JaOp27M}*#QIpjG3aBIq0;&#Ji$30$u>neldSo8I_p3n%ktOR<_pikvqpw|o{ zTTZgxHi&FF$=an6+cLoVG(Z={23p=#>}%L^S?m;R1fz9q%OGpEL1fDyYm-4_%OL9| zjWAnW6B}gx)u6KIrr6gk?`prag<`N(8lW3vL#)05x-~Y;8pDV@ad&KlbseK;IQNm( zEm~6S@HWLpTH8!qf7QbqZQ0-C90bj&W2{+>o)Ki(Y1UN+RjK=9r&;zjTJkab$=K=E z(TtuEkJ-<~##yK8IQGi~Yg~XDtcg}VBeLvgvB}nxCLPt$6zdg($d)NqpKC)~rdned zXPcE!%LdNLwgK8V#=V{{zX?M!Q;K~%Rhtr~;q$)mHZc?MBU zpJg=}L^XYuMfz#Sh3uRaAhI(=q15w#nbW< zr_TC@LDkVqoH^FF4ax zwCWA|oY4kG??p%CuSVQPjpPw|B>7zvw~piJdDosE(Y%6?PEuhwlfVD)yeOsW=C+-- z9qPc(>*g4RHT_dAg^z7TW3WNt8A6Kvzwp1#51Dm3K8Jk%CTh?!o^Q#qxh~qOFWrhV z>-68H)-pYy!!1iK@w{ucXM8`j|L_qa_Qu-D=MMz5ValO8;GY)4uEsYgvkq&_WcR`YtTA#Cu%h ztvUOzK|O2iE3ZT4Z{)U0REet#+n$g9eS7PndLy%@T6-q+k|nPBKVJo-oIj==jK^B~ z&=#k&p8w7^f2ghEUoD^6>U6lZH;(5OCQ9B6AEnABep-grw)skVXuQ_vG z)BVCLpf>*`_nO1&^|QFY=(Ha9$JXJ0?j6mAl6-X+s1#us?^kgtF5%b*I5rGh8TYD6 zyv^&7)}v5sP9tmk4r^;2o5|_HV@RgFA697L?FtmEZO3Dg&nNrCu$6UJ9+oTnK6?K( zrAJ8JTJ|+6wr)k#{#&=7{~Oc(ea7nl{bO2YtNT}sLSKD^3GXzeP&|?lRpM{l_ciBW zWON_YTU)l~4!A#3;+LRO4B(MO&j?TD)41_7-cNhlCYc9Yh1=49IC}ij>9lR< z`&%C2GwBC>&t4d;#FTK^dwTrQE94(wPm}(O;Z6K};o*(U7~Wcp;kU1H@Lhsjy!D)i zH<RFMPg?|zFn$T?6Wf%a~rx^d{z?B`WYt%Lg3(E9gSJd2uEze?rhMY`wTOeisR)Zc^BxLIom{~q^GC{%8zm%6GI{MG~OV;*?wM3 z0)17~fW9f}AhQcHbgn#5UX=S=alW8;Z_nqqu+JCt=I!~gXRm1B99Q6(&WK#W`7YtK zM0GBmCFQtFtbk-8Y}1-Q${i%vLxUsMi)jVZ5T++|*7N(+#GfzM$SVq)z@c;R^@7gA zm$3Xp@X0#x>Djw$*#i{b0?sK4&n9r}4dP5|r(D8Tt>=?$qB|i&CAy3)xrMde!l~Bq zlSGs+>7g@u|qT~m9;%GZG%$HArex_akC9CM!ob~Wtd+QT% zsnrePZdN(d`G}=4=?TA)eu+R5RsHrr$@o z8X!+kU%W2pd5N8D;p>8)4S5~Upio})EF^{ZLIZjGUiQXLlP^6L@VcOGk^6g~yv%3Rlu!p=^15nEd%&vm=mPsmfzkBVfI+uQz--_!q) z-`W3A(Amz1g3f|IgiZ?6+0Tc9&H)>le#ZHd#|p(~ocm|&fkw8!ku`jV@O;_GdKy{7 z6X;EokZ*;WW>c(#wB-LrK7soTwK-oBM}kjn<_YD!ZA}Hghh` ztiPG{H?wWW%Zu}^W1+5Z!xfS?kODE9b;yBRL#d^>w z;s(%};ttTcplifJSSS?UZ3U%p8Po3SVzDQ8xS`jGPjlyT_+oX9I3@39rcW|ww_1r* zwng+9rgJUQb2C$EQ}}46Lz&hwUBmPyrn_@kLoRDzI-;1u^-R|?eX4{wyO};!%3-E< z2TsM*?#O(mb|>aD9nqb_^-R|?-Q9yY_OUFZX)g+oU|P@AuHsmxBbeSYfH+Sv-L1m| zS>_a?Lxz1vJdnG30+n|&)5n>StYGU2Sc$Hd{Zm-mr@7)tpL2*mPZ2%UC3=xf^vVLFqw|Q)X1X#);UO-i z8ppKEEp!8I)~}17={1Dxol(&H$+L#>73)MtoaV+RCyi2|BFL( zQ;g_kQKB~#5WSJZwxaMvi|9_K^PU`Cte)%&lb^DF`^6Y6F{34 z(N*|lq7WksPXhh3MRW#-SH&nivTzXdiO%5gsu+bw77k@T(HR_G6{GMQ4%M%=X9(Bz zIHp$=jspLf=me(IK)-Fz1iieF?BC0!Si#{UuO6HtZvp6XN#Wa=UQxIR;bWr9K(8oV z#o+_%`LkRH$-leb0R6Kh+jRJt=!Sr!Tc+m!Dv#v5D{m#HVT@PkZ6|`BiC?@>_`bwI z&>D>TO3V;n1D%Oqa8cqcF%)zbdaFXu90^)0MuW~4V?paMGbk|!-!f9@vlBp9i%Fns zkQ+T5I1Th-2FfEv)RL#q<&pihZQph<~Kp+jL^KNs{HxL;7>ay0yHWJdB9sbWa>GCRi-`oRqF;N}*D`bMX0FGW>#^oqZmxaIwZFLz zFxQiDU5*w7m4i;5TU$G#A-%YT{4VuR_cX-=jHjZe(4Yi?MUND~-W*SuiV(k2#V#u*Li<_tv!LM+vAF8G5^J*l>K zd8%$P1sB!Uj)GB*jVmh2;1etRim^@2ReeLLzG6DeNT!GtO8eX@N>w$WpAqUO#*H|U zSbb0IF9wZHG@Ifh{i*e}wN)pHLF1D3OB)lXVniFCNY&R)nL0|$Pc+vKoicpvSTSWq zx;e3^V(bJo$f5Q1)dDV_o2X`qGZIbnn-^4zMssaws!yC-ErutTHZ@n*ka&$2ugMUv zG2%6X#cRZ}y2ho6+FCKZAvL!#F*KE^gU9DK*EP*IXv&hMbtxS|c8#cOt`liLP)~^1 z7jn;ceGx?*&qDUoWJE50Dsi_rbBpW6;sSfkHx~QprVzGiAZjdGM1MO0_Abz&p4MThW{# zLq&6vFH;leHgh2Cjba|flPwdMrWR9D-40Ej95bOwOHh_N0}ip@IW(dnrTZ(RW)d5o zT(lUCNsLU@;m5Dx8_?m6Nl?F`hXt(ALGl^A2oW*|J_*7T<}@$$*=Yk7`(p@8k6606 zkw+9U9PPR}fgW2~TbpjCAZa^uK?6c(ridY4s~_5oQDV+g2#iR~Svr3{ zxjy6#O{Wu!<}|LD+R&WI9*bsEhb}&aavE1RcR@o_MxqIG(#gg|a|UN>T?*!mO4Th& zEKjBuhWd4$iPV^edbH1w@8?U^HXRPZpx8QcY}34CY7xdo8c6pkH9XlguVMaD*xRO( z5sCENR0EI3VGbh_^Xis1HjhKu6RD7`oyUqMCmQR{wHvxpk$( z@KCBHioigYOi`aQ!td)HBtz56NE96=($#mY?_;_M^E>=lyN|XX#o^7HL1U> zOCyE}`EySNHK__%N^)pCa~E)@g(GN?6EwH7)ijQBkvXuK(DH_Q6RBq=Gt-E4Gsa8I zRAOR-NX|LOxDkW37>*%!p-3*S9nIY{HFZH<(}dJWOgN3iJtL7$XR^!~kvX$Wm~#%s z7#eaLdGH?E*k~L_A@u7-bcNLz&C?V_iRm&$UmBVgFJ+uwkX%muzzy{Pa781HgpF+S zsHG+_Hk}b1Ph9dD{Fta)WTw#(4G40Jf(7g*3<-m3_=SQ z30;{+7fsAd7ol1~vR#$wBhGF3in=Baz@G^n8k^1x4@+T2X~I0*B+y7HJxyXXd|^bbNwD4@)=3l-8(J&4L)r2~bHm(`=gv*=cp=6oo2M*Yyf~S{ zI2v+?rsiV>*wj2>Y4e16JOQ?j3po>(B~tSmlgmR6xphV&mDK)CbC6dC+69e?x|E3; z&f(z;z(_VPNTkF>T0D)bTS!6loJAOfQ~ny1hf2Z|lgmLDGp(zy$1Eo1(lUesJQnE5 z1TWBLEJA%hWwuST>Z$O>Fmnu=dMXw}8H+$sK}$(czUYOe7zJCFVi_H_M(TD6^u~s{ zX+I}4vH4BOG_!(Mn;}<$Wh-2V0tZR_k-(qiFp?~5pm;sapvO~3N^@hx1%}eF7bKsO zn7b6UyrN=wYQ^H_ksp62dw0PR7aNW=G7Up6!a2{K%*YaaC+MEXVb2TPucD#)>Q&2S6kFg0g5nC=PE zqLC>zu#x9-P%nxn*VQ*HMe+0ncHkyO=($z+eMRVzh@3`)i(g9_Mh5Kw6<#r!hI2N1 zGR=3U!G>XsCUqGR0YsM@yNDJw4b9a3MxJZJWV4x-1;#NyNbA`NsZ4Z6UAj5s@KSeb z5>16V#9Z`BW64x3LDRHU1E-B)w`J2tkp>wt?T1qK4&$6XvSAR5R}QFtIjMi^J&C%o7Xw&CDzu#1zU)Vrn>; zPx(U42e(z2QbclTGhN1Eu|FQmYu|^o)D~0gmKrbngB!z|L?gyI%vI-N-aVHy9ZPp~ z973IjfDF(G)e8YC8V}GqNXsKE`ZXAhl@sja6_lu>b(C*Qo86g~23#(Gg#|_sM1vcL zWnaVM#uZrb2Z|2V*DCaV1-Dn4+A)Mscx+R`M^pfR5rkE1LlcP*(_ai_F-I<1Y@)}e zY5K*AA%mmC{H8aygz%-;zSt&73%sl!!Q2I!V%jVg;0Gn9g4Q9f7CVMb*z>E!{(l1d z`;eP30{ebx>;@(opNzfE1(0kOi@`k^JD9y8l_^ny-NO0c!Y|mv90$oW#R%NC*Wkb2 zLe!0hH08P!_sDH&YpH#HhCH2eC9(I|n>CQdCjgVhCom<8CAJHiA-AAS?UZxd=_)uM zN=Kn2@{oCbMIZRB5*&EXx<^QNGHVri_})A`F**wk%R)mnnlKL9n(%KCO5B7rbCG`& z{!7BjGWZ|?Iv>7GuwCT!GE+K|UIgyBCiNoNA*>$wA%+oIIZe^XttRHonn6q>BBNnoy~=or6@0zqz?ZwQ~0?N4>LVtb<3hUt8AgY2FFqd*1jC&sAnw) z&>iW8JVXvzNVf6kDa6_}JvWs;_wJbQO>C||;y-_VpRmg$ULY?MGJ-%+5y5Bs%K%)a$#%jk6YYy@5TFc-S0F1DAx3Ar413Lh zouloGXUq1*BV+^-vt>SbI2;wltFLg%WS2;ni09gL$=BR(K@k8f&Cibrl}{AHH!;1H z>GzrbN5r-AEh-!dTb|Rt=m^-MkgKE3X(wzKB}A<19C1~bTrbCsbjj8KAvc-dCEs;z zFuYvbRk=|TkGrl#5}qq;WS*ZNg?XF?IiM7*+G{7AG9_`boh}rXk}i1OtjkftjzP$B zr3X!3ab0o3E)&Id?4MatS9#iBP)2TxBB}NyGKUJ738#9lRb1Cj6enV?(sE$JE>Os{ zFK&P+6r!vs7g&@NMZ#9TvRryaFX!yUB>MM zBOGr-otIz6wTT}L(&~NKP8{K@XC)|SBjjCbAkYb`3F1)%51*=XJgODSu0hh{39@qs z?Fn5n$`BYT2%~hxbzX5IPiJMgh-by@kTW2L92VgcV~?(WQFE5yg1S{6#7$|DbG|~o z=X>NifmU0z`c<7fRj&g-!$j06RRxre0W$~J5vJU+Fz5*`92X1i6>Wmt=9XEKbQimJ zaUBU$P3kM^ms$juNTEciuTTW-q^J)PnIu6{aQ2CzRZQs^NUvh62p_MDxeziT_Wgh zF%-{3uSN4FUDSWs09;XSia<-%F@^Y%C@#LHXd&4QV==U!#hTE-^1DRP98fjr4qYNJ zWHt=3g;e>)ZiM;{mCRRXImLC#=?u~0gm=&2+6#-`h@EUt{rrR>HvJG6$a6z%fj?Uk zQAFtE$tI?aQA9{7FNkZ6=b9z8f3 z6J!gIItc0jj72SC%n?QPXlODQSrv7NpfTxzC>P(uE$Yyv2v2l^L;txtkjvLx#vJ3I zVv9Q9hl`W~7o(M?V3Eqs4xF8v3w1VKSZ(JnMV&dP&ZN9E{YOf1Vdb5388ZWg0>4aO z`soWjDhn3$Mj{c?i%Wzc)hHk?xXPlkE=6UWO&MiVM*mSZxJ39GVayCtTvpT>9?Q+8 z5_CavEHW1tFBij&P`SC9qEr&YF#HxLJK{7b=wijY5P}2alwX|wqkM4TV#RYAGlP8= zhj#K=oP96O(2M><4jiH+eMqKHm!du_(}!gG z(0^nFE^I}gT*l0xQuirhul6Zoul6Gi{kjzOV-5XCLqGbDG~mJ-`sFfa25IPrI_66s zePKldNYQ{UMFUvT08%u7{v$=Wu%ZFEjF~}62WUkDidfMA(jcsr-#w#1mRAJQg zM|2Dc?J#%e&|szqU{pK85X~*K0v?7S02=QK%7SiA!?lN$eh>8u%Pbu>nn*BTS` zmiLXDs#g?bJw)M{dsDT%=~oEIz79Lj-;tRpC-u{Mfu zrct3JmA`dL;!<0}7=*c{Gx}ZeM4A$1K4u_{k36T)S}npezK5{|aa|&)JDE?$;;~6t zT%C_;Ucva;T8Q^&+EwB9I)Yu|%6x8$LhKVdZO4^6T$h%IQmjR5) zX^`lQfBAMCMfaq@ssVpT(GRsvRV8O)=Wu+oDcI7T`v2NHpWZf#FpSTN6bca(sjU<) zXbwe5MY2hww5q~CflVM1Nvp&}J*?C^@y52i_HI3!M!A(67rsKJeuJJWai9lIoPh%e zuG~PCI3W&{-!r@GIDf&8oz6)rl?<-@j24*T;|Fls{ z;hnQ=wuGiXxOX*NK*1XqMod|`=3pJ-%$OS){afQ#0ag zwwc!gGxNJ@ilob%^K8>>kEnYzR;L!+Zhj4oZ%PWhDCl$OPWODdzG~e{|yU&-FZUTj;dl*w{V}Y_jIht!=xv}+sFo0(0t4zIEu3r!!fCO$ zz~~B;s6rRjw#7?QZM+gfDVc<_+7y`@HszPBA8+YE`r*jM;) z6(i}rW+umEx4g};TchzBM^i&aK%3Gst8D{6@&)cVz&a@Ck;TXR3W<$;R$AgaH85Y$ zSKCWzG&4pG#$wRrfh(Mm7%IFZrL` z@5>m~>9@MNy1Kf0IepFybC+BwEFpxAzfV39;x=6AGnwh($#!HHA9;JRxTWBsfw##y z4-KquY0bns)2Y?zM0>0$(b190##Sa{>8_4gYe%eZ{-RiWsySH`jYb9;)eBA%Vve-L z3m4t`s#n{K;;2}m93jMBaKf5fbr-HN{Jn@jAxb!{wB5uY`}q@-LV!;nOPui~5~crw ztAWJA=jl6zm`{lpg{btE5X1XOQG{g4okG-mtj}_d`KGgU7&E_!AT2jGA;N-2}w8y@-U1zpL?=^O=n9s!1o?QV=9tg)lz&4g;S|7GkOoOrq#6 zogmwkaKwXW3Q>0|Yv?ZeneYIW>LWy?s>cXRoQx8%q%__aoOnMFm8t}dxT*fQ6lMm1 z7L`YbR)#|b7aRrQG{igOM}nP-fgDp%(GV>No!>g@g>Y&h7*)SkvAZw7=c+`BP_Z9w z9CyVMB-D{5&4*`Hy_^m~@pfpp`i(;r{&1sqUGl)Hrg}!mZ>nJ8xNWf;=x|Yw*4)CjqT>I0VDW`fPRmQ14NcG@UU!;0+s$W&+7{tRS3K{C^sv2}o?bHl) z8mB|kg7lYj(zoQu)aLMo(DJi&Ozon;vf{^5%$=w^#$s2Y^;HHVIXy=@4v$2tmMD(I z_z-~fFob*@F&n8mU9+wD(0o3{vn@s;jxaJx)%mUG4aPuj{99BS1yg<#5Ip`(XPdp2_qazljv!Q?52+ zb=LYu9pMAWs-d#tjGWpi*Hj(k`o>bO0YR>B7v&n@hg~m(}E2W*9lL2r%2x z8mUz~&?gFWx!#YEN~^pg{%z!}DUr6HRF0ptiUYQdS(`dl*;}c@l(Ut3MitvzsSjv9 zw#6x=6d$F#+|#4W>5le!tVDOO&tr|cQ+=M+uIJ3%&~4|=x!&Yk=p~B0M6|qzJ#@BP zYO7NF0%|x%G ze+C<`MW2S^M8ixAnCj5}XR+}*wvlK!PPBljwh;?Db=fW=Why|_I3hnZQ?TMQz}pIs#Nv;wu-XE7oA(2I2lq}N z$J{<@3q_3K_D#=VZa=k!!p3kb)2A}GzuH2vqq*^F+D-Hr;fNMp-KW&2HyQ_3=&`%i z=&`$1Y1q2Xw{o43tS_bwX*7n=l@!yJbQ-ZdLzd(k0uUGi5E!x~-w>~q zSHP3?#k3(yj3IO-#dIZ|Ml8>erMZRx1cm?vhAhoD#4F_$@ML{4ZOBq%2wh1rT}h`A zg9q@p*4?Bf&@YLoCrr3heP5?_4 z&ykzdX51Ge7x%)T{g~or*w)!qYBOms$1Nt3q?@ckk_^b>TC`VUfsxpb_*U?C8X9@s|DXq`c`4&@eefHIT#`T%%iVwrOnzvk1 zorasUT2kGHo3mJw4VwE|)@N=TpT`|kp=H?JYV_FMsx)kWeGZ(4l{N4gK;SZfz+(-% z3oh3K&+Wl~I6(rLu<48h787y=L&0uUIoB;OFPlvlu$^~JOyv>uaox{_kLl1?L*X9!l- zzz~4I5P-mtrTK<3tS_bwq4k)w)0Gs{m2?_0UY{?(0M+X=rOf(FdsHl}+ommf zT<;%z5YEjh2mr4qI5C7EPTmUWx_v*L99PjgphOI8oE(&Lenb_P7Y!{6g?C5Yf`&-A zqM;~EC(ysu=cvbiHd)*?tyzkr*PWI3FUfV(wU50p-ZPrQ35T+1kU%8b58Hl;@`<2l=Vm*g(FXL{@}dwM5syZjH4jz85Br zdfO@=9%c!boOL_*%%tVi50l3A(8%x_8{m;beKzynA>*K zmvPjC8Mu_r(Q%S%$8U!+Iyx63{v49k-nsBY0I+X@7K6b3bOaqh93R;^5V=*aX#W@;=(E0cGF?9WNaW1IO#RERsZwWlgGO=`^7wPk2O4rlC zzQ*Gl_BEbw9a>hK=?jzIL&$2WZi@f54UM1224DE^Yr~SyV}mdJ_q9RCz3z)c`d7!t zQtf8X;Ll+LFI_*S!OE$-bPDIxoZ>Ti%BAIu0kJhOG6eF&ln>}R`Y^N5(L1H}0X=gy z<^y^yr4Q&?iVx@mDSZ~t=J5eN=V&I|rw{0fs}JZ66E~fK4t*BiO^0T7)1eRO4HF0S zq=TN2^33rCwFQsOZ11^V?KEtj@bt`1R%G5Hr>#4R9+9feBt&~wS7%pbenYv_kt_5W zv61g^s_{I4pB0u!+&EG>+&Gd-x>Mw*0=C1YcSJBoy}1uJ==7RF@J!1)O{JYcwHsF9 z3rL)e4W2~q33(Z8^d8PZG#>YV|9WT^)hC|+*m|zxdWf2OFzJ#@b`dd? z?!~&JEZtqTkgdi&4>{jrilF8*Nxz()ZEsHBiYZn*_dq#4MC2#^>HW;5;(VM)&$1&` zdvk;>dhYJ#$mugcEqGa;F<9tL>}XRO%5@0kOAYNN)p$rLY~%8DEjgsr$Zk?gjTFxa z?;=wVeM-@2pNd%C{t1)J0m@|tJuJamA27BNV_U#5;jbC9%}UQ`2e#Jq{Lb2nhtM<# zdeI<2oYUFCg2To8Q5^47d@~i*QO=N51X2EUZj@^a{+_yn$o~854x-uf+*)ejE+QtF zzo1)hu@C6pof>a3_2SqsqT~4T^g|r6ezFJX`>Z2@j? z0|Oeg)wsc90WZ&IdquRlhMlJl^K785F<+gR=d-msx?!aLT#))+Kh?u?L7Lb04#smqs>N{ore9$$o(ocKnyXLysGl7F8Tp}go5y$Em3!=N z+6`N)&ucs8!l3B@LCYJo^EMezd4isdpRIjJ=Y*t)uB5|c=hcOYGN=n6sH-u*E>F;t z@w0VZG_#T-x{?l)omUrT(V#AXpspqPb$NoGjGwLRqG^{D(Uo+V?7X@##Rhc&1a&RV zugeqkWc+Mh7tP6}h_0l=Wb@p7j6XM1ist4#6UOF+FwN9~5xDCq&zG*vlcsq)N1EpC zCv%6#*vj1Y(JUTF>sg$QtH>`^n^%hF^q`cU(@m+B`T?>&nbeOowbwAS({imBjZBOj z0NG%&*UtpCEWM(WJLNOXOs6uOl{4>C)})-QoXMZEwgp+aD*&=E=d;3eaB$>pCyBoU zXR!(vT6!%A3g`@e@YbEV39AG*$lltQn(A!j$DDXrM-MvnyE3~`@#lHw=Do{8=CHTC zM{dlZYP=_I%%BRr2X4%un)9BwefqmB><-$){xjIvecdtdviwuo*nNF6@3OFsSf$AS zyNH-o>bJTBE$&8oRz|&NF{L$&y3S%sYZmpJ#nfA~e06ziRx?F1KK{Eb{+dORc<`D< zb^2@8yWW~bbsKJF`mfBzyDVfw?n-vZcUki4^A@a}MUorIXNG$R_f6;3=t+00GH-dq z0~u~qSHP3?#k3)`5R!Jfl481&P9v6Q2-dm45P-lCfWVL?`G$Ct=!KY@RPpKhYV-8b5*_HHB|6ZjmuRDJ)4@x$e%(m-&Fs8|x{ln6 zg}VEzJ(-gz17}_%a4uDz!g)_5g?Hm4YcwY{n$rF~T{oesQ8`jo(=)XY9vmM7x|Jlo z`zl&raavZY;$x9e6%}RTK(8>qiQ;C)fsq*x;uWCt=_#JiS>CD`UXm_UqBGqOBy${u zH`&B%CEiA#r)(=Tp}RUhCz|>{)#r4#?-=YO;>V*BI=r@>_(V#Ieu$GVpbng*;BC{< zCs^#v)CtIp;7bK5_&kzDX1_ueik}GJrf?n@8TQ%>rEV9tma-^})7cb`c_YtNeQM#T zDu_?|8-<|@!J_a*u_K2IoKaJHt~jzyr~Bc1An*`p)5eNfYMC!+Tt#tH zq{4A@s(uve;^z8|D(VBoktinF6h>{}`fpJYay=C}oa=S{A#vm}y8d&tlQhj48yse- zI%ump|5HRPjvOs>yLEo+K{`gdnUkOZW0?BE%1j5<;x}770RL7AE!?5SY#z8)Y6i6U z-|^zOgq7lm?)_bn*Do_ssM@Y5e4)Q_&P!hJjES53qMQ;ux`)SU>FexpM=pN#cRyed*D3}e3Fy`l=SVJVF=Yv;X zC=Ky^5G|;73-oZK=X=`k#bTiG`)sRXbV$YLqAb3hh0~4*9!16H({kt2io0P*~H(r>w^_&x~gm{6Ws z2)hQWt&0xP?t0=a%=3klI+d8TzL0I0Y|%GEN8^o-3N7dI7z$Y|r@#8ey{h>IGNVz!Dm;A*9a#v6%+Uc;t1;xD5E z321$HKpz%~QtP;zkV@Z!Wezjo_zMB>Ft5Sb5MrCdJno|fJo1NGJ%>iitOMoL*Zc^I zANxnb+G<^bTT{_kQ{<-agJvT^uLvC^HR_U3PJ4Bkhx{@*e&Vgdq!pih@`+oepM6o= zQ%k5#c*TViw4FOfZC(oA`K|04nz6vbvdZ046PH2^<=K!N#`^_kZKX2CH`rzfoI!Z| z3F|y+Dhr@T`)KuUnbdoX(AAX7{br4Nh5H{JCvfC_=<-+@sVdhF%6SHldbKKjkWE%K z-htBAU4C#T>#8oo1VKtoBk0~dOC3oza7M&Ef7nr~B4~(am*+R4N@1<5Xb7Yb2?$=& z9CpLJGP2S91ecb@S4?I%HB>*{Z({3_Q-9w>)NirAgX`r%L-mH-P*5)iLr%RRQ~a>& zIPD7jf^SsOTuO@L%R#CZ>jqd{hrh6qK5U}|?F+O3Z4QPSQ;NbYSY1)3EKZrBK!cFJ z?dn(d2)6hT6W+gWiM33`GapfhP&AXTZ;sS@a?c?L0~=NZllCL7&R zB;$xLLI(4SX-hX5ySmjX8fvP*aHkqzSb4e2HEjBmI^hOo#B_3Thg)>ofNO`+;`2#t*@CJC1bu(=E%{{JnMDa+X#^RGjW> z^yX^x7z9il?;Wz&ix4THVDFR@FDrCt>Y}3_;qR^6g4WJFo#(e6LSYcIhf|od1aM!& z4}M>x-$g&zZdKQN3&7A5F!PgO$VApb^E_s2%BQ}f>HVOoT4#>B&7Y((`KD-zS2PW$ zXxPz9e>?>b);T)%Y=K}GxV{ zwyU$=z>7twktP7tZ7EJ!sEp>P;i#*BP*>w&>oN*o!BRjot%i0ynZwn6 z5r>ar)EAkb?wIGqAVs5Gx6bANWE$|`FStCq&tJ+nmGa;ek zYe4h#D5Hl98a*^G3`W_3R5ustol~`|;%(59Y6md|zGIb-Dz;P{4^tzl6v(K;^kZ~D z(24XW&9_o(0jT*TW!b5;ff-!k4J^!&sxwubp`GahjIYbdf}?a+9vAIYd~R_R`{^ zm0$2`#yB4wvPMQimfbMi1}W6C*aEOi*^zpLY2QCi{ZC_T0j}sr=q3|QAL_!XZQ$US z7xXR1x8OZVw?*5*J=`sajx#;(`iLXP>-&z|l~!uScX&qI)xCACl^i*k&`7l|4%_g{ zI-YG_(Jux?XXh5h%JF}0>kx6|Ol>RT?<~}WfIAx(8h#Az_?L3Hu#Lt5?(D=d99Pfj zxY`MsoVXh74o-a;EFD;nVfP>Z3Lx+5Q=~61${r7*j8_$|k=J1AC+uT%OnnvQR6MAO zV`?xwOf~7CdJGF^P!sFPi?GK{ge^3sFxbu^yT~LxHzCX z6?5n{UNLzo-7;Q9FVrE1v*~trvr+Bmc@7Lo;eK;ovv~=bL`bmIYVYG1TB_vqEautymW~d`|8B?MMa);feo2Ghdt-4Ci*{)lQ z95SOk@&Zm&E=B4&m(RIuwBeCQbem~zr#%JyTI#inHSu9h#I1H+KCJO#8hZ~dYuc&} z>Mo3+paxX+&0L1dCJ&LT&>Z2dc7N6$EQRvq#_2A&x~-qbeQCh!NM^0XuO z78Vo({zZLU^GI|0fxPNA2J13YV#5JBV8@{qkO_to_t7u6hwrD zSP;@zSG;0BQ{ajX4$-@;oAFC2e=a~==)P zW8aLj5u0*1hwj1sR&~LqXt6k7oDy|Ki~IYcGVz@dr5|I>=eZ==942}#>--L<&u98$ zrYA=!_cTE?qwYaVw?VTj4sh-UQ1Z_;MBpnac3^P}M{dUc)I(1jWQzjI6E|bOVZ+~q z_Ns3dOhLMkQ9}VC7r)a+c@H{-B4Qouyv6-y!Erbx-^+P-7gAm+zJ*JY=W)3*@j9ax zL3usJpBa6DQMu?RNpdHnK4OxTxDy*AUWgor5z@@4hS30VfxHrJ87S^SzaA;>;k^6R zB`(hJ#LpSs2viRA2&4T#eSw~nJD^jFOWfmtUXuzTa{!Td3Us|Azlho|fyU!7Yrn&J zWftYd#rx7i9tJb=h60Thrxy&gKqK2h2ZsmZZN)#zi{O_M_iW1*7Z(uyHmBD~N@tl~ zT<~S)6I~~XW8siHr_5B~)V@k@Pbpyj&9%0Z~>+s^r*>n)pf?ts2z%-ycR}-sVgfkJK^Mf}B#h#l3NHtz!JzZSe^^S~XwZr3YFPF*g|95U9@Z@M z(QQ^pEYp(VTjkwWSlqMN_nt@T+V7Tx#xQ!lAnp>XGkI$*LRo{x zLlksfLDxlbfGmFOqe8r; zb+3=g>}v6-LHi(CBcAtBp*=#p<)botl=#4)2XLcPD?-?KQ)?dx720D(nUBis@uI&$ z&p>j580Mowd!iWcqcZzMG0mVbBqxjIJ}R`QinNc)>^kvfg9boyy13Fuh4xJG10R*y zv&AnAy0Wm3JxBb~M@QOo#j}idhW`sAXP$V+px-0P=ZTLE`Y=SO_*iP+&hWJuRr5s5 zpkH8g%oCFhvbo&7j4lg*=nl5$iRTP@(joMFgWe1iipI6iUJDUA+MuaXLdO~OTh5zr z(3z6*k_Mft2yHg#my9klXb($XW6*^bN#0>lDcA5zMmsS!tC07mk4D<3h{@QtqO}62 z4dPU>hY^j3Pq6_R+G1Es4_8O5gs1J0ui|_boft?bM`KZBOD?T*n zy672pMyTOh=RTk=afCsa7Pi>y#cYGFEKJ!OM2nBs*&D@|8R;0@BrZ0HVsMlAra=^g zo5ZySQ4DSp-#3V2aFck55k=irdy{y|peG$duNm}an9%PGdM!jq(ajG$F*Qo4w?V(< zykiVHQ&Qe|gU(firW^E2M)d~mVab&SU1*Wy27^kuhI1HE)O`_o|KX#r+FQj>d~}h$ zL;TW5yX~{Zhm0r&_t;+%w~S<~5rcc|uZqr58kL6k*yo7q(S&pio+~CXq8Pl^-X%7h zJc_~d#DxY?44#Ky3ZQa22G0{&Mig~7*yoEIeRQjRp?K0q`|XRxUkw@t$xFoeF{I_P z@UZZ$_GMy)kM`TU#ZH4dqBq!=i@SVutNjh}rjPd9SBN8Umr7dtK<6GY+ef$Bd&OEG z?YFNMyA8T7dY}DmvDct|K-Y>J4Z5=M5&JvhEsexY&Xe|k3W28ps6p(O&)VM=)droV zp0%$RD-3!${E~fx*x{o$?eB?e4LSpow}?j#s*FBs?-L&zR2qKP{(*>(*EOs~-mRkE zpossgJ}PelBVGhC$;P(fuNMes#z}-c1I*qX_-j zpohbR?q@`i{E)R@yy&BdbEkOUM^*Mu1r|NhiP$Z1?h$ncRYpskd&SuXm4-{4`@~Nf z>DawrJi&-!_j&8*;yoYrb{-J&c+z>Vph*6O=wT2=@-IXcBOS@V5Os_wk_R{sicTLL z>pU#J;iKWsqvC#phC%Xi@xG6ab$%scbO6P1J=}Rx%rU4VI>32aZ1B;s&acJQJ{s;k zCmuDZ4|KjDKK9YE&Wj?B(+<+vCp_GFSu8T>y68CPRk7ShlbqMZY9CE^-V|#M+6T$E z#20)t$$49x>!az;Z^dqd9te$dekZQ=(In^h;`=_D?z}I4V$d^?{F8XtN0Xcn#WOyd z?)*i(YET%GABzJ%n&cc1JxW zEVDjZeAm%PD9(jK~(e2Ni8 z-FBy3{?(viK)vPBQv^P=`fhjn%2@{WL0+Y#hg+0)UG%HY0J+hieLyj})1bSf7dc1C ze>3PEMd(_Cp60wC8uW0O@*ZHMN9s}Xc^^fbqvh|kB>ZxjGg!`<%C%!%xy(66UTaV( z?pThM_B6`Veu>KpM&y?(oFQ_Y$s@m1$yo-GU#euMktDxV$*(gazg+DMmACuodS{q? z%t!m2;qpy`hCyGetgO&~?!}oN4mE4B7{Dl6>2s2SRr^Gi1?8x`tdV>Z4&6QgWy0Y*dXTH3^M-Ms+#UKl`{)CwT{^RM4Sk?9B}e<{ zU1zOa=%Wvuj9hEbbdv^$h^p zCKniVDW0P3kgYx{cE2dM7<6S}FZV2YsX=!~E8Vl@O$NQA2>rsKr#bI+gB}i3o}5GV z>3%<34)9UL`H~#xqbmE$a*mHi+ULkNMid1D-ScJ1T(%nHeV}`Ryv3l>@Id!M*)Wgt zbQD}9*D#_e7~)j!WV_c$U9}HL6?Un%Ad+D z8euP-b?=dbPUUjqF`R(jC%5?MQlMY?Xq&uWip8GfGWl~^Z;-&r_ycmik1hrJcOPw& zzmO03XqkLaeqfLao$Wp(d!D9s4z|vhkI1Y+j}%=h9+eOJXq$XY4r-H`+-1;@ix!Gs$+vxUiTf-0i9sKVz48eeYSdar6pjJv=c6m!r)0H3BSR0%U&~!S zy2kyr{GCDRg45))@)LvV+z$6y*<*>;Sz9Z3iwPuCL`IfxHpvyyX`QP$BQ|_H;U-^#wrOxBXdPlzLBZ<@W_%d!E^5XKh zax^BFh!Om(|O)Uv|q&fxh9RZSoKDejhE9@5?6*QlZD)Kgzca zqL}!T9DlmjLNW1yO!{b>{7`oIXqo)8++q+#!C&N!28}3;%D>1veDsw2k$ljgk)i)` z|0;iF5cTa}<*NqOxl;U9hF9p?>)hAe1M)J1Y76o5srr_Wwn?RK@X<19sUI6eQDCdL z8BrAcx9h0z8KhH3fvb8lqM5c`g;a}=)~m3(jgh|VDNuJBL@`mI9yO8_69sBQLf}Jl z>&q&l>U{J^w@A(NQ7BZb&hSy6P>K41j~-KH>P{aG3H4MD8Z<22CseM&D|HRS!V^Nh zRjrRs4)s;L4C;vX3010>4Z1G+lpLV`+ea%xG4;NW+CoREzZ$d;l7m!1ldfT3bVcYG z)yqe1p|~1o(3OQ7Lse>skG>Qds;CtF8T~GvI8^(Ho&W@>pPQREj?qZgLNjIwBq#gm zqR=qapliVT_HUu#Y8Rt>#V|al7@>9>^fmd-&kQuZpHce(Ym&?HssqX$A$)J+<(Wz*Dt9}Smv>S;z~%dbMy z)#%lvMcXn%O*V*XpP|0NXeZY`Q{7_nsP@_FW0QBe_3O}VRomj(@?vO?+NDu=5gswm zQ5a$4gqt&X?pQ*ttZt81$Q>AwbK{q`Vzs7FORS>MI6yGP;@3O9fMl#v|``jpX=3 zlDy00oy~dlZ1{bb=yOFxZ9mf7+&=x^(rX8|rF*L-p3mod#`8mW{-;YG zT+9DW9t&Eh1bv&<60xW^t`FuMYP^#Myh+M4gPuc(DsdFg8@aPeZZ003VSdn(2OO$b za{_z3x^lh!zcEVxw~VGwvop6x<{?59-cl(k!TY4#;|Ftc<#jr@2lcA)X?1;G{$!3- zq6+WJcya4R&Of^L&ui^JT0YnF2YV*)k|jR)m#=u|^Lahi-G{d5`!7!($dencTF_ z9j_Gh>$Z3ts&P5**omX^+LEh5+mkzE>oxcA?K-%<+UA4#x%=Uhx$RnJa)i8naJqsc z;qZELbsj$b6!)*Dzu?-5Dv@MA{{rip6r(v#4(_Q#$>)|O`(J_vC02$4JwHc{O8k`T z-D6SiZQO&o=|gG$d>Xu+RZyys`#P5{i@9RBaV&`PtJ%L2s8%%DQr3E*#=2% z1D$^^6LjuLl=yV^y-d*g<{UxK2j&QRW-teK?ggLPPWtg=j_qmYH++}jJVt^~XO`5K ziD(7+XO5tA?qz~b>E?j*F4FX_@htgX^Z?Sk22UpE!C_iA%EyBggp5(A)j<_R3wA9vO%dVoeEJJa}ZmekUw=E zgiJ&DF{Ur8T9&V6{k5#QmNnP1RjnK$wXCO)taC$FANlP_FHnk&E&N9I7JehUncu2z z7IbRU%qKa`{8n`{zg6ALZ(BDDI{jJ8yjX@!}28Y2tm*lSN}ejaVdFL6?dy z&?e9wVh!xMQ)HM@`bFkkEjJ^5w>(SiEBG0wU*YttoIYCJE%p~oQ?9Z6K%G53;&LF0BOwaB`oU56hUCwEyKV$l;PFFC$H_@LleU+(w6mbSItz&xi zAeLeJs-{)Mv4^rG(=$e#E6ytT*+}BN%G4f3={*zK1596JDo!BI_7i_ZxlCh|C_S0! z8BDL9O=TC0e;5CWS@CYX#q_9nLcAu9mUVKKY?tfgPI-yE2G7~vkP%g)daC|vkg8T= z)d^~I1ip1rf_G8N#Oe4p#|o?t3GBQ+h`f&dPQ-l+^yl(j(3>2hS3AVN zPZF(miFR2;kBbsrTS)XArq6~cUE@-zcuJ`Rzd?{bZgu;#Gly9dC3%^~_>nCNdpM5jlI9^iC`r1S-f=u=E@V9q5LaeA@j z;p_U?#ehRCL_Z7@{Y{AI^eE8-obHg6zCaOuis=o^xx^w)FP6N?2_v25wrIb(>@m+v zlzY5ObX_P4`ko^Ce3X<(p^d^VmLEB%$v2i@p zD?*EqdxoUkd))@4pD$bn+OKF?SaB38#35b{LnJ!bpA_OszYtac8U<2_#3<+y_(#9p zPzqX#IY}WZdx7@AZ;>cOXCKgBn57hAx<6=zz_$>=9SGVN^Oi#1V9-i@PnEutHw1J5 zW-{D&h+&|!@Le^9*dGacGUhgg)o%>wT)Y;lFdmKrosZd$zLR_c=qY%8Oks>n0bPW# zqp%k^3G`I_ZiK>P@L8azL6Z^<(4nxmnh&}T<&;>D5=v}02WTTp`%`=DEiA3&=Tw?ZFwr_iLZBl{BQ>*C9xZ-}pgzA4TH{j)d^^e^H9 z(2ua6Q{rRsHPC)oRpC$hZ=n6<*Fgu!e+Qi;zX>{7{s-t3c_rvnc@=20{1#|ZUIV&H zUI)5b{wL@fc|Cf+4OHQqUpInYD8C2JMW9MtEWZzWkK6}(ue=rXKKVn?`>_*L`2N=& zkbD$W;TiaTq+bVx{qioP-vovI@@~+N~#==;`C&_7wj5IvQM zgo$D*dj8A!#@@R^$sY1{xmsPR`dapOjP($18T`-9NZ}CE|4g@Dz;3%c?8)+aGe(N}o!Qn@ zN1_eMStoULwI|bwY${D?UUGFJ+qy290hrU8$>K6MfiHw^Kw{#F<5sL#pH6gAvVFyh z>8()Fwh^T|vZF@@*`vhbWE1oeD-iRzqfKtDm|HhSOq`L-1{R#yykf=Zabn`!RC8Bb z@WyWvlk??EeCO%Ti3NVCp%zLXD3}2!gJWCl842jrj}$=OE#IV?@F&k|8#)Y1Q&I+ zuS%vF)p2PtBbl9<$h1sLH77aZ(49%qoLrqwCdHI>2)5NpZtDCrT$&WK>RL0MsZ3&J z8?wpAViAnTW$MOkk|I`QQ+%mUZpdtj2n$|tSC`)3~Qth4SU2#%6kx2?z3p%YW1?oj!U~i31>PlvHpluK%ljg6? zcA4a?i~-XSNZBL?#mE&aGFeKJ6xv~h>U>m)l1#57!5~QADlU>V^u2Mjwywvn@^RRmg-p5y1EPY9#TnN zGSif99(bblni?%1z0b4td6)jA*B{py>6XbhVFGypKY04g)F)h`(G2Obl zB`0e^0$!PtPA4`7;xs%H&GS3ja(JF@j-Za53=@*f&$g~?ZEMZu)T~U9 zo@&r3Sh-r8Xji48ijj%Eh2D6vkL^(KF# zC=V`3Wm;)rfGO=MT+;fo2$NW%t#uQHX2wsS)X|h`#u)ZSjA?(32>{BePwC$o@MriM zila0Kr zD?!UqSG%C)vReysO=q3cHYPeafo3LkYE~vUJvE(LgN(VY9RguN%6TD*iU8z?a5^VP7P7=iuhWG$?3Y(nFwlC`m zp`&hUS8H2yGA&Zs7SMLgBdwintw=6F47X!mObfHd@a#o+L25l{CsVA|SU5xzt;v+& zu_$4Y2%s^ZA>XhPTIgpy`5W_Xm0I7Q}hKZPg5c*^dcp^ zco*|mo{4P%If%x-*9$pD*5q_@%|c9lSxgG8tFmnTLRvmd=mlv+ULq&MhZsDw+7W$C ztyvmKCv7lkOfY7R)4Q@!gu`gatteM?;)$bHtUySzfxL$oiFVq`V}ehlvlw=?OS&DC!ek#%#TYX^xC(_5hPm?yP& zB6}0xFggul6b@SIMGH<5vN%teFFJ6BumYzUSk7?{E#}wZ90BLDI6ELbLBt@N#lKE) zC*VY6IJmhIH8_1(4KCWp=Neg@Uew{XtP%f)3z3)s=`3_~;U4Hv+PZ6Bog+`D#VMR+ z3}+2w@i1VrcomW;p$-`xB}TwMBf%MgSCMWKGPIDj zif9aHFfp9tPzyXXH4jbEX#QMi>%d<-THFEYCe+`7e<@fQgAbCRtKr)u+eKcFnbwhX zJGh8HF5OPQnS|2`5vt3pX^}>uhCFVgMupnaB|x5?ln$&uO`{{)U;%aoTsOY#Ft-jC z#(X=e4NamAZD?kT6UfUg5rgz9!^2vDl=d{WVI+REDOVO>dpP-TYhRC6H?x+%p&JL) z)u=__w@XAJ*+~{|;P7r6-`=!+_B(YKjyd&{H_rR(dBToK8Mb0V;){{8w3J}6+pBD{ zEbXZ;gD9gc0TJc&Dr=RMb`0l-fR%s?WMu)-US$)d!?+kZ;ewFe-|6p^oe;M1)8AWh z;8V7J2lVuJid~}p9n@1?3{KezQ~))WmdGALL9yFIP>nr=9fA#zQg={dwMRrIP6;Po;p^!xq;gGOVuDF=Y;WA+~X*^UH;yRIy?ja&U z67}{FBr}n&IBMnuRQ3>VOvx}=reHS!^24E+CBtBrh3v9MEnBwSl!=M5#sV}$L;PNA zS!3C9{2WPt6vTfatE>?Pm%|$pEErtYsLGbZ0BDYe>~NqE?k=rH6{Z5eBA9sw3=5ei zq4nW#IA&}?aA(pO#)Q3#1B+(!CaKplA7>R^+?c`jvn^couy2>`<`wOzTbo=$- zR+er59voiQMLeV_$PikjXJ%Pf1hEowRSsDN9gR-ea*AE21V4qx-KJ>|oO0(e zG&_t!b4VZTqzn2L{(+aux{AXToEC+_0$8ftV&#U*Lil=#cATfza?xdOB^kRseAA>A z+e)8^Ot9-e95&ge9~lJs`D8>tev(ZRQAF^QWn``P#%6rp4Qi=;J z?_I>087{2oU0SIxBlM+~^j4By$8kt6E)GEo96($!gk@=E|I$jX29IP^X(j!mYH)G* z>M&*oDXuK-4UZKSQ49K`ITo3VOSmYE8ABBnX^K`!Od9apAhH9~oI)Y0Z%}_iaNr=S zZxH>XdT`-p4Ju;H4EEU|_JDq5=*)t0iN+ERMz zrN<8WI2=9#)QlyLbZ{|u>DiK|CZxi841_rtN-#+yvP<;Hi_mx`v2fVNBBJzEM-0sd zQz3j%5z09+ny|Q9Re&MGGefvEe@cLa&p}!XL9I@hGXA{c3HS^x&>z!ZUI}7{i_ohk zzXzVrDVp>&E)+EJ`)OZ@Y%Ru$C(G)J(G;mboG`ZlV*`2podUX00f)q9Vi{G^QN(4Y zBJLdKT8h=-S8s*F4|ZX$!2d$1Cy{zPOev7wL@J3lh*ErStQ%8<|D95OaZms3l@68L5*z2?C{~n75ygoVPLw;6 z*!ZWL@vEG8IEu5)BppmMSea=XHnIlW)@CVKhMt(jS~IaktgUrr8b{@^S+Vv+b265N zrWj5yGO^Y4{2|c>4o(F!$fv{_T;qw3=Ggj{R1&vVF`Qv%Vy)RBvGq9DB7|M(5fZE#sN^eqs{j1_Nz?B5-u%UxjW@qTI_f4Y^ZXSg zaDchYboa83WERol=hbvJH@%js&IjbrJ!5Z2aj7g&~tVQ2Mfc0(X?taW6%8V6$*{v^clpZ@P;AZkK$;I z??36zw}bQXzJ@)3_F=FI@4i6;-5nmR=`W~QqSfBNTHMpZ2lyT5Gr*q)eeL*1_m()K z0pB}WSOLBD&=-Sdx?j|Hl&vUD7Nv215QDw?4p`rFdiU-m+l+ryYBg)7yXFL1pzk`h zrIbtMsT6V67#xQr-6O{E)joqgWP&Yv7Z(|M+(+-;p8Ek=i}}+ldYrhR*=M- zH@RiHdnwmPROUqX=@hhpdcGZPY2&y%TsiWq=UdY8uh0Jj9=KEgR(ds#vi|k?f6oK| EA9wD5CjbBd diff --git a/Scripts/Filesaving.cs b/Scripts/Files.cs similarity index 53% rename from Scripts/Filesaving.cs rename to Scripts/Files.cs index 0392759..1fb28f7 100644 --- a/Scripts/Filesaving.cs +++ b/Scripts/Files.cs @@ -1,188 +1,261 @@ -using System; -using Nerd_STF.Lists; -using System.IO; -using System.Runtime.Serialization.Formatters.Binary; - -namespace Nerd_STF.Filesaving -{ - [Obsolete(nameof(BinaryFile) + " uses the " + nameof(BinaryFormatter) + ", which is considered dangerous. Go to 'https://aka.ms/binaryformatter/' for more information.")] - public class BinaryFile : File - { - public BinaryFile(string path) => Path = path; - public BinaryFile(string path, object data) - { - Data = data; - Path = path; - } - - public static BinaryFile Load(string path) - { - BinaryFile file = new(path); - FileStream stream = new(path, FileMode.Open); - BinaryFormatter formatter = new(); - file.Data = formatter.Deserialize(stream); - stream.Close(); - return file; - } - - public override void Erase() => Data = null; - public override void Load(bool erase = true) - { - if (erase) Erase(); - FileStream stream = new(Path, FileMode.Open); - BinaryFormatter formatter = new(); - Data = formatter.Deserialize(stream); - stream.Close(); - } - public override void Save() - { - FileStream stream = new(Path, FileMode.Create); - BinaryFormatter formatter = new(); - formatter.Serialize(stream, Data); - stream.Close(); - } - } - public class ByteFile : File> - { - public byte this[int index] - { - get - { - if (index < 0 || index >= Data.Length) throw new ArgumentOutOfRangeException(nameof(index)); - return Data[index]; - } - set { Data[index] = value; } - } - - public ByteFile(string path) => Path = path; - public ByteFile(string path, byte[] data) - { - Data = new List(data); - Path = path; - } - public ByteFile(string path, List data) - { - Data = data; - Path = path; - } - - public static ByteFile Load(string path) - { - ByteFile file = new(path); - FileStream stream = new(file.Path, FileMode.Open); - for (long i = 0; i < stream.Length; i++) file.Data.Add((byte)stream.ReadByte()); - stream.Close(); - return file; - } - - public override void Erase() => Data = new(); - public void Fill(int length, byte fill = 0) => Data = new List(length, fill); - public override void Load(bool erase = true) - { - if (erase) Erase(); - FileStream stream = new(Path, FileMode.Open); - for (long i = 0; i < stream.Length; i++) Data.Add((byte)stream.ReadByte()); - stream.Close(); - } - public void Remove(int start, int amount) - { - List old = Data; - Data = new List(old.Length - amount); - for (int i = 0; i < old.Length; i++) - { - if (i > start && i < start + amount) i = start + amount; - Data[i] = old[i]; - } - } - public override void Save() - { - FileStream stream = new(Path, FileMode.Create); - foreach (byte b in Data) stream.WriteByte(b); - stream.Close(); - } - public void Write(byte write, bool toFile = false) - { - Data += write; - if (toFile) - { - FileStream stream = new(Path, FileMode.Append); - stream.WriteByte(write); - stream.Close(); - } - } - public void Write(List write, bool toFile = false) - { - Data += write; - if (toFile) - { - FileStream stream = new(Path, FileMode.Append); - foreach (byte b in write) stream.WriteByte(b); - stream.Close(); - } - } - } - public class TextFile : File - { - public TextFile(string path) => Path = path; - public TextFile(string path, string data) - { - Data = data; - Path = path; - } - - public static TextFile Load(string path) - { - TextFile file = new(path); - FileStream stream = new(file.Path, FileMode.Open); - for (long i = 0; i < stream.Length; i++) file.Data += ((char)stream.ReadByte()); - stream.Close(); - return file; - } - - public override void Erase() => Data = ""; - public override void Load(bool erase = true) - { - if (erase) Erase(); - FileStream stream = new(Path, FileMode.Open); - for (long i = 0; i < stream.Length; i++) Data += (char)stream.ReadByte(); - stream.Close(); - } - public void Remove(int start, int amount) => Data = Data.Remove(start, amount); - public override void Save() - { - FileStream stream = new(Path, FileMode.Create); - foreach (byte b in Data) stream.WriteByte(b); - stream.Close(); - } - public void Write(char write, bool toFile = false) - { - Data += write; - if (toFile) - { - FileStream stream = new(Path, FileMode.Append); - stream.WriteByte((byte)write); - stream.Close(); - } - } - public void Write(string write, bool toFile = false) - { - Data += write; - if (toFile) - { - FileStream stream = new(Path, FileMode.Append); - foreach (byte b in write) stream.WriteByte(b); - stream.Close(); - } - } - } - - public abstract class File - { - public T Data { get; set; } - public string Path { get; set; } - - public abstract void Erase(); - public abstract void Load(bool erase = true); - public abstract void Save(); - } +using System; +using System.Text; +using Nerd_STF.Lists; +using System.IO; +using System.Runtime.Serialization.Formatters.Binary; + +namespace Nerd_STF.File.Saving +{ + [Obsolete(nameof(BinaryFile) + " uses the " + nameof(BinaryFormatter) + ", which is considered dangerous. Go to 'https://aka.ms/binaryformatter/' for more information.")] + [Serializable] + public class BinaryFile + { + public object Data { get; set; } + public string Path { get; set; } + + public BinaryFile(string path) => Path = path; + public BinaryFile(string path, object data) + { + Data = data; + Path = path; + } + + public static BinaryFile Load(string path) + { + BinaryFile file = new(path); + FileStream stream = new(path, FileMode.Open); + BinaryFormatter formatter = new(); + file.Data = formatter.Deserialize(stream); + stream.Close(); + return file; + } + + public void Erase() => Data = null; + public void Load() + { + FileStream stream = new(Path, FileMode.Open); + BinaryFormatter formatter = new(); + Data = formatter.Deserialize(stream); + stream.Close(); + } + public void Save() + { + FileStream stream = new(Path, FileMode.Create); + BinaryFormatter formatter = new(); + formatter.Serialize(stream, Data); + stream.Close(); + } + } + [Obsolete(nameof(BinaryFile) + " uses the " + nameof(BinaryFormatter) + ", which is considered dangerous. Go to 'https://aka.ms/binaryformatter/' for more information.")] + [Serializable] + public class BinaryFile + { + public T Data { get; set; } + public string Path { get; set; } + + public BinaryFile(string path) => Path = path; + public BinaryFile(string path, T data) + { + Data = data; + Path = path; + } + + public static BinaryFile Load(string path) + { + BinaryFile file = new(path); + FileStream stream = new(path, FileMode.Open); + BinaryFormatter formatter = new(); + file.Data = (T)formatter.Deserialize(stream); + stream.Close(); + return file; + } + + public void Erase() => Data = default; + public void Load() + { + FileStream stream = new(Path, FileMode.Open); + BinaryFormatter formatter = new(); + Data = (T)formatter.Deserialize(stream); + stream.Close(); + } + public void Save() + { + FileStream stream = new(Path, FileMode.Create); + BinaryFormatter formatter = new(); + formatter.Serialize(stream, Data); + stream.Close(); + } + } + [Serializable] + public class ByteFile : File> + { + public byte this[int index] + { + get + { + if (index < 0 || index >= Data.Length) throw new ArgumentOutOfRangeException(nameof(index)); + return Data[index]; + } + set { Data[index] = value; } + } + + public ByteFile(string path) => Path = path; + public ByteFile(string path, params byte[] data) + { + Data = new List(data); + Path = path; + } + public ByteFile(string path, List data) + { + Data = data; + Path = path; + } + + public static ByteFile Load(string path) + { + ByteFile file = new(path); + FileStream stream = new(file.Path, FileMode.Open); + byte[] b = new byte[stream.Length]; + while (stream.Read(b, 0, b.Length) > 0) ; + file.Data = new(b); + stream.Close(); + return file; + } + + public override void Erase() => Data = new(); + public void Fill(int length, byte fill = 0) => Data = new List(length, fill); + public override void Load(bool erase = true) + { + if (erase) Erase(); + FileStream stream = new(Path, FileMode.Open); + byte[] b = new byte[stream.Length]; + while (stream.Read(b, 0, b.Length) > 0) ; + Data.AddRange(b); + stream.Close(); + } + public void Remove(int start, int amount) + { + List old = Data; + Data = new List(old.Length - amount); + for (int i = 0; i < old.Length; i++) + { + if (i > start && i < start + amount) i = start + amount; + Data[i] = old[i]; + } + } + public override void Save() + { + FileStream stream = new(Path, FileMode.Create); + stream.Write(Data.ToArray(), 0, Data.Length); + stream.Close(); + } + public override bool TryLoad(out File> file) + { + bool success = false; + try + { + file = new ByteFile(Path); + FileStream stream = new(file.Path, FileMode.Open); + byte[] b = new byte[stream.Length]; + while (stream.Read(b, 0, b.Length) > 0) ; + file.Data.AddRange(b); + stream.Close(); + success = true; + } + catch { file = null; } + + return success; + } + public void Write(byte write, bool toFile = false) + { + Data += write; + if (toFile) Save(); + } + public override void Write(List write, bool toFile = false) + { + Data += write; + if (toFile) Save(); + } + } + [Serializable] + public class TextFile : File + { + public TextFile(string path) => Path = path; + public TextFile(string path, string data) + { + Data = data; + Path = path; + } + + public static TextFile Load(string path) + { + TextFile file = new(path); + FileStream stream = new(file.Path, FileMode.Open); + byte[] b = new byte[stream.Length]; + while (stream.Read(b, 0, b.Length) > 0) ; + file.Data += Encoding.Default.GetString(b); + stream.Close(); + return file; + } + + public override void Erase() => Data = ""; + public override void Load(bool erase = true) + { + if (erase) Erase(); + FileStream stream = new(Path, FileMode.Open); + byte[] b = new byte[stream.Length]; + while (stream.Read(b, 0, b.Length) > 0) ; + Data += Encoding.Default.GetString(b); + stream.Close(); + } + public void Remove(int start, int amount) => Data = Data.Remove(start, amount); + public override void Save() + { + FileStream stream = new(Path, FileMode.Create); + byte[] b = Encoding.Default.GetBytes(Data); + stream.Write(b, 0, b.Length); + stream.Close(); + } + public override bool TryLoad(out File file) + { + bool success = false; + try + { + file = new TextFile(Path); + FileStream stream = new(file.Path, FileMode.Open); + byte[] b = new byte[stream.Length]; + while (stream.Read(b, 0, b.Length) > 0) ; + file.Data += Encoding.Default.GetString(b); + stream.Close(); + success = true; + } + catch { file = null; } + + return success; + } + public void Write(char write, bool toFile = false) + { + Data += write; + if (toFile) Save(); + } + public override void Write(string write, bool toFile = false) + { + Data += write; + if (toFile) Save(); + } + } + + [Serializable] + public abstract class File + { + public T Data { get; set; } + public bool Exists => System.IO.File.Exists(Path); + public string Path { get; set; } + + public abstract void Erase(); + public abstract void Load(bool erase = true); + public abstract void Save(); + public abstract bool TryLoad(out File file); + public abstract void Write(T write, bool toFile = false); + } } \ No newline at end of file diff --git a/Scripts/General.cs b/Scripts/General.cs index 1b6a633..c5640da 100644 --- a/Scripts/General.cs +++ b/Scripts/General.cs @@ -1,28 +1,22 @@ -using System; -using System.Linq; -using System.Security.Cryptography; +using System; +using System.Text; namespace Nerd_STF { public static class Hashes { - public static int Default(object obj) - { - return obj.GetHashCode(); - } + public static int Default(object obj) => obj.GetHashCode(); + public static byte[] MD5(byte[] input) => System.Security.Cryptography.MD5.Create().ComputeHash(input); public static string MD5(string input) { - var md5 = System.Security.Cryptography.MD5.Create(); + System.Security.Cryptography.MD5 md5 = System.Security.Cryptography.MD5.Create(); - byte[] inputB = System.Text.Encoding.ASCII.GetBytes(input); + byte[] inputB = Encoding.ASCII.GetBytes(input); byte[] hash = md5.ComputeHash(inputB); - var builder = new System.Text.StringBuilder(); - for (int i = 0; i < hash.Length; i++) - { - builder.Append(hash[i].ToString("X2")); - } - return builder.ToString(); + string s = ""; + for (int i = 0; i < hash.Length; i++) s += hash[i].ToString("X2"); + return s; } public static uint SchechterTurbulence(uint seed) { @@ -35,6 +29,68 @@ namespace Nerd_STF return seed; } + public static byte[] SHA1(byte[] input) => System.Security.Cryptography.SHA1.Create().ComputeHash(input); + public static string SHA1(string input) + { + System.Security.Cryptography.SHA1 sha1 = System.Security.Cryptography.SHA1.Create(); + + byte[] inputB = Encoding.ASCII.GetBytes(input); + byte[] hash = sha1.ComputeHash(inputB); + + string s = ""; + for (int i = 0; i < hash.Length; i++) s += hash[i].ToString("X2"); + return s; + } + public static byte[] SHA256(byte[] input) => System.Security.Cryptography.SHA256.Create().ComputeHash(input); + public static string SHA256(string input) + { + System.Security.Cryptography.SHA256 sha256 = System.Security.Cryptography.SHA256.Create(); + + byte[] inputB = Encoding.ASCII.GetBytes(input); + byte[] hash = sha256.ComputeHash(inputB); + + string s = ""; + for (int i = 0; i < hash.Length; i++) s += hash[i].ToString("X2"); + return s; + } + public static byte[] SHA384(byte[] input) => System.Security.Cryptography.SHA384.Create().ComputeHash(input); + public static string SHA384(string input) + { + System.Security.Cryptography.SHA384 sha384 = System.Security.Cryptography.SHA384.Create(); + + byte[] inputB = Encoding.ASCII.GetBytes(input); + byte[] hash = sha384.ComputeHash(inputB); + + string s = ""; + for (int i = 0; i < hash.Length; i++) s += hash[i].ToString("X2"); + return s; + } + public static byte[] SHA512(byte[] input) => System.Security.Cryptography.SHA512.Create().ComputeHash(input); + public static string SHA512(string input) + { + System.Security.Cryptography.SHA512 sha512 = System.Security.Cryptography.SHA512.Create(); + + byte[] inputB = Encoding.ASCII.GetBytes(input); + byte[] hash = sha512.ComputeHash(inputB); + + string s = ""; + for (int i = 0; i < hash.Length; i++) s += hash[i].ToString("X2"); + return s; + } + } + + public static class Misc + { + public static string PlaceMaker(int num) + { + return num.ToString()[^1] switch + { + '1' => num + "st", + '2' => num + "nd", + '3' => num + "rd", + _ => num + "th", + }; + } } public static class Stats @@ -46,32 +102,18 @@ namespace Nerd_STF "Github: https://https://github.com/that-one-nerd", "Itch: https://that-one-nerd.itch.io/" }; - public static readonly string Version = "2021.0"; + public static readonly string Version = "2021.2"; } + [Serializable] public struct Optional { - public bool Exists - { - get - { - return Value != null; - } - } + public bool Exists => Value != null; public T Value { get; internal set; } - public Optional(T input) - { - Value = input; - } + public Optional(T input) => Value = input; - public static explicit operator T(Optional input) - { - return input.Value; - } - public static explicit operator Optional(T input) - { - return new Optional(input); - } + public static explicit operator T(Optional input) => input.Value; + public static explicit operator Optional(T input) => new(input); } -} +} \ No newline at end of file diff --git a/Scripts/Interfaces.cs b/Scripts/Interfaces.cs deleted file mode 100644 index e00893c..0000000 --- a/Scripts/Interfaces.cs +++ /dev/null @@ -1,16 +0,0 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; - -namespace Nerd_STF.Interfaces -{ - public interface INegatives - { - public T Absolute { get; } - public bool IsNegative { get; } - public T Negative { get; } - public T Positive { get; } - } -} \ No newline at end of file diff --git a/Scripts/Lists.cs b/Scripts/Lists.cs index 63eccbd..356295a 100644 --- a/Scripts/Lists.cs +++ b/Scripts/Lists.cs @@ -1,541 +1,465 @@ using System; using System.Collections; +using System.Collections.Generic; +using System.Collections.ObjectModel; using Nerd_STF.Mathematics; namespace Nerd_STF.Lists { - public class Matrix + [Serializable] + public class List : IEnumerable, IEnumerable { - internal List> lists; + public static List Empty => new(); - public Vector2 Length - { - get - { - return new(lists.Get(0).Length, lists.Length); - } - } - public int LengthX - { - get - { - return lists.Get(0).Length; - } - } - public int LengthY - { - get - { - return lists.Length; - } - } + internal T[] array; - public static Matrix Empty + public int this[T item] { - get - { - return new Matrix { lists = List>.Empty }; - } - } - - public Matrix() - { - lists = new List>(1, new List(1, default)); - } - public Matrix(int lengthX, int lengthY) - { - if (lengthX < 1) throw new ArgumentOutOfRangeException(nameof(lengthX), "Do not include a length of less than 1"); - if (lengthY < 1) throw new ArgumentOutOfRangeException(nameof(lengthY), "Do not include a width of less than 1"); - lists = new List>(lengthY, new List(lengthX)); - } - public Matrix(int lengthX, int lengthY, T inputAll) - { - if (lengthX < 1) throw new ArgumentOutOfRangeException(nameof(lengthX), "Do not include a length of less than 1"); - if (lengthY < 1) throw new ArgumentOutOfRangeException(nameof(lengthY), "Do not include a width of less than 1"); - lists = new List>(lengthY, new List(lengthX, inputAll)); - } - public T this[int indexX, int indexY] - { - get - { - return Get(indexX, indexY); - } - - set - { - Set(indexX, indexY, value); - } - } - - public void Add(Matrix input, DirectionType addDir) - { - if (addDir == DirectionType.y) - { - foreach (List list in input.lists) - { - AddY(list); - } - return; - } - - foreach (List list in input.lists) - { - AddX(list); - } - } - public void AddX() - { - foreach (List list in lists) - { - list.Add(); - } - } - public void AddX(T input) - { - foreach (List list in lists) - { - list.Add(input); - } - } - public void AddX(T[] input) - { - foreach (T t in input) - { - AddX(t); - } - } - public void AddX(List input) - { - foreach (T t in input) - { - AddX(t); - } - } - public void AddY() - { - lists.Add(new List(lists.Get(0).Length)); - } - public void AddY(T input) - { - lists.Add(new List(lists.Get(0).Length, input)); - } - public void AddY(T[] input) - { - if (input.Length > lists.Get(0).Length) throw new OverflowException(); - lists.Add(new List(input)); - } - public void AddY(List input) - { - if (input.Length > lists.Get(0).Length) throw new OverflowException(); - lists.Add(input); - } - public bool Check(int placeX, int placeY) - { - return lists.Get(placeY).Get(placeX) != null; - } - public bool Compare(T input) - { - foreach (List list in lists) - { - if (list.Compare(input)) return true; - } - - return false; - } - public void Convert(T input) - { - foreach (List list in lists) - { - list.Convert(input); - } - } - public void Convert(T[] input) - { - foreach (List list in lists) - { - list.Convert(input); - } - } - public void Convert(List input) - { - foreach (List list in lists) - { - list.Convert(input); - } - } - public void Convert(Matrix input) - { - lists = input.lists; - } - public int Count() - { - int returned = 0; - - foreach (List list in lists) - { - returned += list.Count(); - } - - return returned; - } - public int Count(DirectionType type) - { - if (type == DirectionType.y) return LengthY; - return LengthX; - } - public Vector2 CountXY() - { - return Length; - } - public T Get(int placeX, int placeY) - { - return lists.Get(placeY).Get(placeX); - } - public void Get(int placeX, int placeY, out T output) - { - output = Get(placeX, placeY); - } - public List GetAll() - { - List returned = new(); - - foreach (List list in lists) - { - returned.Add(list); - } - - return returned; - } - public void GetAll(out List output) - { - List returned = new(); - - foreach (List list in lists) - { - returned.Add(list); - } - - output = returned; - } - public IEnumerator GetEnumerator() - { - foreach (List list in lists) - { - foreach (T t in list) - { - yield return t; - } - } - } - public void Remove(int placeX, int placeY) - { - lists.Get(placeY).Remove(placeX); - } - public void Set(int placeX, int placeY, T input) - { - lists.Get(placeY).Set(placeX, input); - } - public void SetAll(T input) - { - for (int i = 0; i < lists.Length; i++) - { - for (int j = 0; j < lists.Get(i).Length; j++) - { - lists.Get(i).Set(j, input); - } - } - } - - public static Matrix AllDefault(int lengthX, int lengthY) - { - return new(lengthX, lengthY, default); - } - - public override bool Equals(object obj) - { - return base.Equals(obj); - } - public bool Equals(Matrix other) - { - return GetAll() == other.GetAll(); - } - public override int GetHashCode() - { - return base.GetHashCode(); - } - public override string ToString() - { - return lists.ToString(); - } - public string ToString(bool showAll) - { - if (showAll) - { - string r = ""; - for (int i = 0; i < lists.Length; i++) - { - for (int j = 0; j < lists.Get(i).Length; j++) - { - r += lists.Get(i).Get(j); - if (j != lists.Get(i).Length - 1) r += ", "; - } - if (i != lists.Length - 1) r += "\n"; - } - return r; - } - else - { - return ToString(); - } - } - - public static bool operator ==(Matrix a, Matrix b) - { - return a.Equals(b); - } - public static bool operator !=(Matrix a, Matrix b) - { - return !a.Equals(b); - } - - public enum DirectionType - { - x, - y, - } - } - - public class List - { - internal T[] list; - - public int Length - { - get - { - return list.Length; - } + get => FindIndex(item); + set => Insert(value, item); } public T this[int index] { - get - { - return Get(index); - } - set - { - Set(index, value); - } + get => array[index]; + set => array[index] = value; } - public static List Empty - { - get - { - return new List(Array.Empty()); - } - } + public List Duplicate => new(array); + public bool IsEmpty => array == Array.Empty(); + public bool IsNull => array == null; + public bool IsNullOrEmpty => IsNull || IsEmpty; + public int Length => array.Length; - public List() + public List() => array = Array.Empty(); + public List(params T[] items) => array = items; + public List(int length) => array = new T[length]; + public List(int length, T itemAll) { - list = Array.Empty(); + array = new T[length]; + for (int i = 0; i < array.Length; i++) array[i] = itemAll; } - public List(int length) + public List(IEnumerable items) { - list = new T[length]; - for (int i = 0; i < length; i++) - { - list[i] = default; - } - } - public List(int length, T inputAll) - { - list = new T[length]; - for (int i = 0; i < list.Length; i++) - { - list[i] = inputAll; - } - } - public List(T[] input) - { - list = Array.Empty(); - if (input != default) list = input; - } - public List(List input) - { - list = Array.Empty(); - if (input.list != default) list = input.list; - } + int length = 0; + foreach (object _ in items) length++; + array = new T[length]; - public void Add() + AddRange(items); + } + public List(IEnumerable items) { - T[] before = list; + int length = 0; + foreach (object _ in items) length++; + if (length == 0) array = Array.Empty(); - if (before.Length == 0) - { - list = new T[1]; - list[0] = default; - } + AddRange(items); + } + public List(List list) => array = list.array; + + public void Add() => Add(default); + public void Add(T item) + { + if (array == null || array == Array.Empty()) array = new T[1] { item }; else { - list = new T[before.Length + 1]; - int place = 0; - while (place < before.Length) - { - list[place] = before[place]; - place++; - } - list[place] = default; + T[] old = array; + array = new T[old.Length + 1]; + for (int i = 0; i < old.Length; i++) array[i] = old[i]; + array[old.Length] = item; } } - public void Add(T add) + public void AddRange(IEnumerable items) { foreach (T t in items) Add(t); } + public void AddRange(IEnumerable items) { foreach (T t in items) Add(t); } + public void AddRange(List items) { foreach (T t in items) Add(t); } + public void AddRange(params T[] items) { foreach (T t in items) Add(t); } + public bool Any(Predicate predicate) { - T[] before = list; - - if (before.Length == 0) - { - list = new T[1]; - list[0] = add; - } - else - { - list = new T[before.Length + 1]; - int place = 0; - while (place < before.Length) - { - list[place] = before[place]; - place++; - } - list[place] = add; - } - } - public void Add(T[] add) - { - foreach (T input in add) - { - Add(input); - } - } - public void Add(List add) - { - Add(add.list); - } - public bool Check(int place) - { - return list[place] != null; - } - public bool Compare(T input) - { - foreach (T place in list) - { - if (place == null) continue; - if (place.Equals(input)) return true; - } - + foreach (T t in array) if (predicate.Invoke(t)) return true; return false; } - public void Convert(T input) + public bool Any(T match) { - for (int i = 0; i < list.Length; i++) - { - list[i] = input; - } + foreach (T t in array) if (t.Equals(match)) return true; + return false; } - public void Convert(T[] input) + public void Clear(bool resetSize = false) { - list = input; + if (resetSize) array = Array.Empty(); + else { for (int i = 0; i < array.Length; i++) array[i] = default; } } - public void Convert(List input) + public bool Contains(Predicate predicate) { - Convert(input.list); + foreach (T t in array) if (predicate.Invoke(t)) return true; + return false; + } + public bool Contains(T match) + { + foreach (T t in array) if (t.Equals(match)) return true; + return false; } public int Count() { - int returned = 0; - foreach (T _ in list) - { - returned++; - } - return returned; + int r = 0; + foreach (T _ in array) r++; + return r; } - public T Get(int place) + public int Count(Predicate predicate) { - return list[place]; + if (!Contains(predicate)) return 0; + int r = 0; + foreach (T t in array) if (predicate.Invoke(t)) r++; + return r; } - public void Get(int place, out T output) + public int Count(T match) { - output = Get(place); + if (!Contains(match)) return 0; + int r = 0; + foreach (T t in array) if (t.Equals(match)) r++; + return r; } - public T[] GetAll() + public void Fill(T item) { for (int i = 0; i < Length; i++) array[i] = item; } + public T Find(Predicate predicate) { - return list; + foreach (T t in array) if (predicate.Invoke(t)) return t; + throw new Exception("Parameter " + nameof(predicate) + " does not exist in the list."); } - public IEnumerator GetEnumerator() + public T Find(T match) { - return list.GetEnumerator(); + foreach (T t in array) if (t.Equals(match)) return t; + throw new Exception("Parameter " + nameof(match) + " does not exist in the list."); } - public void Remove(int place) + public T Find(Predicate predicate, int start) { - list[place] = default; + for (int i = start; i < array.Length; i++) if (predicate.Invoke(array[i])) return array[i]; + throw new Exception("Parameter " + nameof(predicate) + " does not exist in the list."); } - public void Remove(int place, bool shift) + public T Find(T match, int start) { - list[place] = default; - if (shift) - { - for (int i = place; i < list.Length - 1; i++) - { - list[i] = list[i + 1]; - } - T[] save = list; - list = new T[save.Length - 1]; - for (int i = 0; i < save.Length - 1; i++) - { - list[i] = save[i]; - } - } + for (int i = start; i < array.Length; i++) if (array[i].Equals(match)) return array[i]; + throw new Exception("Parameter " + nameof(match) + " does not exist in the list."); } - public void Set(int place, T input) + public T Find(Predicate predicate, int start, int max) { - list[place] = input; + for (int i = start; i <= max; i++) if (predicate.Invoke(array[i])) return array[i]; + throw new Exception("Parameter " + nameof(predicate) + " does not exist in the list."); } - public void Set(T[] input) + public T Find(T match, int start, int max) { - list = input; + for (int i = start; i <= max; i++) if (array[i].Equals(match)) return array[i]; + throw new Exception("Parameter " + nameof(match) + " does not exist in the list."); } - public void Set(List input) + public T FindOrDefault(Predicate predicate) { - Set(input.list); + foreach (T t in array) if (predicate.Invoke(t)) return t; + return default; } - public void SetAll(T input) + public T FindOrDefault(T match) { - for (int i = 0; i < list.Length; i++) - { - list[i] = input; - } + foreach (T t in array) if (t.Equals(match)) return t; + return default; } + public T FindOrDefault(Predicate predicate, int start) + { + for (int i = start; i < array.Length; i++) if (predicate.Invoke(array[i])) return array[i]; + return default; + } + public T FindOrDefault(T match, int start) + { + for (int i = start; i < array.Length; i++) if (array[i].Equals(match)) return array[i]; + return default; + } + public T FindOrDefault(Predicate predicate, int start, int max) + { + for (int i = start; i <= max; i++) if (predicate.Invoke(array[i])) return array[i]; + return default; + } + public T FindOrDefault(T match, int start, int max) + { + for (int i = start; i <= max; i++) if (array[i].Equals(match)) return array[i]; + return default; + } + public List FindAll(Predicate predicate) + { + List r = new(); + foreach (T t in array) if (predicate.Invoke(t)) r.Add(t); + return r; + } + public List FindAll(T match) + { + List r = new(); + foreach (T t in array) if (t.Equals(match)) r.Add(t); + return r; + } + public List FindAll(Predicate predicate, int start) + { + List r = new(); + for (int i = start; i < array.Length; i++) if (predicate.Invoke(array[i])) r.Add(array[i]); + return r; + } + public List FindAll(T match, int start) + { + List r = new(); + for (int i = start; i < array.Length; i++) if (array[i].Equals(match)) r.Add(array[i]); + return r; + } + public List FindAll(Predicate predicate, int start, int max) + { + List r = new(); + for (int i = start; i <= max; i++) if (predicate.Invoke(array[i])) r.Add(array[i]); + return r; + } + public List FindAll(T match, int start, int max) + { + List r = new(); + for (int i = start; i <= max; i++) if (array[i].Equals(match)) r.Add(array[i]); + return r; + } + public T FindLast(Predicate predicate) + { + for (int i = array.Length - 1; i >= 0; i--) if (predicate.Invoke(array[i])) return array[i]; + throw new Exception("Parameter " + nameof(predicate) + " does not exist in the list."); + } + public T FindLast(T match) + { + for (int i = array.Length - 1; i >= 0; i--) if (array[i].Equals(match)) return array[i]; + throw new Exception("Parameter " + nameof(match) + " does not exist in the list."); + } + public T FindLast(Predicate predicate, int start) + { + for (int i = array.Length - 1; i >= start; i--) if (predicate.Invoke(array[i])) return array[i]; + throw new Exception("Parameter " + nameof(predicate) + " does not exist in the list."); + } + public T FindLast(T match, int start) + { + for (int i = array.Length - 1; i >= start; i--) if (array[i].Equals(match)) return array[i]; + throw new Exception("Parameter " + nameof(match) + " does not exist in the list."); + } + public T FindLast(Predicate predicate, int start, int max) + { + for (int i = max; i >= start; i--) if (predicate.Invoke(array[i])) return array[i]; + throw new Exception("Parameter " + nameof(predicate) + " does not exist in the list."); + } + public T FindLast(T match, int start, int max) + { + for (int i = max; i >= start; i--) if (array[i].Equals(match)) return array[i]; + throw new Exception("Parameter " + nameof(match) + " does not exist in the list."); + } + public T FindLastOrDefault(Predicate predicate) + { + for (int i = array.Length - 1; i >= 0; i--) if (predicate.Invoke(array[i])) return array[i]; + return default; + } + public T FindLastOrDefault(T match) + { + for (int i = array.Length - 1; i >= 0; i--) if (array[i].Equals(match)) return array[i]; + return default; + } + public T FindLastOrDefault(Predicate predicate, int start) + { + for (int i = array.Length - 1; i >= start; i--) if (predicate.Invoke(array[i])) return array[i]; + return default; + } + public T FindLastOrDefault(T match, int start) + { + for (int i = array.Length - 1; i >= start; i--) if (array[i].Equals(match)) return array[i]; + return default; + } + public T FindLastOrDefault(Predicate predicate, int start, int max) + { + for (int i = max; i >= start; i--) if (predicate.Invoke(array[i])) return array[i]; + return default; + } + public T FindLastOrDefault(T match, int start, int max) + { + for (int i = max; i >= start; i--) if (array[i].Equals(match)) return array[i]; + return default; + } + public int FindIndex(Predicate predicate) + { + for (int i = 0; i < array.Length; i++) if (predicate.Invoke(array[i])) return i; + return -1; + } + public int FindIndex(T match) + { + for (int i = 0; i < array.Length; i++) if (array[i].Equals(match)) return i; + return -1; + } + public int FindIndex(Predicate predicate, int start) + { + for (int i = start; i < array.Length; i++) if (predicate.Invoke(array[i])) return i; + return -1; + } + public int FindIndex(T match, int start) + { + for (int i = start; i < array.Length; i++) if (array[i].Equals(match)) return i; + return -1; + } + public int FindIndex(Predicate predicate, int start, int max) + { + for (int i = start; i <= max; i++) if (predicate.Invoke(array[i])) return i; + return -1; + } + public int FindIndex(T match, int start, int max) + { + for (int i = start; i <= max; i++) if (array[i].Equals(match)) return i; + return -1; + } + public List FindAllIndex() + { + List ret = new(); + for (int i = 0; i < array.Length; i++) ret.Add(i); + return ret; + } + public List FindAllIndex(Predicate predicate) + { + List r = new(); + for (int i = 0; i < array.Length; i++) if (predicate.Invoke(array[i])) r.Add(i); + return r; + } + public List FindAllIndex(T match) + { + List r = new(); + for (int i = 0; i < array.Length; i++) if (array[i].Equals(match)) r.Add(i); + return r; + } + public List FindAllIndex(int start) + { + List ret = new(); + for (int i = start; i < array.Length; i++) ret.Add(i); + return ret; + } + public List FindAllIndex(Predicate predicate, int start) + { + List r = new(); + for (int i = start; i < array.Length; i++) if (predicate.Invoke(array[i])) r.Add(i); + return r; + } + public List FindAllIndex(T match, int start) + { + List r = new(); + for (int i = start; i < array.Length; i++) if (array[i].Equals(match)) r.Add(i); + return r; + } + public List FindAllIndex(int start, int max) + { + List ret = new(); + for (int i = start; i <= max; i++) ret.Add(i); + return ret; + } + public List FindAllIndex(Predicate predicate, int start, int max) + { + List r = new(); + for (int i = start; i <= max; i++) if (predicate.Invoke(array[i])) r.Add(i); + return r; + } + public List FindAllIndex(T match, int start, int max) + { + List r = new(); + for (int i = start; i <= max; i++) if (array[i].Equals(match)) r.Add(i); + return r; + } + public int FindLastIndex(Predicate predicate) + { + for (int i = array.Length - 1; i >= 0; i--) if (predicate.Invoke(array[i])) return i; + return -1; + } + public int FindLastIndex(T match) + { + for (int i = array.Length - 1; i >= 0; i--) if (array[i].Equals(match)) return i; + return -1; + } + public int FindLastIndex(Predicate predicate, int start) + { + for (int i = array.Length - 1; i >= start; i--) if (predicate.Invoke(array[i])) return i; + return -1; + } + public int FindLastIndex(T match, int start) + { + for (int i = array.Length - 1; i >= start; i--) if (array[i].Equals(match)) return i; + return -1; + } + public int FindLastIndex(Predicate predicate, int start, int max) + { + for (int i = max; i >= start; i--) if (predicate.Invoke(array[i])) return i; + return -1; + } + public int FindLastIndex(T match, int start, int max) + { + for (int i = max; i >= start; i--) if (array[i].Equals(match)) return i; + return -1; + } + public IEnumerator GetEnumerator() => array.GetEnumerator(); + IEnumerator IEnumerable.GetEnumerator() => (IEnumerator)array.GetEnumerator(); + public List GetRange(int start, int max) + { + List r = new(); + for (int i = start; i <= max; i++) r.Add(array[i]); + return r; + } + public void Insert(int index, T item) + { + T[] old = array; + array = new T[old.Length + 1]; + for (int i = 0; i < index; i++) array[i] = old[i]; + array[index] = item; + for (int i = index + 1; i < array.Length; i++) array[i] = old[i - 1]; + } + public void InsertRange(int index, IEnumerable items) + { + List list = new(items); - public static List AllDefault(int length) - { - return new(length, default); + T[] old = array; + array = new T[old.Length + list.Length]; + for (int i = 0; i < index; i++) array[i] = old[i]; + for (int i = 0; i < list.Length; i++) array[index + i] = list[i]; + for (int i = index + list.Length; i < array.Length; i++) array[i] = old[i - list.Length]; } - - public override bool Equals(object obj) + public bool MatchesAll(Predicate predicate) => FindAll(predicate).array == array; + public bool MatchesAll(T match) => FindAll(match).array == array; + public void Randomize() { - return base.Equals(obj); - } - public bool Equals(List other) - { - bool returned = true; - if (Length == other.Length) + List newL = new(); + List possibleIndexes = FindAllIndex(); + for (int i = 0; i < possibleIndexes.Length; i++) { - for (int i = 0; i < Length; i++) - { - returned &= Get(i).Equals(other.Get(i)); - } + int index = possibleIndexes[new Random().Next(0, possibleIndexes.Length)]; + newL.Add(array[index]); + possibleIndexes.Remove(x => x == index); } - return returned; + array = newL.ToArray(); } + public void Remove(Predicate predicate) => Remove(FindIndex(predicate)); + public void Remove(T item) => Remove(FindIndex(item)); + public void Remove(int index) + { + List newList = new(); + for (int i = 0; i < array.Length; i++) if (i != index) newList.Add(array[i]); + array = newList.array; + } + public void RemoveAll(Predicate predicate) { foreach (int i in FindAllIndex(predicate)) Remove(i); } + public void RemoveAll(T match) { foreach (int i in FindAllIndex(match)) Remove(i); } + public void RemoveLast(Predicate predicate) => Remove(FindLastIndex(predicate)); + public void RemoveLast(T item) => Remove(FindLastIndex(item)); + public void RemoveRange(int index, int max) + { + List newList = new(); + for (int i = 0; i < array.Length; i++) if (i < index || i > max) newList.Add(array[i]); + array = newList.array; + } + public void Reverse() + { + T[] old = array; + array = new T[old.Length]; + + for (int i = old.Length - 1; i >= 0; i--) array[i] = old[i]; + } + public void Shuffle() => Randomize(); + public T[] ToArray() => array; + public ReadOnlyList ToReadOnly() { return new ReadOnlyList(array); } + public ReadOnlyCollection ToSystemReadOnly() { return new ReadOnlyCollection(array); } + public System.Collections.Generic.List ToSystemList() { return new System.Collections.Generic.List(array); } + + public override bool Equals(object obj) => base.Equals(obj); public bool Equals(T[] other) { bool returned = true; @@ -543,86 +467,54 @@ namespace Nerd_STF.Lists { for (int i = 0; i < Length; i++) { - returned &= Get(i).Equals(other[i]); + returned &= array[i].Equals(other[i]); } } return returned; } - public override int GetHashCode() + public bool Equals(List list) { - return base.GetHashCode(); + if (Length != list.Length) return false; + bool equal = true; + for (int i = 0; i < Length; i++) equal &= array[i].Equals(list[i]); + return equal; } - public override string ToString() + public bool Equals(IEnumerable list) => Equals(new List(list)); + public override int GetHashCode() => base.GetHashCode(); + public override string ToString() => ToString(false); + public string ToString(bool showAll = false) { - return list.ToString(); - } - public string ToString(bool showAll) - { - if (showAll) - { - string r = ""; - for (int i = 0; i < list.Length; i++) - { - r += list[i].ToString(); - if (i != list.Length - 1) r += "\n"; - } - return r; - } - else - { - return ToString(); - } + string ret = "List of " + Length + " Elements (" + typeof(T).ToString() + ")"; + if (showAll) for (int i = 0; i < Length; i++) ret += "\n" + i + ": " + array[i]; + return ret; } - public static List operator +(List a, List b) + public static List operator +(List a, T b) { a.Add(b); return a; } + public static List operator +(List a, IEnumerable b) + { + a.AddRange(b); + return a; + } + public static List operator +(List a, List b) + { + a.AddRange(b); + return a; + } public static List operator +(List a, T[] b) { - a.Add(b); + a.AddRange(b); return a; } - public static List operator +(T[] a, List b) - { - List returned = new(a); - returned.Add(b); - return returned; - } - public static List operator +(List a, int add) - { - List returned = new(a.Length + add); - int i = 0; - while (i < a.Length) - { - returned.Set(i, a.Get(i)); - i++; - } - while (i < returned.Length) - { - returned.Set(i, default); - } - return returned; - } - public static List operator +(List a, T b) - { - a.Add(b); - - return a; - } - public static List operator +(T a, List b) - { - b.Add(a); - - return b; - } public static List operator -(List a, int remove) { List returned = new(a.Length - remove); for (int i = 0; i < returned.Length; i++) { - returned.Set(i, a.Get(i)); + returned[i] = a[i]; } return returned; } @@ -642,25 +534,12 @@ namespace Nerd_STF.Lists } return a; } - public static List operator *(List a, int multiplier) + public static List operator -(List a, T b) { - List returned = new(a.Length * multiplier); - int i = 0; - while (i < a.Length) - { - returned.Set(i, a.Get(i)); - i++; - } - while (i < returned.Length) - { - returned.Set(i, default); - } - return returned; - } - public static bool operator ==(List a, List b) - { - return a.Equals(b); + a.Remove(b); + return a; } + public static bool operator ==(List a, List b) => a.Equals(b); public static bool operator ==(List a, T[] b) { return a.Equals(b); @@ -669,10 +548,7 @@ namespace Nerd_STF.Lists { return b.Equals(a); } - public static bool operator !=(List a, List b) - { - return !a.Equals(b); - } + public static bool operator !=(List a, List b) => !a.Equals(b); public static bool operator !=(List a, T[] b) { return !a.Equals(b); @@ -681,14 +557,539 @@ namespace Nerd_STF.Lists { return !b.Equals(a); } + } - public static explicit operator T[](List list) + [Serializable] + [Obsolete("This class will be removed or heavily modified in a future release.")] + public class Matrix + { + internal List> lists; + + public Vector2 Length => new(lists[0].Length, lists.Length); + public int LengthX => lists[0].Length; + public int LengthY => lists.Length; + + public static Matrix Empty => new() { lists = List>.Empty }; + + public Matrix() => lists = new List>(1, new List(1, default)); + public Matrix(int lengthX, int lengthY) { - return list.list; + if (lengthX < 1) throw new ArgumentOutOfRangeException(nameof(lengthX), "Do not include a length of less than 1"); + if (lengthY < 1) throw new ArgumentOutOfRangeException(nameof(lengthY), "Do not include a width of less than 1"); + lists = new List>(lengthY, new List(lengthX)); } - public static explicit operator List(T[] list) + public Matrix(int lengthX, int lengthY, T inputAll) { - return new List(list); + if (lengthX < 1) throw new ArgumentOutOfRangeException(nameof(lengthX), "Do not include a length of less than 1"); + if (lengthY < 1) throw new ArgumentOutOfRangeException(nameof(lengthY), "Do not include a width of less than 1"); + lists = new List>(lengthY, new List(lengthX, inputAll)); + } + public T this[int indexX, int indexY] + { + get => Get(indexX, indexY); + set => Set(indexX, indexY, value); + } + + public void Add(Matrix input, DirectionType addDir) + { + if (addDir == DirectionType.y) + { + foreach (List list in input.lists) AddY(list); + return; + } + + foreach (List list in input.lists) AddX(list); + } + public void AddX() { foreach (List list in lists) list.Add(); } + public void AddX(T input) { foreach (List list in lists) list.Add(input); } + public void AddX(T[] input) { foreach (T t in input) AddX(t); } + public void AddX(List input) { foreach (T t in input) AddX(t); } + public void AddY() => lists.Add(new List(lists[0].Length)); + public void AddY(T input) => lists.Add(new List(lists[0].Length, input)); + public void AddY(T[] input) + { + if (input.Length > lists[0].Length) throw new OverflowException(); + lists.Add(new List(input)); + } + public void AddY(List input) + { + if (input.Length > lists[0].Length) throw new OverflowException(); + lists.Add(input); + } + public bool Check(int placeX, int placeY) => lists[placeY][placeX] != null; + public bool Compare(T input) + { + foreach (List list in lists) if (list.Contains(input)) return true; + + return false; + } + public void Convert(T input) { for (int i = 0; i < lists.Length; i++) lists[i] = new(input); } + public void Convert(T[] input) { for (int i = 0; i < lists.Length; i++) lists[i] = new(input); } + public void Convert(List input) { for (int i = 0; i < lists.Length; i++) lists[i] = input; } + public void Convert(Matrix input) => lists = input.lists; + public int Count() + { + int returned = 0; + + foreach (List list in lists) returned += list.Count(); + + return returned; + } + public int Count(DirectionType type) + { + if (type == DirectionType.y) return LengthY; + return LengthX; + } + public Vector2 CountXY() => Length; + public T Get(int placeX, int placeY) => lists[placeY][placeX]; + public void Get(int placeX, int placeY, out T output) => output = Get(placeX, placeY); + public List GetAll() + { + List returned = new(); + + foreach (List list in lists) returned.AddRange(list); + + return returned; + } + public void GetAll(out List output) + { + List returned = new(); + + foreach (List list in lists) returned.AddRange(list); + + output = returned; + } + public IEnumerator GetEnumerator() { foreach (List list in lists) foreach (T t in list) yield return t; } + public void Remove(int placeX, int placeY) => lists[placeY].Remove(placeX); + public void Set(int placeX, int placeY, T input) => lists[placeY][placeX] = input; + public void SetAll(T input) { for (int i = 0; i < lists.Length; i++) for (int j = 0; j < lists[i].Length; j++) lists[i][j] = input; } + + public static Matrix AllDefault(int lengthX, int lengthY) => new(lengthX, lengthY, default); + + public override bool Equals(object obj) => base.Equals(obj); + public bool Equals(Matrix other) => GetAll() == other.GetAll(); + public override int GetHashCode() => base.GetHashCode(); + public override string ToString() => lists.ToString(); + public string ToString(bool showAll) + { + if (showAll) + { + string r = ""; + for (int i = 0; i < lists.Length; i++) + { + for (int j = 0; j < lists[i].Length; j++) + { + r += lists[i][j]; + if (j != lists[i].Length - 1) r += ", "; + } + if (i != lists.Length - 1) r += "\n"; + } + return r; + } + else return ToString(); + } + + public static bool operator ==(Matrix a, Matrix b) => a.Equals(b); + public static bool operator !=(Matrix a, Matrix b) => !a.Equals(b); + + public enum DirectionType + { + x, + y, } } + + [Serializable] + public class ReadOnlyList : IEnumerable, IEnumerable + { + public static ReadOnlyList Empty => new(); + + internal T[] array; + + public T this[int index] => array[index]; + + public List Duplicate => new(array); + public bool IsEmpty => array == Array.Empty(); + public bool IsNull => array == null; + public bool IsNullOrEmpty => IsNull || IsEmpty; + public int Length => array.Length; + + public ReadOnlyList() => array = Array.Empty(); + public ReadOnlyList(params T[] items) => array = items; + public ReadOnlyList(int length) => array = new T[length]; + public ReadOnlyList(int length, T itemAll) + { + array = new T[length]; + for (int i = 0; i < array.Length; i++) array[i] = itemAll; + } + public ReadOnlyList(IEnumerable items) => array = new List(items).ToArray(); + + public bool Contains(Predicate predicate) + { + foreach (T t in array) if (predicate.Invoke(t)) return true; + return false; + } + public bool Contains(T match) + { + foreach (T t in array) if (t.Equals(match)) return true; + return false; + } + public int Count() + { + int r = 0; + foreach (T _ in array) r++; + return r; + } + public int Count(Predicate predicate) + { + if (!Contains(predicate)) return 0; + int r = 0; + foreach (T t in array) if (predicate.Invoke(t)) r++; + return r; + } + public int Count(T match) + { + if (!Contains(match)) return 0; + int r = 0; + foreach (T t in array) if (t.Equals(match)) r++; + return r; + } + public T Find(Predicate predicate) + { + foreach (T t in array) if (predicate.Invoke(t)) return t; + throw new Exception("Parameter " + nameof(predicate) + " does not exist in the list."); + } + public T Find(T match) + { + foreach (T t in array) if (t.Equals(match)) return t; + throw new Exception("Parameter " + nameof(match) + " does not exist in the list."); + } + public T Find(Predicate predicate, int start) + { + for (int i = start; i < array.Length; i++) if (predicate.Invoke(array[i])) return array[i]; + throw new Exception("Parameter " + nameof(predicate) + " does not exist in the list."); + } + public T Find(T match, int start) + { + for (int i = start; i < array.Length; i++) if (array[i].Equals(match)) return array[i]; + throw new Exception("Parameter " + nameof(match) + " does not exist in the list."); + } + public T Find(Predicate predicate, int start, int max) + { + for (int i = start; i <= max; i++) if (predicate.Invoke(array[i])) return array[i]; + throw new Exception("Parameter " + nameof(predicate) + " does not exist in the list."); + } + public T Find(T match, int start, int max) + { + for (int i = start; i <= max; i++) if (array[i].Equals(match)) return array[i]; + throw new Exception("Parameter " + nameof(match) + " does not exist in the list."); + } + public T FindOrDefault(Predicate predicate) + { + foreach (T t in array) if (predicate.Invoke(t)) return t; + return default; + } + public T FindOrDefault(T match) + { + foreach (T t in array) if (t.Equals(match)) return t; + return default; + } + public T FindOrDefault(Predicate predicate, int start) + { + for (int i = start; i < array.Length; i++) if (predicate.Invoke(array[i])) return array[i]; + return default; + } + public T FindOrDefault(T match, int start) + { + for (int i = start; i < array.Length; i++) if (array[i].Equals(match)) return array[i]; + return default; + } + public T FindOrDefault(Predicate predicate, int start, int max) + { + for (int i = start; i <= max; i++) if (predicate.Invoke(array[i])) return array[i]; + return default; + } + public T FindOrDefault(T match, int start, int max) + { + for (int i = start; i <= max; i++) if (array[i].Equals(match)) return array[i]; + return default; + } + public List FindAll(Predicate predicate) + { + List r = new(); + foreach (T t in array) if (predicate.Invoke(t)) r.Add(t); + return r; + } + public List FindAll(T match) + { + List r = new(); + foreach (T t in array) if (t.Equals(match)) r.Add(t); + return r; + } + public List FindAll(Predicate predicate, int start) + { + List r = new(); + for (int i = start; i < array.Length; i++) if (predicate.Invoke(array[i])) r.Add(array[i]); + return r; + } + public List FindAll(T match, int start) + { + List r = new(); + for (int i = start; i < array.Length; i++) if (array[i].Equals(match)) r.Add(array[i]); + return r; + } + public List FindAll(Predicate predicate, int start, int max) + { + List r = new(); + for (int i = start; i <= max; i++) if (predicate.Invoke(array[i])) r.Add(array[i]); + return r; + } + public List FindAll(T match, int start, int max) + { + List r = new(); + for (int i = start; i <= max; i++) if (array[i].Equals(match)) r.Add(array[i]); + return r; + } + public T FindLast(Predicate predicate) + { + for (int i = array.Length - 1; i >= 0; i--) if (predicate.Invoke(array[i])) return array[i]; + throw new Exception("Parameter " + nameof(predicate) + " does not exist in the list."); + } + public T FindLast(T match) + { + for (int i = array.Length - 1; i >= 0; i--) if (array[i].Equals(match)) return array[i]; + throw new Exception("Parameter " + nameof(match) + " does not exist in the list."); + } + public T FindLast(Predicate predicate, int start) + { + for (int i = array.Length - 1; i >= start; i--) if (predicate.Invoke(array[i])) return array[i]; + throw new Exception("Parameter " + nameof(predicate) + " does not exist in the list."); + } + public T FindLast(T match, int start) + { + for (int i = array.Length - 1; i >= start; i--) if (array[i].Equals(match)) return array[i]; + throw new Exception("Parameter " + nameof(match) + " does not exist in the list."); + } + public T FindLast(Predicate predicate, int start, int max) + { + for (int i = max; i >= start; i--) if (predicate.Invoke(array[i])) return array[i]; + throw new Exception("Parameter " + nameof(predicate) + " does not exist in the list."); + } + public T FindLast(T match, int start, int max) + { + for (int i = max; i >= start; i--) if (array[i].Equals(match)) return array[i]; + throw new Exception("Parameter " + nameof(match) + " does not exist in the list."); + } + public T FindLastOrDefault(Predicate predicate) + { + for (int i = array.Length - 1; i >= 0; i--) if (predicate.Invoke(array[i])) return array[i]; + return default; + } + public T FindLastOrDefault(T match) + { + for (int i = array.Length - 1; i >= 0; i--) if (array[i].Equals(match)) return array[i]; + return default; + } + public T FindLastOrDefault(Predicate predicate, int start) + { + for (int i = array.Length - 1; i >= start; i--) if (predicate.Invoke(array[i])) return array[i]; + return default; + } + public T FindLastOrDefault(T match, int start) + { + for (int i = array.Length - 1; i >= start; i--) if (array[i].Equals(match)) return array[i]; + return default; + } + public T FindLastOrDefault(Predicate predicate, int start, int max) + { + for (int i = max; i >= start; i--) if (predicate.Invoke(array[i])) return array[i]; + return default; + } + public T FindLastOrDefault(T match, int start, int max) + { + for (int i = max; i >= start; i--) if (array[i].Equals(match)) return array[i]; + return default; + } + public int FindIndex(Predicate predicate) + { + for (int i = 0; i < array.Length; i++) if (predicate.Invoke(array[i])) return i; + return -1; + } + public int FindIndex(T match) + { + for (int i = 0; i < array.Length; i++) if (array[i].Equals(match)) return i; + return -1; + } + public int FindIndex(Predicate predicate, int start) + { + for (int i = start; i < array.Length; i++) if (predicate.Invoke(array[i])) return i; + return -1; + } + public int FindIndex(T match, int start) + { + for (int i = start; i < array.Length; i++) if (array[i].Equals(match)) return i; + return -1; + } + public int FindIndex(Predicate predicate, int start, int max) + { + for (int i = start; i <= max; i++) if (predicate.Invoke(array[i])) return i; + return -1; + } + public int FindIndex(T match, int start, int max) + { + for (int i = start; i <= max; i++) if (array[i].Equals(match)) return i; + return -1; + } + public List FindAllIndex() + { + List ret = new(); + for (int i = 0; i < array.Length; i++) ret.Add(i); + return ret; + } + public List FindAllIndex(Predicate predicate) + { + List r = new(); + for (int i = 0; i < array.Length; i++) if (predicate.Invoke(array[i])) r.Add(i); + return r; + } + public List FindAllIndex(T match) + { + List r = new(); + for (int i = 0; i < array.Length; i++) if (array[i].Equals(match)) r.Add(i); + return r; + } + public List FindAllIndex(int start) + { + List ret = new(); + for (int i = start; i < array.Length; i++) ret.Add(i); + return ret; + } + public List FindAllIndex(Predicate predicate, int start) + { + List r = new(); + for (int i = start; i < array.Length; i++) if (predicate.Invoke(array[i])) r.Add(i); + return r; + } + public List FindAllIndex(T match, int start) + { + List r = new(); + for (int i = start; i < array.Length; i++) if (array[i].Equals(match)) r.Add(i); + return r; + } + public List FindAllIndex(int start, int max) + { + List ret = new(); + for (int i = start; i <= max; i++) ret.Add(i); + return ret; + } + public List FindAllIndex(Predicate predicate, int start, int max) + { + List r = new(); + for (int i = start; i <= max; i++) if (predicate.Invoke(array[i])) r.Add(i); + return r; + } + public List FindAllIndex(T match, int start, int max) + { + List r = new(); + for (int i = start; i <= max; i++) if (array[i].Equals(match)) r.Add(i); + return r; + } + public int FindLastIndex(Predicate predicate) + { + for (int i = array.Length - 1; i >= 0; i--) if (predicate.Invoke(array[i])) return i; + return -1; + } + public int FindLastIndex(T match) + { + for (int i = array.Length - 1; i >= 0; i--) if (array[i].Equals(match)) return i; + return -1; + } + public int FindLastIndex(Predicate predicate, int start) + { + for (int i = array.Length - 1; i >= start; i--) if (predicate.Invoke(array[i])) return i; + return -1; + } + public int FindLastIndex(T match, int start) + { + for (int i = array.Length - 1; i >= start; i--) if (array[i].Equals(match)) return i; + return -1; + } + public int FindLastIndex(Predicate predicate, int start, int max) + { + for (int i = max; i >= start; i--) if (predicate.Invoke(array[i])) return i; + return -1; + } + public int FindLastIndex(T match, int start, int max) + { + for (int i = max; i >= start; i--) if (array[i].Equals(match)) return i; + return -1; + } + public IEnumerator GetEnumerator() => array.GetEnumerator(); + IEnumerator IEnumerable.GetEnumerator() => (IEnumerator)array.GetEnumerator(); + public List GetRange(int start, int max) + { + List r = new(); + for (int i = start; i <= max; i++) r.Add(array[i]); + return r; + } + public bool MatchesAll(Predicate predicate) => FindAll(predicate).array == array; + public bool MatchesAll(T match) => FindAll(match).array == array; + public T[] ToArray() => array; + public List ToList() => new(array); + public System.Collections.Generic.List ToSystemList() => new(array); + public ReadOnlyCollection ToSystemReadOnly() => new(array); + + public override bool Equals(object obj) => base.Equals(obj); + public bool Equals(T[] other) + { + bool returned = true; + if (Length == other.Length) + { + for (int i = 0; i < Length; i++) + { + returned &= array[i].Equals(other[i]); + } + } + return returned; + } + public bool Equals(ReadOnlyList list) + { + if (Length != list.Length) return false; + bool equal = true; + for (int i = 0; i < Length; i++) equal &= array[i].Equals(list[i]); + return equal; + } + public bool Equals(IEnumerable list) => Equals(new ReadOnlyList(list)); + public override int GetHashCode() => base.GetHashCode(); + public override string ToString() => ToString(false); + public string ToString(bool showAll = false) + { + string ret = "List of " + Length + " Elements (" + typeof(T).ToString() + ")"; + if (showAll) for (int i = 0; i < Length; i++) ret += "\n" + i + ": " + array[i]; + return ret; + } + + public static bool operator ==(ReadOnlyList a, ReadOnlyList b) => a.Equals(b); + public static bool operator ==(ReadOnlyList a, T[] b) + { + return a.Equals(b); + } + public static bool operator ==(T[] a, ReadOnlyList b) + { + return b.Equals(a); + } + public static bool operator ==(IEnumerable a, ReadOnlyList b) => a.Equals(b); + public static bool operator ==(ReadOnlyList a, IEnumerable b) => a.Equals(b); + public static bool operator !=(ReadOnlyList a, ReadOnlyList b) => !a.Equals(b); + public static bool operator !=(ReadOnlyList a, T[] b) + { + return !a.Equals(b); + } + public static bool operator !=(T[] a, ReadOnlyList b) + { + return !b.Equals(a); + } + public static bool operator !=(IEnumerable a, ReadOnlyList b) => !a.Equals(b); + public static bool operator !=(ReadOnlyList a, IEnumerable b) => !a.Equals(b); + } } \ No newline at end of file diff --git a/Scripts/Mathematics.cs b/Scripts/Mathematics.cs index 991219d..1830e35 100644 --- a/Scripts/Mathematics.cs +++ b/Scripts/Mathematics.cs @@ -1,9 +1,10 @@ -using System; -using Nerd_STF.Interfaces; +using Nerd_STF.Mathematics.Interfaces; +using System; namespace Nerd_STF.Mathematics { - public struct Angle : INegatives + [Serializable] + public struct Angle : IMathFunctions, INegatives { public float value; @@ -12,14 +13,8 @@ namespace Nerd_STF.Mathematics get { Angle returned = this; - while (returned.value >= 360) - { - returned.value -= 360; - } - while (returned.value < 0) - { - returned.value += 360; - } + while (returned.value >= 360) returned.value -= 360; + while (returned.value < 0) returned.value += 360; return returned; } } @@ -32,74 +27,14 @@ namespace Nerd_STF.Mathematics return returned; } } - public bool IsAcute - { - get - { - Angle returned = Clamped; - - return returned.value > 0 && returned.value < 90; - } - } - public bool IsClamped - { - get - { - return value < 360 && value >= 0; - } - } - public bool IsNegative - { - get - { - return value < 0; - } - } - public bool IsObtuse - { - get - { - Angle returned = Clamped; - - return returned.value > 90 && returned.value < 180; - } - } - public bool IsReflex - { - get - { - Angle returned = Clamped; - - return returned.value > 180 && returned.value < 360; - } - } - public bool IsRight - { - get - { - Angle returned = Clamped; - - return returned.value == 90; - } - } - public bool IsStraight - { - get - { - Angle returned = Clamped; - - return returned.value == 180; - } - } - public bool IsZero - { - get - { - Angle returned = Clamped; - - return returned.value == 0; - } - } + public bool IsAcute => Clamped.value > 0 && Clamped.value < 90; + public bool IsClamped => value < 360 && value >= 0; + public bool IsNegative => value < 0; + public bool IsObtuse => Clamped.value > 90 && Clamped.value < 180; + public bool IsReflex => Clamped.value > 180 && Clamped.value < 360; + public bool IsRight => Clamped.value == 90; + public bool IsStraight => Clamped.value == 180; + public bool IsZero => Clamped.value == 0; public Angle Negative { get @@ -109,13 +44,7 @@ namespace Nerd_STF.Mathematics return returned; } } - public Angle Positive - { - get - { - return Absolute; - } - } + public Angle Positive => Absolute; public AngleType Type { get @@ -130,236 +59,77 @@ namespace Nerd_STF.Mathematics } } - public Angle(float degree) - { - value = degree; - } + public Angle(float degree) => value = degree; - public static Angle Acute - { - get - { - return new Angle(45); - } - } - public static Angle Obtuse - { - get - { - return new Angle(135); - } - } - public static Angle Reflex - { - get - { - return new Angle(270); - } - } - public static Angle Right - { - get - { - return new Angle(90); - } - } - public static Angle Straight - { - get - { - return new Angle(180); - } - } - public static Angle Zero - { - get - { - return new Angle(0); - } - } + public static Angle Acute => new(45); + public static Angle Obtuse => new(135); + public static Angle Reflex => new(270); + public static Angle Right => new(90); + public static Angle Straight => new(180); + public static Angle Zero => new(0); - public override bool Equals(object obj) - { - return base.Equals(obj); - } - public bool Equals(Angle other) - { - return value == other.value; - } - public bool Equals(float other) - { - return value == other; - } - public override int GetHashCode() - { - return base.GetHashCode(); - } - public override string ToString() - { - return value.ToString() + "°"; - } - public string ToString(string format) - { - return value.ToString(format) + "°"; - } + public override bool Equals(object obj) => base.Equals(obj); + public bool Equals(Angle other) => value == other.value; + public bool Equals(float other) => value == other; + public override int GetHashCode() => base.GetHashCode(); + public override string ToString() => value.ToString() + "°"; + public string ToString(string format) => value.ToString(format) + "°"; - public static Angle Average(params Angle[] input) + public Angle Average(params Angle[] objs) { - float[] average = new float[input.Length]; - for (int i = 0; i < input.Length; i++) - { - average[i] = input[i].value; - } + float[] average = new float[objs.Length + 1]; + for (int i = 0; i < objs.Length; i++) average[i] = objs[i].value; + average[objs.Length] = value; return new(Math.Average(average)); } - public static Angle Max(params Angle[] input) + public Angle Max(params Angle[] objs) { - float[] max = new float[input.Length]; - for (int i = 0; i < input.Length; i++) - { - max[i] = input[i].value; - } + float[] max = new float[objs.Length + 1]; + for (int i = 0; i < objs.Length; i++) max[i] = objs[i].value; + max[objs.Length] = value; return new(Math.Max(max)); } - public static Angle Min(params Angle[] input) + public Angle Min(params Angle[] objs) { - float[] min = new float[input.Length]; - for (int i = 0; i < input.Length; i++) - { - min[i] = input[i].value; - } + float[] min = new float[objs.Length + 1]; + for (int i = 0; i < objs.Length; i++) min[i] = objs[i].value; + min[objs.Length] = value; return new(Math.Min(min)); } - public static Angle operator +(Angle a, Angle b) - { - return new(a.value + b.value); - } - public static Angle operator +(Angle a, float b) - { - return new(a.value + b); - } - public static Angle operator +(float a, Angle b) - { - return new(a + b.value); - } - public static Angle operator -(Angle a, Angle b) - { - return new(a.value - b.value); - } - public static Angle operator -(Angle a, float b) - { - return new(a.value - b); - } - public static Angle operator -(float a, Angle b) - { - return new(a - b.value); - } - public static Angle operator *(Angle a, Angle b) - { - return new(a.value * b.value); - } - public static Angle operator *(Angle a, float b) - { - return new(a.value * b); - } - public static Angle operator *(float a, Angle b) - { - return new(a * b.value); - } - public static Angle operator /(Angle a, Angle b) - { - return new(a.value / b.value); - } - public static Angle operator /(Angle a, float b) - { - return new(a.value / b); - } - public static Angle operator /(float a, Angle b) - { - return new Angle(a / b.value); - } - public static bool operator ==(Angle a, Angle b) - { - return a.Equals(b); - } - public static bool operator ==(Angle a, float b) - { - return a.Equals(b); - } - public static bool operator ==(float a, Angle b) - { - return b.Equals(a); - } - public static bool operator !=(Angle a, Angle b) - { - return !a.Equals(b); - } - public static bool operator !=(Angle a, float b) - { - return !a.Equals(b); - } - public static bool operator !=(float a, Angle b) - { - return !b.Equals(a); - } - public static bool operator >(Angle a, Angle b) - { - return a.value > b.value; - } - public static bool operator >(Angle a, float b) - { - return a.value > b; - } - public static bool operator >(float a, Angle b) - { - return a > b.value; - } - public static bool operator <(Angle a, Angle b) - { - return a.value < b.value; - } - public static bool operator <(Angle a, float b) - { - return a.value < b; - } - public static bool operator <(float a, Angle b) - { - return a < b.value; - } - public static bool operator >=(Angle a, Angle b) - { - return a.value > b.value || a.Equals(b); - } - public static bool operator >=(Angle a, float b) - { - return a.value > b || a.Equals(b); - } - public static bool operator >=(float a, Angle b) - { - return a > b.value || b.Equals(a); - } - public static bool operator <=(Angle a, Angle b) - { - return a.value < b.value || a.Equals(b); - } - public static bool operator <=(Angle a, float b) - { - return a.value < b || a.Equals(b); - } - public static bool operator <=(float a, Angle b) - { - return a < b.value || b.Equals(a); - } + public static Angle operator +(Angle a, Angle b) => new(a.value + b.value); + public static Angle operator +(Angle a, float b) => new(a.value + b); + public static Angle operator +(float a, Angle b) => new(a + b.value); + public static Angle operator -(Angle a, Angle b) => new(a.value - b.value); + public static Angle operator -(Angle a, float b) => new(a.value - b); + public static Angle operator -(float a, Angle b) => new(a - b.value); + public static Angle operator *(Angle a, Angle b) => new(a.value * b.value); + public static Angle operator *(Angle a, float b) => new(a.value * b); + public static Angle operator *(float a, Angle b) => new(a * b.value); + public static Angle operator /(Angle a, Angle b) => new(a.value / b.value); + public static Angle operator /(Angle a, float b) => new(a.value / b); + public static Angle operator /(float a, Angle b) => new(a / b.value); + public static bool operator ==(Angle a, Angle b) => a.Equals(b); + public static bool operator ==(Angle a, float b) => a.Equals(b); + public static bool operator ==(float a, Angle b) => b.Equals(a); + public static bool operator !=(Angle a, Angle b) => !a.Equals(b); + public static bool operator !=(Angle a, float b) => !a.Equals(b); + public static bool operator !=(float a, Angle b) => !b.Equals(a); + public static bool operator >(Angle a, Angle b) => a.value > b.value; + public static bool operator >(Angle a, float b) => a.value > b; + public static bool operator >(float a, Angle b) => a > b.value; + public static bool operator <(Angle a, Angle b) => a.value < b.value; + public static bool operator <(Angle a, float b) => a.value < b; + public static bool operator <(float a, Angle b) => a < b.value; + public static bool operator >=(Angle a, Angle b) => a.value > b.value || a.Equals(b); + public static bool operator >=(Angle a, float b) => a.value > b || a.Equals(b); + public static bool operator >=(float a, Angle b) => a > b.value || b.Equals(a); + public static bool operator <=(Angle a, Angle b) => a.value < b.value || a.Equals(b); + public static bool operator <=(Angle a, float b) => a.value < b || a.Equals(b); + public static bool operator <=(float a, Angle b) => a < b.value || b.Equals(a); - public static explicit operator float(Angle input) - { - return input.value; - } - public static explicit operator Angle(float input) - { - return new Angle(input); - } + public static explicit operator float(Angle input) => input.value; + public static explicit operator Angle(float input) => new(input); public enum AngleType { @@ -372,45 +142,16 @@ namespace Nerd_STF.Mathematics } } - public struct Color + [Serializable] + public struct Color : IMathFunctions { public float r, g, b, a; - public bool IsBlue - { - get - { - return b != 0; - } - } - public bool IsClear - { - get - { - return a == 0; - } - } - public bool IsGreen - { - get - { - return g != 0; - } - } - public bool IsRed - { - get - { - return a != 0; - } - } - public bool IsTransparent - { - get - { - return a > 0 && a < 1; - } - } + public bool IsBlue => b != 0; + public bool IsClear => a == 0; + public bool IsGreen => g != 0; + public bool IsRed => a != 0; + public bool IsTransparent => a > 0 && a < 1; public bool IsBroken { get @@ -424,94 +165,22 @@ namespace Nerd_STF.Mathematics } } - public static Color Black - { - get - { - return new Color(0, 0, 0); - } - } - public static Color Blue - { - get - { - return new Color(0, 0, 1); - } - } - public static Color Clear - { - get - { - return new Color(0, 0, 0, 0); - } - } - public static Color Cyan - { - get - { - return new Color(0, 1, 1); - } - } - public static Color Gray - { - get - { - return new Color(0.5f, 0.5f, 0.5f); - } - } - public static Color Green - { - get - { - return new Color(0, 1, 0); - } - } - public static Color Magenta - { - get - { - return new Color(1, 0, 1); - } - } - public static Color Orange - { - get - { - return new Color(1, 0.5f, 0); - } - } - public static Color Purple - { - get - { - return new Color(0.5f, 0, 1); - } - } - public static Color Red - { - get - { - return new Color(1, 0, 0); - } - } - public static Color White - { - get - { - return new Color(1, 1, 1); - } - } - public static Color Yellow - { - get - { - return new Color(1, 1, 0); - } - } + public static Color Black => new(0, 0, 0); + public static Color Blue => new(0, 0, 1); + public static Color Clear => new(0, 0, 0, 0); + public static Color Cyan => new(0, 1, 1); + public static Color Gray => new(0.5f, 0.5f, 0.5f); + public static Color Green => new(0, 1, 0); + public static Color Magenta => new(1, 0, 1); + public static Color Orange => new(1, 0.5f, 0); + public static Color Purple => new(0.5f, 0, 1); + public static Color Red => new(1, 0, 0); + public static Color White => new(1, 1, 1); + public static Color Yellow => new(1, 1, 0); public Color(float r, float g, float b) { - this = new Color(r, g, b, 1); + this = new(r, g, b, 1); } public Color(float r, float g, float b, float a) { @@ -534,272 +203,114 @@ namespace Nerd_STF.Mathematics a = Math.Clamp(a, 0, 1); } - public static Color Average(params Color[] input) + public Color Average(params Color[] objs) { - float[] averageR = new float[input.Length]; - float[] averageG = new float[input.Length]; - float[] averageB = new float[input.Length]; - float[] averageA = new float[input.Length]; - for (int i = 0; i < input.Length; i++) + float[] averageR = new float[objs.Length + 1]; + float[] averageG = new float[objs.Length + 1]; + float[] averageB = new float[objs.Length + 1]; + float[] averageA = new float[objs.Length + 1]; + for (int i = 0; i < objs.Length; i++) { - averageR[i] = input[i].r; - averageG[i] = input[i].g; - averageB[i] = input[i].b; - averageA[i] = input[i].a; + averageR[i] = objs[i].r; + averageG[i] = objs[i].g; + averageB[i] = objs[i].b; + averageA[i] = objs[i].a; } + averageR[objs.Length] = r; + averageG[objs.Length] = g; + averageB[objs.Length] = b; + averageA[objs.Length] = a; return new(Math.Average(averageR), Math.Average(averageG), Math.Average(averageB), Math.Average(averageA)); } - public static Color Max(params Color[] input) + public Color Max(params Color[] objs) { - float[] maxR = new float[input.Length]; - float[] maxG = new float[input.Length]; - float[] maxB = new float[input.Length]; - float[] maxA = new float[input.Length]; - for (int i = 0; i < input.Length; i++) + float[] maxR = new float[objs.Length + 1]; + float[] maxG = new float[objs.Length + 1]; + float[] maxB = new float[objs.Length + 1]; + float[] maxA = new float[objs.Length + 1]; + for (int i = 0; i < objs.Length; i++) { - maxR[i] = input[i].r; - maxG[i] = input[i].g; - maxB[i] = input[i].b; - maxA[i] = input[i].a; + maxR[i] = objs[i].r; + maxG[i] = objs[i].g; + maxB[i] = objs[i].b; + maxA[i] = objs[i].a; } + maxR[objs.Length] = r; + maxG[objs.Length] = g; + maxB[objs.Length] = b; + maxA[objs.Length] = a; return new(Math.Max(maxR), Math.Max(maxG), Math.Max(maxB), Math.Max(maxA)); } - public static Color Min(params Color[] input) + public Color Min(params Color[] objs) { - float[] minR = new float[input.Length]; - float[] minG = new float[input.Length]; - float[] minB = new float[input.Length]; - float[] minA = new float[input.Length]; - for (int i = 0; i < input.Length; i++) + float[] minR = new float[objs.Length + 1]; + float[] minG = new float[objs.Length + 1]; + float[] minB = new float[objs.Length + 1]; + float[] minA = new float[objs.Length + 1]; + for (int i = 0; i < objs.Length; i++) { - minR[i] = input[i].r; - minG[i] = input[i].g; - minB[i] = input[i].b; - minA[i] = input[i].a; + minR[i] = objs[i].r; + minG[i] = objs[i].g; + minB[i] = objs[i].b; + minA[i] = objs[i].a; } + minR[objs.Length] = r; + minG[objs.Length] = g; + minB[objs.Length] = b; + minA[objs.Length] = a; return new(Math.Min(minR), Math.Min(minG), Math.Min(minB), Math.Min(minA)); } - public override bool Equals(object obj) - { - return base.Equals(obj); - } - public bool Equals(Color other) - { - return r == other.r && g == other.g && b == other.b && a == other.a; - } - public override int GetHashCode() - { - return base.GetHashCode(); - } - public override string ToString() - { - return "R: " + r.ToString() + " | G: " + g.ToString() + " | B: " + b.ToString() + " | A: " + a.ToString(); - } - public string ToString(string format) - { - return "R: " + r.ToString(format) + " | G: " + g.ToString(format) + " | B: " + b.ToString(format) + " | A: " + a.ToString(format); - } + public override bool Equals(object obj) => base.Equals(obj); + public bool Equals(Color other) => r == other.r && g == other.g && b == other.b && a == other.a; + public override int GetHashCode() => base.GetHashCode(); + public override string ToString() => "R: " + r.ToString() + " | G: " + g.ToString() + " | B: " + b.ToString() + " | A: " + a.ToString(); + public string ToString(string format) => "R: " + r.ToString(format) + " | G: " + g.ToString(format) + " | B: " + b.ToString(format) + " | A: " + a.ToString(format); - public static Color operator +(Color a, Color b) - { - return new Color(a.r + b.r, a.g + b.g, a.b + b.b, a.a + b.a); - } - public static Color operator +(Color a, float b) - { - return new Color(a.r + b, a.g + b, a.b + b, a.a + b); - } - public static Color operator +(float a, Color b) - { - return new Color(a + b.r, a + b.g, a + b.b, a + b.a); - } - public static Color operator -(Color a, Color b) - { - return new Color(a.r - b.r, a.g - b.g, a.b - b.b, a.a - b.a); - } - public static Color operator -(Color a, float b) - { - return new Color(a.r - b, a.g - b, a.b - b, a.a - b); - } - public static Color operator -(float a, Color b) - { - return new Color(a - b.r, a - b.g, a - b.b, a - b.a); - } - public static Color operator *(Color a, Color b) - { - return new Color(a.r * b.r, a.g * b.g, a.b * b.b, a.a * b.a); - } - public static Color operator *(Color a, float b) - { - return new Color(a.r * b, a.g * b, a.b * b, a.a * b); - } - public static Color operator *(float a, Color b) - { - return new Color(a * b.r, a * b.g, a * b.b, a * b.a); - } - public static Color operator /(Color a, Color b) - { - return new Color(a.r / b.r, a.g / b.g, a.b / b.b, a.a / b.a); - } - public static Color operator /(Color a, float b) - { - return new Color(a.r / b, a.g / b, a.b / b, a.a / b); - } - public static Color operator /(float a, Color b) - { - return new Color(a / b.r, a / b.g, a / b.b, a / b.a); - } - public static bool operator ==(Color a, Color b) - { - return a.Equals(b); - } - public static bool operator !=(Color a, Color b) - { - return !a.Equals(b); - } + public static Color operator +(Color a, Color b) => new(a.r + b.r, a.g + b.g, a.b + b.b, a.a + b.a); + public static Color operator +(Color a, float b) => new(a.r + b, a.g + b, a.b + b, a.a + b); + public static Color operator +(float a, Color b) => new(a + b.r, a + b.g, a + b.b, a + b.a); + public static Color operator -(Color a, Color b) => new(a.r - b.r, a.g - b.g, a.b - b.b, a.a - b.a); + public static Color operator -(Color a, float b) => new(a.r - b, a.g - b, a.b - b, a.a - b); + public static Color operator -(float a, Color b) => new(a - b.r, a - b.g, a - b.b, a - b.a); + public static Color operator *(Color a, Color b) => new(a.r * b.r, a.g * b.g, a.b * b.b, a.a * b.a); + public static Color operator *(Color a, float b) => new(a.r * b, a.g * b, a.b * b, a.a * b); + public static Color operator *(float a, Color b) => new(a * b.r, a * b.g, a * b.b, a * b.a); + public static Color operator /(Color a, Color b) => new(a.r / b.r, a.g / b.g, a.b / b.b, a.a / b.a); + public static Color operator /(Color a, float b) => new(a.r / b, a.g / b, a.b / b, a.a / b); + public static Color operator /(float a, Color b) => new(a / b.r, a / b.g, a / b.b, a / b.a); + public static bool operator ==(Color a, Color b) => a.Equals(b); + public static bool operator !=(Color a, Color b) => !a.Equals(b); - public static implicit operator Color(ColorByte input) - { - return new Color(input.r / 255, input.g / 255, input.b / 255, input.a / 255); - } - public static explicit operator Color(Vector3 input) - { - return new Color(input.x, input.y, input.z, 1); - } - public static explicit operator Color(Vector4 input) - { - return new Color(input.x, input.y, input.z, input.w); - } + public static implicit operator Color(ColorByte input) => new(input.r / 255, input.g / 255, input.b / 255, input.a / 255); + public static explicit operator Color(Vector3 input) => new(input.x, input.y, input.z, 1); + public static explicit operator Color(Vector4 input) => new(input.x, input.y, input.z, input.w); } - public struct ColorByte + [Serializable] + public struct ColorByte : IMathFunctions { public byte r, g, b, a; - public bool IsBlue - { - get - { - return b != byte.MinValue; - } - } - public bool IsClear - { - get - { - return a == byte.MinValue; - } - } - public bool IsGreen - { - get - { - return g != byte.MinValue; - } - } - public bool IsRed - { - get - { - return a != byte.MinValue; - } - } - public bool IsTransparent - { - get - { - return a > byte.MinValue && a < byte.MaxValue; - } - } + public bool IsBlue => b != byte.MinValue; + public bool IsClear => a == byte.MinValue; + public bool IsGreen => g != byte.MinValue; + public bool IsRed => a != byte.MinValue; + public bool IsTransparent => a > byte.MinValue && a < byte.MaxValue; - public static ColorByte Black - { - get - { - return new ColorByte(0, 0, 0); - } - } - public static ColorByte Blue - { - get - { - return new ColorByte(0, 0, 255); - } - } - public static ColorByte Clear - { - get - { - return new ColorByte(0, 0, 0, 0); - } - } - public static ColorByte Cyan - { - get - { - return new ColorByte(0, 255, 255); - } - } - public static ColorByte Gray - { - get - { - return new ColorByte(128, 128, 128); - } - } - public static ColorByte Green - { - get - { - return new ColorByte(0, 255, 0); - } - } - public static ColorByte Magenta - { - get - { - return new ColorByte(255, 0, 255); - } - } - public static ColorByte Orange - { - get - { - return new ColorByte(1, 128, 0); - } - } - public static ColorByte Purple - { - get - { - return new ColorByte(128, 0, 1); - } - } - public static ColorByte Red - { - get - { - return new ColorByte(255, 0, 0); - } - } - public static ColorByte White - { - get - { - return new ColorByte(255, 255, 255); - } - } - public static ColorByte Yellow - { - get - { - return new ColorByte(255, 255, 0); - } - } + public static ColorByte Black => new(0, 0, 0); + public static ColorByte Blue => new(0, 0, 255); + public static ColorByte Clear => new(0, 0, 0, 0); + public static ColorByte Cyan => new(0, 255, 255); + public static ColorByte Gray => new(128, 128, 128); + public static ColorByte Green => new(0, 255, 0); + public static ColorByte Magenta => new(255, 0, 255); + public static ColorByte Orange => new(1, 128, 0); + public static ColorByte Purple => new(128, 0, 1); + public static ColorByte Red => new(255, 0, 0); + public static ColorByte White => new(255, 255, 255); + public static ColorByte Yellow => new(255, 255, 0); - public ColorByte(byte r, byte g, byte b) - { - this = new ColorByte(r, g, b, byte.MaxValue); - } + public ColorByte(byte r, byte g, byte b) => this = new(r, g, b, byte.MaxValue); public ColorByte(byte r, byte g, byte b, byte a) { this.r = r; @@ -807,10 +318,7 @@ namespace Nerd_STF.Mathematics this.b = b; this.a = a; } - public ColorByte(int r, int g, int b) - { - this = new ColorByte(r, g, b, byte.MaxValue); - } + public ColorByte(int r, int g, int b) => this = new(r, g, b, byte.MaxValue); public ColorByte(int r, int g, int b, int a) { this.r = (byte)r; @@ -819,134 +327,86 @@ namespace Nerd_STF.Mathematics this.a = (byte)a; } - public static ColorByte Average(params ColorByte[] input) + public ColorByte Average(params ColorByte[] objs) { - float[] averageR = new float[input.Length]; - float[] averageG = new float[input.Length]; - float[] averageB = new float[input.Length]; - float[] averageA = new float[input.Length]; - for (int i = 0; i < input.Length; i++) + float[] averageR = new float[objs.Length + 1]; + float[] averageG = new float[objs.Length + 1]; + float[] averageB = new float[objs.Length + 1]; + float[] averageA = new float[objs.Length + 1]; + for (int i = 0; i < objs.Length; i++) { - averageR[i] = input[i].r; - averageG[i] = input[i].g; - averageB[i] = input[i].b; - averageA[i] = input[i].a; + averageR[i] = objs[i].r; + averageG[i] = objs[i].g; + averageB[i] = objs[i].b; + averageA[i] = objs[i].a; } + averageR[objs.Length] = r; + averageG[objs.Length] = g; + averageB[objs.Length] = b; + averageA[objs.Length] = a; return new(Math.RoundToInt(Math.Average(averageR)), Math.RoundToInt(Math.Average(averageG)), Math.RoundToInt(Math.Average(averageB)), Math.RoundToInt(Math.Average(averageA))); } - public static ColorByte Max(params ColorByte[] input) + public ColorByte Max(params ColorByte[] objs) { - float[] maxR = new float[input.Length]; - float[] maxG = new float[input.Length]; - float[] maxB = new float[input.Length]; - float[] maxA = new float[input.Length]; - for (int i = 0; i < input.Length; i++) + float[] maxR = new float[objs.Length + 1]; + float[] maxG = new float[objs.Length + 1]; + float[] maxB = new float[objs.Length + 1]; + float[] maxA = new float[objs.Length + 1]; + for (int i = 0; i < objs.Length; i++) { - maxR[i] = input[i].r; - maxG[i] = input[i].g; - maxB[i] = input[i].b; - maxA[i] = input[i].a; + maxR[i] = objs[i].r; + maxG[i] = objs[i].g; + maxB[i] = objs[i].b; + maxA[i] = objs[i].a; } + maxR[objs.Length] = r; + maxG[objs.Length] = g; + maxB[objs.Length] = b; + maxA[objs.Length] = a; return new(Math.RoundToInt(Math.Max(maxR)), Math.RoundToInt(Math.Max(maxG)), Math.RoundToInt(Math.Max(maxB)), Math.RoundToInt(Math.Max(maxA))); } - public static ColorByte Min(params ColorByte[] input) + public ColorByte Min(params ColorByte[] objs) { - float[] minR = new float[input.Length]; - float[] minG = new float[input.Length]; - float[] minB = new float[input.Length]; - float[] minA = new float[input.Length]; - for (int i = 0; i < input.Length; i++) + float[] minR = new float[objs.Length + 1]; + float[] minG = new float[objs.Length + 1]; + float[] minB = new float[objs.Length + 1]; + float[] minA = new float[objs.Length + 1]; + for (int i = 0; i < objs.Length; i++) { - minR[i] = input[i].r; - minG[i] = input[i].g; - minB[i] = input[i].b; - minA[i] = input[i].a; + minR[i] = objs[i].r; + minG[i] = objs[i].g; + minB[i] = objs[i].b; + minA[i] = objs[i].a; } + minR[objs.Length] = r; + minG[objs.Length] = g; + minB[objs.Length] = b; + minA[objs.Length] = a; return new(Math.RoundToInt(Math.Min(minR)), Math.RoundToInt(Math.Min(minG)), Math.RoundToInt(Math.Min(minB)), Math.RoundToInt(Math.Min(minA))); } - public override bool Equals(object obj) - { - return base.Equals(obj); - } - public bool Equals(ColorByte other) - { - return r == other.r && g == other.g && b == other.b && a == other.a; - } - public override int GetHashCode() - { - return base.GetHashCode(); - } - public override string ToString() - { - return "R: " + r.ToString() + " | G: " + g.ToString() + " | B: " + b.ToString() + " | A: " + a.ToString(); - } - public string ToString(string format) - { - return "R: " + r.ToString(format) + " | G: " + g.ToString(format) + " | B: " + b.ToString(format) + " | A: " + a.ToString(format); - } + public override bool Equals(object obj) => base.Equals(obj); + public bool Equals(ColorByte other) => r == other.r && g == other.g && b == other.b && a == other.a; + public override int GetHashCode() => base.GetHashCode(); + public override string ToString() => "R: " + r.ToString() + " | G: " + g.ToString() + " | B: " + b.ToString() + " | A: " + a.ToString(); + public string ToString(string format) => "R: " + r.ToString(format) + " | G: " + g.ToString(format) + " | B: " + b.ToString(format) + " | A: " + a.ToString(format); - public static ColorByte operator +(ColorByte a, ColorByte b) - { - return new ColorByte(a.r + b.r, a.g + b.g, a.b + b.b, a.a + b.a); - } - public static ColorByte operator +(ColorByte a, byte b) - { - return new ColorByte(a.r + b, a.g + b, a.b + b, a.a + b); - } - public static ColorByte operator +(byte a, ColorByte b) - { - return new ColorByte(a + b.r, a + b.g, a + b.b, a + b.a); - } - public static ColorByte operator -(ColorByte a, ColorByte b) - { - return new ColorByte(a.r - b.r, a.g - b.g, a.b - b.b, a.a - b.a); - } - public static ColorByte operator -(ColorByte a, byte b) - { - return new ColorByte(a.r - b, a.g - b, a.b - b, a.a - b); - } - public static ColorByte operator -(byte a, ColorByte b) - { - return new ColorByte(a - b.r, a - b.g, a - b.b, a - b.a); - } - public static ColorByte operator *(ColorByte a, ColorByte b) - { - return new ColorByte(a.r * b.r, a.g * b.g, a.b * b.b, a.a * b.a); - } - public static ColorByte operator *(ColorByte a, byte b) - { - return new ColorByte(a.r * b, a.g * b, a.b * b, a.a * b); - } - public static ColorByte operator *(byte a, ColorByte b) - { - return new ColorByte(a * b.r, a * b.g, a * b.b, a * b.a); - } - public static ColorByte operator /(ColorByte a, ColorByte b) - { - return new ColorByte(a.r / b.r, a.g / b.g, a.b / b.b, a.a / b.a); - } - public static ColorByte operator /(ColorByte a, byte b) - { - return new ColorByte(a.r / b, a.g / b, a.b / b, a.a / b); - } - public static ColorByte operator /(byte a, ColorByte b) - { - return new ColorByte(a / b.r, a / b.g, a / b.b, a / b.a); - } - public static bool operator ==(ColorByte a, ColorByte b) - { - return a.Equals(b); - } - public static bool operator !=(ColorByte a, ColorByte b) - { - return !a.Equals(b); - } + public static ColorByte operator +(ColorByte a, ColorByte b) => new(a.r + b.r, a.g + b.g, a.b + b.b, a.a + b.a); + public static ColorByte operator +(ColorByte a, byte b) => new(a.r + b, a.g + b, a.b + b, a.a + b); + public static ColorByte operator +(byte a, ColorByte b) => new(a + b.r, a + b.g, a + b.b, a + b.a); + public static ColorByte operator -(ColorByte a, ColorByte b) => new(a.r - b.r, a.g - b.g, a.b - b.b, a.a - b.a); + public static ColorByte operator -(ColorByte a, byte b) => new(a.r - b, a.g - b, a.b - b, a.a - b); + public static ColorByte operator -(byte a, ColorByte b) => new(a - b.r, a - b.g, a - b.b, a - b.a); + public static ColorByte operator *(ColorByte a, ColorByte b) => new(a.r * b.r, a.g * b.g, a.b * b.b, a.a * b.a); + public static ColorByte operator *(ColorByte a, byte b) => new(a.r * b, a.g * b, a.b * b, a.a * b); + public static ColorByte operator *(byte a, ColorByte b) => new(a * b.r, a * b.g, a * b.b, a * b.a); + public static ColorByte operator /(ColorByte a, ColorByte b) => new(a.r / b.r, a.g / b.g, a.b / b.b, a.a / b.a); + public static ColorByte operator /(ColorByte a, byte b) => new(a.r / b, a.g / b, a.b / b, a.a / b); + public static ColorByte operator /(byte a, ColorByte b) => new(a / b.r, a / b.g, a / b.b, a / b.a); + public static bool operator ==(ColorByte a, ColorByte b) => a.Equals(b); + public static bool operator !=(ColorByte a, ColorByte b) => !a.Equals(b); - public static explicit operator ColorByte(Color input) - { - return new ColorByte((byte)(input.r * 255), (byte)(input.g * 255), (byte)(input.b * 255), (byte)(input.a * 255)); - } + public static explicit operator ColorByte(Color input) => new((byte)(input.r * 255), (byte)(input.g * 255), (byte)(input.b * 255), (byte)(input.a * 255)); } public static class Math @@ -964,20 +424,14 @@ namespace Nerd_STF.Mathematics public static float Add(params float[] input) { float returned = 0; - foreach (float f in input) - { - returned += f; - } + foreach (float f in input) returned += f; return returned; } public static float Average(params float[] input) { float returned = 0; - foreach (float f in input) - { - returned += f; - } + foreach (float f in input) returned += f; returned /= input.Length; return returned; } @@ -1005,50 +459,35 @@ namespace Nerd_STF.Mathematics public static float Divide(params float[] input) { float returned = input[0]; - for (uint i = 1; i < input.Length; i++) - { - returned /= input[i]; - } + for (uint i = 1; i < input.Length; i++) returned /= input[i]; return returned; } public static float Max(params float[] input) { - float returned = input[1]; - for (uint i = 0; i < input.Length; i++) - { - if (input[i] > returned) returned = input[1]; - } + float returned = input[0]; + for (uint i = 0; i < input.Length; i++) if (input[i] > returned) returned = input[i]; return returned; } public static float Min(params float[] input) { - float returned = input[1]; - for (uint i = 0; i < input.Length; i++) - { - if (input[i] < returned) returned = input[1]; - } + float returned = input[0]; + for (uint i = 0; i < input.Length; i++) if (input[i] < returned) returned = input[0]; return returned; } public static float Multiply(params float[] input) { float returned = 1; - foreach (float f in input) - { - returned *= f; - } + foreach (float f in input) returned *= f; return returned; } public static float Power(float input, int power) { float returned = 1; - for (uint i = 0; i < Absolute(power); i++) - { - returned *= input; - } + for (uint i = 0; i < Absolute(power); i++) returned *= input; if (power < 0) returned = 1 / returned; return returned; } @@ -1060,62 +499,33 @@ namespace Nerd_STF.Mathematics return value; } - public static float Round(float value, float dividend) - { - return Round(value / dividend) * dividend; - } - public static int RoundToInt(float value) - { - return (int)Round(value); - } + public static float Round(float value, float dividend) => Round(value / dividend) * dividend; + public static int RoundToInt(float value) => (int)Round(value); public static float Subtract(params float[] input) { float returned = input[0]; - for (uint i = 1; i < input.Length; i++) - { - returned -= input[i]; - } + for (uint i = 1; i < input.Length; i++) returned -= input[i]; return returned; } public static class Formulas { - public static float CircleArea(float radius) - { - return Pi * radius * radius; - } - public static float CircleCircum(float radius) - { - return 2 * radius * Pi; - } - public static float CircleDiam(float radius) - { - return radius * 2; - } - public static float CircleRadius(float circumference) - { - return circumference / Pi / 2; - } + public static float CircleArea(float radius) => Pi * radius * radius; + public static float CircleCircum(float radius) => 2 * radius * Pi; + public static float CircleDiam(float radius) => radius * 2; + public static float CircleRadius(float circumference) => circumference / Pi / 2; - public static float Perimeter(params float[] sideLengths) - { - return Add(sideLengths); - } + public static float Perimeter(params float[] sideLengths) => Add(sideLengths); - public static float RectangleArea(float length, float width) - { - return length * width; - } + public static float RectangleArea(float length, float width) => length * width; - public static float SquareArea(float length) - { - return RectangleArea(length, length); - } + public static float SquareArea(float length) => RectangleArea(length, length); } } - public struct Percent : INegatives + [Serializable] + public struct Percent : IMathFunctions, INegatives { public float value; @@ -1123,39 +533,15 @@ namespace Nerd_STF.Mathematics { get { - Percent returned = new (value); + Percent returned = new(value); if (returned < 0) returned *= -1; return returned; } } - public bool IsFull - { - get - { - return value == 100; - } - } - public bool IsNegative - { - get - { - return value < 0; - } - } - public bool IsOverflow - { - get - { - return value > 100; - } - } - public bool IsZero - { - get - { - return value == 0; - } - } + public bool IsFull { get => value == 100; } + public bool IsNegative { get => value < 0; } + public bool IsOverflow { get => value > 100; } + public bool IsZero { get => value == 0; } public Percent Negative { get @@ -1165,260 +551,90 @@ namespace Nerd_STF.Mathematics return returned; } } - public Percent Positive - { - get - { - return Absolute; - } - } + public Percent Positive { get => Absolute; } - public static Percent Full - { - get - { - return new Percent(100); - } - } - public static Percent One - { - get - { - return new Percent(1); - } - } - public static Percent Zero - { - get - { - return new Percent(0); - } - } + public static Percent Full { get => new(100); } + public static Percent One { get => new(1); } + public static Percent Zero { get => new(0); } - public Percent(float value) - { - this = new Percent(value, 0, 100); - } - public Percent(float value, float maxValue) - { - this = new Percent(value, 0, maxValue); - } - public Percent(float value, float minValue, float maxValue) - { - this.value = value / (maxValue - minValue); - } + public Percent(float value) => this = new(value, 0, 100); + public Percent(float value, float maxValue) => this = new(value, 0, maxValue); + public Percent(float value, float minValue, float maxValue) => this.value = value / (maxValue - minValue); - public static Percent Average(params Percent[] input) + public Percent Average(params Percent[] objs) { - float[] average = new float[input.Length]; - for (int i = 0; i < input.Length; i++) - { - average[i] = input[i].value; - } + float[] average = new float[objs.Length + 1]; + for (int i = 0; i < objs.Length; i++) average[i] = objs[i].value; + average[objs.Length] = value; return new(Math.Average(average)); } - public static Percent Max(params Percent[] input) + public Percent Max(params Percent[] objs) { - float[] max = new float[input.Length]; - for (int i = 0; i < input.Length; i++) - { - max[i] = input[i].value; - } + float[] max = new float[objs.Length]; + for (int i = 0; i < objs.Length; i++) max[i] = objs[i].value; + max[objs.Length] = value; return new(Math.Max(max)); } - public static Percent Min(params Percent[] input) + public Percent Min(params Percent[] objs) { - float[] min = new float[input.Length]; - for (int i = 0; i < input.Length; i++) - { - min[i] = input[i].value; - } + float[] min = new float[objs.Length]; + for (int i = 0; i < objs.Length; i++) min[i] = objs[i].value; + min[objs.Length] = value; return new(Math.Min(min)); } - public override bool Equals(object obj) - { - return base.Equals(obj); - } - public bool Equals(float other) - { - return value == other || value == (other / 100); - } - public bool Equals(Percent other) - { - return value == other.value; - } - public override int GetHashCode() - { - return base.GetHashCode(); - } - public override string ToString() - { - return value.ToString() + "%"; - } - public string ToString(string format) - { - return value.ToString(format) + "%"; - } + public override bool Equals(object obj) => base.Equals(obj); + public bool Equals(float other) => value == other || value == (other / 100); + public bool Equals(Percent other) => value == other.value; + public override int GetHashCode() => base.GetHashCode(); + public override string ToString() => value.ToString() + "%"; + public string ToString(string format) => value.ToString(format) + "%"; - public static Percent operator +(Percent a, Percent b) - { - return new Percent { value = a.value + b.value }; - } - public static Percent operator +(Percent a, float b) - { - return new Percent { value = a.value + (b / 100) }; - } - public static Percent operator +(float a, Percent b) - { - return new Percent { value = (a / 100) + b.value }; - } - public static Percent operator -(Percent a, Percent b) - { - return new Percent { value = a.value - b.value }; - } - public static Percent operator -(Percent a, float b) - { - return new Percent { value = a.value - (b / 100) }; - } - public static Percent operator -(float a, Percent b) - { - return new Percent { value = (a / 100) + b.value }; - } - public static Percent operator *(Percent a, Percent b) - { - return new Percent { value = a.value * b.value }; - } - public static Percent operator *(Percent a, float b) - { - return new Percent { value = a.value * (b / 100) }; - } - public static Percent operator *(float a, Percent b) - { - return new Percent { value = (a / 100) + b.value }; - } - public static Percent operator /(Percent a, Percent b) - { - return new Percent { value = a.value / b.value }; - } - public static Percent operator /(Percent a, float b) - { - return new Percent { value = a.value / b / 100 }; - } - public static Percent operator /(float a, Percent b) - { - return new Percent { value = (a / 100) + b.value }; - } - public static bool operator ==(Percent a, Percent b) - { - return a.Equals(b); - } - public static bool operator ==(Percent a, float b) - { - return a.Equals(b); - } - public static bool operator ==(float a, Percent b) - { - return b.Equals(a); - } - public static bool operator !=(Percent a, Percent b) - { - return !a.Equals(b); - } - public static bool operator !=(Percent a, float b) - { - return !a.Equals(b); - } - public static bool operator !=(float a, Percent b) - { - return !b.Equals(a); - } - public static bool operator >(Percent a, Percent b) - { - return a.value > b.value; - } - public static bool operator >(Percent a, float b) - { - return a.value > b; - } - public static bool operator >(float a, Percent b) - { - return a > b.value; - } - public static bool operator <(Percent a, Percent b) - { - return a.value < b.value; - } - public static bool operator <(Percent a, float b) - { - return a.value < b; - } - public static bool operator <(float a, Percent b) - { - return a < b.value; - } - public static bool operator >=(Percent a, Percent b) - { - return a.value > b.value || a.Equals(b); - } - public static bool operator >=(Percent a, float b) - { - return a.value > b || a.Equals(b); - } - public static bool operator >=(float a, Percent b) - { - return a > b.value || b.Equals(a); - } - public static bool operator <=(Percent a, Percent b) - { - return a.value < b.value || a.Equals(b); - } - public static bool operator <=(Percent a, float b) - { - return a.value < b || a.Equals(b); - } - public static bool operator <=(float a, Percent b) - { - return a < b.value || b.Equals(a); - } + public static Percent operator +(Percent a, Percent b) => new() { value = a.value + b.value }; + public static Percent operator +(Percent a, float b) => new() { value = a.value + (b / 100) }; + public static Percent operator +(float a, Percent b) => new() { value = (a / 100) + b.value }; + public static Percent operator -(Percent a, Percent b) => new() { value = a.value - b.value }; + public static Percent operator -(Percent a, float b) => new() { value = a.value - (b / 100) }; + public static Percent operator -(float a, Percent b) => new() { value = (a / 100) + b.value }; + public static Percent operator *(Percent a, Percent b) => new() { value = a.value * b.value }; + public static Percent operator *(Percent a, float b) => new() { value = a.value * (b / 100) }; + public static Percent operator *(float a, Percent b) => new() { value = (a / 100) + b.value }; + public static Percent operator /(Percent a, Percent b) => new() { value = a.value / b.value }; + public static Percent operator /(Percent a, float b) => new() { value = a.value / b / 100 }; + public static Percent operator /(float a, Percent b) => new() { value = (a / 100) + b.value }; + public static bool operator ==(Percent a, Percent b) => a.Equals(b); + public static bool operator ==(Percent a, float b) => a.Equals(b); + public static bool operator ==(float a, Percent b) => b.Equals(a); + public static bool operator !=(Percent a, Percent b) => !a.Equals(b); + public static bool operator !=(Percent a, float b) => !a.Equals(b); + public static bool operator !=(float a, Percent b) => !b.Equals(a); + public static bool operator >(Percent a, Percent b) => a.value > b.value; + public static bool operator >(Percent a, float b) => a.value > b; + public static bool operator >(float a, Percent b) => a > b.value; + public static bool operator <(Percent a, Percent b) => a.value < b.value; + public static bool operator <(Percent a, float b) => a.value < b; + public static bool operator <(float a, Percent b) => a < b.value; + public static bool operator >=(Percent a, Percent b) => a.value > b.value || a.Equals(b); + public static bool operator >=(Percent a, float b) => a.value > b || a.Equals(b); + public static bool operator >=(float a, Percent b) => a > b.value || b.Equals(a); + public static bool operator <=(Percent a, Percent b) => a.value < b.value || a.Equals(b); + public static bool operator <=(Percent a, float b) => a.value < b || a.Equals(b); + public static bool operator <=(float a, Percent b) => a < b.value || b.Equals(a); - public static explicit operator float(Percent input) - { - return input.value; - } - public static explicit operator Percent(float input) - { - return new Percent(input); - } + public static explicit operator float(Percent input) => input.value; + public static explicit operator Percent(float input) => new(input); } - public struct Vector + [Serializable] + public struct Vector : IMathFunctions { public Angle direction; public float strength; - public Vector Inverse - { - get - { - return new(direction.value - 180, -strength); - } - } - public Vector Reflected - { - get - { - return new(360 - direction, strength); - } - } + public Vector Inverse { get => new(direction.value - 180, -strength); } + public Vector Reflected { get => new(360 - direction, strength); } - public static Vector Zero - { - get - { - return new Vector(0, 0); - } - } + public static Vector Zero { get => new(0, 0); } public Vector(Angle direction, float strength, bool clampDir = true) { @@ -1426,313 +642,159 @@ namespace Nerd_STF.Mathematics this.direction = direction; this.strength = strength; } - public Vector(float direction, float strength, bool clampDir = true) - { - this = new Vector(new Angle(direction), strength, clampDir); - } + public Vector(float direction, float strength, bool clampDir = true) => this = new Vector(new Angle(direction), strength, clampDir); - public static Vector Average(params Vector[] input) + public Vector Average(params Vector[] objs) { - float[] averageD = new float[input.Length]; - float[] averageS = new float[input.Length]; - for (int i = 0; i < input.Length; i++) + float[] averageD = new float[objs.Length + 1]; + float[] averageS = new float[objs.Length + 1]; + for (int i = 0; i < objs.Length; i++) { - averageD[i] = input[i].direction.Clamped.value; - averageS[i] = input[i].strength; + averageD[i] = objs[i].direction.Clamped.value; + averageS[i] = objs[i].strength; } + averageD[objs.Length] = direction.Clamped.value; + averageS[objs.Length] = strength; return new(Math.Average(averageD), Math.Average(averageS)); } - public static Vector Max(params Vector[] input) + public Vector Max(params Vector[] objs) { - float[] maxD = new float[input.Length]; - float[] maxS = new float[input.Length]; - for (int i = 0; i < input.Length; i++) + float[] maxD = new float[objs.Length + 1]; + float[] maxS = new float[objs.Length + 1]; + for (int i = 0; i < objs.Length; i++) { - maxD[i] = input[i].direction.Clamped.value; - maxS[i] = input[i].strength; + maxD[i] = objs[i].direction.Clamped.value; + maxS[i] = objs[i].strength; } + maxD[objs.Length] = direction.Clamped.value; + maxS[objs.Length] = strength; return new(Math.Max(maxD), Math.Max(maxS)); } - public static Vector Min(params Vector[] input) + public Vector Min(params Vector[] objs) { - float[] minD = new float[input.Length]; - float[] minS = new float[input.Length]; - for (int i = 0; i < input.Length; i++) + float[] minD = new float[objs.Length + 1]; + float[] minS = new float[objs.Length + 1]; + for (int i = 0; i < objs.Length; i++) { - minD[i] = input[i].direction.Clamped.value; - minS[i] = input[i].strength; + minD[i] = objs[i].direction.Clamped.value; + minS[i] = objs[i].strength; } + minD[objs.Length] = direction.Clamped.value; + minS[objs.Length] = strength; return new(Math.Min(minD), Math.Min(minS)); } - public override bool Equals(object obj) - { - return base.Equals(obj); - } - public bool Equals(Vector other) - { - return direction == other.direction && strength == other.strength; - } - public override int GetHashCode() - { - return base.GetHashCode(); - } - public override string ToString() - { - return "D: " + direction.ToString() + " | S: " + strength.ToString(); - } - public string ToString(string format) - { - return "D: " + direction.ToString(format) + " | S: " + strength.ToString(format); - } + public override bool Equals(object obj) => base.Equals(obj); + public bool Equals(Vector other) => direction == other.direction && strength == other.strength; + public override int GetHashCode() => base.GetHashCode(); + public override string ToString() => "D: " + direction.ToString() + " | S: " + strength.ToString(); + public string ToString(string format) => "D: " + direction.ToString(format) + " | S: " + strength.ToString(format); - public static Vector operator +(Vector a, Vector b) - { - return new Vector(a.direction + b.direction, a.strength + b.strength, false); - } - public static Vector operator -(Vector a, Vector b) - { - return new Vector(a.direction - b.direction, a.strength - b.strength, false); - } - public static Vector operator *(Vector a, Vector b) - { - return new Vector(a.direction * b.direction, a.strength * b.strength, false); - } - public static Vector operator /(Vector a, Vector b) - { - return new Vector(a.direction / b.direction, a.strength / b.strength, false); - } - public static bool operator ==(Vector a, Vector b) - { - return a.Equals(b); - } - public static bool operator !=(Vector a, Vector b) - { - return !a.Equals(b); - } + public static Vector operator +(Vector a, Vector b) => new(a.direction + b.direction, a.strength + b.strength, false); + public static Vector operator -(Vector a, Vector b) => new(a.direction - b.direction, a.strength - b.strength, false); + public static Vector operator *(Vector a, Vector b) => new(a.direction * b.direction, a.strength * b.strength, false); + public static Vector operator /(Vector a, Vector b) => new(a.direction / b.direction, a.strength / b.strength, false); + public static bool operator ==(Vector a, Vector b) => a.Equals(b); + public static bool operator !=(Vector a, Vector b) => !a.Equals(b); } - public struct Vector2 + [Serializable] + public struct Vector2 : IMathFunctions { public float x, y; - public static Vector2 NegativeInfinity - { - get - { - return new Vector2(float.NegativeInfinity, float.NegativeInfinity); - } - } - public static Vector2 One - { - get - { - return new Vector2(1, 1); - } - } - public static Vector2 PositiveInfinity - { - get - { - return new Vector2(float.PositiveInfinity, float.PositiveInfinity); - } - } - public static Vector2 Zero - { - get - { - return new Vector2(0, 0); - } - } + public static Vector2 NegativeInfinity { get => new(float.NegativeInfinity, float.NegativeInfinity); } + public static Vector2 One { get => new(1, 1); } + public static Vector2 PositiveInfinity { get => new(float.PositiveInfinity, float.PositiveInfinity); } + public static Vector2 Zero { get => new(0, 0); } - public Vector2(float x) - { - this = new Vector2(x, 0); - } + public Vector2(float x) => this = new Vector2(x, 0); public Vector2(float x, float y) { this.x = x; this.y = y; } - public static Vector2 Average(params Vector2[] input) + public Vector2 Average(params Vector2[] objs) { - float[] averageX = new float[input.Length]; - float[] averageY = new float[input.Length]; - for (int i = 0; i < input.Length; i++) + float[] averageX = new float[objs.Length + 1]; + float[] averageY = new float[objs.Length + 1]; + for (int i = 0; i < objs.Length; i++) { - averageX[i] = input[i].x; - averageY[i] = input[i].y; + averageX[i] = objs[i].x; + averageY[i] = objs[i].y; } + averageX[objs.Length] = x; + averageY[objs.Length] = y; return new(Math.Average(averageX), Math.Average(averageY)); } - public static Vector2 Max(params Vector2[] input) + public Vector2 Max(params Vector2[] objs) { - float[] maxX = new float[input.Length]; - float[] maxY = new float[input.Length]; - for (int i = 0; i < input.Length; i++) + float[] maxX = new float[objs.Length + 1]; + float[] maxY = new float[objs.Length + 1]; + for (int i = 0; i < objs.Length; i++) { - maxX[i] = input[i].x; - maxY[i] = input[i].y; + maxX[i] = objs[i].x; + maxY[i] = objs[i].y; } + maxX[objs.Length] = x; + maxY[objs.Length] = y; return new(Math.Max(maxX), Math.Max(maxY)); } - public static Vector2 Min(params Vector2[] input) + public Vector2 Min(params Vector2[] objs) { - float[] minX = new float[input.Length]; - float[] minY = new float[input.Length]; - for (int i = 0; i < input.Length; i++) + float[] minX = new float[objs.Length + 1]; + float[] minY = new float[objs.Length + 1]; + for (int i = 0; i < objs.Length; i++) { - minX[i] = input[i].x; - minY[i] = input[i].y; + minX[i] = objs[i].x; + minY[i] = objs[i].y; } + minX[objs.Length] = x; + minY[objs.Length] = y; return new(Math.Min(minX), Math.Min(minY)); } - public override bool Equals(object obj) - { - return base.Equals(obj); - } - public bool Equals(Vector2 other) - { - return x == other.x && y == other.y; - } - public override int GetHashCode() - { - return base.GetHashCode(); - } - public override string ToString() - { - return "X: " + x.ToString() + " | Y: " + y.ToString(); - } - public string ToString(string format) - { - return "X: " + x.ToString(format) + " | Y: " + y.ToString(format); - } + public override bool Equals(object obj) => base.Equals(obj); + public bool Equals(Vector2 other) => x == other.x && y == other.y; + public override int GetHashCode() => base.GetHashCode(); + public override string ToString() => "X: " + x.ToString() + " | Y: " + y.ToString(); + public string ToString(string format) => "X: " + x.ToString(format) + " | Y: " + y.ToString(format); - public static Vector2 operator +(Vector2 a, Vector2 b) - { - return new Vector2(a.x + b.x, a.y + b.y); - } - public static Vector2 operator +(Vector2 a, float b) - { - return new Vector2(a.x + b, a.y + b); - } - public static Vector2 operator +(float a, Vector2 b) - { - return new Vector2(a + b.x, a + b.y); - } - public static Vector2 operator -(Vector2 a, Vector2 b) - { - return new Vector2(a.x - b.x, a.y - b.y); - } - public static Vector2 operator -(Vector2 a, float b) - { - return new Vector2(a.x - b, a.y - b); - } - public static Vector2 operator -(float a, Vector2 b) - { - return new Vector2(a - b.x, a - b.y); - } - public static Vector2 operator *(Vector2 a, Vector2 b) - { - return new Vector2(a.x * b.x, a.y * b.y); - } - public static Vector2 operator *(Vector2 a, float b) - { - return new Vector2(a.x * b, a.y * b); - } - public static Vector2 operator *(float a, Vector2 b) - { - return new Vector2(a * b.x, a * b.y); - } - public static Vector2 operator /(Vector2 a, Vector2 b) - { - return new Vector2(a.x / b.x, a.y / b.y); - } - public static Vector2 operator /(Vector2 a, float b) - { - return new Vector2(a.x / b, a.y / b); - } - public static Vector2 operator /(float a, Vector2 b) - { - return new Vector2(a / b.x, a / b.y); - } - public static bool operator ==(Vector2 a, Vector2 b) - { - return a.Equals(b); - } - public static bool operator !=(Vector2 a, Vector2 b) - { - return !a.Equals(b); - } - public static bool operator >(Vector2 a, Vector2 b) - { - return a.x > b.x && a.y > b.y; - } - public static bool operator <(Vector2 a, Vector2 b) - { - return a.x < b.x && a.y < b.y; - } - public static bool operator >=(Vector2 a, Vector2 b) - { - return (a.x > b.x && a.y > b.y) || a.Equals(b); - } - public static bool operator <=(Vector2 a, Vector2 b) - { - return (a.x < b.x && a.y < b.y) || a.Equals(b); - } + public static Vector2 operator +(Vector2 a, Vector2 b) => new(a.x + b.x, a.y + b.y); + public static Vector2 operator +(Vector2 a, float b) => new(a.x + b, a.y + b); + public static Vector2 operator +(float a, Vector2 b) => new(a + b.x, a + b.y); + public static Vector2 operator -(Vector2 a, Vector2 b) => new(a.x - b.x, a.y - b.y); + public static Vector2 operator -(Vector2 a, float b) => new(a.x - b, a.y - b); + public static Vector2 operator -(float a, Vector2 b) => new(a - b.x, a - b.y); + public static Vector2 operator *(Vector2 a, Vector2 b) => new(a.x * b.x, a.y * b.y); + public static Vector2 operator *(Vector2 a, float b) => new(a.x * b, a.y * b); + public static Vector2 operator *(float a, Vector2 b) => new(a * b.x, a * b.y); + public static Vector2 operator /(Vector2 a, Vector2 b) => new(a.x / b.x, a.y / b.y); + public static Vector2 operator /(Vector2 a, float b) => new(a.x / b, a.y / b); + public static Vector2 operator /(float a, Vector2 b) => new(a / b.x, a / b.y); + public static bool operator ==(Vector2 a, Vector2 b) => a.Equals(b); + public static bool operator !=(Vector2 a, Vector2 b) => !a.Equals(b); + public static bool operator >(Vector2 a, Vector2 b) => a.x > b.x && a.y > b.y; + public static bool operator <(Vector2 a, Vector2 b) => a.x < b.x && a.y < b.y; + public static bool operator >=(Vector2 a, Vector2 b) => (a.x > b.x && a.y > b.y) || a.Equals(b); + public static bool operator <=(Vector2 a, Vector2 b) => (a.x < b.x && a.y < b.y) || a.Equals(b); - public static explicit operator Vector2(Vector3 input) - { - return new Vector2(input.x, input.y); - } - public static explicit operator Vector2(Vector4 input) - { - return new Vector2(input.x, input.y); - } + public static explicit operator Vector2(Vector3 input) => new(input.x, input.y); + public static explicit operator Vector2(Vector4 input) => new(input.x, input.y); } - public struct Vector3 + [Serializable] + public struct Vector3 : IMathFunctions { public float x, y, z; - public static Vector3 NegativeInfinity - { - get - { - return new Vector3(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity); - } - } - public static Vector3 One - { - get - { - return new Vector3(1, 1, 1); - } - } - public static Vector3 PositiveInfinity - { - get - { - return new Vector3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity); - } - } - public static Vector3 Zero - { - get - { - return new Vector3(0, 0, 0); - } - } + public static Vector3 NegativeInfinity { get => new(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity); } + public static Vector3 One { get => new(1, 1, 1); } + public static Vector3 PositiveInfinity { get => new(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity); } + public static Vector3 Zero { get => new(0, 0, 0); } - public Vector3(float x) - { - this = new Vector3(x, 0, 0); - } - public Vector3(float x, float y) - { - this = new Vector3(x, y, 0); - } + public Vector3(float x) => this = new(x, 0, 0); + public Vector3(float x, float y) => this = new(x, y, 0); public Vector3(float x, float y, float z) { this.x = x; @@ -1740,198 +802,97 @@ namespace Nerd_STF.Mathematics this.z = z; } - public static Vector3 Average(params Vector3[] input) + public Vector3 Average(params Vector3[] objs) { - float[] averageX = new float[input.Length]; - float[] averageY = new float[input.Length]; - float[] averageZ = new float[input.Length]; - for (int i = 0; i < input.Length; i++) + float[] averageX = new float[objs.Length + 1]; + float[] averageY = new float[objs.Length + 1]; + float[] averageZ = new float[objs.Length + 1]; + for (int i = 0; i < objs.Length; i++) { - averageX[i] = input[i].x; - averageY[i] = input[i].y; - averageZ[i] = input[i].z; + averageX[i] = objs[i].x; + averageY[i] = objs[i].y; + averageZ[i] = objs[i].z; } + averageX[objs.Length] = x; + averageY[objs.Length] = y; + averageZ[objs.Length] = z; return new(Math.Average(averageX), Math.Average(averageY), Math.Average(averageZ)); } - public static Vector3 Max(params Vector3[] input) + public Vector3 Max(params Vector3[] objs) { - float[] maxX = new float[input.Length]; - float[] maxY = new float[input.Length]; - float[] maxZ = new float[input.Length]; - for (int i = 0; i < input.Length; i++) + float[] maxX = new float[objs.Length + 1]; + float[] maxY = new float[objs.Length + 1]; + float[] maxZ = new float[objs.Length + 1]; + for (int i = 0; i < objs.Length; i++) { - maxX[i] = input[i].x; - maxY[i] = input[i].y; - maxZ[i] = input[i].z; + maxX[i] = objs[i].x; + maxY[i] = objs[i].y; + maxZ[i] = objs[i].z; } + maxX[objs.Length] = x; + maxY[objs.Length] = y; + maxZ[objs.Length] = z; return new(Math.Max(maxX), Math.Max(maxY), Math.Max(maxZ)); } - public static Vector3 Min(params Vector3[] input) + public Vector3 Min(params Vector3[] objs) { - float[] minX = new float[input.Length]; - float[] minY = new float[input.Length]; - float[] minZ = new float[input.Length]; - for (int i = 0; i < input.Length; i++) + float[] minX = new float[objs.Length + 1]; + float[] minY = new float[objs.Length + 1]; + float[] minZ = new float[objs.Length + 1]; + for (int i = 0; i < objs.Length; i++) { - minX[i] = input[i].x; - minY[i] = input[i].y; - minZ[i] = input[i].z; + minX[i] = objs[i].x; + minY[i] = objs[i].y; + minZ[i] = objs[i].z; } + minX[objs.Length] = x; + minY[objs.Length] = y; + minZ[objs.Length] = z; return new(Math.Min(minX), Math.Min(minY), Math.Min(minZ)); } - public override bool Equals(object obj) - { - return base.Equals(obj); - } - public bool Equals(Vector3 other) - { - return x == other.x && y == other.y && z == other.z; - } - public override int GetHashCode() - { - return base.GetHashCode(); - } - public override string ToString() - { - return "X: " + x.ToString() + " | Y: " + y.ToString() + " | Z:" + z.ToString(); - } - public string ToString(string format) - { - return "X: " + x.ToString(format) + " | Y: " + y.ToString(format) + " | Z:" + z.ToString(format); - } + public override bool Equals(object obj) => base.Equals(obj); + public bool Equals(Vector3 other) => x == other.x && y == other.y && z == other.z; + public override int GetHashCode() => base.GetHashCode(); + public override string ToString() => "X: " + x.ToString() + " | Y: " + y.ToString() + " | Z:" + z.ToString(); + public string ToString(string format) => "X: " + x.ToString(format) + " | Y: " + y.ToString(format) + " | Z:" + z.ToString(format); - public static Vector3 operator +(Vector3 a, Vector3 b) - { - return new Vector3(a.x + b.x, a.y + b.y, a.z + b.z); - } - public static Vector3 operator +(Vector3 a, float b) - { - return new Vector3(a.x + b, a.y + b, a.z + b); - } - public static Vector3 operator +(float a, Vector3 b) - { - return new Vector3(a + b.x, a + b.y, a + b.z); - } - public static Vector3 operator -(Vector3 a, Vector3 b) - { - return new Vector3(a.x - b.x, a.y - b.y, a.z - b.z); - } - public static Vector3 operator -(Vector3 a, float b) - { - return new Vector3(a.x - b, a.y - b, a.z - b); - } - public static Vector3 operator -(float a, Vector3 b) - { - return new Vector3(a - b.x, a - b.y, a - b.z); - } - public static Vector3 operator *(Vector3 a, Vector3 b) - { - return new Vector3(a.x * b.x, a.y * b.y, a.z * b.z); - } - public static Vector3 operator *(Vector3 a, float b) - { - return new Vector3(a.x * b, a.y * b, a.z * b); - } - public static Vector3 operator *(float a, Vector3 b) - { - return new Vector3(a * b.x, a * b.y, a * b.z); - } - public static Vector3 operator /(Vector3 a, Vector3 b) - { - return new Vector3(a.x / b.x, a.y / b.y, a.z / b.z); - } - public static Vector3 operator /(Vector3 a, float b) - { - return new Vector3(a.x / b, a.y / b, a.z / b); - } - public static Vector3 operator /(float a, Vector3 b) - { - return new Vector3(a / b.x, a / b.y, a / b.z); - } - public static bool operator ==(Vector3 a, Vector3 b) - { - return a.Equals(b); - } - public static bool operator !=(Vector3 a, Vector3 b) - { - return !a.Equals(b); - } - public static bool operator >(Vector3 a, Vector3 b) - { - return a.x > b.x && a.y > b.y && a.z > b.z; - } - public static bool operator <(Vector3 a, Vector3 b) - { - return a.x < b.x && a.y < b.y && a.z < b.z; - } - public static bool operator >=(Vector3 a, Vector3 b) - { - return (a.x > b.x && a.y > b.y && a.z > b.z) || a.Equals(b); - } - public static bool operator <=(Vector3 a, Vector3 b) - { - return (a.x < b.x && a.y < b.y && a.z < b.z) || a.Equals(b); - } + public static Vector3 operator +(Vector3 a, Vector3 b) => new(a.x + b.x, a.y + b.y, a.z + b.z); + public static Vector3 operator +(Vector3 a, float b) => new(a.x + b, a.y + b, a.z + b); + public static Vector3 operator +(float a, Vector3 b) => new(a + b.x, a + b.y, a + b.z); + public static Vector3 operator -(Vector3 a, Vector3 b) => new(a.x - b.x, a.y - b.y, a.z - b.z); + public static Vector3 operator -(Vector3 a, float b) => new(a.x - b, a.y - b, a.z - b); + public static Vector3 operator -(float a, Vector3 b) => new(a - b.x, a - b.y, a - b.z); + public static Vector3 operator *(Vector3 a, Vector3 b) => new(a.x * b.x, a.y * b.y, a.z * b.z); + public static Vector3 operator *(Vector3 a, float b) => new(a.x * b, a.y * b, a.z * b); + public static Vector3 operator *(float a, Vector3 b) => new(a * b.x, a * b.y, a * b.z); + public static Vector3 operator /(Vector3 a, Vector3 b) => new(a.x / b.x, a.y / b.y, a.z / b.z); + public static Vector3 operator /(Vector3 a, float b) => new(a.x / b, a.y / b, a.z / b); + public static Vector3 operator /(float a, Vector3 b) => new(a / b.x, a / b.y, a / b.z); + public static bool operator ==(Vector3 a, Vector3 b) => a.Equals(b); + public static bool operator !=(Vector3 a, Vector3 b) => !a.Equals(b); + public static bool operator >(Vector3 a, Vector3 b) => a.x > b.x && a.y > b.y && a.z > b.z; + public static bool operator <(Vector3 a, Vector3 b) => a.x < b.x && a.y < b.y && a.z < b.z; + public static bool operator >=(Vector3 a, Vector3 b) => (a.x > b.x && a.y > b.y && a.z > b.z) || a.Equals(b); + public static bool operator <=(Vector3 a, Vector3 b) => (a.x < b.x && a.y < b.y && a.z < b.z) || a.Equals(b); - public static implicit operator Vector3(Color input) - { - return new Vector3(input.r, input.g, input.b); - } - public static implicit operator Vector3(Vector2 input) - { - return new Vector3(input.x, input.y); - } - public static explicit operator Vector3(Vector4 input) - { - return new Vector3(input.x, input.y, input.z); - } + public static implicit operator Vector3(Color input) => new(input.r, input.g, input.b); + public static implicit operator Vector3(Vector2 input) => new(input.x, input.y); + public static explicit operator Vector3(Vector4 input) => new(input.x, input.y, input.z); } - public struct Vector4 + [Serializable] + public struct Vector4 : IMathFunctions { public float x, y, z, w; - public static Vector4 NegativeInfinity - { - get - { - return new Vector4(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity); - } - } - public static Vector4 One - { - get - { - return new Vector4(1, 1, 1, 1); - } - } - public static Vector4 PositiveInfinity - { - get - { - return new Vector4(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity); - } - } - public static Vector4 Zero - { - get - { - return new Vector4(0, 0, 0, 0); - } - } + public static Vector4 NegativeInfinity { get => new(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity); } + public static Vector4 One { get => new(1, 1, 1, 1); } + public static Vector4 PositiveInfinity { get => new(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity); } + public static Vector4 Zero { get => new(0, 0, 0, 0); } - public Vector4(float x) - { - this = new Vector4(x, 0, 0, 0); - } - public Vector4(float x, float y) - { - this = new Vector4(x, y, 0, 0); - } - public Vector4(float x, float y, float z) - { - this = new Vector4(x, y, z, 0); - } + public Vector4(float x) => this = new(x, 0, 0, 0); + public Vector4(float x, float y) => this = new(x, y, 0, 0); + public Vector4(float x, float y, float z) => this = new(x, y, z, 0); public Vector4(float x, float y, float z, float w) { this.x = x; @@ -1940,157 +901,109 @@ namespace Nerd_STF.Mathematics this.w = w; } - public static Vector4 Average(params Vector4[] input) + public Vector4 Average(params Vector4[] objs) { - float[] averageX = new float[input.Length]; - float[] averageY = new float[input.Length]; - float[] averageZ = new float[input.Length]; - float[] averageW = new float[input.Length]; - for (int i = 0; i < input.Length; i++) + float[] averageX = new float[objs.Length + 1]; + float[] averageY = new float[objs.Length + 1]; + float[] averageZ = new float[objs.Length + 1]; + float[] averageW = new float[objs.Length + 1]; + for (int i = 0; i < objs.Length; i++) { - averageX[i] = input[i].x; - averageY[i] = input[i].y; - averageZ[i] = input[i].z; - averageW[i] = input[i].w; + averageX[i] = objs[i].x; + averageY[i] = objs[i].y; + averageZ[i] = objs[i].z; + averageW[i] = objs[i].w; } + averageX[objs.Length] = x; + averageY[objs.Length] = y; + averageZ[objs.Length] = z; + averageW[objs.Length] = w; return new(Math.Average(averageX), Math.Average(averageY), Math.Average(averageZ), Math.Average(averageW)); } - public static Vector4 Max(params Vector4[] input) + public Vector4 Max(params Vector4[] objs) { - float[] maxX = new float[input.Length]; - float[] maxY = new float[input.Length]; - float[] maxZ = new float[input.Length]; - float[] maxW = new float[input.Length]; - for (int i = 0; i < input.Length; i++) + float[] maxX = new float[objs.Length + 1]; + float[] maxY = new float[objs.Length + 1]; + float[] maxZ = new float[objs.Length + 1]; + float[] maxW = new float[objs.Length + 1]; + for (int i = 0; i < objs.Length; i++) { - maxX[i] = input[i].x; - maxY[i] = input[i].y; - maxZ[i] = input[i].z; - maxW[i] = input[i].w; + maxX[i] = objs[i].x; + maxY[i] = objs[i].y; + maxZ[i] = objs[i].z; + maxW[i] = objs[i].w; } + maxX[objs.Length] = x; + maxY[objs.Length] = y; + maxZ[objs.Length] = z; + maxW[objs.Length] = w; return new(Math.Max(maxX), Math.Max(maxY), Math.Max(maxZ), Math.Max(maxW)); } - public static Vector4 Min(params Vector4[] input) + public Vector4 Min(params Vector4[] objs) { - float[] minX = new float[input.Length]; - float[] minY = new float[input.Length]; - float[] minZ = new float[input.Length]; - float[] minW = new float[input.Length]; - for (int i = 0; i < input.Length; i++) + float[] minX = new float[objs.Length + 1]; + float[] minY = new float[objs.Length + 1]; + float[] minZ = new float[objs.Length + 1]; + float[] minW = new float[objs.Length + 1]; + for (int i = 0; i < objs.Length; i++) { - minX[i] = input[i].x; - minY[i] = input[i].y; - minZ[i] = input[i].z; - minW[i] = input[i].w; + minX[i] = objs[i].x; + minY[i] = objs[i].y; + minZ[i] = objs[i].z; + minW[i] = objs[i].w; } + minX[objs.Length] = x; + minY[objs.Length] = y; + minZ[objs.Length] = z; + minW[objs.Length] = w; return new(Math.Min(minX), Math.Min(minY), Math.Min(minZ), Math.Min(minW)); } - public override bool Equals(object obj) + public override bool Equals(object obj) => base.Equals(obj); + public bool Equals(Vector4 other) => x == other.x && y == other.y && z == other.z && w == other.w; + public override int GetHashCode() => base.GetHashCode(); + public override string ToString() => "X: " + x.ToString() + " | Y: " + y.ToString() + " | Z: " + z.ToString() + " | W: " + w.ToString(); + public string ToString(string format) => "X: " + x.ToString(format) + " | Y: " + y.ToString(format) + " | Z: " + z.ToString(format) + " | W: " + w.ToString(format); + + public static Vector4 operator +(Vector4 a, Vector4 b) => new(a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w); + public static Vector4 operator +(Vector4 a, float b) => new(a.x + b, a.y + b, a.z + b, a.w + b); + public static Vector4 operator +(float a, Vector4 b) => new(a + b.x, a + b.y, a + b.z, a + b.w); + public static Vector4 operator -(Vector4 a, Vector4 b) => new(a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w); + public static Vector4 operator -(Vector4 a, float b) => new(a.x - b, a.y - b, a.z - b, a.w - b); + public static Vector4 operator -(float a, Vector4 b) => new(a - b.x, a - b.y, a - b.z, a - b.w); + public static Vector4 operator *(Vector4 a, Vector4 b) => new(a.x * b.x, a.y * b.y, a.z * b.z, a.w * b.w); + public static Vector4 operator *(Vector4 a, float b) => new(a.x * b, a.y * b, a.z * b, a.w * b); + public static Vector4 operator *(float a, Vector4 b) => new(a * b.x, a * b.y, a * b.z, a * b.w); + public static Vector4 operator /(Vector4 a, Vector4 b) => new(a.x / b.x, a.y / b.y, a.z / b.z, a.w / b.w); + public static Vector4 operator /(Vector4 a, float b) => new(a.x / b, a.y / b, a.z / b, a.w / b); + public static Vector4 operator /(float a, Vector4 b) => new(a / b.x, a / b.y, a / b.z, a / b.w); + public static bool operator ==(Vector4 a, Vector4 b) => a.Equals(b); + public static bool operator !=(Vector4 a, Vector4 b) => !a.Equals(b); + public static bool operator >(Vector4 a, Vector4 b) => a.x > b.x && a.y > b.y && a.z > b.z && a.w > b.w; + public static bool operator <(Vector4 a, Vector4 b) => a.x < b.x && a.y < b.y && a.z < b.z && a.w < b.w; + public static bool operator >=(Vector4 a, Vector4 b) => (a.x > b.x && a.y > b.y && a.z > b.z && a.w > b.w) || a.Equals(b); + public static bool operator <=(Vector4 a, Vector4 b) => (a.x < b.x && a.y < b.y && a.z < b.z && a.w < b.w) || a.Equals(b); + + public static implicit operator Vector4(Color input) => new(input.r, input.g, input.b, input.a); + public static implicit operator Vector4(Vector2 input) => new(input.x, input.y); + public static implicit operator Vector4(Vector3 input) => new(input.x, input.y, input.z); + } + + namespace Interfaces + { + public interface IMathFunctions { - return base.Equals(obj); - } - public bool Equals(Vector4 other) - { - return x == other.x && y == other.y && z == other.z && w == other.w; - } - public override int GetHashCode() - { - return base.GetHashCode(); - } - public override string ToString() - { - return "X: " + x.ToString() + " | Y: " + y.ToString() + " | Z: " + z.ToString() + " | W: " + w.ToString(); - } - public string ToString(string format) - { - return "X: " + x.ToString(format) + " | Y: " + y.ToString(format) + " | Z: " + z.ToString(format) + " | W: " + w.ToString(format); + public T Average(params T[] objs); + public T Max(params T[] objs); + public T Min(params T[] objs); } - public static Vector4 operator +(Vector4 a, Vector4 b) + public interface INegatives { - return new Vector4(a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w); - } - public static Vector4 operator +(Vector4 a, float b) - { - return new Vector4(a.x + b, a.y + b, a.z + b, a.w + b); - } - public static Vector4 operator +(float a, Vector4 b) - { - return new Vector4(a + b.x, a + b.y, a + b.z, a + b.w); - } - public static Vector4 operator -(Vector4 a, Vector4 b) - { - return new Vector4(a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w); - } - public static Vector4 operator -(Vector4 a, float b) - { - return new Vector4(a.x - b, a.y - b, a.z - b, a.w - b); - } - public static Vector4 operator -(float a, Vector4 b) - { - return new Vector4(a - b.x, a - b.y, a - b.z, a - b.w); - } - public static Vector4 operator *(Vector4 a, Vector4 b) - { - return new Vector4(a.x * b.x, a.y * b.y, a.z * b.z, a.w * b.w); - } - public static Vector4 operator *(Vector4 a, float b) - { - return new Vector4(a.x * b, a.y * b, a.z * b, a.w * b); - } - public static Vector4 operator *(float a, Vector4 b) - { - return new Vector4(a * b.x, a * b.y, a * b.z, a * b.w); - } - public static Vector4 operator /(Vector4 a, Vector4 b) - { - return new Vector4(a.x / b.x, a.y / b.y, a.z / b.z, a.w / b.w); - } - public static Vector4 operator /(Vector4 a, float b) - { - return new Vector4(a.x / b, a.y / b, a.z / b, a.w / b); - } - public static Vector4 operator /(float a, Vector4 b) - { - return new Vector4(a / b.x, a / b.y, a / b.z, a / b.w); - } - public static bool operator ==(Vector4 a, Vector4 b) - { - return a.Equals(b); - } - public static bool operator !=(Vector4 a, Vector4 b) - { - return !a.Equals(b); - } - public static bool operator >(Vector4 a, Vector4 b) - { - return a.x > b.x && a.y > b.y && a.z > b.z && a.w > b.w; - } - public static bool operator <(Vector4 a, Vector4 b) - { - return a.x < b.x && a.y < b.y && a.z < b.z && a.w < b.w; - } - public static bool operator >=(Vector4 a, Vector4 b) - { - return (a.x > b.x && a.y > b.y && a.z > b.z && a.w > b.w) || a.Equals(b); - } - public static bool operator <=(Vector4 a, Vector4 b) - { - return (a.x < b.x && a.y < b.y && a.z < b.z && a.w < b.w) || a.Equals(b); - } - - public static implicit operator Vector4(Color input) - { - return new Vector4(input.r, input.g, input.b, input.a); - } - public static implicit operator Vector4(Vector2 input) - { - return new Vector4(input.x, input.y); - } - public static implicit operator Vector4(Vector3 input) - { - return new Vector4(input.x, input.y, input.z); + public T Absolute { get; } + public bool IsNegative { get; } + public T Negative { get; } + public T Positive { get; } } } } \ No newline at end of file diff --git a/changelog.md b/changelog.md index ae9fccc..72c6c80 100644 --- a/changelog.md +++ b/changelog.md @@ -23,11 +23,143 @@ * public static class Stats # Version 2021.1: - Mainly centered around files and filesaving. + This update is mainly centered around files and filesaving. * Nerd_STF + Nerd_STF.Filesaving + File + BinaryFile + ByteFile + TextFile - - public class Miscellaneous \ No newline at end of file + - public class Miscellaneous + +# Version 2021.2: + This update is centered around lists. + * Nerd_STF: + * public static class Hashes: + + public static string SHA1(string) + + public static string SHA256(string) + + public static string SHA384(string) + + public static string SHA512(string) + + public static byte[] MD5(byte[]) + + public static byte[] SHA1(byte[]) + + public static byte[] SHA256(byte[]) + + public static byte[] SHA384(byte[]) + + public static byte[] SHA512(byte[]) + = Made `public static string MD5(string)` include more of my own scripting + * Nerd_STF.File: + = Nerd_STF.Filesaving: Moved to Nerd_STF.File.Saving + * Nerd_STF.File.Saving: + + public class BinaryFile + * public class ByteFile: + + public override bool TryLoad(out File>) + = Made `public static ByteFile Load(string)` load files faster + = Made `public override void Load(bool)` load files faster + = Made `public override void Save()` save files faster + = Made `public override void Write(byte, bool)` save files faster + = Made `public override void Write(List, bool)` save files faster + * public abstract class File: + + public bool Exists; + + public abstract bool TryLoad(out File) + * public class TextFile: + + public override bool TryLoad(out File) + = Made `public static TextFile Load(string)` load files faster + = Made `public override void Load(bool)` load files faster + = Made `public override Save()` save files faster + = Made `public override void Write(char, bool)` save files faster + = Made `public override void Write(string, bool)` save files faster + - Nerd_STF.Interfaces: + = Moved `public interface INegatives` to `Nerd_STF.Mathematics.Interfaces` + * Nerd_STF.Lists: + + public class ReadOnlyList + = public class List: Completely reworked everything in `List` + + public int this[T] { get; set; } + + public List(IEnumerable) + + public bool IsEmpty { get; } + + public bool IsNull { get; } + + public bool IsNullOrEmpty { get; } + + public bool Contains(Predicate) + + public int Count (Predicate) + + public void AddRange(IEnumerable) + + public bool Any(Predicate) + + public bool Any(T) + + public T Find(Predicate) + + public T Find(Predicate, int) + + public T Find(Predicate, int, int) + + public T FindOrDefault(Predicate) + + public T FindOrDefault(T) + + public T FindOrDefault(Predicate, int) + + public T FindOrDefault(T, int) + + public T FindOrDefault(Predicate, int, int) + + public T FindOrDefault(T, int, int) + + public List FindAll(Predicate) + + public List FindAll(Predicate, int) + + public List FindAll(Predicate, int, int) + + public List FindLast(Predicate) + + public List FindLast(Predicate, int) + + public List FindLast(Predicate, int, int) + + public T FindLastOrDefault(Predicate) + + public T FindLastOrDefault(T) + + public T FindLastOrDefault(Predicate, int) + + public T FindLastOrDefault(T, int) + + public T FindLastOrDefault(Predicate, int, int) + + public T FindLastOrDefault(T, int, int) + + public int FindIndex(Predicate) + + public int FindIndex(Predicate, int) + + public int FindIndex(Predicate, int, int) + + public List FindAllIndex(Predicate) + + public List FindAllIndex(Predicate, int) + + public List FindAllIndex(Predicate, int, int) + + public int FindLastIndex(Predicate) + + public int FindLastIndex(Predicate, int) + + public int FindLastIndex(Predicate, int, int) + + public bool MatchesAll(Predicate) + + public void Remove(Predicate) + + public void RemoveAll(Predicate) + + public void RemoveAll(T) + + public void RemoveLast(Predicate) + + public void RemoveLast(T) + + IEnumerator IEnumerable.GetEnumerator() + + public void Randomize() + + public List FindAllIndex() + + public void Shuffle() + + public List FindAllIndex(int) + + public List FindAllIndex(int, int) + + public ReadOnlyList ToReadOnly() + = Made `public List Duplicate()` a readonly variable and better (`public List Duplicate { get; }`) + = Renamed the internal array to `array,` as opposed to `list` + = Renamed `public void Add(T[])` to `public void AddRange(T[])` + = Renamed `public void Add(List)` to `public void AddRange(List)` + = Renamed `public bool Compare(T)` to `public bool Contains(T)` + = Renamed `public void Remove(int, bool)` to `public void Remove(int)` + = Renamed `public void SetAll(T)` to `public void Fill(T)` + = Made `public string ToString(bool)` count up from zero instead of one when the bool is set to true. + = Renamed `public ReadOnlyCollection AsReadOnly()` to `public ReadOnlyCollection ToSystemReadOnly()` + - public bool Check(int) + - public void Convert(T) + - public void Convert(T[]) + - public void Convert(List) + - public T Get(int) + - public void Get(int, out T) + - public T[] GetAll() + - public void Set(int, T) + - public void Set(T[]) + - public void Set(List) + - public static List AllDefault(int) + - public static List operator +(T[], List) + - public static List operator +(List, int) + - public static List operator +(T, List) + - public static List operator *(List, int) + - public static explicit operator T[](List) + - public static explicit operator List(T[]) + = Marked `public class Nerd_STF.Lists.Matrix` as deprecated. This class will be removed or heavily modified in a future release. Also removed all instances of removed List methods and replaced them with work-arounds. + * Nerd_STF.Mathematics: + = Marked `public struct Angle` as serializable + = Marked `public struct Color` as serializable + = Marked `public struct ColorByte` as serializable + = Marked `public struct Percent` as serializable + = Marked `public struct Vector` as serializable + = Marked `public struct Vector2` as serializable + = Marked `public struct Vector3` as serializable + = Marked `public struct Vector4` as serializable + + public static class Misc + + public static string PlaceMaker(int) \ No newline at end of file