Sensei

I was doing it in 2007 with 2.4 GHz. With directional transmitter I could receive signal at 100 meters of air with ~100% quality. After moving 1 cm behind concrete wall (few cm size, really small), signal couldn't pass through it.. Pointing two directional transmitter and receiver at 100 meters distance so they see each other = nightmare. Now I think I should attach to them laser pointers to see exactly where they're pointing. I also hate adjusting satellite receiver. 1mm difference and there is no signal from satellite. You don't know where is satellite (just by looking at neighborhood set up their dishes) and have to do it blindly.. Wifi 2.4 GHz/satellite transmission is really badly working/not working when there is heavy rain or snow.

One needs to be very careful to distinguish bouncing from walls so many times it appears to be "passing through" from real transparency. It would require using directional transmitter with directional receiver, experiment outdoor (to not have reflections from walls).

This is almost never the case, because ideally we want to have offset inside of instruction, not in additional parameter. To reduce needed memory accesses. From link that I gave post #17: Encoding bits inside of instruction long word is our offset/index. Motorola 680x0 has 8 bits offset -128..+127 and 16 bits offset -32768...+32767 MIPS OP is working on has 16 bits offset -32768...+32767 Simply the most significant bit of offset is extended to the all higher bits of real addressing bus. 0x8000 (=%1000 0000) is becoming 0xFFFF8000, and 0x7FFF (=%0111 1111) is becoming 0x00007FFF,

I meant "weighted" = measured. Read it as: "52 kg is already measured invariant mass of bomb. After acceleration to constant velocity v (whether v=0.03c or v=0.5c or v=0.866c doesn't matter) it's still 52 kg invariant mass." Are you aware that m0 in your equation is rest mass=invariant mass. Then how can it change? Change is in relativistic mass m' in your equation.

52 kg is already weighted invariant mass of bomb. After acceleration to constant velocity it's still 52 kg invariant mass.

If you're putting something on weight scale when you're on ground at rest, and measure mass, and then repeat it when you're traveling with fast constant velocity, the both measurement will show the same result, as either you and weighting scale and measured item, has the same velocity vector, you are all in the same frame of reference.

You should start from that. When you have 1 gram of water, which has 18.015 g/mol, it means there is 1 g/18.015 g/mol = 0.05551 mol 1 mol is 6.022141*10^23 particles/molecules. 0.05551 mol * 6.022141*10^23 = ~3.34285*10^22 molecules of water in 1 gram (in 1 cm^3 volume, STP). Similarly when you have 52 kg = 52000 g of pure U-235, which has 235.044 g/mol, it is 52000 / 235.044 = 221.235 moles = 1.3323*10^26 U-235 atoms in such ball. Quantity of molecules/particles don't change while falling into BH, nor when it's traveling with speed close to speed of light. Instead of thinking about critical mass, you can start thinking about critical quantity of atoms.

IMHO it's myth. There are even people building their own fusion reactors at home f.e. http://www.bbc.co.uk/news/10385853 People with knowledge, don't find reason for building their own fission reactors or nuclear bombs. Without purpose, there is little sense building them. And danger of ending up radiated. Real extremists are plain stupid. How many hours per day they are spending on praying? The last thing they would be doing is reading (in foreign language) "decadent" western science books, every day for 8+ hours, every book, and making experiments.. They would have to spend 10-20 years on learning quantum physics to build working bomb and they would in mean time lost all their extremisms.. Marie Curie-Sklodowska was processing uranium ore in hovel.. Tons of ore..

Recursion - binary search. f.e. database of words, and search whether word is present or not present in it. *) Recursion - octree. Recursion - kd-tree. Recursion - 3d ray tracing. *) I was doing once such where file was so big (millions entries), it was not loaded to memory, just used virtual page and memory mapping MMU for accessing just needed part. And in mean time searching using binary search in it. Typically students are doing sorting algorithms using couple different methods and comparing between them. But I guess so, this is what you did already? As it's the basic thing to do on every programming learning. Colleague was aspiring to Oracle, and told me this week the first thing guy asked him to do was doing multi-threaded queue/stack without using mutex/locks etc. You can make a lot of exercises for multi-threading.

See link http://www.mrc.uidaho.edu/mrc/people/jff/digital/MIPSir.html There is showed where index-offset is going inside of instruction, in which bits it is stored. They are showed by chain of "i" (especially lw instruction). It's signed 16 bit integer. Local variables on stack of currently executed function are always stored at negative offset from base register. Well, it's even clearly visible on screen-shot that I gave in post #11. EBP-0x10014 = EBP - 65556 (but it's Intel)

You're just calculating new address. In C/C++ it would be: char *address; int offset; char *new_address = address + offset; Actually it's meaningless whether it's address or integer. Because result will be the same. Just adding two together. On many CPUs if you want to increment/change some memory location, you need to load that memory location to register, increment/change register, and store register in the same place. You calculated register $t0, and now want to read word from memory address at $t0+0, and store it in register $s0 Equivalent to C/C++: unsigned long data = *( (unsigned long *) new_address ); // if word = 32 bits. If it would be f.e. lw $s0, 100($t0) Equivalent to C/C++: unsigned long data = *( (unsigned long *) ( &new_address[ 100 ] ) ); // if word = 32 bits. In this case offset 0 is hard-coded in instruction. See Encoding of LW instruction in link below. Data from memory location at $t0+0 will be stored in $s0 Offsets are essential for structures and class object members. Arrays have indexes. Offset in array is equivalent to sizeof( struct ) * index Full multiply of size of single element of array. f.e. struct Data { char Name[ 16 ]; long Age; long Sex; }; will have Name at offset 0 Age at offset 16 Sex at offset 16+4=20 and sizeof( Data ) = 16+4+4=24 I don't think so $s6 is most probably operation on register while 0($s6) is read/write of memory location specified by register. See this http://www.mrc.uidaho.edu/mrc/people/jff/digital/MIPSir.html You have description of operation in 2nd row of table of each instruction. It has even Encoding supplied, so you can see which registers/data/offsets are in which bits of instruction.

I tried with my white balloon & half of lemon and it didn't blow up. Recorded it on video, so I can send it to you in private mail. Have you tried lemon, and other citruses? Have you tried other balloon models? Are you pumping them by air, helium or something else?

I agree. The most probable answer, is the most probably the right one.

See is not waving, but holding car's window by left hand.. See has bracelet or watch on forearm (find another photo with her left forearm with watch). There is no controversy in this photo at all. ps. I didn't waste time on reading entire thread, so excuse me if somebody already pointed this out..

I don't think so. Are you aware of f.e. pair production and other photon-nucleus, photon-particle interactions?

You have all this wrong in your head. Integers are even bigger than bytes. On 32 bit machine "int" has 4 bytes.. This book is CORRECT. Except little fact of saying +-32768, while in reality it's -32768.... +32767 bytes (and this part about 213, not sure what does it means. Maybe this CPU has function like Motorola MOVEM.L for loading/writing all CPU registers at once. It has 38-40 registers?). They didn't say that buffer with size 32768 bytes is copied. Just word at offset from base register is accessed. Imagine: char buffer[ 65536 ]; char *ptr = buffer + 32768; now on ptr[ 0 ] refers to middle of buffer ptr[ -32768 ] refers to the beginning of buffer and ptr[ +32767 ] refers to the end of buffer ptr is like base register in book. and in brackets you have 16 bit signed integer offset. If you compile such code, there will be generated: Do you see our 16 bit integer offsets.. ? eax is loaded by data from stack. Then it's used as base register, and byte from memory location at hard coded offset 0x8000 (-32768) copied.

Probability of hitting atom by free neutron.. One U-235 after fission will produce new 3 free neutrons. At least one of them must collide with yet another U-235 to sustain reaction.

They are talking about relative offset from address. -32768.... +32767 bytes In total 65536 bytes, where 0 is in middle. Read more about signed short (integer).

See sodium oxide website: http://en.wikipedia.org/wiki/Sodium_oxide Na2O + H2O -> 2 NaOH Even if Na2O would be made in solution, it would quickly react like above. It reacts with hydrochloric acid AFAIK: Na2O + 2HCl -> 2NaCl+H2O Such reaction cannot occur, because simply it's not balanced.

i & j are typical names of variables for counters f.e. for( int i = 0; i < 100; i++ ) {} Otherwise I don't know about what i & j, you're talking about. You didn't provide any sample code.

CSV means comma separated values. http://en.wikipedia.org/wiki/Comma-separated_values I wrote about it, because it's easy to make loader/writer for it in any programming language. Excel/OpenOffice obviously support it. Of course not. It's C/C++/C# normal software compiler.. In what sense "limited in functionality"? You can always buy pro version. Every application on this world written for Windows in C/C++ can be compiled by Visual Studio.. Everything what you use everyday is most likely written in it.. You will have to write everything by yourself. Code downloading stuff from net, then writing files, and analyzing.. In C#/Managed C++ code downloading file from URL is simply one row of code f.e.: String ^str = System::Net::WebClient::DownloadString::DownloadString( "http://www.google.com"); Then you split string to rows, then you analyze rows, etc. and write output file..

If it's Excel issue, you know, Excel is not the only one application on the world. I am using OpenOffice SpreadSheet. You can try it to see whether it works better than Excel for free http://www.openoffice.org Does Scilab support CSV file format? You can code downloading app, which is writing CSV, and then use that with SciLab, if it does. Visual Studio Express is free...

I was not talking about optimizing by using multiple threads! This way there is completely no way to compare one algorithm with another. You're to some level right: in some special circumstances your algorithm thanks to parallel working could be faster. But: - triangles must be already in GPU memory. Uploading them takes a lot of time. You might end up uploading data for longer than algorithm is working. - GPU memory is several times smaller than main-board memory, thus quantity of triangles possible to process will be much smaller. How much memory do you have on gfx card? 2 GB? 4 GB? If user of application will have small amount of memory, whole algorithm might have no sense. 2 GB, with 3*4*3=36 bytes per triangle, is enough for holding just 59 millions triangles. Or 28 mln with double precision. - for 3d scenes, only few right one triangles should be examined, just those that are in kd-tree/octree leaf, not entire scene.. And we can launch 1024 cores to process 256 triangles at once.. Or we can launch renderfarm with 200 computers, and have even faster result. *) But if somebody would do it this way, with this algorithm, it would be sign he has no idea about programming.. In typical case, quantity of triangles SHOULD be less than 10 in KD-Tree/Octree leaf.. And then just content of leaf is processed, instead of entire scene! Simple compare min-max bounding box with point will get rid of 99.999% of wrong triangles. And main routine will be working with just these which are very very close to triangle. *) Yes, I was writing software which was working on renderfarm. It did job in less than 1 hour on 70+ Xenon/Core i7 machines what my couple machines crunched whole week. But better optimized algorithm is a way to bypass need for adding more cores, more machines, and crunching by brute force way, in the first place.

You have xp,yp and xa,ya and xb,yb, raw positions, in total 6 variables, right? Daedalus, congratulations. Finally something new. +1 for fresh algorithm. But I don't think so it's going to be faster than algorithm #1. You will have something like 16 multiplications (division can replaced by multiply by 1/x), 12 subtractions, 8 additions or more, for 2D triangle calculation.