аЯрЁБс;ўџ ўџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ§џџџ(ўџџџ)  !"#$%&'*ўџџџўџџџ+,-./0123456789:;<ўџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџRџџџџџџџџ РF$ЯпњЛРCompObjџџџџџџџџџџџџ^WordDocumentџџџџџџџџ[mObjectPoolџџџџ$ЯпњЛ$ЯпњЛўџџџ ўџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџўџџџџџ РFMicrosoft Word 6.0 (dokument)ўџџџNB6WWord.Document.6;џў ўџ ђŸ…рOљhЋ‘+'Гй0х˜Ц/Hg m y …‘™ Ё­Ъ внџџџџџџџџџџџџџџџџџџџџџџџџ&PowerMac:Microsoft Word:Mallar:Normala============Suggested LIA-2 section 5.3 (1/2), elementary transcendental operations=============Gšran SchumacherмЅhQРev?[mY<^Ж^ЖЖbЖbЖbЖbЖb ct c”f”f”fЄf4иf cтk‡юfђf(ggggggКkМkМkМkМkМkМk&ilXСlšтkЖbЋh$,ggЋhЋhтkЋhЖbЖbgюfЋhЋhЋhЋhЖbgЖbgКkЪb ъb6ЖbЖbЖbЖbg‘КkЋhЋhComments on additional operations on integer type values and on floating point type values LIAа1 "undefined" is split into "invalid" (called "undefined" in the current LIAа2 text) and "pole" (i.e. IEC 559 "divide_by_zero"). Issue: should floating invalid be distinguished from integer invalid? Or should floating_overflow and integer_overflow be joined? To section 4: round (:R(Z) rounds to the nearest integer, ties round to the even one.] resultF should be extended to specify the contination value upon overflow (IEC 559 infinities if rounding is to nearest, ). resultF : R ( (R ( F*) ( F ({underflow, floating_overflow} resultF(x, rnd) = rnd(x) if fminNF ( |rnd(x)| ( fmaxF resultF(x, rnd) = 0 if x = 0 resultF(x, upF) = floating_overflow(д+(е) if upF(x) > fmaxF resultF(x, upF) = floating_overflow(аfmaxF) if upF(x) < аfmaxF resultF(x, nearestF) = floating_overflow(д+(е) if nearestF(x) > fmaxF resultF(x, nearestF) = floating_overflow(да(е) if nearestF(x) < аfmaxF resultF(x, downF) = floating_overflow(fmaxF) if downF(x) > fmaxF resultF(x, downF) = floating_overflow(да(е) if downF(x) < аfmaxF (underflow as before, but maybe a bit more explicit.) Additional integer operations Max and min No versions for вsequencesг need be included for Fortran's sake. Fortran's MAX/MIN are already covered, just as +, а, * etc. in many p.l.s are already covered by the operations specified in part 1 (most p.l. allows one to write, e.g. a+b+c+d, which is similar to Fortran's MAX/MIN, except for infix vs. prefix notation). As far as I know, the MAX/MIN operations in Fortran cannot be applied to an argument that represents any kind of sequence. If any operations on sequences are to be included, for Common Lisp's and ISLisp's sake, I strongly recommend including also those for adding, subtracting, multiplying etc. on lists. Note that the add, max etc. operations of Common Lisp and ISLisp can be applied to an argument that represents a sequence (specifically a list). E.g. (+ . xs) [note the period] adds the elements of xs, (max . xs) finds the max element of xs, etc. LIA-2 having sequence operations just for max/min but not for other operations, displays a very irregular operation selection policy, and cannot be accepted. I suggest skipping all of them. Positive difference (monus) Integer square root (rounded to nearest integer) Integer power Arithmetic shifts There seems to be a misconception around that says that вarithmetic shift rightг would round towards 0. The ordinary algorithm for implementing what is called arithmetic shift on two's complement representations, however, round towards negative infinity. Also for other representations, rounding towards negative infinity seems to be ideal. Thus, LIA-2 has now the possibility to fix the semantics of the notion of arithmetic shift. I suggest having two arithmetic shift operations, one for an assumed base two, one for the assumed base ten (regardless of the underlying actual base). These operations should also have a sensible semantics for вarithmetic shift leftг, i.e. negative shift amount. Wether these operations actually can be implemented as single instructions or not is beyond the scope of LIA. Additional roundings for integer division and remainder The integer division and remainder operations using a to nearest or a towards plus infinity rounding are provided by Common Lisp (as two results of the twoаargument versions of "round" and "ceiling"). Common Lisp also provides these operations for floating point arguments, with floating point results. The round to nearest integer division provides the common integer division with unbiased rounding. The corresponding remainder can be used to compute the accumulated error. The round towards positive infinity integer division provides for conventional grouping into equal sized groups (except for the last one). E.g. if elements 1 to n go into group 1, elements n+1 to 2*n go into group 2, etc. then element i goes into group divc(i,n) and it is the n+remc(i,n)'th element of that group. It may be a bit more natural to use negremc here instead: "and it is the nаnegremc(i,n)'th element of that group". Also, negremc is useful for unsigned types, where remc then mostly overflows. As just one concrete example, of many: year 1996 is in the divc(1996,100)'th century, and it is the 100аnegremc(1996,100)'th year of that century (i.e. year 96 of the 20'th century). (Note that the year 2000 is the 100'th year of the 20'th century!) This seems commonplace enough to merit inclusion into LIAа2. For bindings, binding divcI to "grp" or "group", and binding negremcI to "pad" or "padding" is suggested (for the informative bindings annex). Divisibility and even/odd tests Note: dividesI(0,0) = false, since 0 does not divide anything, not even 0. Check in section 4 that 0|0 actually is false (that is currently not the case in section 4). Note: dividesI cannot be implemented as, e.g., eqI(0, remfI(y,x)), since the remainder functions are invalid for a zero second argument. And a divides predicate (|) is also used in mathematics (and in LIA!) when divisibility is to be easily expressed. A divides test also generalises the even/odd tests. These reasons should suffice to merit inclusion of dividesI into LIAа2. Also already present in C/C++. Greatest common divisor and least common multiple Integer operations supporting extended range mul_wrapI and mul_ovI are called mulloI and mulhiI respectively in the current LIAа2 text, but those names are confusing since these operations are not very closely related to the floating point operations of the same names. They should thus be renamed. LIA-2 currently specify only mul_wrapI and mul_ovI, and none of the other operations supporting extended integer range. LIA-2 should include all six of them, or none of them. I see no great point in including any "wrapping" integer division operations, since integer division hardly ever overflows (only occasion: minint divided by а1 when minint=аmaxintа1). When implementing extended range integer types, this special case can easily be tested for explicitly. And similarly for negation and absolute value. (But I would not oppose introducing "neg_wrap" etc.) Operations supporting LID modulo integer types These types are not very likely to become separate types in any programming language, yet anyway. Still they can be effectively emulated using these operations on ordinary integer type values, if the modulo parameter to the LID type is in the integer type. Note that add_wrapI cannot, however, be implemented using add_modI, since the first parameter would then need to be maxintI+1, which of course is not in I. Additional basic floating point operations downF : R ( F* is a rounding function, rounds towards negative infinity. upF : R ( F* is a rounding function , rounds towards positive infinity. nearestF : R ( F* is a rounding function, rounds to nearest (ties: impl. defined). The current LIA-2 text misuses the floor and ceiling brackets for the up and down roundings. The current LIA-2 definitions are in addition incomplete, as the "S" subset is not required to be unbounded. In addition the LIA-2 syntax for these helper functions does not work well (syntactically) with the resultF helper function. (I don't mind expressing the semantics of these helper functions more precisely, but it has to be done correctly.) Max and min What the max and min operations should return on one NaN input depend on the context. Sometimes NaN is the appropriate result, sometimes the nonаNaN argument is the appropriate result. Therefore, two variants (each) of the floating point max and min operation are specified here, and the user can decide which one is appropriate to use at each particular place of usage. No versions for вsequencesг need be included for Fortran's sake. Fortran's MAX/MIN are already covered, just as +, а, * etc. in many p.l.s are already covered by the operations specified in part 1 (most p.l. allows one to write, e.g. a+b+c+d, which is similar to Fortran's MAX/MIN, except for infix vs. prefix notation). As far as I know, the MAX/MIN operations in Fortran cannot be applied to an argument that represents any kind of sequence. If any operations on sequences are to be included, for Common Lisp's and ISLisp's sake, I strongly recommend including also those for adding, subtracting, multiplying etc. lists. Note that the add, max etc. operations of Common Lisp and ISLisp can be applied to an argument that represents a sequence (specifically a list). E.g. (+ . xs) [note the period] adds the elements of xs, (max . xs) finds the max element of xs, etc. LIA-2 having sequence operations just for max/min but not for other operations, displays a very irregular operation selection policy, and cannot be accepted. I suggest skipping all of them. Please observe that the current specifications for the "sequence" varieties are grossly ill defined. The max and min functions (on sets) work specifically only on sets of numbers. They cannot handle NaNs, negative zeroes, or infinities! Positive difference The current specification in the LIA-2 text for dimF is a poor, and very incorrect, attempt at mimicing the LIA-1 specification for floating point addition/subtraction. I think the only way of correcting this specification is to follow the LIA-1 style very closely, as I have suggested, augmenting with specifications for how to handle negative zeroes and infinities. Addаthreeаnumbers, multiplyаadd, and multiplyаconvert add3F and add3_midF are intended to replace the somewhat strange operations sumhi and sumlo. Those operations have strange conditions for use, and incomplete specifications. add3F and add3_midF here are intended to clean that up. mulF(F' is called DPRODF(G in the current LIAа2 text. mulF(F' is specified only for F and F' types for which rF=rF' and pF' >= 2*pF and emaxF' >= 2*emaxF and eminF' <= 2*eminF, and if denormF=true then denormF'=true, unless eminF' <= 2*eminFаpF, must hold too for the resultF' to be justifiably removable. I suggest removing this hard-to-express-precisely condition, and specify mulF(F' for any pair of floating point types. Floor, ceiling, and round In the current LIAа2 text "floorF" etc. are classified as "conversions". But since the argument and result type is the same, there is no conversion involved, and they belong in this section rather than in the section on conversions. The "roundingF" operation cannot be called "nearestF", because that name is used for a helper function. Nor can it be called "roundF", because that is an LIAа1 operation that does something a bit different. The closest related operation in LIAа1 is intpartF, the same as current LIAа2 "TRUNCATEF", so we could call these operations intpartfF, intpartrF, intpartcF, and fractpartfF, fractpartrF, fractpartcF. Since the truncating variety has a "remainder", namely fractpartF, the other varieties should also have a "remainder" operation each; they are more likely to be useful than the truncating variety! Truncation is already in LIA-1, by the name intpartF, and need not be repeated in LIA-2! The rest after truncation is already in LIA-1, by the name fractpartF, and need not be repeated in LIA-2. Divideаandаfloor, аceiling, аround The idiv and irem operations are provided by Common Lisp as the floating point versions of the twoаargument/twoаresult versions of floor/round/ceiling. These provide the floating point versions of the integer division and remainder operations. They are useful for cyclic functions. E.g., exact angle reduction (to within a cycle close to zero) for angle values in given in a floating point angular unit (i.e. angular units that can be expressed exactly as a floating point number). The вrevolution numberг is obtained as the idiv result, as long as that integer number is in F (otherwise a "rounded" result is obtained). iremrF is required by IEC 559, but I see no reason for it not to be possible to provide it also for nonаIEC 559 conformant floating point types. Square root and inverted square root Support for extended floating point precision c.v.addF(x,y) is the continuation value for addF(x,y). I.e., if addF(x,y) ( F then c.v.addF(x,y) = addF(x,y), and, e.g., if addF(x,y) = underflow, then c.v.addF(x,y) = rndF(x+y), if denormF = true. And similarly if denormF=false or addF(x,y) = floating_overflow, and for c.v.subF(x,y), etc. For simplicity floating_overflow is returned if add overflows, but the proper result for add_lo does not overflow. Alternatives: return invalid when add overflows (seems illogical though); or return the proper result, i.e. x+yаnearestF(x+y) when add overflows. The latter alternative is of course logical enough, but is it worthwhile? (This issue arises for all of the "lo" (and "mid") operations.) The intent is that add_loF(x,y) should be computed as subF(y,subF(addF(x,y),x)), if x,y ( F and |x| >= |y| [otherwise swap x and y]. In any programming language with reasonable syntax that is: yа((x+y)аx) (if y has the smaller magnitude). As far as I can see, this would work for IEC 559 floating point, I don't know for others. Support for extended floating point range These operations are specified only if iec_559F=true. Prof. Kahans paper on the status of IEEE f.p. arithmetic presents the idea of using a counter to count wouldаbe overflows/underflows, and scaling the result. The countF helper function (similar to resultF): increment and decrement are similar to the other notifications, but increment increments and decrement decrements a system variable (initially 0). This system variable is otherwise handled like the notification flags (indicators). (I.e., separate counters for separate threads, and a hardаtoаignore message if counter not zero on termination.) Support for floating point interval arithmetic These operations are specified only if iec_559F=true. They provide static selection of rounding modes towards plus and minus infinity. These operations partially support interval arithmetic: The following operations partially support extended range floating point interval arithmetic. ... (there are a few comments interspersed in the дsuggestionд document on section 5.3) Suggested LIAа2 sections 5.4 and 5.5: additional conversion operations and numerals Conversion operations Integer to integer conversions Floating point to integer conversions Integer to floating point conversions Note: Integer to nearest floating point conversions are covered by LIA-1. The others are currently missing from LIA-2. Floating point to floating point conversions Note: Floating point to nearest floating point conversions are covered by LIA-1 when both types conform to LIA-1. Note: This covers, among other things, вinputг and вoutputг of floating point type values, for floating point string formats. Floating point to fixed point conversions D is a fixed point type (essentially LID scaled, but it may be limited). None of the characterising values need be accessible via parameters in any way. Introduce a fixed_overflow? Or just use integer_overflow despite the incorrect reference to integers? Fixed point to floating point conversions Numerals Each numeral is an operation. So this section introduces a very large number of operations. Numerals for integer types Numerals for floating point types SIDA 12 SIDA 1 ™ Є}.ЅŠAІŠЇŠЈŠЉŠ„ HH28џєџѓ>FG{рHH dџ'h@N-Upџџ@’SWII@copyџџ@|destџџ@,extl@ˆfeedџџ@vffmtџџ@2job џџ@šnmapџџ@$objsџџ@цpddsџџ@pmapџџ@8ppWMџџ@Šppanџџ@Vqualџџ@rangџџ@zsmapџџ@*sortџџ@„tmapџџ@0univџџ@ђєBestNormalDraft##: US Letter@ї™ЈџюџюRsyptPtv­kРMicrosoft WordgerџџџџQИ—Microsoft Word - nydefs.lia2.Щ(Gšran Schumacher"@€нимP #P PrinterŠR5>@5=‚;,Z №6 Sidor/ark 'ZppWM€ Peirce WatermarkerрBpHBwN-Up€  Sidor/arktermarkerрBpHBw4ДYЌ US Letter@ї™Јџюџю@ї™ЈџюџюR@baseџџ@creaџџ@ flagџџ@unitџџ@syptP@dirmџџ@ layoџџ@scalџџ@ dd A4 Letter…'џс =џп…'џс =џп™Ј4zт'`@baseџџ@creaџџ@ flagџџ@unitџџ@sypt@@dirmџџ@layoџџ@scalџџ@  ddunivnonerastSWIIStyleWriter GXStyleWriter GXаЯрЁБс;џў џџџўџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџSummaryInformation(џџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџInst fšr Datavetenskap'@Ъ8дЛ@tKZњЛ@F•ХњЛ@Microsoft Word 6.0.122;џў џџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ[\cl}„˜КОњ '3DIY|}~ КНУФ=CDGHIJLMNOPQTUVWXYZcev|‚ƒ„…‡ŠŽ‘’“šŸ ЁЂЄЇЈЉЌ­ЎВГЗНОПРТХбвлстуфцћљїїїїїїїїѕђѕ№ѕэѕэѕъѕђѕђѕчїїѕэѕѕѕѕѕэфѕѕфѕэѕэѕѕѕѕэѕJЃJШJДVh^JЎVU]UVc Zцшщє #)*+,.01<MOSTY[\]^cghmstuvx€„•˜™ŸІЇЈЉЏГДИОПРСУЪЫЯруфъёђѓєљ§ў    +,016:;<=CGHLўћљіўћўўћўћўўћљўћўћўўћўћўўћљіўћўўћўћўўћљіўћўўћўћўўћљўћўћўўћJЅUVhVaLRSTUW[\ctwx~‚ƒ„…ŠŽ’›h n   pqŒ•–КЛЬЯабвгдфхцщъыьэю/56TUV\]^_`a…‹ŒБДЕ   6<= !"DJKLНФХЭвfmn‘’–™š›ўћўўћљіўћўўћљўўўўўўўєўўўўєўўўєўўєўўўєўєўєўєўєћўєћўћљўћўћўєћhJЅUVhV`›œžŸХЬФЫЬX[\`afijlmy~„‰Štwx|}‚…†ˆ‰’˜ЌВДКЪЭЮвгњ4:;YZŠŽ•–—˜™šйлмцчшщъы+236789:;ЎДЕй%м%'''(”(•(š(Ђ(Ѓ(@)D)ўўќўљўўљўўљўљўљўўљўўљўўўўўљўљўљўўљўіўўљўіўўљўіўўљўўљўљўљўJЎVhUVaD)E)J)R)S)x){)|)})~))‹))‘)’)“)А)Г)Д)Е)Ж)З)Ю)Я)д)е)ш)щ)ъ)ы)ь)ю)ѓ)є)і)ќ)§)ў)** ***** *"*(*,*-*6*<*=*>*B*H*N*P*Q*U*^*b*d*j*n*o*p*q*r*Š**’*њ*§*ў*џ*++]+b+c+1,9,:,X,_,`,Ћ,А,Б,'-.-/-1-<-L-§ћ§ћ§ї§ѕћ§ї§ћ§ї§ѕћћћ§ћ§ћ§ћ§ћ§ћ§ћ§ћ§ћ§ѓћ§ѓћ§ћ§ћ§ћ§ћ§ї§ѕћ§ћ§ћ§ћ§ћ§ё^UhJЎhVVh_L-T-U-z--‚-ƒ-…-Œ--Ž--—-˜-™-Ÿ-Ј-Љ-Њ-Ќ-Е-Ж-З-Й-Т-У-Ф-§-..З.О.П. /)/*/v/z//ƒ/‚1†1Д1Е1т1ц1ч1ш1Ъ2Э2Ю2Я2а2б2в2ђ2ѕ2і2ї2ј2љ2њ23 3 3 3 3 3333333 3!3"3#3$3%3)3,3-3.3/30313B3E3F3G3H3I3J3N3W3b3ўћўљћўљћўљћўљћўљћўљћўћўћўћўўўўўљћўћўўўћўўўћўўіўўћўўўћўўўћўўєUJЮhVhV`b3e3f3g3h3i3j3n3q3r3s3t3u3v3|3‚3ƒ3†3Š3ž3Є3Ѕ3І3Ћ3Џ3В3Г3Д3Е3Ж3З3Л3Ь3к3н3о3п3р3с3т3љ3 4s4z4Ъ4Ы4Ь4Э4Ю4е4ж4з4и4й4к4Ž5”5•5–5—5˜5™5Б5Д5Е5Ж5З5И5Л5М5Н5Р5С5Т5У5Ф5Х5Ч5Ш5Я5а5б5в5г5д5е5ж5м5н5у5ф5і5ї5ќ5§5=6>6A6ўћўўўћўўўћљўћљўћўўљўћўўљљўўўћўўўћўўўћўўћўћўўўўўіўўўўўўJЮUVhVaA6B6C6D6F6G6N6O6777 7$7Ш7Э7Ю7ы7ё7ђ7ѕ7ў78 898B8R8[8Є9Ћ9Ќ9­9Б9є:;;H;I;‹=Œ=0>>>M>]>Y?Z?`?a?c?d?e?g?h?n?o?p?q?r?u?v?FўўўўўћљўћўћљљљљўћљѕѕѓўљљэыэыэыэыэыэыщuP uDPc UVc UVhV;[\eН9:xyДзи ijЕџI‘Чхё_  : k y ‹ И№ Ю–Ж_щљ+XW§d#hћd#Шљd#мљd#№љd#мћd#мїd#№їd#мїd#№їd#мїd#мїd#№їd#мїd#мїd#№їd#№їd#мїd#мїd#№їd#мљd#мѕd#,ѓd#ё d#мљd#мѓd#ѓd#ѓd#ѓd#ћ d#мѓd#ёd#мљd#мљ d#мљd#мѓd#яd#Дљd#мяd#Дљd#мѓd#ѓd#ёd#м+WМ\‡ж(~; G М!'%ц%е&щ&Z((x)(+B+,,Ц-‹.O/r/ 0т1s2˜2Ц2ъ3{5Ц6№6&7Ф7ѕ7N9}9>:œ: :є:ўd#мўd#мќd#њd#мјd#,њd#№њd#№њd#№ўd#мќd#іd#мў d#мўd#мўd#мќd#њd#мќd#ўd#мўџd#ьќd#іd#мўџd#иўd#мўd#мќd#ўd#мўd#мўd#мќd#ќd#іџd#Јўd#мўџd#ќќd#њd#мўd#мўd#мўd#мќd#њd#мўd#мјd#,іd#м+є:;H;I;_;~;Є;Ъ;<B<o<т<a=‹=д=$>‹>Е>О>?6?X?Y?e?f?g?r?s?t?u?v?§d#h§d#hћd#hљd#,їd#їd#їd#ѕd#Дѓd#мїd#яd#Дѕd#Дїd#ћd#мѓd#мѓd#мїd#љd#,ћd#мїd#їd#шd#мснћгнћћшd#м  a'„%h`јџ%77Щ§ЂK@ёџђNormal]a d@dRubrik 1B №< 4 €Comments on . U]ck`@`Rubrik 2B №< 4€.U^c^@^Rubrik 3B №< 4€.Ucb@bRubrik 4B №< 4€. UV]c\@\Rubrik 5@ №< 4€.]c^@^Rubrik 6@ №< 4€.V]cZ@ZRubrik 7@ №< 4€.]\@\Rubrik 8@ №< 4€.V]^ @^Rubrik 9@ №< 4€.V]c&A@ђџЁ&Standardstycketeckensnitt(@ђ(Normalt indrag << @ Sidfot Иp#ўOђNormal 14I@"4Meddelanderubrik77Щ§<<cўO2Def)@ЂA Sidnummer"@R"Sidhuvud Иp#v<v?Œ?!џџ џџ џџ џџ џџП \K*є7v<љz{&[\eН9:xyДзи ijЕџI‘Чхё_ : k y ‹ И № Ю–Ж_щљ+XWМ\‡ж(~;GМ'"ц"е#щ#Z%%x&((B(,)Ц*‹+O,r, -т.s/˜/Ц/ъ0{2Ц3№3&4Ф4ѕ4N6}6>7œ7 7є78H8I8_8~8Є8Ъ89B9o9т9a:‹:д:$;‹;Е;О;<6<X<Y<Z<v<˜˜˜˜˜˜˜˜˜˜˜˜˜˜˜˜˜˜˜˜˜$˜˜$$$$˜$˜˜˜˜$˜˜˜˜$$˜˜˜$˜˜˜˜˜$˜˜˜˜$˜$˜˜$˜˜˜˜$˜˜˜$$˜˜˜$˜˜˜˜$˜˜˜˜˜˜   ˜˜ ˜˜ ˜˜˜ ˜  œœœцL›D)L-b3A6F$%&'()*+Wє:v?,-.v< !”џ•€!џ•€‘dŒhmmsС;0x#-+'"е`, ,RKF…RF KOMMENTARSKAPADATREDTIDDOKNAMN FILSTORLEK NYCKELORD SENSPARATAVANTALTKNANTALSIDANTALORD UTSKRIFTSDATPRIVATRDVERSIONSPARADAT€MNEINHODOKMALLTITELXOALFAARABINITVERS GRUNDTEXT TECKENFORM VALUTATEXT F…RSTVERSHEXGEMEN KOPPLAFORMORDTALORDTEXTROMANVERSALABSAVRUNDADEFHELTALOCHFALSKTMAXMINRESTMEDELANTALICKEELLERPRODUKTOMTECKENSUMMASANTGšran Schumacher+Gšrans HD:Temporary Items:Word Work File A Gšran SchumacherAGšrans HD:Kents mapp:LIA2:Nya nydefs:nydefs.lia2.int&fp.cmnts.wrdGšran SchumacherAGšrans HD:Kents mapp:LIA2:Nya nydefs:nydefs.lia2.int&fp.cmnts.wrdGšran SchumacherAGšrans HD:Kents mapp:LIA2:Nya nydefs:nydefs.lia2.int&fp.cmnts.wrdGšran SchumacherAGšrans HD:Kents mapp:LIA2:Nya nydefs:nydefs.lia2.int&fp.cmnts.wrdGšran Schumacher.Gšrans HD:Temporary Items:Word Work File A 670Gšran SchumacherAGšrans HD:Kents mapp:LIA2:Nya nydefs:nydefs.lia2.int&fp.cmnts.wrdGšran SchumacherAGšrans HD:Kents mapp:LIA2:Nya nydefs:nydefs.lia2.int&fp.cmnts.wrdInst fšr Datavetenskap.PowerMac:Temporary Items:Word arbetsfil A 4054Inst fšr Datavetenskap@PowerMac:AnvŠndare:kentk:Nya nydefs:nydefs.lia2.int&fp.cmnts.wrdџ@€@ѓ‡MTimes New Roman Symbol MArial MTekton Plus RegularTimes MTimesMNew Century SchlbkMHelvetica"0Фh'FЉ &І &˜ƒБš`============Suggested LIA-2 section 5.3 (1/2), elementary transcendental operations=============Gšran SchumacherInst fšr DatavetenskapаЯрЁБс;џў џџџўџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ