computers programming

[Darkover]

most least significant bit,
msb,lsb,big,little,endian msb[1,0,0,1]lsb, pop3,imap,rc4,base64,xml,zlib,registry,opengl,rsa,ssl,md5,xor cipher ,ftp,html,ports 80,20,21 , mysql, http, post,get,cgi,sockets, win32api,gui,windows,inf,rgb,palette
binary 8,4,2,1, zero and ones 0011,logic and not or nand xor nor,shift bits left right,power,sin,cos,sqr,sqrt,min,max,degress to radians,abs,floor,wrap,pi 3.14159,vector,normalize, magnitude ,direction,dot and cross product, hash functions sha1, ascii characters set,
strings,int, float, integer,short,word,dword,boolean,byte,bits, binary,octal,decimal,hex,matrix,ocr,neuron,weight,threshold,socks4,tcp ip,fat32, ntfs, exfat,partition, GUID, 8 bit 256, 16 bit 65536, 32,64,128, #FF , frequency, amplitude, gdi, ram,rom,circular buffer ,Inverse-square law, point_direction, distributed hash table, peer routing table, bootstrap node, pwm, random, randomseed,
kb 1024, 1000
mb=1024*1024, 1,000,000
gb=1024*1024*1024 1,000,000,000
tb=1024*1024*1024*1024 1,000,000,000,000

3d, view frustrum ,backface culling, painter's algorithm, ray tracing, binary space partitioning (BSP) , Visible Surface, md2 3d model, polygons quads,fps,camera

circle,point,x,y,radius,diameter,circumference
circle radius,
circumference divided by diameter gives PI,
by multiplying 3.14 pi by the diameter of the circle gives the circumference
point_distance(x1,y1,x2,y2), x = pow(x1-x2,2) y = pow(y1-y2,2) return sqrt(x + y)
if distance between two circles is less than combind radius than colliding with eath other

cellular automata,turing machine, lexer, parser, virtual machine interpreter, bytecode, x86 asm, opcodes, z80,6502,arm,4000 chips,pic12f675, nop 0x90

CPU, alu, control unit, registers, fetch,program counter, data bus, address bus, store, load, interrupt,, system clock, full adder, shift register, jk flip-flop, bcd, decoder, multiplexer,opcode

asymmetry, symmetry,
bresenham's line algorithm, flood fill, eclipse,virtual screen, c malloc,dos mode 0x13, 0xA000, 256-Color.
texture mapping,sprite,texture atlas
steering behaviors flee,arrival,wander,seek,

delta time, frame rate independent movement, system time,
1000 millseconds per second , pixels per second 120
120/1000= 0.12 *elsapedtime, delta time
1000/60(fps) =16.666666666666666666666666666667
0.12*16.666*60 =120 pixels, bitmap
0.12 speed
16.666 delta_time
x+=cos(angle)*speed*delta_time;
y-=sin(angle)*speed*delta_time;

k value between 1 and 26 the key,
shift cipher,
cipher mod 26,

perlin noise, encryption alice bob, private, public,key,
linear interpolation,lerp,distance -kademlia,field of view, serialization, deserialization, json, inputs, outputs, dma,immediate,absolute,memory mapping, lookup tables,truth tables,stacks, pop, push,top ,queues,first in first out, last in first out, FIFO & LILO , LIFO & FILO, link list, double linked list, node,child,root,head,tail,pointer,
two's complement, addition, subtraction, a star, modulo, windows environment variables, a variable

a=not(a) toggle on and off 0,1 repeatedly

(angle * (PI/180)) degtorad
(angle * (180/PI)) radtodeg

and_bits(test_integer, 1) = 0 is_odd or is_even

record input steam plus delta time between frames
then to playback replace the delta time with the record dt and to keep the same game state make everything deterministic and update each system with the dt, use the record input stream to create the output stream at each tick of the game 8 bits for movment 1 bit for each button plus 4 bytes for the dt
also a global seed for the random_seed function saved

function wrap_between(integer v,integer min, integer max)
return v - (max - min) * floor( v / (max - min))
end function

hash a image
image_data[23,1,66,12,11,7...] rgb colour values from a picture 24bit
16,777,216 colors
for i=1 to length(image_data) do
hash_index+=image_date
end for
return wrap_between(hash_index, 0,1000) room for one thousand images with hash collisions

packet protocol 5 bytes+data
5 byte header+data, per packet type
[1,0,0,0,10]+['h','e','l','l','o']
first byte packet id 0--255
next four bytes, data length is the total size of the packet-5
read and write ,byte,string,int,float,bool,short
if (buffer>=5)
{
packet_id=buffer[0]
packet_length=buffer[1..4]
if (packet_length>length(buffer)-5)
{
//packet is ready to be read
packet_id //decides the amount and type of bytes to read from the data buffer
}
}

32*32=1024 total number of pixels
1024*8=8192 total number of bits
256 colours per pixel
2^8192 total number of pictures

8192 bit full adder

constant number_of_bits=8192
sequence a,b,cin,sum,cout

a=repeat(0,number_of_bits)
b=repeat(0,number_of_bits)
cin=repeat(0,number_of_bits)
sum=repeat(0,number_of_bits)
cout=repeat(0,number_of_bits)

integer xor1
xor1=0
for i=1 to number_of_bits do

if cout=1 then
cin=1
end if

xor1=xor_bits(a,b)
sum=xor_bits(xor1,cin)
if (a=1 and b=1) or ( xor1=1 and cin=1) then
cout[i+1]=1
end if
end for

?sum

for i=1 to 8192 do
skip_speed = rand(1)
end for

value=sum
a=VALUE
b=skip_speed
reset values
add or subtract mode
need two's complement for subtraction
skip forward by 8192 bits constant skip_speed
display image on screen 32,32 resize to 320,320
gain some limited access to all images 2^8192


apache,7zip,euphoria,dev c++,code blocks,visual stuido,java, game maker,allegro,sdl,ollydbg, cheat engine,filezilla,virtualbox,bit torrent, camstudio,core temp,cpu-z,dosbox,firefox,fscapture,vcl player,tortoiseSvn,magic disk,power iso, fraps, joytokey,gpu-z


8421
0000 0
0001 1
0010 2
0011 3
0100 4
0101 5
0110 6
Drift velocity, the average speed at which electrons travel in a conductor when subjected to an electric field, is about 1mm per second.
It's the electromagnetic wave rippling through the electrons that propagates at close to the speed of light.

calculation shows that the electron is traveling at about 2,200 kilometers per second.
That's less than 1% of the speed of light, but it's fast enough

2,200 kilometers to meters equals 2200000 meters

2200 kilometers to nanometers
2.2e+15
22,000,000,000,000

6,250,000,000,000,000,000 electrons per second for a amp
2,200,000,000,000,000
2,200,000
2,200,000,000*1000
1000 millimeters in 1 meter
2,200,000,000,000,000 * 1,000,000 1 million because 1 nm equal 1 milion
Electrons Can Travel Over 100 Times Faster In Graphene Than In Silicon, Physicists Show
220,000,000,000,000,000 2,200,000,000,000,000*100


If you could travel at the speed of light, you could go around the Earth 7.5 times in one second

300,000,000,000,000,000 nanometers
2,200,000,000,000,000 electron

die size
192 mm²

192,000,000*192,000,000

36,864,000,000,000,000 nm

300,000,000,000,000,000/192,000,000
2,200,000,000,000,000/192,000,000

stright line
lights can travle from one end to the another 1,562,500,000 times per second

electrons can travle from one end to the another 11,458,333 times per second

145,164,960,000,000,000
145 quadrillion seconds 4.6 billion years
409,968,000,000,000,000 seconds 13 billion years
time the earth been formed
time the universe as been ticking


1,000,000,000,000,000,000 one cubic mm
602,000,000,000,000,000,000,000 one mole
6,250,000,000,000,000,000 electrons per second for a amp
3,273,200,000,000,000,000,000,000 nm in the human brain

Avogadro constant is the number 6.02x10^23
^ 23deicmal places
107 grams of silver in one mole
602,000,000,000,000,000,000,000 atoms
63.55 grams of copper in one mole
196.967 grams of gold in one mole
4.002602 grams helium gas in one mole


1.411 million tonnes of Silver in the world 1,411,000

grams in a ton 907,185

907,185 / 107 equal 8478

8478.364485981308411214953271028

8478 moles in one ton of silver

1,411,000 * 8478

11,962,458,000 billion

12 billion moles of silver in the world
602,000,000,000,000,000,000,000 one mole
7,224,000,000,000,000,000,000,000,000,000,000 atoms of Silver
10,000,000,000,000,000,000,000,000,000 atoms in a human 100,000,000,000,000*100,000,000,000,000

100 trillion atoms in a human cell. Approximately the same number of cells are in the entire human body
1 moles H2O, 18.01528 grams.
1000 grams in a litre of water
average weight of a man 83,600 grams, 83kg
amino acid a protein with a mass of 64kDa has a molecular weight of 64,000 grams per mole. that's a heavey protein
12.001 grams of carbon contains the same # of atoms as 196.967 grams of gold

The adult human brain weighs about 3 pounds (1,300-1,400 g).
The adult human brain is about 2% of the total body weight.
The average human brain is 140 mm wide. 140,000000
The average human brain is 167 mm long. 167,000000
The average human brain is 140 mm height. 140,000000

3,273,200,000,000,000,000,000,000 nm in the human brain

181,881 tons of gold

1nm A hydrogen atom is about 0.1 nanometers
Atoms used in silicon chip fabrication are around 0.2nm
how many nanometers in a millimeter 1,000,000 nm
cubic nanometer (nm³) measurement unit of volume with sides equal to one nanometer

1 cubic mm of silicon there are 125,000,000,000,000,000,000 atoms. 125=5x5x5 1 cubic nm of silicon 125 atoms
1 cubic mm 1,000,000,000,000,000,000

light speed in meters per second
300,000,000 meters
300,000,000,000 millimeters
300,000,000,000,000 micrometers
300,000,000,000,000,000 nanometers


electron speed in meters per second
2,200,000 meters
2,200,000,000 millimeters
2,200,000,000,000 micrometers
2,200,000,000,000,000 nanometers


a high-end desktop x86 processor can execute over
100,000,000,000 billion instructions per second
2,200,000,000,000,000/100,000,000,000
22,000 nanometers per instructions

Intel 4004 92,000 instructions per second
100,000,000,000 billion instructions per second

Moore's "law," which forecasts processor power will double every two years,
1971 to 2017 46 years 46/2 23 years
92,000 ips 2300tc 50 years/2 25 steps of doubling
184,000 1 4600
368,000 2 9200
736,000 3 18400
1,472,000 4 36000
2,944,000 5
5,888,000 6
11,776,000 7
23,552,000 8
47,104,000 9
94,208,000 10
188,416,000 11
376,832,000 12
753,664,000 13
1,507,328,000 14
3,014,656,000 15
6,029,312,000 16
12,058,624,000 17
24,117,248,000 18
48,234,496,000 19 1,205,862,400
96,468,992,000 20 2,411,724,800
192,937,984,000 21 4,823,449,600
385,875,968,000 22 9,646,899,200 transistor count
771,751,936,000 23 19,293,798,400 tc
1,543,503,872,000 24 38,587,596,800 tc
3,087,007,744,000 25 77,175,193,600 transistor count

another 50 years gives below results should not be possible for moores law to go for another 50 years reach a peek
approaching one nanometer scale within the next 9 years 2025
103,582,791,429,521,400,000 inst per sec, 2,589,569,785,738,035,000 tc by 2071

bruteforce was never an option

kiloFLOPS kFLOPS 10^3 1000
megaFLOPS MFLOPS 10^6 1000000
gigaFLOPS GFLOPS 10^9
teraFLOPS TFLOPS 10^12
petaFLOPS PFLOPS 10^15
exaFLOPS EFLOPS 10^18
zettaFLOPS ZFLOPS 10^21
yottaFLOPS YFLOPS 10^24

worlds fastest super computer 2016
93,000,000,000,000,000 93petaFLOPS quadrillion floating point operations per second
900,000,000,000,000,000,000 all the world computers

i3 os windows 10 real time
Floating Point Operations/Second:
97,372,708
Integer Operations/Second:
206,342,312

today it takes
4 years to double performance

cpu mostly use a single layer of transistors 14nm 70 atoms think in all 3 dimensions 70*70*70, dimensions maxium 343,000 atoms

ryzen
Transistor count is .... 8-core Ryzen, 4,800,000,000, 2017, AMD, 14 nm, 192 mm² 2017
300,000,000,000 billion instructions

1090t 45nm, 346mm2 in size, contains ~904 million transistors 2010 78,000,000,000 billion inst

1 billion on 2010
2 billion on 2012
4 billion on 2014
8 billion on 2016


how to add Specular lighting : simulates the bright spot of a light that appears on shiny objects
i've got diffused lighting how to add in Specular lighting

Figure 1 shows a fixed vector with the following coordinates ie. components,
a[3 1 2]
in other words,
ax = 3,
ay = 1,
az = 2,


Figure 1

The magnitude (length) of the vector is,

length = sqrt((ax * ax) + (ay * ay) + (az * az))
length = sqrt(9 + 1 + 4) = 3.742

Given vector a its xyz components are calculated as follows,

x = ax/length
y = ay/length
z = az/length

As a "worked example" the vector shown in figure 1 has the xyz components of 3, 1, 2 and a length of 3.742. Therefore, a normalized copy of the vector will have components,

x = 3.0 / 3.742 = 0.802
y = 1.0 / 3.742 = 0.267
z = 2.0 / 3.742 = 0.534




function rgbs(atom rgb)
return ( {and_bits(#000000FF, rgb),
and_bits(#0000FF00, rgb) / #100,
and_bits(#00FF0000, rgb) / #10000 } )
end function


constant byte_width =640,byte_height=480, byte_depth=64

sequence byte_array
byte_array={}

for i=1 to byte_depth do
byte_array=append(byte_array, repeat(repeat(0,byte_width),byte_height) )
end for


procedure sphere(integer center_x, integer center_y, integer center_z, integer dist, atom colour)
atom dd

for x=1 to byte_width do
for y=1 to byte_height do
for z=1 to byte_depth do
dd=distance3d(x,y,z ,center_x,center_y,center_z)
if dd<dist then
byte_array[z][x][y]=colour
end if
end for
end for
end for
end procedure

procedure cube(integer start_x, integer start_y, integer start_z, integer size, atom colour)

for x=start_x to start_x+size do
for y=start_y to start_y+size do
for z=start_z to start_z+size do
byte_array[z][x][y]=colour
end for
end for
end for
end procedure

sphere(320,240,24, 24, rgb(255,0,0))

sphere(320,340,32, 32, rgb(255,255,0))

sphere(120,140,16, 16, rgb(255,0,255))

sphere(32,32,32, 32, rgb(0,255,0))

sphere(280,180,32, 32, rgb(0,0,255))

cube(320,240,1, 32 , rgb(0,0,255) )

sequence screen_pixels
screen_pixels=repeat(repeat({0,0,0},byte_width),byte_height)

integer light_x,light_y,light_z
light_x=320
light_y=240
light_z=-32


integer surface_x,surface_y,surface_z
atom length1
surface_x=0
surface_y=0
surface_z=-1

length1=sqrt(surface_x*surface_x + surface_y*surface_y + surface_z*surface_z )

surface_x=surface_x/length1
surface_y=surface_y/length1
surface_z=surface_z/length1


for x=1 to byte_width-1 do
for y=1 to byte_height-1 do
for z=1 to byte_depth do
if byte_array[z][y][x]!=0 then

vx= light_x-x
vy= light_y-y
vz= light_z-z

length1=sqrt(vx*vx + vy*vy + vz*vz )

if length1!=0 then
--normalized vectors
vx= vx/length1
vy= vy/length1
vz= vz/length1
--Taking the Dot product of two normalized vectors
lightness=(vx*surface_x) + (vy*surface_y) + (vz*surface_z)
end if

screen_pixels[x][y]=rgbs(byte_array[z][y][x]*lightness)
fastPutDibPixel( dib, y, x, screen_pixels[x][y] )
end for
end for
end for
some pics

 

[western_heart]

Are these snippets from notes/tags or something? I would have understood more of it a decade ago but I forgot most graphics stuff shortly after college

 

[whatevs]

But can it play Doom?

 

[jodes2]

Are you ok god I remember studying algorithms, it did my head in. Trying to figure out what a complex bit of code does is painful. And once you understand, you forget so quickly! That's maths for you. Difficult in, easy out. DIEO