jim@ism780.UUCP (05/16/84)
#R:uvacs:-127900:ism780:20100003:177600:2359 ism780!jim May 14 19:04:00 1984 > (a) The definition of "interesting" is fuzzy. Apparently it > is sufficiently general to include "is the least member of a > well-defined set" or we would not be able to conclude (4). > (b) In which case, we have another Russell's antinomy here, > in which the definition of U is such as to make U impossible > to construct. Nonsense. The fact that a set, when constructed, is empty does not make the set impossible to construct! The problem with Russell's "the set of all sets which do not contain themselves" is that it is semantically meaningless because the mere introduction of such a "thing" into the language gives rise to a contradiction (that it neither does nor does not contain itself). The notion of an [un]interesting number is much different. One reasonable definition of an interesting number is "any number which any person claims to find interesting". This is perfectly consistent and meaningful, although it makes a decision procedure rather difficult. > My claim would be that one > cannot properly define the predicate "is an interesting number" unless > it excludes "is the least member of a well-defined set" Properly? You are going to have a harder time defining "properly" than "interesting". A basic rule for philosophers is that, when formulating definitions, if their definition excludes cases commonly held to be members of the set, or includes members commonly held not to be members of the set, they are making an error. The real problem is that interestingness is not an absolute quality; even if we grant that the smallest number which is not interesting for some other reason *is* interesting just for that reason, it isn't *very* interesting, and the next number which is not interesting for any other reason is even less interesting, and in fact we might well want to concede that it isn't interesting at all. So, in fact, while the property of being the least member of a well-defined set makes a number interesting for certain sets, it obviously does not do so for all sets. But the "proof" asserts that the least member of the set of uninteresting numbers really is interesting, which can be considered a false claim when several other numbers have already been labeled as not uninteresting for just the same reason. -- Jim Balter, Interactive Systems (ima!jim)
jim@ism780.UUCP (05/16/84)
#R:umcp-cs:-689800:ism780:20100005:177600:266 ism780!jim May 14 19:06:00 1984 > With regard to changing when an electric timer turns on the lights, > don't reset it at all. You synchronized it with the sky, the > springforward didn't affect the sky, it is still synchronized. I don't know about Maryland, but around here the days get longer.
paul@hpfclp.UUCP (paul) (08/07/84)
Anyone have any good references on numerical methods involving complex
numbers? I see that many of the math functions in Common Lisp take
complex arguments, and was curious on references to see how these
functions can be efficiently computed.
Paul Beiser
Hewlett-Packard Ft. Collins, Colorado
...{ihnp4,hplabs}!hpfcla!paulseshacha@uokvax.UUCP (seshacha) (01/08/85)
This is in response to Karmarkar paper in ACM symposium
on automata(1983)...
I could not find any paper authored by him except
another paper on the Knapscak problem with reduced complexity.
Could anyone kindly give the correct source of this?
Another request: If anyone has an algorithm to generate
palindromic primes,please mail one to me.ed@ISM780.UUCP (02/17/85)
/* Written 5:20 am Feb 13, 1985 by mam@charm in ISM780:net.math */
A netter asked:
1) What is the sum of
1 + 11 + 111 + ... {n ones} ?
2) At what time between 4:00 and 5:00 do the hour and minute hands of
a clock form a right angle?
My (possible buggy) solutions:
1) This series contains:
n 1's
n-1 10's
n-2 100's
...
1 10^n.
**********************
Your representation is incorrect; e.g., if n=2, you are saying the sum has
2 1's, and 1 100. Obviously, the last one should be "1 10^n-1".
Regardless, a far easier way to solve this problem is to realize that
each term t in the sum can be expressed as:
i
i
t = 10 - 1
i ------
9
Then it is easily shown that
n
---
\ n+1
/ t = 10 - 10 - 9n
--- i --------------
i=1 81
Ed Lycklama
decvax!cca!ima!ism780!edken@turtlevax.UUCP (04/30/85)
In article <920001@acf4.UUCP> hkr4627@acf4.UUCP (Hedley K. J. Rainnie) writes: >I am attempting to perform limited precision fractional math using a digital >computer. The idea is to not use a float where a fraction would do. A >fraction also is just integer multiplication,addition,etc... No floating >point nastiness need creep into the calculation. I am troubled by ways to >efficiently handle normalization. I was wondering whether anyone in the >mathematics community has heard of procedures that deal with this problem. >I feel that for my applications it will be much faster than floating point >work. There are two commonly used fixed-point fractional formats: those that include 1 and those that don't. For 16-bit two-s complement fractions, they are: s.fffffffffffffff and su.ffffffffffffff Where "s" is the sign bit, "f" is a fractional bit, and "u" is a unit's bit, and "." is the radix point. The first format is most widely used, especially in the signal processing community. This is probably because TRW and a host of others make multiplier chips that support this format with rounding. You can get something awfully close to 1 with 0.111111111111111. Don't be tempted to use 1.000000000000000 as 1, because it is really -1 (note the sign bit). Addition and subtraction are easy, because they are identical to regular two's complement additiona and subtraction. Multiplication needs to be done in a few assembly instructions, because C does not support fractional arithmetic. Roughly, the product of two fractions is the high part of the two numbers considered as integers. More specifically, the product of two numbers of the form s.fffffffffffffff (sign plus 15 fractional bits) is ss.ffffffffffffffffffffffffffffff (two signs plus 30 fractional bits). Normal integer multiplication truncates off the top of the product, whereas fractional multiplication truncates off the bottom, after first throwing out one of the duplicated sign bits. This is the only "normalization" necessary. One of the features of fractional multiplication is that there is no overflow: the product of any two numbers between 0 and 1 will remain between 0 and 1. Division, on the other hand, is very prone to overflow. What happens when you divide 0.5 by 0.25? You get 2.0, which is not representable in a fractional format. I prefer the second format, because you can represent 1 exactly, at the expense of throwing out 1 fractional bit. Below you will find PDP-11 assembly code for fractional multiplication of numbers with the s.fff... format. Because it is so simple, translation to any other machine should be trivial. Also included is a fixed point square root routine, which is required to have an even number of fractional bits (works with su.fffff... fractions as well as integers). The code for division will be left to the reader, and is only slightly more difficult than multiplication. There is no restriction to using 16 bits; for any of the modern computing machines, 32 bits would be more suitable, especially if your machine has a 32x32-->64 bit multiplication. ----------------------------------------------------------------- # This is a shell archive. Remove anything before this line, then # unpack it by saving it in a file and typing "sh file". (Files # unpacked will be owned by you and have default permissions.) # # This archive contains: # frmul.s sqrt.s echo x - frmul.s cat > "frmul.s" << '//E*O*F frmul.s//' .globl _frmul _frmul: mov 2(sp),r0 /* Get the first parameter */ mul 4(sp),r0 /* Multiply it by the second */ ashc $1,r0 /* Shift out the extra sign bit */ add $100000,r1 /* Rounding */ adc r0 /* Carry the rounding up to the high word */ rts pc /* Return */ //E*O*F frmul.s// echo x - sqrt.s cat > "sqrt.s" << '//E*O*F sqrt.s//' .globl _sqrt .text _sqrt: / int sqrt((long) arg) ~~sqrt: / 256ths come out with 16ths, longs with ints ~arg=4 / high=4, low=6 ~div=r1 ~rem=r2 ~counter=r4 jsr r5,csv clr r0 clr r2 mov 4(r5),r3 / Enter high word jsr pc,Lroot / Calculate root for top word mov 6(r5),r3 / Enter low word jsr pc,Lroot / Calculate root for bottom word jmp cret Lroot: mov $8,r4 / Load counter to loop for the entire high word Lrtlp: ashc $2,r2 / Bring in the next two bits asl r0 / Get ready for the next bit in the root mov r0,r1 / Test divisor = 2 * (partial root) + 1 asl r1 inc r1 sub r1,r2 / Compute next partial remainder jmi Lrestor / Test for divisibility inc r0 / Enter a 1 into the square root sob r4,Lrtlp rts pc Lrestor: add r1,r2 / Test divisor doesn't divide partial remainder sob r4,Lrtlp rts pc .globl .data //E*O*F sqrt.s// exit 0 -- Ken Turkowski @ CADLINC, Menlo Park, CA UUCP: {amd,decwrl,hplabs,nsc,seismo,spar}!turtlevax!ken ARPA: turtlevax!ken@DECWRL.ARPA