ࡱ; \  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~R FaqCompObj^WordDocumentObjectPoolpp  FMicrosoft Word 6.0 (dokument)NB6WWord.Document.6;  Oh+'0/Hg m y   &PowerMac:Microsoft Word:Mallar:Normala============Suggested LIA-2 section 5.3 (1/2), elementary transcendental operations=============Gran SchumacherܥhQe\LLL\h|@D(llllll&XWflll@llʦn8lSuggested LIA2 sections 5.1 and 5.2: additional operations on integer type values and on floating point type values Additional integer operations LIA1's clause 5.1 specifies a number of integer operations. In this clause some additional integer operations are specified. I is an LIA1 conforming integer type. [(where, preferably, moduloI = false).] LIA1 conforming integer types usually do not contain any NaN or infinity values, so here are no specifications for such values as arguments. String formats for integer values usually do contain (signalling) NaNs, however, when that string format is regarded as an (nonLIA1) integer type. See section 5.4 on conversions. The resultI helper function: resultI : Z ( I ( {integer_overflow} resultI(x) = x if x ( I = integer_overflow if x ( I, x ( Z The wrapI helper function (from LIA-1) is defined only if boundedI=true: wrapI : Z ( I wrapI(x) = x (n*(maxintIminintI+1)) if x ( Z where n ( Z is chosen such that the result is in I, i.e., n = ((xminintI)/(maxintIminintI+1)( = ((xmaxintI)/(maxintIminintI+1)(, if x ( Z. Note: For some wrapping basic arithmetic operations this n is computed by the _ov operations in 5.1.8 Max and min maxI : I ( I ( I maxI(x,y) = max{x,y} if x,y ( I minI : I ( I ( I minI(x,y) = min{x,y} if x,y ( I Note: These operations cover both two-argument max/min operations, as well as syntactic varieties for these operations that allow two or more arguments (like in Fortran); e.g. MAX(x1, x2, ..., xn) can be bound to maxI(x1,maxI(x2,maxI(...,xn))). However, they do not directly cover list max/min operations, like those in Common Lisp or ISLisp. Positive difference (monus) dimI : I ( I ( I ( {integer_overflow} dimI(x,y) = resultI(max{0, xy}) if x,y ( I Note: dimI cannot be implemented as maxI(0, subI(x,y)) for limited integer types, since this latter expression has other overflow properties. Integer square root (rounded to nearest integer) sqrtI : I ( I ( {invalid} sqrtI(x) = round((x) if x ( I and x ( 0 = invalid if x ( I and x < 0 Integer power powerI : I ( I ( I ( {integer_overflow, invalid} powerI(x,y) = resultI(xy) if x,y ( I and y > 0 = 1 if x ( I and y = 0 and x ( 0 = invalid(1) if y = 0 and x = 0 [no invalid?] = invalid if x,y ( I and y < 0 Arithmetic shifts shift2I : I ( I ( I ( {integer_overflow} shift2I(n,x) = resultI((x/2n() if x,n ( I Note: If minintI = maxintI1, and the integer radix is 2, then shift2I may give access to some hardware arithmetic shift instruction. shift10I : I ( I ( I ( {integer_overflow} shift10I(n,x) = resultI((x/10n() if x,n ( I Additional roundings for integer division and remainder divrI : I ( I ( I ( {integer_overflow, invalid} divrI(x,y) = resultI(round(x/y)) if x,y ( I and y ( 0 = invalid if x ( I and y = 0 divcI : I ( I ( I ( {integer_overflow, invalid} divcI(x,y) = resultI((x/y() if x,y ( I and y ( 0 = invalid if x ( I and y = 0 Note: divfI is in LIA1. remrI : I ( I ( I ( {integer_overflow, invalid} remrI(x,y) = resultI(x (round(x/y)*y)) if x,y ( I and y ( 0 = invalid if x ( I and y = 0 Note: remrI can overflow only for unsigned integer types. remcI : I ( I ( I ( {integer_overflow, invalid} remcI(x,y) = resultI(x ((x/y(*y)) if x,y ( I and y ( 0 = invalid if x ( I and y = 0 Note: remcI can overflow only for unsigned integer types. negremcI : I ( I ( I ( {invalid} negremcI(x,y) = ((x/y(*y) x if x,y ( I and y ( 0 = invalid if x ( I and y = 0 Note: remfI is in LIA1. Divisibility and even/odd tests dividesI : I ( I ( Boolean dividesI(x,y) = true if x,y ( I and x|y = false if x,y ( I and not x|y Note: dividesI(0,0) = false, since 0 does not divide anything, not even 0. [check 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. evenI : I ( Boolean evenI(x) = true if x ( I and 2|x = false if x ( I and not 2|x oddI : I ( Boolean oddI(x) = true if x ( I and not 2|x = false if x ( I and 2|x Greatest common divisor and least common multiple gcdI : I ( I ( I ( {integer_overflow, invalid} gcdI(x,y) = resultI(max{v ( Z | v|x and v|y}) if x,y ( I and (x ( 0 or y ( 0) = invalid if x = 0 and y = 0 Note: Returning 0 for gcdI(0,0) would be incorrect, since the greatest common divisor for 0 and 0 is infinity. This makes the computation of the gcd of a list of numbers only slightly more difficult: the zero elements must be ignored. Note: gcdI will overflow only if boundedI=true, minintI=maxintI1, and both arguments to gcdI are minintI. The greatest common divisor is then minintI, which is then not in I. lcmI : I ( I ( I ( {integer_overflow} lcmI(x,y) = resultI(min{v ( Z | x|v and y|v and v > 0}) if x,y ( I and x ( 0 and y ( 0 = 0 if x,y ( I and (x = 0 or y = 0) Note: lcmI(x,y) easily overflows for many arguments: e.g., if x and y are (positive) relative primes, then the least common multiple is x*y, which may be greater than maxintI. Integer operations supporting extended range The following six operations are specified only if boundedI = true, since wrapI is not defined otherwise. These operations can be used to implement extended range integer types, and unbounded integer types. add_wrapI : I ( I ( I add_wrapI(x,y) = wrapI(x+y) if x,y ( I add_ovI : I ( I ( I add_ovI(x,y) = ((x+y) add_wrapI(x,y))/(maxintI minintI + 1) if x,y ( I sub_wrapI : I ( I ( I sub_wrapI(x,y) = wrapI(xy) if x,y ( I sub_ovI : I ( I ( I sub_ovI(x,y) = ((xy) sub_wrapI(x,y))/(maxintI minintI + 1) if x,y ( I mul_wrapI : I ( I ( I mul_wrapI(x,y) = wrapI(x*y) if x,y ( I mul_ovI : I ( I ( I mul_ovI(x,y) = ((x*y) mul_wrapI(x,y))/(maxintI minintI + 1) if x,y ( I Operations supporting LID modulo integer types Here operations for addition, subtraction, multiplication, negation, and equality modulo a given argument, avoiding intermediate overflows, are specified. These would implement operations on the LID modulo(x) types. add_modI : I ( I ( I ( I ( {invalid} add_modI(x,y,z) = (y+z)(((y+z)/x(*x) if x,y,z ( I and x ( 0 = invalid if y,z ( I and x = 0 sub_modI : I ( I ( I ( I ( {invalid} sub_modI(x,y,z) = (yz)(((yz)/x(*x) if x,y,z ( I and x ( 0 = invalid if y,z ( I and x = 0 mul_modI : I ( I ( I ( I ( {invalid} mul_modI(x,y,z) = (y*z)(((y*z)/x(*x) if x,y,z ( I and x ( 0 = invalid if y,z ( I and x = 0 neg_modI : I ( I ( I ( {invalid} neg_modI(x,y) = negremcI(y,x) Note: (y)((y/x(*x) = (y)+((y/x(*x) = ((y/x(*x) y = negremcI(y,x), if x,y ( I, x ( 0. eq_modI : I ( I ( I ( Boolean ( {invalid} eq_modI(x,y,z) = eqI(remfI(y,x),remfI(z,x)) if x,y,z ( I and x ( 0 = invalid if y,z ( I and x = 0 Additional basic floating point operations LIA1's clause 5.2 specifies a number of floating point operations. In this clause some additional floating point operations are specified. Further floating point operations, for elementary numerical functions, are specified in clause 5.3. F is an LIA1 conforming floating point type. Floating point rounding helper functions: 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. The handling of ties is implementation defined, but must be sign symmetric. If iec_559F = true, then ties are rounded to even last digit. 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 nonNaN 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. maxF : F ( F ( F maxF(x,y) = max{x,y} if x,y ( F = y if x = 0 and y ( F and y ( 0 = 0 if x = 0 and y ( F and y < 0 = 0 if x = 0 and y = 0 = x if y = 0 and x ( F and x ( 0 = 0 if y = 0 and x ( F and x < 0 = +( if x = +( and y ( F({(,0} = x if y = ( and x ( F({(,0} = y if x = ( and y ( F({+(,0} = +( if y = +( and x ( F({+(,0} = qnan if x is a quiet NaN and y is not a signalling NaN = qnan if y is a quiet NaN and x is not a signalling NaN = invalid(qnan) if x is a signalling NaN or y is a signalling NaN minF : F ( F ( F minF(x,y) = min{x,y} if x,y ( F = 0 if x = 0 and y ( F and y ( 0 = y if x = 0 and y ( F and y < 0 = 0 if x = 0 and y = 0 = 0 if y = 0 and x ( F and x ( 0 = x if y = 0 and x ( F and x < 0 = y if x = +( and y ( F({(,0} = ( if y = ( and x ( F({(,0} = ( if x = ( and y ( F({+(,0} = x if y = +( and x ( F({+(,0} = qnan if x is a quiet NaN and y is not a signalling NaN = qnan if y is a quiet NaN and x is not a signalling NaN = invalid(qnan) if x is a signalling NaN or y is a signalling NaN mmaxF : F ( F ( F mmaxF(x,y) = maxF(x,y) if x,y ( F({+(,0,(} = x if x ( F({+(,0,(} and y is a quiet NaN = y if y ( F({+(,0,(} and x is a quiet NaN = qnan if x is a quiet NaN and y is a quiet NaN = invalid(qnan) if x is a signalling NaN or y is a signalling NaN mminF : F ( F ( F mminF(x,y) = minF(x,y) if x,y ( F({+(,0,(} = x if x ( F({+(,0,(} and y is a quiet NaN = y if y ( F({+(,0,(} and x is a quiet NaN = qnan if x is a quiet NaN and y is a quiet NaN = invalid(qnan) if x is a signalling NaN or y is a signalling NaN Note: If one of the arguments to mmaxF or mminF is a quiet NaN, that argument is ignored. Note: These operations cover both two-argument max/min operations, as well as syntactic varieties for these operations that allow two or more arguments (like in Fortran); e.g. MAX(x1, x2, ..., xn) can be bound to maxF(x1,maxF(x2,maxF(...,xn))). However, they do not directly cover list max/min operations, like those in Common Lisp or ISLisp. Positive difference dimF : F ( F ( F({floating_overflow, underflow} dimF(x,y) = resultF(max{0, add*F(x,y))}, rndF) if x,y ( F = dimF(0,y) if x = 0 and y ( F ( {(,0,+(} = dimF(x,0) if y = 0 and x ( F ( {(,+(} = +( if x = +( and y ( F({(} = +( if y = ( and x ( F = 0 if x = ( and y ( F({+(} = 0 if y = +( and x ( F = invalid(qnan) if x = +( and y = +( = invalid(qnan) if x = ( and y = ( = qnan if x is a quiet NaN and y is not a signalling NaN = qnan if y is a quiet NaN and x is not a signalling NaN = invalid(qnan) if x is a signalling NaN or y is a signalling NaN Note: dimF cannot be implemented by maxF(0, subF(x,y)), since this latter expression has other overflow properties. Note: This operation does not return underflow if iec_559F = true. Addthreenumbers, multiplyadd, and multiplyconvert add3F : F ( F ( F ( F({floating_overflow, underflow} add3F(x,y,z) = resultF((x+y)+z, rndF) if x,y,z ( F = addF(addF(x,y),z) if x ( {(,0,+(} and y,z ( F({(,0,+(} = addF(addF(x,y),z) if y ( {(,0,+(} and x ( F and z ( F({(,0,+(} = addF(addF(x,y),z) if z ( {(,0,+(} and x,y ( F = qnan if x is a quiet NaN and not y nor z is a signalling NaN = qnan if y is a quiet NaN and not x nor z is a signalling NaN = qnan if z is a quiet NaN and not x nor y is a signalling NaN = invalid(qnan) if x is a signalling NaN or y is a signalling NaN or z is a signalling NaN Note: add3F(x,y,z) = addF(addF(x,y),z) if x ( F or y ( F or z ( F, thus add3F(0,0,0) = 0. Note: This operation does not return underflow if iec_559F = true. add3_midF : F ( F ( F ( F({floating_overflow, underflow} add3_midF(x,y,z) = resultF(((x+y)+z)c.v.add3F(x,y,z), rndF) if x,y,z,c.v.add3F(x,y,z) ( F = floating_overflow(() if add3F(x,y,z) = floating_overflow(+() = floating_overflow(+() if add3F(x,y,z) = floating_overflow(() = underflow if add3F(x,y,z) = underflow = add3_midF(0,y,z) if x = 0 and y,z ( F ( {(,0,+(} = add3_midF(x,0,z) if y = 0 and x ( F ( {(,+(} and z ( F ( {(,0,+(} = add3_midF(x,y,0) if z = 0 and x,y ( F ( {(,+(} = invalid(qnan) if x ( {(,+(} and y,z ( F({(,+(} = invalid(qnan) if y ( {(,+(} and x ( F and z ( F({(,+(} = invalid(qnan) if z ( {(,+(} and x,y ( F = qnan if x is a quiet NaN and not y nor z is a signalling NaN = qnan if y is a quiet NaN and not x nor z is a signalling NaN = qnan if z is a quiet NaN and not x nor y is a signalling NaN = invalid(qnan) if x is a signalling NaN or y is a signalling NaN or z is a signalling NaN Note: This operation does not return underflow if iec_559F = true. mul_addF : F ( F ( F ( F({floating_overflow, underflow} mul_addF(x,y,z) = resultF((x*y)+z, rndF) if x,y,z ( F and x(0 and y(0 and z(0 = addF(mulF(x,y),z) if x ( {(,0,0,+(} and y,z ( F ( {(,0,+(} = addF(mulF(x,y),z) if y ( {(,0,0,+(} and x ( F and x ( 0 and z ( F ( {(,0,+(} = addF(mulF(x,y),z) if z ( {(,0,0,+(} and x,y ( F and x ( 0 and y ( 0 = qnan if x is a quiet NaN and not y nor z is a signalling NaN = qnan if y is a quiet NaN and not x nor z is a signalling NaN = qnan if z is a quiet NaN and not x nor y is a signalling NaN = invalid(qnan) if x is a signalling NaN or y is a signalling NaN or z is a signalling NaN Note: mul_addF(x,y,z) = addF(mulF(x,y),z) if x ( F or y ( F or z ( F or x=0 or y=0 or z=0. E.g., mul_addF(0,1,0) = 0. F' is a floating point type conforming to LIA-1. mulF(F' : F ( F ( F' ( {0, floating_overflow, underflow} mulF(F'(x,y) = resultF'(x*y, rndF') if x,y ( F and x ( 0 and y ( 0 = cvtF(F'(mulF(x,y)) if x ( {(,0,0,+(} and y ( F ( {(,0,+(} = cvtF(F'(mulF(x,y)) if y ( {(,0,0,+(} and x ( F and x ( 0 = cvtF(F'(qnan) if x is a quiet NaN and y is not a signalling NaN = cvtF(F'(qnan) if y is a quiet NaN and x is not a signalling NaN = cvtF(F'(snan) if x is a signalling NaN or y is a signalling NaN Note: Converting a signalling NaN results in a notification of invalid. See clause 5.4. Floor, ceiling, and round floorF : F ( F [intpartfF] floorF(x) = (x( if x ( F = 0 if x = 0 = +( if x = +( = ( if x = ( = qnan if x is a quiet NaN = invalid(qnan) if x is a signalling NaN roundingF : F ( F({0} [intpartrF] roundingF(x) = round(x) if x ( F and (x >= 0 or round(x) ( 0) = negF(0) if x ( F and x < 0 and round(x) = 0 = 0 if x = 0 = +( if x = +( = ( if x = ( = qnan if x is a quiet NaN = invalid(qnan) if x is a signalling NaN ceilingF : F ( F({0} [intpartcF] ceilingF(x) = (x( if x ( F and (x = 0 or (x( ( 0) = negF(0) if x ( F and x ( 0 and (x( = 0 = 0 if x = 0 = +( if x = +( = ( if x = ( = qnan if x is a quiet NaN = invalid(qnan) if x is a signalling NaN Note: The result in the second case for roundingF and ceilingF is 0, if 0 is not in the type corresponding to F, otherwise it is 0. Note: floorF(x) = negF(ceilingF(negF(x))), ceilingF(x) = negF(floorF(negF(x))), and roundingF(x) = negF(roundingF(negF(x))). Negative zeroes, if available, are handed in such a way as to maintain these identites. Note: Truncation is already in LIA-1, by the name intpartF. floor_restF : F ( F [fractpartfF] floor_restF(x) = x(x( if x ( F = 0 if x = 0 = invalid(qnan) if x = +( = invalid(qnan) if x = ( = qnan if x is a quiet NaN = invalid(qnan) if x is a signalling NaN rounding_restF : F ( F [fractpartrF] rounding_restF(x) = xround(x) if x ( F = 0 if x = 0 = invalid(qnan) if x = +( = invalid(qnan) if x = ( = qnan if x is a quiet NaN = invalid(qnan) if x is a signalling NaN ceiling_restF : F ( F [fractpartcF] ceiling_restF(x) = x(x( if x ( F = 0 if x = 0 = invalid(qnan) if x = +( = invalid(qnan) if x = ( = qnan if x is a quiet NaN = invalid(qnan) if x is a signalling NaN Note: The rest after truncation is already in LIA-1, by the name fractpartF. Divideandfloor, ceiling, round idivfF : F ( F ( F({0, floating_overflow, invalid} idivfF(x,y) = resultF((x/y(, downF) if x,y ( F and x ( 0 and y ( 0 = divF(x,y) if x ( F or y ( F or x = 0 or y = 0 idivrF : F ( F ( F({0, floating_overflow, invalid} idivrF(x,y) = resultF(round(x/y), nearestF) if x,y ( F and x ( 0 and y ( 0 = divF(x,y) if x ( F or y ( F or x = 0 or y = 0 idivcF : F ( F ( F({0, floating_overflow, invalid} idivcF(x,y) = resultF((x/y(, upF) if x,y ( F and x ( 0 and y ( 0 = divF(x,y) if x ( F or y ( F or x = 0 or y = 0 Note: idivcF(x,y) = negF(idivfF(negF(x),y)), idivcF(x,y) = negF(idivfF(x,negF(y))), idivfF(x,y) = negF(idivcF(negF(x),y)), idivfF(x,y) = negF(idivcF(x,negF(y))), idivrF(x,y) = negF(idivrF(negF(x),y)), idivrF(x,y) = negF(idivrF(x,negF(y))). ["floating modulo", if denormF=true] iremfF : F ( F ( F({underflow, invalid} [no underflow if iec_559F=true] iremfF(x,y) = resultF(x((x/y(*y), rndF) if x,y ( F and y ( 0 = iremfF(0,y) if x = 0 and y ( {(,0,+(} = iremfF(x,0) if y = 0 and x ( {(,+(} = invalid(qnan) if x ( F({(,+(} and y = 0 = invalid(qnan) if x ( {(,+(} and y ( F({(,+(} = +( if y = +( and x ( F and x < 0 = ( if y = ( and x ( F and x < 0 = x if y ( {(,+(} and x ( F and x ( 0 = qnan if x is a quiet NaN and y is not a signalling NaN = qnan if y is a quiet NaN and x is not a signalling NaN = invalid(qnan) if x is a signalling NaN or y is a signalling NaN Note: iremfF is exact if both arguments have the same sign and there is no underflow. [IEC 559 rem, if denormF=true] iremrF : F ( F ( F({0, underflow, invalid} [no underflow if iec_559F=true] iremrF(x,y) = resultF(x(round(x/y)*y), rndF) if x,y ( F and y ( 0 and (x ( 0 or x(round(x/y)*y)( 0) = 0 if x,y ( F and y ( 0 and x < 0 and x(round(x/y)*y) = 0 = negF(iremrF(0,y)) if x = 0 and y ( F({(,0,+(} = iremrF(x,0) if y = 0 and x ( F({(,+(} = invalid(qnan) if x ( F({(,+(} and y = 0 = invalid(qnan) if x ( {(,+(} and y ( F({(,+(} = x if y ( {(,+(} and x ( F = qnan if x is a quiet NaN and y is not a signalling NaN = qnan if y is a quiet NaN and x is not a signalling NaN = invalid(qnan) if x is a signalling NaN or y is a signalling NaN Note: iremrF is exact when there is no underflow. iremcF : F ( F ( F({0, underflow, invalid} [no underflow if iec_559F=true] iremcF(x,y) = resultF(x((x/y(*y), rndF) if x,y ( F and y ( 0 and x((x/y(*y) ( 0 = 0 if x,y ( F and y ( 0 and x((x/y(*y) = 0 = iremcF(0,y) if x = 0 and y ( F({(,0,+(} = iremcF(x,0) if y = 0 and x ( F({(,+(} = invalid(qnan) if x ( F({(,+(} and y = 0 = invalid(qnan) if x ( {(,+(} and y ( F({(,+(} = ( if y = +( and x ( F and x > 0 = +( if y = ( and x ( F and x > 0 = x if y ( {(,+(} and x ( F and x ( 0 = qnan if x is a quiet NaN and y is not a signalling NaN = qnan if y is a quiet NaN and x is not a signalling NaN = invalid(qnan) if x is a signalling NaN or y is a signalling NaN Note: iremcF is exact if both arguments have different signs and there is no underflow. Note: iremcF(x,y) = negF(iremfF(negF(x),y)), iremcF(x,y) = iremfF(x,negF(y)), iremfF(x,y) = negF(iremcF(negF(x),y)), iremfF(x,y) = iremcF(x,negF(y)), iremrF(x,y) = negF(iremrF(negF(x),y)), iremrF(x,y) = iremrF(x,negF(y)). Square root and reciprocal square root sqrtF : F ( F({invalid} sqrtF(x) = nearestF((x) if x ( F and x >= 0 = 0 if x = 0 = invalid(qnan) if (x ( F and x < 0) or x = ( = +( if x = +( = qnan if x is a quiet NaN = invalid(qnan) if x is a signalling NaN Note: As usual, (x ( [0, ([, when the function is defined. rec_sqrtF : F ( F({invalid, pole} rec_sqrtF(x) = resultF(1/(x, rndF) if x ( F and x > 0 = pole(+() if x ( F and x = 0 = pole(() ?if x = 0 = 0 if x = +( = invalid(qnan) if (x ( F and x < 0) or x = ( = qnan if x is a quiet NaN = invalid(qnan) if x is a signalling NaN [Too stringent spec. for rec_sqrtF? Use a rec_sqrt*F?] Support for extended floating point precision [no underflow if iec_559F = true] add_loF : F ( F ( F({floating_overflow, underflow} add_loF(x,y) = resultF((x+y)c.v.addF(x,y), rndF) if x,y,c.v.addF(x,y) ( F = floating_overflow(() if addF(x,y) = floating_overflow(+() = floating_overflow(+() if addF(x,y) = floating_overflow(() = underflow if addF(x,y) = underflow = add_loF(0,y) if x = 0 and y ( F ( {(,0,+(} = add_loF(x,0) if y = 0 and x ( F ( {(,+(} = invalid(qnan) if x ( {(,+(} and y ( F({(,+(} = invalid(qnan) if y ( {(,+(} and x ( F = qnan if x is a quiet NaN and y is not a signalling NaN = qnan if y is a quiet NaN and x is not a signalling NaN = invalid(qnan) if x is a signalling NaN or y is a signalling NaN Note: If rnd_styleF=nearest (and add*F is true addition, which is implied by rnd_styleF=nearest), then in the absence of notifications, add_loF returns an exact result. [no underflow if iec_559F = true] sub_loF : F ( F ( F({floating_overflow, underflow} sub_loF(x,y) = resultF((xy)c.v.subF(x,y), rndF) if x,y,c.v.subF(x,y) ( F = floating_overflow(() if subF(x,y) = floating_overflow(+() = floating_overflow(+() if subF(x,y) = floating_overflow(() = underflow if subF(x,y) = underflow = sub_loF(0,y) if x = 0 and y ( F ( {(,0,+(} = sub_loF(x,0) if y = 0 and x ( F ( {(,+(} = invalid(qnan) if x ( {(,+(} and y ( F({(,+(} = invalid(qnan) if y ( {(,+(} and x ( F = qnan if x is a quiet NaN and y is not a signalling NaN = qnan if y is a quiet NaN and x is not a signalling NaN = invalid(qnan) if x is a signalling NaN or y is a signalling NaN Note: if rnd_styleF=nearest (and add*F is true addition, which is implied by rnd_styleF=nearest), then in the absence of notifications, sub_loF returns an exact result. Note: sub_loF(x,y) = add_loF(x,negF(y)). mul_loF : F ( F ( F({floating_overflow, underflow} mul_loF(x,y) = resultF((x*y)c.v.mulF(x,y), rndF) if x,y,c.v.mulF(x,y) ( F = 0 if x,y ( F and c.v.mulF(x,y) = 0 = floating_overflow(() if mulF(x,y) = floating_overflow(+() = floating_overflow(+() if mulF(x,y) = floating_overflow(() = underflow if mulF(x,y) = underflow = mul_loF(0,y) if x = 0 and y ( F ( {(,0,+(} = mul_loF(x,0) if y = 0 and x ( F ( {(,+(} = invalid(qnan) if x ( {(,+(} and y ( F({(,+(} = invalid(qnan) if y ( {(,+(} and x ( F = qnan if x is a quiet NaN and y is not a signalling NaN = qnan if y is a quiet NaN and x is not a signalling NaN = invalid(qnan) if x is a signalling NaN or y is a signalling NaN Note: In the absence of notifications, mul_loF returns an exact result. div_restF : F ( F ( F({floating_overflow, underflow, invalid} div_restF(x,y) = resultF(x(c.v.divF(x,y)*y), rndF) if x,y,c.v.divF(x,y) ( F = x if x,y ( F and c.v.divF(x,y) = 0 = invalid(NaN) if x ( F and y = 0 = floating_overflow(() if divF(x,y) = floating_overflow(+() = floating_overflow(+() if divF(x,y) = floating_overflow(() = underflow if divF(x,y) = underflow = div_restF(0,y) if x = 0 and y ( F ( {(,0,+(} = invalid(qnan) if y = 0 and x ( F ( {(,+(} = invalid(qnan) if x ( {(,+(} and y ( F({(,+(} = invalid(qnan) if y ( {(,+(} and x ( F = qnan if x is a quiet NaN and y is not a signalling NaN = qnan if y is a quiet NaN and x is not a signalling NaN = invalid(qnan) if x is a signalling NaN or y is a signalling NaN sqrt_restF : F ( F({underflow, invalid} sqrt_restF(x) = resultF(x(sqrtF(x)*sqrtF(x)), rndF) if x ( F and x ( 0 = 0 if x = 0 = invalid(qnan) if (x ( F and x < 0) or x = ( or x = +( = qnan if x is a quiet NaN = invalid(qnan) if x is a signalling NaN Note: sqrt_restF(x) is exact when there is no underflow. Support for extended floating point range These operations are specified only if iec_559F=true. The countF helper function (similar to resultF): countF : R ( (R(F*) ( F({increment, decrement} countF(x, rnd) = rnd(x) if |rnd(x)| ( fmaxF and |x| ( fminNF = increment(rnd(x/rF^(3*(emaxFeminF)/4))) if |rnd(x)| > fmaxF [?] = decrement(rnd(x*rF^(3*(emaxFeminF)/4))) if |x| < fminNF [?] 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 hardtoignore message if counter not zero on termination.) get_countI: I ( I get_countI, for some signed I returns the system underflow/overflow counter's value and sets that system counter to the value of the argument. These operations return integer_overflow if the system counter used for increment/ decrement overflows. add_cntF : F ( F ( F({increment, decrement, integer_overflow} add_cntF(x,y) = countF(x+y, nearestF) if x,y ( F = addF(x,y) if x ( F or y ( F sub_cntF : F ( F ( F({increment, decrement, integer_overflow} sub_cntF(x,y) = countF(xy, nearestF) if x,y ( F = subF(x,y) if x ( F or y ( F mul_cntF : F ( F ( F({0, increment, decrement, integer_overflow} mul_cntF(x,y) = countF(x*y, nearestF) if x,y ( F and x (0 and y ( 0 = mulF(x,y) if x ( F or y ( F or x = 0 or y = 0 div_cntF : F(F ( F({0,increment,decrement,pole,invalid,integer_overflow} div_cntF(x,y) = countF(x/y, nearestF) if x,y ( F and x (0 and y ( 0 = divF(x,y) if x ( F or y ( F or x = 0 or y = 0 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: addupF : F ( F ( F({floating_overflow} addupF(x,y) = resultF(x+y, upF) if x,y ( F = addF(x,y) if x ( F or y ( F subupF : F ( F ( F({floating_overflow} subupF(x,y) = resultF(xy, upF) if x,y ( F = subF(x,y) if x ( F or y ( F mulupF : F ( F ( F({0, floating_overflow, underflow} mulupF(x,y) = resultF(x*y, upF) if x,y ( F and x ( 0 and y ( 0 = mulF(x,y) if x ( F or y ( F or x = 0 or y = 0 divupF : F ( F ( F({0, floating_overflow, underflow, invalid, pole} divupF(x,y) = resultF(x/y, upF) if x,y ( F and x ( 0 and y ( 0 = divF(x,y) if x ( F or y ( F or x = 0 or y = 0 sqrtupF : F ( F({invalid} sqrtupF(x) = resultF((x, upF) if x ( F and x >= 0 = invalid(NaN) if x ( F and x < 0 = sqrtF(x) if x ( F adddownF : F ( F ( F({0, floating_overflow} adddownF(x,y) = resultF(x+y, downF) if x,y ( F and addF(x,y) ( 0 = 0 if addF(x,y) = 0 = addF(x,y) if (x ( F or y ( F) and addF(x,y) ( 0 subdownF : F ( F ( F({0, floating_overflow} subdownF(x,y) = resultF(xy, downF) if x,y ( F and subF(x,y) ( 0 = 0 if subF(x,y) = 0 = subF(x,y) if (x ( F or y ( F) and subF(x,y) ( 0 muldownF : F ( F ( F({0, floating_overflow, underflow} muldownF(x,y) = resultF(x*y, downF) if x,y ( F and x ( 0 and y ( 0 = mulF(x,y) if x ( F or y ( F or x = 0 or y = 0 divdownF : F ( F ( F({0, floating_overflow, underflow, invalid, pole} divdownF(x,y) = resultF(x/y, downF) if x,y ( F and x ( 0 and y ( 0 = divF(x,y) if x ( F or y ( F or x = 0 or y = 0 sqrtdownF : F ( F({0, invalid} sqrtdownF(x) = resultF((x, downF) if x ( F and x > 0 = 0 ?if x = 0 = invalid(qnan) if x ( F and x < 0 = sqrtF(x) if x ( F The following operations partially support extended range floating point interval arithmetic. add_cntupF : F ( F ( F({increment, decrement, integer_overflow} add_cntupF(x,y) = countF(x+y, upF) if x,y ( F = addupF(x,y) if x ( F or y ( F sub_cntupF : F ( F ( F({increment, decrement, integer_overflow} sub_cntupF(x,y) = countF(xy, upF) if x,y ( F = subupF(x,y) if x ( F or y ( F mul_cntupF : F ( F ( F({0, increment, decrement, integer_overflow} mul_cntupF(x,y) = countF(x*y, upF) if x,y ( F and x (0 and y ( 0 = mulupF(x,y) if x ( F or y ( F or x = 0 or y = 0 div_cntupF:F(F ( F({0,increment,decrement,pole,invalid,integer_overflow} div_cntupF(x,y) = countF(x/y, upF) if x,y ( F and x (0 and y ( 0 = divupF(x,y) if x ( F or y ( F or x = 0 or y = 0 add_cntdownF : F ( F ( F({increment, decrement, integer_overflow} add_cntdownF(x,y) = countF(x+y, downF) if x,y ( F = adddownF(x,y) if x ( F or y ( F sub_cntdownF : F ( F ( F({increment, decrement, integer_overflow} sub_cntdownF(x,y) = countF(xy, downF) if x,y ( F = subdownF(x,y) if x ( F or y ( F mul_cntdownF : F ( F ( F({0, increment, decrement, integer_overflow} mul_cntdownF(x,y) = countF(x*y, downF) if x,y ( F and x (0 and y ( 0 = muldownF(x,y) if x ( F or y ( F or x = 0 or y = 0 div_cntdownF:F(F(F({0,increment,decrement,pole,invalid,integer_overflow} div_cntdownF(x,y) = countF(x/y, downF) if x,y ( F and x (0 and y ( 0 = divdownF(x,y) if x ( F or y ( F or x = 0 or y = 0 Elementary trancendental floating point operations See separate document! Suggested LIA2 sections 5.4 and 5.5: additional conversion operations and numerals Conversion operations If both the source and target types contain 0, +(, (, or quiet NaN, then such a value is converted to the same special value in the target type without notification. A signalling NaN causes an invalid notification with, if possible, a quiet NaN as continuation value. For quiet NaN, if the target type does not contain such a value, an invalid notification results when converting a quiet NaN. For each of the +( and (, if the source but not the target type contain the value, an appropriate overflow notification results when converting the special value. 0 is converted to 0 without any notification if 0 is missing in the target type (integer_overflow, if the target type is an integer type, etc.). Fixed point string formats and floating point string formats should have formats for 0, +(, (, quiet and signalling NaNs. Integer string formats may have formats for such values. Note: In ordinary string formats, the string Hello word!, e.g., is a signalling NaN. Note: This part of LIA does not specify any string formats, not even for the special values 0, +(, (, and quiet NaN, but possibilities include the strings used in the text of this part of LIA, as well as strings like +infinity or positiva ondligheten, etc, and the strings used may depend on locale, or user, preference settings. String formats for numerical values, and if and how they may depend on preference settings, is also an issue for bindings, not for this part of LIA. Integer to integer conversions I and I' represent different integer data types (even if the sets I and I' are the same). At least one of I and I' conform to LIA-1. Note: If both are I and I' are conforming to LIA-1, then this conversion is covered by LIA-1. This operation generalises the cvtI(I' of LIA-1, with respect to that one of the integer types in the conversion need not be conforming to LIA-1. convertI(I' : I ( I'({integer_overflow} convertI(I'(x) = resultI'(x) if x ( I Note: This covers, among other things, input and output of integer type values, including the possibility of overflow (for either input or output). Note: The conversion of values that are not elements of Z are covered by the first paragraph of section 5.4. (E.g. trying to interpret the string hello world as an integer value, under ordinary formatting constraints.) Floating point to integer conversions I is an LIA-1 conforming integer type. F is an LIA-1 conforming floating point type. The operations in this clause are more specific than the floating point to integer conversion in LIA-1 which allows any rounding. floorF(I : F ( I({integer_overflow} floorF(I (x) = resultI((x() if x ( F ceilingF(I : F ( I({integer_overflow} ceilingF(I (x) = resultI((x() if x ( F roundingF(I : F ( I({integer_overflow} roundingF(I (x) = resultI(round(x)) if x ( F Note: The conversion of values that are not elements of R are covered by the first paragraph of section 5.4. Integer to floating point conversions convertdownI(F : I ( F({floating_overflow} convertdownI(F(x) = resultF(x, downF) if x ( I convertupI(F : I ( F({floating_overflow} convertupI(F(x) = resultF(x, upF) if x ( I convertnearestI(F : I ( F({floating_overflow} convertnearestI(F(x) = resultF(x, nearestF) if x ( I [= cvtI(F of LIA-1] 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 F and F' represent different floating point data types (even if the sets F and F' are the same). At least one of F and F' conform to LIA-1. Note: How to convert values in the source type that are not in F is covered by the first paragraph of section 5.4. convertdownF(F' : F ( F'({floating_overflow, underflow} convertdownF(F'(x) = resultF'(x, downF') if x ( F convertupF(F' : F ( F'({floating_overflow, underflow} convertupF(F'(x) = resultF'(x, upF') if x ( F convertnearestF(F' : F ( F'({floating_overflow, underflow} convertnearestF(F'(x) = resultF'(x, nearestF') if x ( F [gen. cvtF(F' of LIA-1] 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). A fixed point type D shall be a subset of R, characterised by a radix, rD ( Z (( 2), a density, dD(Z (( 0), and if it is limited a maximum positive value, dmaxD ( D* (( 1). Given these values, the following sets are defined: D* = {n/(rDdD) | n ( Z} D = D* if D is unlimited = D*([dmaxD, dmaxD] if D is limited Fixed point rounding helper functions: downD : R ( D* is a rounding function like downF, but for a fixed point type, rounds towards negative infinity. upD : R ( D* is a rounding function like upF, but for a fixed point type, rounds towards positive infinity. nearestD : R ( D* is a rounding function like nearestF, but for a fixed point type, rounds to nearest, ties round to even last digit. Fixed point result helper function: resultD : R ( (R ( D*) ( D({overflow} is like resultF, but for a fixed point type. It will return overflow if the rounded result is not representable: resultD(x, rnd) = rnd(x) if rnd(x) ( D = overflow if rnd(x) ( D F is a floating point type conforming to LIA-1. D is a fixed point type, it cannot conform to LIA-1, since fixed point types are not covered by LIA-1. convertdownF(D : F ( D({overflow} convertdownF(D(x) = resultD(x, downD) if x ( F convertupF(D : F ( D({overflow} convertupF(D(x) = resultD(x, upD) if x ( F convertnearestF(D : F ( D({overflow} convertnearestF(D(x) = resultD(x, nearestD) if x ( F Note: The type D need not be visible in the programming language. D may be a subtype of strings, according to some format. Even so, no type for strings need be present in the programming language. Note: This covers, among other things, output of floating point type values, to fixed point string formats. E.g. a binding may say that float_to_fixed_string(x, m, n) is bound to convertnearestF(Sm,n(x) where Sm,n is strings of length m, representing fixed point values in (LID) scaled(10, n). The binding should also detail how NaNs, signed zeroes and infinities are represented in Sm,n, as well as the precise format of the strings representing ordinary values. (Note that if the length of the target string is limited, the conversion may overflow.) Fixed point to floating point conversions F is a floating point type conforming to LIA-1. D is a fixed point type, it cannot conform to LIA-1, since fixed point types are not covered by LIA-1. convertdownD(F : D ( F({floating_overflow, underflow} convertdownD(F(x) = resultF(x, downF) if x ( D convertupD(F : D ( F({floating_overflow, underflow} convertupD(F(x) = resultF(x, upF) if x ( D convertnearestD(F : D ( F({floating_overflow, underflow} convertnearestD(F(x) = resultF(x, nearestF) if x ( D Note: This covers, among other things, input of floating point type values, from fixed point string formats. E.g. a binding may say that string_to_float(s) is bound to convertnearestSm,n(F(s) where Sm,n is strings of length m, where m is the length of s, and n is the number of digits after the decimal symbol in s. The binding should also detail how NaNs, signed zeroes and infinities are represented in Sm,n, as well as the precise format of the strings representing ordinary values. Numerals Each numeral is an operation. So this section introduces a very large number of operations. Numerals for integer types A numeral, denoting a mathematical value n in Z, for an integer type, I, results in resultI(n) For each LIA-1 conforming integer type there shall be integer numerals for all non-negative values of I. Integer numeral representations using radix 10 should be available. Note: Negative values (except minintI if minintI=maxintI1) can be obtained by using the negation operation (negI). Note: Other radices may also be available for integer numerals, and the radix used may be part of determining the goal integer type. E.g., radix 10 may be for signed integer types, and radix 8 or 16 may be for unsigned integer types. Note: Syntaxes for numerals for different integer types need not be different, nor need they be the same. LIA-2 does not further specify the format for integer numerals. That is an issue for bindings. Note: Overflow can be detected at compile time, and warned about. Numerals for floating point types Afractional numeral, denoting a mathematical value x in R, for a floating point type, F, shall normally result in: resultF(x, nearestF) shall in a round towards positive infinity circumstance result in: resultF(x, upF) shall in a round towards negative infinity circumstance result in: resultF(x, downF) If iec_559F=true then the directed roundings shall be available also for fractional numerals. The rounding circumstance should be statically determined, if other than the normal is at all available. For each LIA-1 conforming floating point type, F, there shall be fractional numerals for all radix 10 limited precision and limited range expressible non-negative values of R. The precision and range for the numerals shall be large enough to allow all non-negative values of F to be reachable. Note: Negative values can be obtained by using the negation operation (negF). Note: Other radices may also be available for floating point numerals. Note: Integer numerals may also be fractional numerals, i.e. their syntaxes need not be different. Nor need syntaxes for numerals for different floating point types be different, nor need they be the same. LIA-2 does not further specify the syntax for numerals. That is an issue for bindings. SIDA 12 SIDA 1  }.A HH28>FG{HH d'h<@N-Up@SWII@copy@|dest@,extl@feed@vffmt@2fpan@job @nmap@$objs@pdds@pmap@8ppWM@ppan@Vqual@rang@zsmap@*sort@tmap@0univ@BestNormalDraft##: US Letter@RsyptPtvkMicrosoft WordgerQMicrosoft Word - nydefs.lia2.(Gran Schumacher"@P #P PrinterR5>@5=;,Z6 Sidor/ark 'ZppWMPeirce WatermarkerBpHBwN-Up Sidor/arktermarkerBpHBw4Y P̏P  A4 Letter' =' =ߙ4z'`@base@crea@ flag@unit@sypt@@dirm@ layo@scal@ dd A4 Letter' =' =ߙ4z'`@base@crea@ flag@unit@sypt@@dirm@layo@scal@  ddunivnonerastSWIIStyleWriter GXStyleWriter GXࡱ; u9OUVY^a  .2345679:;<=>DHIzJJUJJVhU]V]hV]]VUVc W &'*01289<=@ABCDJKNTUV\]`afghijk  !$%()JJJJJVhJJV[)*+,-./01589:;<=EFGHOPQRSTUV        - 0 1 2 3 4 5 8 9 : ; < = @ A B E F G H          ! UJhJVhJVJ\! " # $ - 0 1 K N O S V W X Y Z [        % & ' ( ) * / 0 1 2 F M S T U V W X ] ^ v { |  VhJJJUJJVhVJZ    " # > E J K L M N O P Q V W s y z } ~    JVhJJJJVhUJJVY X _ ` c d e f g h i j k l m n p "%&'()*+/56=>?@GHIJKLMNSTUVJhJJVhJUJJJVhVXVlsyz}~,/01CFGHKLMNOPQRSTUVJJJJJJVhhJVUYVXhjqvyz{|}~$'(),-./012345679IKRWZ[\]^_`djklmqrstuvwJJJJJJJVhhVUYwx~   !&,-./012789:;<=>BCHIJKLMNOTUVWdkpqstuv|}JJJJJVhhUJJVY !"#,-./8?@HM|#'(+,-./6:>?@AGKQRSTUV]h]JUJJVhV]]^rw}~69:=>?@ABCDEFGHJZ\chklmnoptz{JJJVhJUV^     :=>CIJrxy JJJJVhUJV\    <=>?@ABCIJTUdghijkl  nuvy} !"#$(0123459=>?@ABHIJKLMNOTZ[^_`abcJJUVhJVJ]cdefgkqrstuv~    !"#+,-.JJVhVJ_.2:;<=>?CIJMST]^_`abcdiqruvwxyz{|}~   JJJVhV`  %,-0123456789:;<=>?AHMTUVWXYZ[`abcfghijkmnopqwxyz{|}~JJJUJJJVhJVZ    !"&'3:BCDEFGHINOX_`cdefghijklmnopqrt{JJJJVhUJJVJZ  !"'-./0123?@CDEFGHIJKhJJJVhUJJJJVYKQRUVWXYZ[\abcdefghlmpvwxyz{|UJJJJJVhhJJVY"#$%&'()./R S ! ! ! ! ! !!O!V!W!Z![!\!]!^!_!!!!!!##################################JJVhUJJV^###########$$$$ $!$"$#$$$%$*$+$?$@$L$M$[$\$a$b$n$o$p$q$r$s$x$y$z${$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ % %%%%%%%%% %!%"%%%&%6%JJJJV`6%7%=%>%C%D%J%K%L%M%N%O%P%S%T%c%d%e%f%h%k%l%%%%%%%%%%%%%%%%%%%%%%%& &&"&%&&&)&*&+&,&-&.&/&0&1&2&6&9&:&;&<&=&>&G&H&I&J&O&P&Q&R&S&T&U&V&f&g&s&t&u&v&w&x&}&JJVhV``UV``ZJJVJW}&~&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&'' ' ''''''' '!','-'2'3'8'9'?'@'A'B'C'D'E'H'I'Y'Z'`'a'f'g'm'n'o'p'q'r's'v'w''''''''''''''''''''''''JJJJV`'''''''''''''''''(((( ("(%(&(:(;(S(Z(a(c(d(e(f(h(k(l((((((((((((((((((((((((((((((((((((((((((((((((((((JJVhV``UV``ZJJVJW(((())))())).)/)0)1)2)3)4)7)8)A)B)I)J)c)d)e)g)k)l))))))))))))))))))))))))))))))))))))****** * **********!*"*-*.*3*4*5*6*7*JJVhV``UZJVJJY7*8*9*<*=*E*F*M*N*f*g*l*m*n*o*p*q*r*u*v*~*********************+++9+=+>+B+F+G+&,',(,*,+,,,3,4,5,G,J,K,L,M,N,O,R,S,T,U,V,W,Z,[,\,_,`,a,b,,,,,,,,,,,,JJhVhV``UZJJJVY,,,,,-----------$-%---0-1-2-3-4-6-7-<-?-@-I-J-K-L-M-N-O-P-U-X-Y-\-]-b-c-o-p-q-r-s-t-u-v-z-{-------------------------------------------JJVhUJV_------. . ..........!."./.0.5.6.<.=.>.?.@.A.F.M.O.P.Q.R.W.X.].^.d.e.j.k.q.x.z.{.|.}............................////// /"/%/&/>/?/S/\/_/V``V``ZUJJJV[_/`/z/}/~///////////0000 00J0N0O0R0S0T0U0V0W0X0Y0Z0[0\0]0^0_0`0a0r0t0}000000000000000000000000000000000000000000000000000JJJJJUVVh\000000000000001 1 1111111 1!1"1#1%1&1+1,1-1.12131<1=1D1E1F1G1H1I1Q1R1V1W1X1Y1Z1[1\1_1`1i1j1v1y1z1{1~11111111111111111111111111111111112ZVhJJVJ^2222 22.2/24252T2U2V2W2\2]2}2~2222222222222223333333 3!3%3(3)3*3-3.3/30313234353:3;3<3=3>3?3C3D3E3F3G3H3L3M3N3O3P3Q3X3\3]33333333333333333333333JJVhUVZ_3333333333344444 4 4 4444444444%4)4*4+4,4-4.4/404346474A4B4C4D4E4F4K4O4P4Q4R4S4T4U4V4X4Y4Z4[4m4~44444444444444444444444444444455 55JJVhUJVJ]5&5*5.5/505152535455595B5T5\5]5`5a5b5c5h5i5u5v5w5x5y5z5{5|5}5~555555555555555555555555555555555555556666666"6#6/6061626364656667686<6=6A6B6V6]6_6JJJVhVU^_6`6a6b6g6h6i6j6n6o6s6t6{6|6}6~66666666666666666666666666666666666666666677777 7 7 7777777 7!7"7#7$7%7&797:7;7<7A7B7b7c7h7i777777777UJJJVZ_7777777778888=8D8F8G8H8I8N8O8p8q888888888888888888999999999 9 9 9 999(9-9495969798999:9;9?9E9F9H9I9J9K9M9N9P9S9T9Y9Z9[9\9]9^9_9`9a9b9g9h9i9o9p9q9JJJJJVhUZV\q9w9x9y9999999999999999999999999999999999999999999999999:::: : :::::: :!:":*:,:0:1:2:3:::;:<:=:>:?:@:A:E:F:O:P:b:e:f:g:j:k:l:m:n:o:q:JJJVhJV^q:r:w:x:y:z:~::::::::::::::::::::::::::::::;; ;!;&;';G;H;M;N;s;t;u;v;{;|;;;;;;;;;;;;;;;<<:<A<B<C<D<E<F<G<H<L<O<P<Q<T<U<V<W<X<Y<[<\<b<c<d<e<f<JVhUZJJJV]f<g<k<l<m<n<o<p<t<u<v<w<x<y<}<~<<<<<<<<<<<<<<<<<<<<<<<<<<== ===%=*=-=.=/=0=1=2=3=4=5=9=?=@=A=B=C=D=E=G=J=K=L=Q=R=S=T=U=V=W=X=]=^=_=`=g=h=i=j=u=x=y=z={=JJUJJJhJhVhJVY{=|=}================================================>>>>>> > > > >>>>>>>!>">#>$>'>*>+>?>@>X>a>d>e>f>g>h>j>k>l>m>p>s>t>>V``ZJJhJJJVhVhY>>>>>>>>>>>>>>>>>>>-?4?e?j?k?n?o?p?q?r?s?x?????????????????????????????????????@@@$@&@'@(@)@/@0@I@Q@R@U@V@W@X@Y@JJJJhJUV``ZhJhVhV`V`TY@Z@[@c@j@k@l@q@y@z@{@|@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@AAAA!A"A0A1A8A9A>A?ALAMANAOATAUAoAvAxAyAzA{AAAAAAAAAAAAAAAAAAAAAAAAAJJUZJJJVhhJVXAAAAAAAAAAAAAAAAABB B B B B BBBBBBBBB B6B7BHBIBPBQBVBWBbBcBjBkBpBqB{B|B}B~BBBBBBBBBBBBBBBCC7C8CWC\C]C^C_CcCfCgChCoCpCqCtCuCvCwCCCCCCCCUZJVhJJJVJ[CCCCCCCCCCCCCCCCCCCCCCCCCCjDqDrDyDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDEEEEEEEEE E%E&E4E5E6E7EFCFDFIFJF^F_F`FaFfFgFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFJJJUJhJVhVZ[FFFFFFFGG,G3G5G6G7G8G=G>GCGDGTG[G]G^G_G`GeGfGkGlG}G~GGGGGGGGGGGGGHHHBHFHGHHHKHLHMHNHOHPHQHRHSHTHUH\HmHoHvH{HHHHHHHHHHHHHHHHHHHHHHHHJJJJJhVhJZUJVXHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHIIIIIIII I I II#I%I,I1I5I6I7I8I9I:I;I?IEIFIMINIOIPISIZI[IaIbIcIdIeIfIgIhImInIoIpIwIxIyIzIIIUJJJhJVhJVJZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIJJJJJJ J J JJJJJJJJJJJ"J#J$J%J,J-J.J/J8J;JJ?J@JFJGJHJIJJJJJJJUJJJhJVVhXJJKJOJPJQJRJSJTJXJYJaJbJoJsJtJuJvJwJxJyJ}JJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJKKKKKVhhJVaKKKKKKKKKKKK K!K"K&K'K(K)K,K-K.K/K1K2K5K:K;KK?K@KCKFKGKHKIKMKNKOKPKUKVKWKXKwK}K~KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKJJJJUVhhV]KKKKKKKKLLLLLLLL L LLLLLLL"L#L)L*L6L7L8L9L=L>LGLHLRLVLWLXLYLZLbLcLoLpLqLrLvLwL{L|LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLJZUJhJJVhJV[LLLLLLLMM M MMMMMMMMM*M+M2M3M8M9M?M@MAMBMCMDMIMJMVMWM]M^M_M`MdMeMiMjMqMrMsMtMuMvM{M|M}M~MMMMMMMMMMMMMMMMMMMMNNNNNNNNNN3N4NHNQNUNVNWNNVhhV``UV``ZJJVJYNNNNNNNNNNNNNNNNNNNNNNNNNNNOO OOOOOOOOO O!O"O)O/O0O1O2O:O;OPJPKPLPMPNPOPPPSPTPXPYPfPmPoPpPqPrPwPxPyPzP{P|P}PPPPPPPPPPPPPPPPPPPPPPPPPPPZUJJJhVhVJ\PPPPPPPPPPPPPPPPPPPPPP Q Q Q QQQQ'Q(Q@QLQMQNQOQQQTQUQiQjQQQQQQQQQQQQQQQQQQQQR R R RRRRRRRRRRRRR(R*R1R7R@RDRKRLRMRQRVRJJVhhV``UV``ZJVJJVVRZR[R\R]R^R_R`RgRmRnRoRpRrRsRtRuRvRwRxRyR|RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRSS SSSSSSSSS S!S.S2S3SJJJJJJVhhV[3S4S5S6S>S?SKSLSMSNSOSPSQSTSUSYSZSgSnSpSqSrSsSxSySzS{S|S}S~SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTTTTTT T!T'T(T)T*T+T,T1T2TATBTHTITJTKTZUJJJVVh^KTOTPTTTUT\T]T^T_T`TaTfTgThTiTwTxTyTzT|TTTTTTTTTTTTTTTTTUUUUUU U U$U%U9UBUFUGUHUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUVhhV``UV``ZJJVJYUUUUUUUUUUUUUUUUUUUUVVVVVV V VVVVVVVVVV V!V"V#V$V'V(V)V*V0V4V5V6V7V8V9V:V>VAVBVCVGVHVIVJVMVNVOVPVRVSVWV[V\V]V^V_V`VaVeViVjVkVlVmVnVqVrVsVtVVVVVVVVVVVJJhVhV`VVVVVVVVVVVVVVVVVVVVVVVV WWWWWWWWWW W!W&W'W0W1W6W7W?W@WGWHWMWNWUWVWWWXW^W_WsWzW|W}W~WWWWWWWWWWWWWWWWWWWWWWWWWX X X X XXXXXXJJJZJJVhVU\XXX"X#X(X)X*X+X,X-X2X3XAXEXHXIXPXQXRXSXTXUXZX[XiXmXpXqXyXzXXXXXXXXXXXXXXXXXXXXXXXXXXXXXYY Y Y Y YYYBYJYKYUY]Y^Y_YYYYYYYYYYYYYYYYYYYYYJJZJUJVhV]YYYYYYYYYYYYYYZZZZZ ZZZZZZZZZZZ(Z)Z*Z+Z0Z3Z4Z5Z6Z7Z8Z:Z;Ze?eEeHeIeJeKeLeJJJVhV``UV``JJVZXLeMeOePeSeVeWeaebecedeielemeneoepeqeseteueveeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeffffff'f8f;fvAvBvCvDvEvFvHvIvPvSvWvXv[v\v]v^v_v`vavbvcvdvevlv}vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvJUJJJhJVhJVZvvvvvvvvvvvvvvvvvvvvvvvvvvww wwwwwwwwwwww w!w"w)w:w{N{S{Z{\{]{^{_{`{a{e{j{k{l{m{n{o{q{s{t{y{z{{{|{}{~{{{{{{{{{{{{{{{{JUJJJJVhhVJZ{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{||||"|&|'|(|)|*|+|/|4|5|6|7|8|9|;|?|@|E|F|G|H|I|J|K|L|O|P|^|a|e|f|g|h|i|j|o|p|q|r|s|t|x|y|z|{|||}|||||JUJJJVhhJV\||||||||||||||||||||||||||||||||||||||||||||||} }}}}}}}}}}}}}"}#}$}%}&}'},}3}7}8};}<}=}>}?}@}A}B}C}D}E}L}U}W}`}b}r}w}~}}}}}JJVhhUJJJV\}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}~ ~ ~~~~~~~~~~$~%~.~/~3~4~;~<~L~Q~X~\~]~^~_~`~a~e~j~k~l~m~n~o~UJJJJhJJVhVZo~q~u~v~{~|~}~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*./<=dkABJK/?̂͂҂ӂ҅Ӆ؅م*+01UJUVc c UV^JhJJVhVY1  !"#38?@ABCDEJPRSTYZ[\]^01$%؉݉މ߉ #$%&'(-45678;JJJUJJhJhVhVZ;<=>?@ABRW^_`abcdiopqrstz{|}~ƊNJΊϊՊ֊׊؊يڊu|hJJJhJhVhUJJVY‹ËŋɋʋЋыҋӋԋՋڋ$%&')+,234567<CJKLMQRSTUVWXinu|}~UJJJhhJVhV\5bchiԍՍڍۍ01hostuwz{|}~ŽÎĎƎʎˎ̎ҎӎԎՎ֎׎܎ "#$-34567JhUJJJhVhhV]Z79;<=CDEFGHMT[\]_bcdefghij{}ÏˏΏϏЏяҏVWmnJUJJJhhJhVhVZ+,124568<=>?@AGHKLSTklmnptuw{|ĒŒƒǒȒɒ245>?@ABCacdؓߓ]cdhijkmnopqruvwxyzJJJJJVhVhJVZz”ʔ  ".6:=>?ABCDFGwx$%&')-.456789>EGHIJMNOPQRST\JJJhhJJVhVU[\ahjklmnox~Ɩ͖ΖϖЖіҖ֖ܖݖޖߖ;<K`abdeghw~DEHH]UJJJJhVhhV\HIĚŚƚǚȚɚʚ˚ܚޚ #*,-./23456789JLUZacdefqwxyz|~ƛJUJJJhVhhV\ƛ˛қٛڛۛܛœÜĜ̜͜М ABȞΞϞОў:;GHLMjk]JJhVhhV_;ABCDFJKQXYZ^DE¤ä)* uP uDPUVhV'&Suvb ?@mn2WX % &  5 c +c d r s  7 \ ] o p T U Y$%?@s !T#Z-Z 01 7_23e"[\;  %PQh,efD!"J%TU}5645`R , K!L!!! "!"-"####$0$U$~$$$%.%\%%%&&3&W&&&&&&'Q''''(T((((( )Z)-Z)))))%*^***++r+,,,-B-Q----.%.B.m.../T/U//0F0G0000 1N1m1111"2J2q2-q2222 33v333394\4444 5C5555E6666'7V7~7778,8h888888*9{999':S::::d#d#d#d#d#d#d#-:;;;c;;;;<1<2<<<<<'=m===>Y>>>>G?a?b??????@E@F@n@@@A$AAAeAAAAAd#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#,A%B?BYBsBBBBPC6DtDuDvDDDDE(EMEEEEEE!FLFwFFFFGGFGnGGGGH>H?HxHHHH.Id#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#,.I}IIII2JgJhJ]K^KKKLKLLLL!MOMMMNINJNNNNNOIOgOOOO#P\PPPPAQQQQRRSRd#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#d#-SRRR$S]SSST7TlTTT:U;UUUxVyVVVVVW9WPWoWWWWWW8X`XXXXX(Y)YbYYYYY Zd#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#, Z>ZZZZ;[v[[[-\n\\\c]d]]]]^Y^^^_I___`A```6a`aaaaaabcbbbcSccc dKdd#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#d#-Kddddd"eYeweeefffffgZgggh`hahhhhh?iciiiii/j0jajbjjjkckdkllll+md#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#,+mhmimmmnHnpnqnnnooVoooo'pnppppqqqqrrBrqrrrrsJsKsss tt,tctttttd#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#d#-ttu=uxuyuuuvLvMvvv w wVwwwww4xMxwxxxxx5ygyyyyz4z5z~zz{{P{{{{{|N|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#d#d#-N|~||||(})}t}}}}N~~~~~~~~~~~*+,-./Uo+q 5d#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#hd#hd#hd#hd#,d#d#Dd#d#d#d#d#d#d#d# *5_`ֈRԉՉ)*Tۊ܊IJKqr֋׋89k5bde؎َIJd#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#,JݏޏQАC'(CDb ./2345YZ"EFޕߕ:;^d#d#d#d#d#d#d#d#4d#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țVqŞƞӞԞm9MN<ҥ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#<+ҥd#d# a'%h`% K@Normal]a d@dRubrik 1B < 4. U]ck`@`Rubrik 2B < 4.U^c^@^Rubrik 3B < 4.Ucb@bRubrik 4B < 4. UV]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#ONormal 14I@"4Meddelanderubrik77<<cO2Def)@A Sidnummer"@R"Sidhuvud p#-!              c U!+{6?IPT^+js{/|K4ԛ')<?5 1 = F 3 &&&Suvb ?@mn2WX%&5cdrs 7 \ ] o p T U  Y $ % ? @ s ! T #Z 01 7_23e"[\;  %PQhefD!"J%TU}5645`RKL !- !0!U!~!!!"."\"""##3#W#####&$Q$$$$%T%%%%% &Z&&&&&%'^'''((r()))*B*Q****+%+B+m+++,T,U,,-F-G---- .N.m...."/J/q//// 00v000091\1111 2C2222E3333'4V4~4445,5h555555*6{666'7S77778;8c8888919299999':m:::;Y;;;;G<a<b<<<<<<=E=F=n===>$>A>e>>>>>%???Y?s????P@6AtAuAvAAAAB(BMBBBBBB!CLCwCCCCDDFDnDDDDE>E?ExEEEE.F}FFFF2GgGhG]H^HHHIKIIII!JOJJJKIKJKKKKKLILgLLLL#M\MMMMANNNNOOSOOO$P]PPPQ7QlQQQ:R;RRRxSySSSSST9TPToTTTTTT8U`UUUUU(V)VbVVVVV W>WWWW;XvXXX-YnYYYcZdZZZZ[Y[[[\I\\\]A]]]6^`^a^^^^_c___`S``` aKaaaaa"bYbwbbbcfcccdZddde`eaeeeee?fcfffff/g0gagbggghchdhiiii+jhjijjjkHkpkqkkkllVllll'mnmmmmnnnnooBoqoooopJpKppp qq,qcqqqqqqr=rxryrrrsLsMsss t tVttttt4uMuwuuuuu5vgvvvvw4w5w~wwxxPxxxxxyNy~yyyy(z)ztzzzzN{{{{{{{{{{{|*|+|,|-|.|/|U||||o+q 5_`օRԆՆ)*Tۇ܇IJKqrֈ׈89k5bde؋ًIJ݌ތQЍC'(CDb ./2345YZ"EFޒߒ:;^ WȘVqśƛӛԛm9MN<Ң$$$$$SummaryInformation(Inst fr Datavetenskap'@ؼ1@q@tKZ@Microsoft Word 6.0.173; $$$$$$$$$$$$$$        )!  VVw] c. K#6%}&'(7*,-_/0235_67q9q:f<{=>Y@ACcEFHIJJKKLNOPVR3SKTUVXY#[T\ ^l_Ua`bcLefg=ij?n ooq~rEs!tuuvwyyz{|}o~1;7z\HƛWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~c Z Z)q2:A.ISR ZKd+mtN|5Jҥ !!dhmms;0x#-+'"`, ,RKFRF KOMMENTARSKAPADATREDTIDDOKNAMN FILSTORLEK NYCKELORD SENSPARATAVANTALTKNANTALSIDANTALORD UTSKRIFTSDATPRIVATRDVERSIONSPARADATMNEINHODOKMALLTITELXOALFAARABINITVERS GRUNDTEXT TECKENFORM VALUTATEXT FRSTVERSHEXGEMEN KOPPLAFORMORDTALORDTEXTROMANVERSALABSAVRUNDADEFHELTALOCHFALSKTMAXMINRESTMEDELANTALICKEELLERPRODUKTOMTECKENSUMMASANTGran Schumacher,Grans HD:Temporary Items:Word Work File A 1Gran Schumacher,Grans HD:Temporary Items:Word Work File A 1Gran Schumacher;Grans HD:Kents mapp:LIA2:Nya nydefs:nydefs.lia2.int&fp.wrdGran Schumacher;Grans HD:Kents mapp:LIA2:Nya nydefs:nydefs.lia2.int&fp.wrdGran Schumacher;Grans HD:Kents mapp:LIA2:Nya nydefs:nydefs.lia2.int&fp.wrdGran Schumacher/Grans HD:Temporary Items:Word Work File A 3046Gran Schumacher;Grans HD:Kents mapp:LIA2:Nya nydefs:nydefs.lia2.int&fp.wrdGran Schumacher;Grans HD:Kents mapp:LIA2:Nya nydefs:nydefs.lia2.int&fp.wrdInst fr Datavetenskap.PowerMac:Temporary Items:Word arbetsfil A 2694Inst fr Datavetenskap:PowerMac:Anvndare:kentk:Nya nydefs:nydefs.lia2.int&fp.wrd@ MTimes New Roman Symbol MArial MTekton Plus RegularTimesMCourier New MTimesMNew Century SchlbkMHelvetica"0hT &s &I`============Suggested LIA-2 section 5.3 (1/2), elementary transcendental operations=============Gran SchumacherInst fr Datavetenskapࡱ; \