About: Base Numbers

Similarly 'decimal' is a base ten number with ten numbers per digit. We normally do not think of decimal in such a complex way.

per digit

10:9
09:8
08:7
07:6
06:5
05:4
04:3
03:2
02:1
01:0

For each digit: think about this

0-9 = 10 numbers; However ten is two digits.

when we use exponential notation for each digit: a three digit base 10 number could look like this;

[(10^2)*n3] + [(10^1)*n2] + [(10^0)*n1];

where: n3 = n2 = n1 = '9'; <-- or '999'

Similarly any base number can be written in exponential form, where the represented number of digits come from the encrypted number. It is much easier to understand the crucial decription accuracy in which these base numbers are written, by first understanding the exponential representation.

Say we have a number '1234' and want to write it in binary(base 2) digits = :: 1 -or- 0 ::

how namy digits long is it?

create a list;

([2^0]*1) = 1
([2^1]*1) = 2
([2^2]*1) = 4
([2^3]*1) = 8
([2^4]*1) = 16
([2^5]*1) = 32
([2^6]*1) = 64
([2^7]*1) = 128
([2^8]*1) = 256
([2^9]*1) = 512
([2^10]*1) = 1024
([2^11]*1) = 2048

That should be enough, considering #1234 is far less than #2048; So, naturally the furthest digit in this list ends with 'zero'

By subtracting the whole '1234' from remaining notation's index we may complete the string of 1's and 0's likewise:

([2^11]*1) = -2048 + 1234 < 0
([2^10]*1) = -1024 + 1234 = 210
([2^9]*1) = -0512 + 210 < 0
([2^8]*1) = -0256 + 210 < 0
([2^7]*1) = -0128 + 210 = 82
([2^6]*1) = -0064 + 82   = 18
([2^5]*1) = -0032 + 18   < 0
([2^4]*1) = -0016 + 18   = 2
([2^3]*1) = -0008 + 2    < 0
([2^2]*1) = -0004 + 2    < 0
([2^1]*1) = -0002 + 2    = 0
([2^0]*1) = -0001 + 0    < 0

the binary number encryption for decimal '1234' is '0'+'10011010010' and this binary number is read from right to left < <

hexadecimal

It is easy to look at a table of hexadecimal numbers '0'-'255'. This utalizes a dual digit system to define the values.

_	0	1	2	3	4	5	6	7	8	9	A	B	C	D	E	F
0	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
1	16	17	18	19	20	21	22	23	24	25	26	27	28	29	30	31
2	32	33	34	35	36	37	38	39	40	41	42	43	44	45	46	47
3	48	49	50	51	52	53	54	55	56	57	58	59	60	61	62	63
4	64	65	66	67	68	69	70	71	72	73	74	75	76	77	78	79
5	80	81	82	83	84	85	86	87	88	89	90	91	92	93	94	95
6	96	97	98	99	100	101	102	103	104	105	106	107	108	109	110	111
7	112	113	114	115	116	117	118	119	120	121	122	123	124	125	126	127
8	128	129	130	131	132	133	134	135	136	137	138	139	140	141	142	143
9	144	145	146	147	148	149	150	151	152	153	154	155	156	157	158	159
A	160	161	162	163	164	165	166	167	168	169	170	171	172	173	174	175
B	176	177	178	179	180	181	182	183	184	185	186	187	188	189	190	191
C	192	193	194	195	196	197	198	199	200	201	202	203	204	205	206	207
D	208	209	210	211	212	213	214	215	216	217	218	219	220	221	222	223
E	224	225	226	227	228	229	230	231	232	233	234	235	236	237	238	239
F	240	241	242	243	244	245	246	247	248	249	250	251	252	253	254	255

The only thing more complicated than the hexadecimal numbering system is the application of hexadecimal numbers in strings.

Usually in strings, especially in graphics, the digits are read '214365', what I mean by this is there are three sets of double hex put into a string with the first ordered par (right to left::ordered pair)[first(left to right)to last]

This graphic may help

Whether Red is the first pair, or blue is; We can not decypher a standard because of this reason: When binary represents the string of [# RR GG BB] the index is not used. 100001(red) 1100111(green) 1100101(blue) are each seperate channels, &100001+1100111+1100101=2189157 is not the index, the binary units must be formated, and Red is first. Fortunately the index is not used for tiny 64x64 pixel images, except on this site.

I created this URL with, in mind, a standard may be developed before it's wide use in indexing images and achieving lookup "in words" to describe the image. the index only protects in finding duplicate images. Even in object detection from a photographic lense, the probibility of having the exact same image is very low.

Trinary

zero, one, or two as placeholders.

Remember to use expotential notation to describe the digits and the result will be individual and uniqe per base 3 number.

(3^0)=1*times*[first digit]<-- from the right
(3^1)=3*times*[second digit]
(3^2)=9*times*[third digit]<-- to the left
'2"2"2' = 26;

For any base number the notation is similar. Always begin zero when counting placeholder maximums and add 1 for the base number. Trinary is base 3, but the placeholders for each digit are a maximum of 2 ; And the exponent is acted on the base number, then multiplied per digit. Once all digit decimals are added together there is understanding.

Reading further

Let's begin working with the smallest square, of four to describe a unit:

binary	decimal	hexadecimal	trinary
0000	00	0	000
0001	01	1	001
0010	02	2	002
0011	03	3	010
0100	04	4	011
0101	05	5	012
0110	06	6	020
0111	07	7	021
1000	08	8	022
1001	09	9	100
1010	10	A	101
1011	11	B	102
1100	12	C	110
1101	13	D	111
1110	14	E	112
1111	15	F	120

If you don't understand, this chart won't help.

The explination does not give an example of when to use encryption types.

Long Strings are Letters and words are Sums

Begin:

256 = FF;
Red = Green = Blue = (0-255)
pixel = [(1)*Red]+[(256)*Green]+[(65536)*Blue]
in any given pixel = 16777215 combinations;
width = 64
height = 64
4096 = (64^2) solve: !([16777216]^4096) <-- factorial gives
blank 'white' answer.
Let's start with binary:

Darkness = "0";
Ambiance = "1";

there are four squares within the boundary

when the width equals the height, squares are important

we are asking how many combinations there are and numbering them comes naturally.
Also, it is important to keep the quadrant we are working in on mind.
For binary the colors are (0 -or- 1) only
we do not want to load all the images in memory (2)^4096 == 1,234 digits long
=104438888141315250669175271071662438257996424904738378038423348328395390797155745684882681_&
&_19349975583408901067144392628379875734381857936072632360878513652779459569765437099983403_&
&_61590134383718314428070011855946226376318839397712745672334684344586617496807908705803704_&
&_07128404874011860911446797778359802900668693897688178778594690563019026094059957945343282_&
&_34693030266964430590250159723998677142155416938355598852914863182379144344967340878118726_&
&_39496475100189041349008417061675093668333850551032972088269550769983616369411933015213796_&
&_82583718809183365675122131849284636812555022599830041234478486259567449219461702380650591_&
&_32456108257318353800876086221028342701976982023131690176780066751954850799216364193702853_&
&_75124784014907159135459982790513399611551794271106831134090584272884279791554849782954323_&
&_53451706522326906139490598769300212296339568778287894844061600741294567491982305057164237_&
&_71548163213806310459029161369267083428564407304478999719017814657634732238502672530598997_&
&_95996090799469201774624817718449867455659250178329070473119433165550807568221846571746373_&
&_29688491281952031745700244092661691087414838507841192980452298185733897764810312608590300_&
&_1302413467189726673216491511131602920781738033436090243804708340403154190335. ^-- files
times file length is for tiny 64x64px only
And, who knows how long to view all monochrome images.

However, with a measured image, we can find it's numerical order of sequence; in a few seconds.

base_64

number	code	purpose:
00		to compress length
01	a	to compress length
02	b	to compress length
03	c	to compress length
04	d	to compress length
05	e	to compress length
06	f	to compress length
07	g	to compress length
08	h	to compress length
09	i	to compress length
10	j	to compress length
11	k	to compress length
12	l	to compress length
13	m	to compress length
14	n	to compress length
15	o	to compress length
16	p	to compress length
17	q	to compress length
18	r	to compress length
19	s	to compress length
20	t	to compress length
21	u	to compress length
22	v	to compress length
23	w	to compress length
24	x	to compress length
25	y	to compress length
26	z	to compress length
27	A	to compress length
28	B	to compress length
29	C	to compress length
30	D	to compress length
31	E	to compress length
32	F	to compress length
33	G	to compress length
34	H	to compress length
35	I	to compress length
36	J	to compress length
37	K	to compress length
38	L	to compress length
39	M	to compress length
40	N	to compress length
41	O	to compress length
42	P	to compress length
43	Q	to compress length
44	R	to compress length
45	S	to compress length
46	T	to compress length
47	U	to compress length
48	V	to compress length
49	W	to compress length
50	X	to compress length
51	Y	to compress length
52	Z	to compress length
53	0	to compress length
54	1	to compress length
55	2	to compress length
56	3	to compress length
57	4	to compress length
58	5	to compress length
59	6	to compress length
60	7	to compress length
61	8	to compress length
62	9	to compress length
63	.	to compress length
0	" "	blank space

An index is used to convert the digits into a serialized data type, in most cases [a long file]. A base number greater than ten; compresses the "number" into less digits. Whereas, a base number smaller than ten inflates the digits beyond decimal into much smaller 'workers'. The english alphabet [upper]+[lower]case+[1-9] with only one punctuation and a space contain words in a language. The combination of letters have meaning in cotext. However, in an encryption, the data set may contain broken-meaning from the language 'letters' that form an extremely long number in decimal. Hince, the reason for using the base number larger than ten. Infact, the calculations between such numbers must be designed by the computer person who manipulates the data.

Did you know that many codes are redefined because the computer language itself has a cost?

The ammount of time it takes to understand code is comperable to the ammount of time it takes to write successful code.

Applying a number larger than a calculator can handle

Square One:

This article begins to help us understand how a calculator defines it's functions. A standard calculator tells the display to use Numeric letters and display the correct number translations via logic. I am not certain that it does not just index the entire list of addition, subtraction, multiplication, division and other operators that we will ignore for this exercise.

I am not a master of any language I know, and admit that; litterally, I mean how I say, not letter for letter.

in mathematics:
    [addition] is primarily forign and using a single digit or even sixteen or more digits per calculation is acceptable.
    [subtraction] is much like addition except it adds the difference of the letters. We want positive numbers only for indexing purposes. The number increases. To bring it back as an image, we subtract from the index until it reaches zero.
    [simple] even exponetial notation may be thought of as addition. Or, by the time we figure the way to teach a computer to read additional functions, the purpose is lost.

Formating Numbers

leading zeros to line up string lengths

10 has two digits and 9 has only one

unless nine is written 09

So, number 0-1-2-3-4-5-6-7-8-and-9 get one-thousand two-hundred thirty-three leading zeros. Now all numbers are the same length. And, even-more confusing is that words [strings] are read from left to right. +Plus, length is measured from the left. In otherwords, if you want to return the length of five for 10,000, the leading zeros will takeover from the left and return "00000". The correct notation is #1234 - minus five is 1229 to 1234;., Ok, enough complaining.

Address of -null or true-

For the purpose of images, flat. Rendering speeds vary before preformance. To call a word and see it as others visualize. The purpose of this article is to apply education to every-day-life. Though it is not far off that augmented reality people handaling security issues will rome the stores of isles with the aid of Global Positioning to find thier item.

Drone only zones of surface robots finding and retrieving orders to recognise parts of images as a reference to (tangible) objects. Electronic shopping within a Virtual Reality mall or struct designed for small businesses to operate fully (online). The future is now, and we will build it.

Since we bit off more than we can chew, let me re-gurgitate.

O.K., Binary from

unacredited skills:

begin again...

binary is a _2 image	O-or-l	natural	machine
false,false,false,false		0000	0000
false,false,false,true		1000	0001
false,false,true ,false		0100	0010
false,false,true ,true		1100	0011
false,true ,false,false		0010	0100
false,true ,false,true		1010	0101
false,true ,true ,false		0110	0110
false,true ,true ,true		1110	0111
true ,false,false,false		0001	1000
true ,false,false,true		1001	1001
true ,false,true ,false		0101	1010
true ,false,true ,true		1101	1011
true ,true ,false,false		0011	1100
true ,true ,false,true		1011	1101
true ,true ,true ,false		0111	1110
true ,true ,true ,true		1111	1111

We have 4096 nodes of true/false value to define a character +plus a string ideograph description (keywords). This is an example of the "eudcedit.exe" custom font dialog. There is a maximum memory usage cap that is well below defining all possible combinations. Text's are graphics, And; the input is small, when keyboards existed. Before "touch"-screen technology.

I began to wonder, why not a visual language included in parallel with lettters, symbols, ideographs, characters.. so on.;

Then the emoji came.

full 24 bit. Reviewing my tiny square..

0000 0000 | 0000 0000 | 0000 0000

          I have never read a number so massive,
     per each; with a combination of:
          16,777,216 per pixel
          ::29,593digits::!for a tiny emoji.

So, for small images the listing order is defined; However it is premature. We have not established the reading order: xy coords.. Quadrants. What information is read first?

Grayscale: when (RED = GREEN = BLUE)

#000000

#010101

#020202

#030303

#040404

#050505

#060606

#070707

#080808

#090909

#0A0A0A

#0B0B0B

#0C0C0C

#0D0D0D

#0E0E0E

#0F0F0F

#101010

#111111

#121212

#131313

#141414

#151515

#161616

#171717

#181818

#191919

#1A1A1A

#1B1B1B

#1C1C1C

#1D1D1D

#1E1E1E

#1F1F1F

#202020

#212121

#222222

#232323

#242424

#252525

#262626

#272727

#282828

#292929

#2A2A2A

#2B2B2B

#2C2C2C

#2D2D2D

#2E2E2E

#2F2F2F

#303030

#313131

#323232

#333333

#343434

#353535

#363636

#373737

#383838

#393939

#3A3A3A

#3B3B3B

#3C3C3C

#3D3D3D

#3E3E3E

#3F3F3F

#404040

#414141

#424242

#434343

#444444

#454545

#464646

#474747

#484848

#494949

#4A4A4A

#4B4B4B

#4C4C4C

#4D4D4D

#4E4E4E

#4F4F4F

#505050

#515151

#525252

#535353

#545454

#555555

#565656

#575757

#585858

#595959

#5A5A5A

#5B5B5B

#5C5C5C

#5D5D5D

#5E5E5E

#5F5F5F

#606060

#616161

#626262

#636363

#646464

#656565

#666666

#676767

#686868

#696969

#6A6A6A

#6B6B6B

#6C6C6C

#6D6D6D

#6E6E6E

#6F6F6F

#707070

#717171

#727272

#737373

#747474

#757575

#767676

#777777

#787878

#797979

#7A7A7A

#7B7B7B

#7C7C7C

#7D7D7D

#7E7E7E

#7F7F7F

#808080

#818181

#828282

#838383

#848484

#858585

#868686

#878787

#888888

#898989

#8A8A8A

#8B8B8B

#8C8C8C

#8D8D8D

#8E8E8E

#8F8F8F

#909090

#919191

#929292

#939393

#949494

#959595

#969696

#979797

#989898

#999999

#9A9A9A

#9B9B9B

#9C9C9C

#9D9D9D

#9E9E9E

#9F9F9F

#A0A0A0

#A1A1A1

#A2A2A2

#A3A3A3

#A4A4A4

#A5A5A5

#A6A6A6

#A7A7A7

#A8A8A8

#A9A9A9

#AAAAAA

#ABABAB

#ACACAC

#ADADAD

#AEAEAE

#AFAFAF

#B0B0B0

#B1B1B1

#B2B2B2

#B3B3B3

#B4B4B4

#B5B5B5

#B6B6B6

#B7B7B7

#B8B8B8

#B9B9B9

#BABABA

#BBBBBB

#BCBCBC

#BDBDBD

#BEBEBE

#BFBFBF

#C0C0C0

#C1C1C1

#C2C2C2

#C3C3C3

#C4C4C4

#C5C5C5

#C6C6C6

#C7C7C7

#C8C8C8

#C9C9C9

#CACACA

#CBCBCB

#CCCCCC

#CDCDCD

#CECECE

#CFCFCF

#D0D0D0

#D1D1D1

#D2D2D2

#D3D3D3

#D4D4D4

#D5D5D5

#D6D6D6

#D7D7D7

#D8D8D8

#D9D9D9

#DADADA

#DBDBDB

#DCDCDC

#DDDDDD

#DEDEDE

#DFDFDF

#E0E0E0

#E1E1E1

#E2E2E2

#E3E3E3

#E4E4E4

#E5E5E5

#E6E6E6

#E7E7E7

#E8E8E8

#E9E9E9

#EAEAEA

#EBEBEB

#ECECEC

#EDEDED

#EEEEEE

#EFEFEF

#F0F0F0

#F1F1F1

#F2F2F2

#F3F3F3

#F4F4F4

#F5F5F5

#F6F6F6

#F7F7F7

#F8F8F8

#F9F9F9

#FAFAFA

#FBFBFB

#FCFCFC

#FDFDFD

#FEFEFE

#FFFFFF

various incryption(s)

16 colors

black

maroon

red

green

olive

lime

yellow

navy

purple

teal

gray

silver

blue

fuchsia

aqua

white

the 16 grayscale

1-00 2-11 3-22 4-33 5-44 6-55 7-66 8-77 9-88 10-99 11-AA 12-BB 13-CC 14-DD 15-EE 16-FF

trinary reduction

3*3*3=26

64

000     100     200
001     101     201
002     102     202
003     103     203

300
301
302
303

310
311
312
313

320
321
322
323

330
331
332
333

010     100     200
011     101     201
012     102     202
013     103     203
020     120     220
021     121     221
022     122     222
023     123     223
030     130     230
031     131     231
032     132     232
033     133     233

512 = 888

4096 = 161616

(44)(44)(4*4)

16777216 = (256256255)+(256255)+(1255)

1111 1111 1111 1111 1111 1111

444 = 8*8

444 = 64

#000000	#550000	#AA0000	#FF0000	#005500	#555500	#AA5500	#FF5500
#00AA00	#55AA00	#AAAA00	#FFAA00	#00FF00	#55FF00	#AAFF00	#FFFF00
#000055	#550055	#AA0055	#FF0055	#005555	#555555	#AA5555	#FF5555
#00AA55	#55AA55	#AAAA55	#FFAA55	#00FF55	#55FF55	#AAFF55	#FFFF55
#0000AA	#5500AA	#AA00AA	#FF00AA	#0055AA	#5555AA	#AA55AA	#FF55AA
#00AAAA	#55AAAA	#AAAAAA	#FFAAAA	#00FFAA	#55FFAA	#AAFFAA	#FFFFAA
#0000FF	#5500FF	#AA00FF	#FF00FF	#0055FF	#5555FF	#AA55FF	#FF55FF
#00AAFF	#55AAFF	#AAAAFF	#FFAAFF	#00FFFF	#55FFFF	#AAFFFF	#FFFFFF

Selecting a Quadrant

color

R
(16^0)*15 = 1*15     15
(16^1)*15            240
G
(16^0)*15 = 1*15     15
(16^1)*15            240
B
(16^0)*15 = 1*15     15
(16^1)*15            240
BGR
((256^2)*255)+((256^1)*255)+((256^0)*255) = 16777216
index of smallest square

	0	1
0
1

0,0 - ((256^2)*255)+((256^1)*255) + ((256^0)*255)+_
1,0 - ((256^5)*255)+((256^4)*255) + ((256^3)*255)+_
0,1 - ((256^8)*255)+((256^7)*255) + ((256^6)*255)+_
1,1 - ((256^11)*255)+((256^10)*255)+((256^9)*255)
-or-
[(256^12)-1]=79,228,162,514,264,337,593,543,950,335+0"combinations"
-or-
0,0 - ((16777216^0)*16777215)+_
1,0 - ((16777216^1)*16777215)+_
0,1 - ((16777216^2)*16777215)+_
1,1 - ((16777216^3)*16777215)

monochrome

(2^0)+(2^1)+(2^2)+(2^3) = [(2^4)-1]

_	0	1	2	3	4	5	6	7	8	9	A	B	C	D	E	F
0	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
1	16	17	18	19	20	21	22	23	24	25	26	27	28	29	30	31
2	32	33	34	35	36	37	38	39	40	41	42	43	44	45	46	47
3	48	49	50	51	52	53	54	55	56	57	58	59	60	61	62	63
4	64	65	66	67	68	69	70	71	72	73	74	75	76	77	78	79
5	80	81	82	83	84	85	86	87	88	89	90	91	92	93	94	95
6	96	97	98	99	100	101	102	103	104	105	106	107	108	109	110	111
7	112	113	114	115	116	117	118	119	120	121	122	123	124	125	126	127
8	128	129	130	131	132	133	134	135	136	137	138	139	140	141	142	143
9	144	145	146	147	148	149	150	151	152	153	154	155	156	157	158	159
A	160	161	162	163	164	165	166	167	168	169	170	171	172	173	174	175
B	176	177	178	179	180	181	182	183	184	185	186	187	188	189	190	191
C	192	193	194	195	196	197	198	199	200	201	202	203	204	205	206	207
D	208	209	210	211	212	213	214	215	216	217	218	219	220	221	222	223
E	224	225	226	227	228	229	230	231	232	233	234	235	236	237	238	239
F	240	241	242	243	244	245	246	247	248	249	250	251	252	253	254	255

_	0	1	2	3	4	5	6	7	8	9	A	B	C	D	E	F
0	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
1	16	17	18	19	20	21	22	23	24	25	26	27	28	29	30	31
2	32	33	34	35	36	37	38	39	40	41	42	43	44	45	46	47
3	48	49	50	51	52	53	54	55	56	57	58	59	60	61	62	63
4	64	65	66	67	68	69	70	71	72	73	74	75	76	77	78	79
5	80	81	82	83	84	85	86	87	88	89	90	91	92	93	94	95
6	96	97	98	99	100	101	102	103	104	105	106	107	108	109	110	111
7	112	113	114	115	116	117	118	119	120	121	122	123	124	125	126	127
8	128	129	130	131	132	133	134	135	136	137	138	139	140	141	142	143
9	144	145	146	147	148	149	150	151	152	153	154	155	156	157	158	159
A	160	161	162	163	164	165	166	167	168	169	170	171	172	173	174	175
B	176	177	178	179	180	181	182	183	184	185	186	187	188	189	190	191
C	192	193	194	195	196	197	198	199	200	201	202	203	204	205	206	207
D	208	209	210	211	212	213	214	215	216	217	218	219	220	221	222	223
E	224	225	226	227	228	229	230	231	232	233	234	235	236	237	238	239
F	240	241	242	243	244	245	246	247	248	249	250	251	252	253	254	255