HDTenEightyP/NetNews huggingface dataset:
From: nickel@cs.tu-berlin.de (Juergen Nickelsen)
Newsgroups: comp.programming
Subject: I was wrong  (Was Re: cleanup on exit)
Date: 22 Jul 92 20:29:53 GMT
	<1992Jul18.203518.14496@murdoch.acc.Virginia.EDU>
	<1992Jul19.160323.8820@organpipe.uug.arizona.edu>
	<NICKEL.92Jul19184631@desaster.cs.tu-berlin.de>
	<9220400.530@mulga.cs.mu.OZ.AU>
	<NICKEL.92Jul22200234@desaster.cs.tu-be
Reply-To: nickel@cs.tu-berlin.de
Organization: STONE Project, Technical University of Berlin, Germany

In article <NICKEL.92Jul22200234@desaster.cs.tu-berlin.de> I wrote:

> In article <9220400.530@mulga.cs.mu.OZ.AU> fjh@munta.cs.mu.OZ.AU
> (Fergus James HENDERSON) writes:
[...]
> > Why not just use at_exit() to install an error handler if necessary?
> 
> I would really *like* to use it, but it's not portable. SunOS has a
> function
[...]
> POSIX doesn't define something like this, SysV.3, BSD 4.3, and Ultrix
> don't seem to have somthing like that.

Mike Lijewski wrote me that atexit() is part of the ANSI C standard.
I had forgotten to look there and so misinterpreted the statement in
the POSIX document about atexit().

Sorry!
--
Juergen Nickelsen
From: sra@ecs.soton.ac.uk (Stephen Adams)
Newsgroups: comp.programming
Subject: in-place merge
Date: 30 Jul 92 21:32:43 GMT
Organization: Southampton University Computer Science

Does anyone know of an O(n) time and O(1) space algorithm
for doing an in-place merge, or have a proof that it is not
possible?

By an in-place merge I mean the following:

Given

  . an array a[1:n] of n elements
  . k such that 1<=k<=n-1
  . a[1:k] is sorted
  . a[k+1:n] is sorted

I want to merge the two sorted lists a[1:k] and a[k+1:n],
resulting in a single sorted list a[1:n], by re-arranging
the elements of a (i.e. in-place).  You are allowed only to
use a fixed amount of extra storage.

The only algorithms I know of for merging assume either a
separate destination array, or pointers that link the
elements together, as in linked lists.

I can think of an O(n^2) time algorthim:

	p := 1;    // `head' for first list
	q := k+1;  // `head' of second list

	while q<n  do
	    if a[p] <= a[q] then
		// a[p] is in the correct position
		p := p+1
	    else
		// must move all of the first list to make a
                // space for a[q]
		for i:= q-1 downto p do  a[i] := a[i-1];
		a[p] := a[q];
		p:=p+1;
		q:=q+1;
	    end if
	end

This is clearly O(n^2): if k=n/2 and a[1]>a[k+1] then the
lists end up by being swapped.  All of the first list is
moved, one place at a time, to the position of the second
list.  This is k moves of k words = n^2/4, assignments.
Space is O(1) as we only use indexes p, q and i.


I am prepared to relax the problem:

  . k is near, or exactly n/2
  . O(log n) space
--
Stephen Adams                           Email: S.R.Adams@ecs.soton.ac.uk
Electronics and Computer Science        Tel: 0703 593649
University of Southampton               Fax: 0703 593045 
Southampton  SO9 5NH,  UK
Newsgroups: comp.programming
From: lowry@watson.ibm.com (Andy Lowry)
Subject: Re: finding 1st one in integer
Date: Tue, 21 Jul 1992 21:58:44 GMT
Disclaimer: This posting represents the poster's views, not necessarily those of IBM
Organization: IBM T.J. Watson Research Center

In article <Brqu3F.1J4@undergrad.math.waterloo.edu> amichail@cayley.waterloo.edu (Amir Michail) writes:

 > I need a very efficient way of finding the first bit set ( doesn't matter
 > which side ) in a 32 bit integer. 

 > One can make the simplifying assumption that only 1 bit will be
 > set in the 32 bit integer (if that helps).

This seems to work nicely:

int firstone(x)
unsigned int x;
{
  static int keys[] = {
    -1,  0,  1, 26,  2, 23, 27, -1,  3, 16,
    24, 30, 28, 11, -1, 13,  4,  7, 17, -1,
    25, 22, 31, 15, 29, 10, 12,  6, -1, 21,
    14,  9,  5, 20,  8, 19, 18 };

  return keys[x % 37];
}

The idea is that you want to use a table lookup, but not on the entire
sparse range 1-2^31, so you need to find a hash function that will map
the set {2^n: 0 <= n <= 31} uniquely to a reasonably dense range of
integers.  Using remainder modulo 37 does the trick, and the table
above was generated by a trivial C program.  The -1 entries are
unused.

There's probably some algebraic way of predicting what divisor to use
instead of 37 to get the minimum sized table for a given "word size,"
but I'll leave that for somebody else to fill in.  I just started with
33 and tried successive numbers until one worked.  But I don't believe
it can be a coincidence that 37 is the least prime greater than 32!
--
Andy Lowry, lowry@watson.ibm.com, (914) 784-7925
IBM Research, P.O. Box 704, Yorktown Heights, NY  10598
From: avg@rodan.UU.NET (Vadim Antonov)
Newsgroups: comp.programming
Subject: Re: finding 1st one in integer
Date: 21 Jul 1992 16:38:28 -0400
Organization: Berkeley Software Design
NNTP-Posting-Host: rodan.uu.net

inline int highbitpos(register int i)
{
	register int bitpos = 0;

	if( i & 0xffff0000 ) {
		i >>= 16;
		bitpos = 16;
	}
	if( i & 0xff00 ) {
		i >>= 8;
		bitpos += 8;
	}
	if( i & 0xf0 ) {
		i >>= 4;
		bitpos += 4;
	}
	bitpos += "\377\0\1\1\2\2\2\2\3\3\3\3\3\3\3\3"[i];
	return bitpos;
}

You can speed it up by sacrificing some data space and removing the
last _if_. There are variants which do not requre additional register
variable or addition at the end (the first makes the code bigger, the
second requires replicating the bit tables). All those trade-offs are
up to you :-)

--vadim
Newsgroups: comp.programming
From: gupw@uniwa.uwa.edu.au (Paul Wagland)
Subject: Is 2.0 PM very different from 1.x PM?
Organization: University of Western Australia
Date: Mon, 27 Jul 1992 01:46:42 GMT

Hi!

Well What I want to know is this...

Is programming for PM under v2.0 much different than under v1.x?

The reason I wish to know is that the only PM programming books around
here are for OS/2 v1.x. Any thoughts on whether it will be worth getting
those books, or whether I should wait for v2.0 books.

many thanks.
-- 
Paul Wagland            | These opinions are mine and no-one elses
gupw@uniwa.uwa.edu.au   | I still don't like Microsoft, even after using
------------------------+  their products. :-)
From: james@crc.ricoh.com (James Allen)
Newsgroups: comp.programming
Subject: Re: finding 1st one in integer
Summary: Mimimal modulus not always prime
Date: 22 Jul 92 01:30:18 GMT
Organization: RICOH California Research Center

In article <LOWRY.92Jul21165844@rotor.watson.ibm.com>
	lowry@watson.ibm.com (Andy Lowry) writes:
] [someone else asks:]
] > I need a very efficient way of finding the first bit set ( doesn't matter
] > which side ) in a 32 bit integer. 
]
] > One can make the simplifying assumption that only 1 bit will be
] > set in the 32 bit integer (if that helps).

Or take the slightly more difficult case where at most 1 bit is set.
Call this case "ALLOWZERO".

]This seems to work nicely:
]
]int firstone(x)
]unsigned int x;
]{
]  static int keys[] = {
]    -1,  0,  1, 26,  2, 23, 27, -1,  3, 16,
]    24, 30, 28, 11, -1, 13,  4,  7, 17, -1,
]    25, 22, 31, 15, 29, 10, 12,  6, -1, 21,
]    14,  9,  5, 20,  8, 19, 18 };
]
]  return keys[x % 37];
]}
]
]The idea is that you want to use a table lookup, but not on the entire
]sparse range 1-2^31, so you need to find a hash function that will map
]the set {2^n: 0 <= n <= 31} uniquely to a reasonably dense range of
]integers.  Using remainder modulo 37 does the trick, and the table
]above was generated by a trivial C program.  The -1 entries are
]unused.
]
]There's probably some algebraic way of predicting what divisor to use
]instead of 37 to get the minimum sized table for a given "word size,"
]but I'll leave that for somebody else to fill in.  I just started with
]33 and tried successive numbers until one worked...

We may need some help from sci.math to get the algebraic solution,
but I followed Andy's approach for all wordsizes up to 490:

	   Wordsize		Minimum Modulus
	   2			   2 (or 3 if ALLOWZERO)
	   3 			   4 (or 5 if ALLOWZERO)
	   4			   5
	   5 -    6		   9
	   7 -   10		  11
	  11 -   12		  13
	  13 -   18		  19
	  19 -   20		  25
	  21 -   28		  29
	  29 -   36		  37
	  37 -   52		  53
	  53 -   58		  59
	  59 -   60		  61
	  61 -   66		  67
	  67 -   82		  83
	  83 -  100		 101
	 101 -  106		 107
	 107 -  110		 121
	 111 -  130		 131
	 131 -  138		 139
	 139 -  148		 149
	 149 -  162		 163
	 163 -  172		 173
	 173 -  178		 179
	 179 -  180		 181
	 181 -  196		 197
	 197 -  210		 211
	 211 -  226		 227
	 227 -  268		 269
	 269 -  292		 293
	 293 -  316		 317
	 317 -  346		 347
	 347 -  348		 349
	 349 -  372		 373
	 373 -  378		 379
	 379 -  388		 389
	 389 -  418		 419
	 419 -  420		 421
	 421 -  442		 443
	 443 -  460		 461
	 461 -  466		 467
	 467 -  490		 491

]		...But I don't believe
]it can be a coincidence that 37 is the least prime greater than 32!

Well, 17 is the least prime greater than 13.
There are four nonprimes in the above "Minimal Moduli" although
they are all squares of primes: 4, 9, 25, 121.

]--
]Andy Lowry, lowry@watson.ibm.com, (914) 784-7925
]IBM Research, P.O. Box 704, Yorktown Heights, NY  10598

James Allen, james@crc.ricoh.com
From: scc@rlgvax.Reston.ICL.COM (Stephen Carlson)
Newsgroups: comp.programming
Subject: Re: finding 1st one in integer
Date: 28 Jul 92 20:04:15 GMT
Reply-To: scc@rlgvax.Reston.ICL.COM (Stephen Carlson)
Organization: International Computers Limited, Reston, Virginia, USA

>amichail@cayley.waterloo.edu (Amir Michail) writes:
>>I need a very efficient way of finding the first bit set ( doesn't matter
>>which side ) in a 32 bit integer. 

Use the TMS34010's LMO [leftmost one] instruction.

I think a better job of specifying the problem/solution domain must be done,
or else this query is unanswerable.
-- 
Stephen Carlson           | ICL OFFICEPOWER Center    | In theory, theory and
scc@rlgvax.reston.icl.com | 11490 Commerce Park Drive | practice are the same.
..!uunet!rlgvax!scc       | Reston, VA  22091         |    (703) 648-3300
Newsgroups: comp.programming
From: aa761@cleveland.Freenet.Edu (Patrick Murowsky)
Subject: The Programming SIG
Reply-To: aa761@cleveland.Freenet.Edu (Patrick Murowsky)
Organization: Case Western Reserve University, Cleveland, OH (USA)
Date: Fri, 31 Jul 92 15:34:31 GMT


Announcing the arrival of new programming language nesgroups.

freenet.sci.comp.prog.basic
freenet.sci.comp.prog.c
freenet.sci.comp.prog.pascal
freenet.sci.comp.prog.questions
freenet.sci.comp.prog.syntax
freenet.sci.comp.prog.var

The latter group will later support more languages, but is not finished
yet.  

For those who use the Cleveland FreeNet system, these can be reached by
typing "go pro" at any prompt.  

Thanks!
-- 
% Patrick Murowsky `94 %%%%%%%%% "I don't like to lose."  -- James T. Kirk 
%% aa761@cleveland.Freenet.Edu % "Everything is impossible until it isn't." 
%%% SysOp of Programming SIG %%%                          -- Jean-Luc Picard
%%%% SysOp of Movies SIG %%%%%%% "A genetic weakness of the species..."  -- Q
Newsgroups: comp.programming
From: stadt@cs.utwente.nl (Richard van de Stadt)
Subject: Re: 400% makes sense
Organization: University of Twente, Dept. of Computer Science
Date: Mon, 27 Jul 1992 14:35:10 GMT

In article <1992Jul25.184259.20358@a.cs.okstate.edu>, norman@a.cs.okstate.edu (Norman Graham) writes:
|> From article <1992Jul25.171314.22419@uwm.edu>, by markh@csd4.csd.uwm.edu (Mark William Hopkins):
|> > 20,000,000 operations/second is 400% of 5,000,000 operations/second.
|> > 
|> > Case closed.
|> 
|> Not exactly. 400% is a nonsensical term. Percent (%) means 'per hundred' or
|> 'of each hundred', and thus is only meaningful for values between 0 and
|> 100 (inclusive). Percent is best used for absolute measurements, rather
|> than relative comparisons such as the above example.
|> 
|> The use of percent in relative comparisons naturally leads to subtle
|> misunderstandings.  Thus its best to say something like "machine A
|> (at 20 M op/sec) is four times as fast as machine B (at 5 M op/sec)."

This might still lead to subtle misunderstandings, because some people might find
that machine A is only three times as fast as machine B (5 + 3*5 = 20)
But then again, maybe it would be three times faster, not as fast as.
That is, if I don't misunderstand :-)
  
|> -- 
|> Norman Graham
|> <norman@a.cs.okstate.edu>                 Standard Disclaimer Applies

Richard
-- 
R.R. van de Stadt ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ stadt@cs.utwente.nl
Usually I use vi instead of xedit:wq
Newsgroups: comp.programming
From: pinkas@caraway.intel.com (Israel Pinkas)
Newsgroups: comp.programming
Subject: Re: finding 1st one in integer
Date: 22 Jul 92 01:13:41 GMT
	<1992Jul21.173805.12045@bcrka451.bnr.ca>
	<1992Jul21.150033@is.morgan.com> <1992Jul21.205127.23216@wdl.loral.com>
Organization: Software Technologies, INTeL Corporation, Santa Clara, CA
In-reply-to: mab@wdl39.wdl.loral.com's message of 21 Jul 92 20:51:27 GMT

mab@wdl39.wdl.loral.com (Mark A Biggar) writes:

   This is no problem as i^(i-1) produces a value consisting on just the least
   sigfinicant bit in i

Not quite.  i-1 zeros the lease significant bit of i, but it sets all the
lower bits.  Exclusive ORing with i zeros all but the least significant 1
bit, but it sets all the lower bits.

(i^(i-1))>>1+1 should do the trick for all values of i.  i should be
defined as an unsigned entity to avoid problems.  Constant time, four
operations.

	i	i-1	i^(i-1)	(i^(i-1))>>1	(i^(i-1))>>1+1
	------------------------------------------------------
	000001	000000	000001	000000		000001
	000010	000001	000010	000001		000010
	000011	000010	000001	000000		000001
Note	000110	000101	000011	000001		000010
	101100	101011	000111	000011		000100
	101010	101001	000011	000001		000010

-Israel
--
Disclaimer: The above are my personal opinions, and in no way represent
the opinions of Intel Corporation.  In no way should the above be taken
to be a statement of Intel.
Newsgroups: comp.programming
From: darcy@druid.uucp (D'Arcy J.M. Cain)
Subject: Re: floating point routines with double precision
Date: Wed, 22 Jul 1992 12:07:24 GMT
Organization: D'Arcy Cain Consulting

hrubin@pop.stat.purdue.edu (Herman Rubin) writes:
>Use assembler for you particular machine if you want any speed.  Even 
>setting it up for the compiler will be a major headache, and you will
>have just as many problems with object size.

Here is how I set up my compiler to generate machine code for a floating
point operation:

    result = value/4.586;    /* Well it does   :-) */

Seriously, there may be cases where the compiler doesn't give the fastest
code for a given operation but they are probably the rare exception.  With
modern compilers the chances are that hand coded assembly won't be as fast
and are certainly longer to program.  A much better method of speeding up
critical sections of code is inlining.  That's why the current Gnu compiler
internally inlines some of the more common string functions.  Function
call overhead is still relatively expensive on most popular CPUs.

-- 
D'Arcy J.M. Cain (darcy@druid)     |
D'Arcy Cain Consulting             |   There's no government
Toronto, Ontario, Canada           |   like no government!
+1 416 424 2871          DoD#0082  |
From: dik@cwi.nl (Dik T. Winter)
Newsgroups: comp.programming
Subject: Re: floating point routines with double precision
Date: 24 Jul 92 00:33:23 GMT
Organization: CWI, Amsterdam

In article <54944@mentor.cc.purdue.edu> hrubin@pop.stat.purdue.edu (Herman Rubin) writes:
 > In article <1992Jul22.120724.3466@druid.uucp> darcy@druid.uucp (D'Arcy J.M. Cain) writes:
 > >hrubin@pop.stat.purdue.edu (Herman Rubin) writes:
 > >>Use assembler for you particular machine if you want any speed.  Even 
 > >>setting it up for the compiler will be a major headache, and you will
 > >>have just as many problems with object size.
 > >Here is how I set up my compiler to generate machine code for a floating
 > >point operation:
Interesting responses, but not to the point.  The original question
explicitly stated that he had *no* compiler, and wanted to hand-translate
the code to assembler!
 > 
 > It depends on what you call double precision.  The IEEE standard
 > double precision probably should be called single precision, and
 > what it calls single precision should be called half precision.
Here, Herman, your 205 indoctrination shows up.  In the IBM world 32 bit
FP is single precision since a very long time (1966?).  And what you
call double precision they call quad precision.  It is only CDC and Cray
where single precision is 60/64 bits and double precision 120/128 bits.
(Oh, well, perhaps a few more, Burroughs I think, and perhaps some others.)
 > 
 > Now I was answering the question assuming that more than the designed
 > precision is needed.  The routines are not difficult for a human to
 > design, but almost hopeless for a compiler.  Anyone who writes such
 > a procedure for a machine which has forced normalization will curse
 > the designers.
Well, as the machine of the original requestor has no floating-point
hardware, this point is moot.  Moreover, it is not the compiler that
suddenly comes up with some code to do double-precision, it is put in
the compiler by the compiler-writer, e.g. hand-coded.  He may have done
a poor job of course (as some code sequences for the 205 show, but that one
had an extremely bad Fortran compiler; past tense because the one I used
has been decommissioned more than a year ago).
-- 
dik t. winter, cwi, kruislaan 413, 1098 sj  amsterdam, nederland
home: bovenover 215, 1025 jn  amsterdam, nederland
dik@cwi.nl
Newsgroups: comp.programming
From: ressler@cs.cornell.edu (Gene Ressler)
Subject: Re: finding 1st one in integer
Organization: Cornell Univ. CS Dept, Ithaca NY 14853
Date: Tue, 21 Jul 1992 19:47:49 GMT

In article <Brqu3F.1J4@undergrad.math.waterloo.edu> amichail@cayley.waterloo.edu (Amir Michail) writes:
>I need a very efficient way of finding the first bit set ( doesn't matter
>which side ) in a 32 bit integer. 
>
>For example:
>
>  binary  -> position
>  	1 -> 0
>    10000 -> 4
>     1000 -> 3

If `doesn't matter which side' means it's acceptable to find the
position of the _least_ significant bit set, then a solution
that's good on 2's complement machines is:

	n = (n & -n) - 1;
	/* return the # 1's in n */

You can count the number of 1's in n with any of the amazing
methods suggested in recent posts.   This works because
in 2's complement, n & -n is the least significant 1 bit of
n.  Subtracting 1 turns it into a string of 1's beneath
the ls1b.

Gene
From: dseal@armltd.co.uk (David Seal)
Newsgroups: comp.programming
Subject: Re: finding 1st one in integer
Date: 23 Jul 92 11:43:10 GMT
Distribution: comp
Organization: A.R.M. Ltd, Swaffham Bulbeck, Cambs, UK

In article <1992Jul22.120735@is.morgan.com> berlin@is.morgan.com (Alexander
Berlin) writes:

>In article <1992Jul22.152827.14267@cs.cornell.edu>, ressler@cs.cornell.edu (Gene Ressler) writes:
>
>|> benchmark code (chris torek?), this runs about 400% faster than the 37 element
>
>Just a side note: it's impossible to have code that runs 400% faster. Twice
>as fast means 50% faster. 100% faster means in NO TIME.
>400% slower makes sense, 400% faster doesn't.
>4 times faster means 75% faster.

I think you're confusing "N% faster" with "takes N% less time".

The standard way of working out a percentage is to take the ratio (old
value)/(new value), subtract 1 and multiply by 100. IMHO, most people would
take "100% faster" to mean that the new speed is 100% greater than the old
speed. This means that you work out the percentage speedup by calculating
the ratio (new speed)/(old speed), or equivalently (old time to run
program)/(new time to run program), subtracting 1 and multiplying by 100.
This makes 50% faster mean 1.5 times as fast, 100% faster mean twice as
fast, 400% faster mean 5 times as fast.

Where you have to be careful about percentages is with reciprocals. For
instance, "speed" and "time to run program" are reciprocals of each other:
if you double the time to run, its speed is half what it was before. The
tricky point is that an N% increase in a quantity does *not* mean an N%
decrease in a reciprocal quantity. (Aside: it's a close approximation when N
is small, but is only exactly true when N is zero.)

For instance, if I double the speed of a program, its speed is twice as much
- i.e. 100% greater - and its time to run is half as much - i.e. 50%
smaller. Or put more briefly, it's 100% faster and takes 50% less time.
"100% faster" and "takes 100% less time" do not mean the same thing.

David Seal
dseal@armltd.co.uk

All opinions are mine only...
Newsgroups: comp.programming
From: berlin@is.morgan.com (Alexander Berlin)
Subject: Re: finding 1st one in integer
Organization: Morgan Stanley - IS
Date: Tue, 21 Jul 1992 19:00:33 GMT

In article <1992Jul21.173805.12045@bcrka451.bnr.ca>, sjm@bcrki65.bnr.ca (Stuart MacMartin) writes:
|> In article <Brqu3F.1J4@undergrad.math.waterloo.edu>,
|> amichail@cayley.waterloo.edu (Amir Michail) writes:
|> > I need a very efficient way of finding the first bit set ( doesn't matter
|> > which side ) in a 32 bit integer. 
|> > 
|> > For example:
|> > 
|> >   binary  -> position
|> >   	1 -> 0
|> >     10000 -> 4
|> >      1000 -> 3
|> > 
|> > One can make the simplifying assumption that only 1 bit will be
|> > set in the 32 bit integer (if that helps).
|> > 
|> > Amir
|> > 
|> > P.S.  Please do not tell me to use a large lookup table.  I know about that.
|> >       I also know that the 68020 and 80386 have instructions to do
|> this; I want
|> >       portable C code though.
|> 
|> Check a byte at a time for non-zero (being careful not to assume byte
|> ordering or behaviour of shifting signed values if you want to be portable).
|> 
|> Either use a lookup table of 256 values, or split the byte into two
|> so that your table is only 16 long.
|> 
|> If you often have numbers with the 2 lowest bytes clear, you might want to
|> start by checking 2-byte values against 0.
|> 
|> Stuart
|> 
|> : Stuart MacMartin                                    email: sjm@bnr.ca      :
|> : Bell-Northern Research                              phone: (613) 763-5625  :
|> : PO Box 3511, Stn C, Ottawa, K1Y-4H7, CANADA    Standard disclaimers apply. :

how about this one line solution:

unsigned int i;  /* given integer */
unsigned int j;  /* working variable */
int          bitset;  /* result */

   for(j=1, bitset=1; ; bitset++, j+=j) if (i==j) break; /* sets bitset */

Will work, of course, only when exactly one bit is set. But you want
efficiency, so there is no unnecessary conditions. And it looks portable -
doesn't even rely on the int size. 

---
Alex Berlin                     
berlin@is.morgan.com
From: 8914437l@levels.unisa.edu.au
Newsgroups: comp.programming
Subject: Collision Detection
Date: 23 Jul 92 03:08:06 GMT
Organization: University of South Australia


Does anybody out there know of a fast efficient way to detect and handle
colliding objects in two dimensions (there may be multiple objects colliding
as well)...

it may be a similar problem to gas particles colliding...

Part of my Honours project is to animate objects and then detect when they
collide and generate there new position...the problems come in when after a
collision occurs the object then collides with another object, when it bounces
away...


Any suggestions or good algorithms???
Please email me...

Thanks in advance,

+-----------------------------------------------------------------------------+
| Andrew "Killer" Kulikovsky                Be alert...the world needs lerts! |
|------------------------------------+----------------------------------------|
|  B.App.Sc (Hons) Computer Studies  | The wise men looked for Jesus Christ...|
|                                    | and so it is today.                    |
| send email to:                     |                                        |
|   kulikovsky@unisa.edu.au          |        - Look to Jesus Christ!         |
+------------------------------------+----------------------------------------+

               - People who live in glass houses shouldn't!
Newsgroups: comp.programming