corrora & //apploc.dek
//apploc.dek...
"impose that a binary function via a pointer, to a hash and an emulated integer back and forth? (edit), emulating a binary to value of integer, then back to a different binary format i.e. binary >> int a >> binary(1) >> int b[index].mod?"
http://www.perl.com/pub/2002/10/01/hashes.html
http://thestarman.pcministry.com/asm/hexawhat.html
octal >> 545[sub 8];
5 4 5
2 1 0 ...
5[sub8]^2 + 4[sub8]^1 + 5[sub8]^0;
5 * 64 + 4 * 8 + 5 * 1;
= 357[sub10] [sub10 is decimal system]
F 9 B D;
3 2 1 0;
15 9 11 13
3 2 1 0;
15x16^3 + 9x16^2 + 11x16^1 + 13x16^0;
A - F = 10 to 15;
10 - 19 = 16 to 25;
1A - 1F = 26 to 31;
20 - 29 = 32 to 41;
2A - 2F = 42 to 47;
hex >> 30, 40, 50, 64;
(3 x 16 + 0)
(4 x 16 + 0)
(5 x 16 + 0)
(6 x 16 + 4)
A0 - F0
10x16 + 0
11x16 + 0
15x16 + 0
A0 = 10 x 16
A00 = 10 x (16 ^ 2) or 10 x 246;
1000 = 1 x 4096 or (16^3);
FFFF = 15::F x (16^3) + 15 x (16^2) + 15 x (16^1)
F: 15, FF: 16 FFF: 256 FFFF: FFFFh = (15x4096) + (15x256) + (15x16) + 15 = 65,535 ;
FF [15: F x 16] + F :: 15 = 255;
16 log[sub: 32]^16 - 2 log[sub: 32]16^2 log[n]X
16^2;
16^4 = 65,536;
X: 2^16 = 65,536;
16^2: [sub: 32] x^5; 32;
X^16: [sub: 32] x^5; 32;
32(2^16) : 2097152 / 65,536 = 32;
: 2097152 / 256 = 32;
: 2097152 / 16 = 2;
(32 x 2)^16: 79228162514264337593543950336 / 65,536... = 1;
32(3^16) = 1377495072 / 256... 1;
32(4^16) = / 65,536...32;
(32 x 4)^16 = / 65,536 ...1;
2^5(X)^16 = 4 x 16^16 = [2]::[1]
2^5(X)^16 = 6 x 16^16 = [3]::[1]
2^5(X)^16 = 8 x 16^16 = [4]::[1]
2^5(X)^16 = 10 x 16^16 = [5]::[1]
using logs within hex. 32 x 5^16 = 10 sixteen times...65,536...so 10x16^16 = [1]
you cannot read irrational, but you can have area of effect:: http://jennyshobbyfarm.com/webelfindesign/dechex.html
Base64 :: hash;
http://thestarman.pcministry.com/asm/hexawhat.html
FF = 15 x 16^1 + 15;
32x / 5 = 51;
AA = (10 x 16^1 + 0) / 16 = 16 / 16 = 1;
BB = (11 x 16^1 + 11) / 3 = 59;
CC = (12 x 16^1 + 12) / 2 = 97;
DD = (13 x 16^1 + 13) * 9 / 3 / 3 = 211;
EE = (14 x 16^1 + 14)
FF = (15 x 16^1 + 15) / 5 = 51;
1, 35, 52, 69, 96... [x] * 16^[y] + [z] - 256
[10..15] x 16^1 + [0, 11..15]
AA;
BB;
CC;
DD:
EE;
FF;
FF - EE; 17; EE - DD; 17; FF - AA; FF - DD; DD - AA; 17 + 17 + 17...check the values.
14 x 16 + 14 = 238;
9 x 16^0 [1] + 9 = 18 - 256 = 238;
[8..1] x [1] + [8..1] - 256 = [EE, F0, F2, F4, F6..] multi level dimensions in hex dump, using this format you can bounce between memory address and program, using divide by 2 and use EE as reference you can bounce around hex values.
0, 16, 32, 48, 128, 144, 160, 176, 192, 208, 225, 240
[0] [10] [20] [30] [40] [50] [60] [70] [80] [90] [A0] [B0] [C0] [D0] [E0][F0]
[10] + 16 = [1A]; 26;
26 + 16 = [2A]; 42;
Binary::
1 0 0 1 1 0 1 1 [sub2]
2^7, 2^ 6, 2^5, 2^4, 2^3, 2^2, 2^1, 2^0;
total == -1 from total, to zero as exponential;
I don't know how to explain this in logs, only algebra II;
128 -- 64 -- 32 -- 16 -- 8 -- 4 -- 2 --1;
1 0 0 1 1 0 1 1
128 0 0 16 8 0 2 1
128 + 0 + 0 + 16 + 8 + 0 + 2 + 1;
therefore every matrices that is zero is not an expoential value or log, how would one negate logs without giving a value and then giving a value for each y = 1 and no value for x = 0?
http://www.wikihow.com/Convert-from-Binary-to-Decimal
It's probably faster and wastes less memory to do an area of effect on a hash, how Ruby does it. And seems a lot stronger in the mapping tree...with easier readability.
http://ruby-doc.org/core-2.1.4/Hash.html
90ab * 13b{1} = 23,409b{3}
13b{1} * 20{b} = [x] as {q}
260 * 180
ab{1} * b{1} = b{3};
b{1} * {b} = [x]
[x] * (a + b + a + b) = d;
d * {q} = {q1}
{q1} * {x::x} / {q3} = {q2}
d * {E = 1440(65) / 360; = 260 * 10% = 26} / {q4} = +(E);
E = {q3}[E = e{count}] = -b{2} / {b} * {a1} / {a + b} * {a2} * {b::2} / {a + b + a + b} = -(E);
{q1} = 16,900;
{b3} = 1,170;
{b2} = 2,340;
ab{1} = 90;
b{1} = 13;
b = 20;
d = 65;
{q} = 260;
{q} * d = {q1}
{q1} = 16,900;
{q3} = 26;
{q2} = 23,400;
-E = -1,300;
+E = +1,300;
{q3}[E] = -b{2} / {b} * {a1} / {a + b} * {a2} * {b::2} / {a + b + a + b} = -(E);
{q4} = 13;
E = 36x + 13 + 65(180a) + 65b(11700a) /> 1/180 =
36x(180) + 13(180) + 65(180a)(180) + 65b(11700a)(180) /> 1
6480x + 2340 + 2,106,000a + 136,890,000ab /> 1
divide 2,106,000a into 136,890,00ab
x + 2340 + a + 65b /> 1
x + a + 65b /> -2340
-2340 / 6480 * 3 * 3...returns as predicted with 1/4th, almost.
s% = 180 - 90(right angle) * 50% + b = d;
1440(180 - 90 * .50 + 20) / 360;
1440 * 65 = 93,600 / 360 = 260;
1440(65) / 360; = 260 * 10% = 26;
This is where the are related to each other, finding that 26 in "d" for the second part of the angles compared to the first, the items add to the "g" of the first part angles above. I got 2600 from "is over of and percent over a hundred formula". 26 * 100 and 180 * % = 180% = 2600 divide by 180% (a + b) is always 180.
You have to do in calculator as this method 2600 / 1.80 = 1444.4444444444444444444444444444 * 180 = 260,000
180b = 2600 / 180% = 1444.4444444444444444444444444444 * (a + b) = 260,000 = g;
(a + b) = 180;
above as E, has two different types one modulus and the other integer. 26 value as hash to modulus key, then to output relation via -E;
c++; codeblocks; save as file.cpp; then compile
#include <iostream>
using namespace std;
int main()
{
int index = 0;
int val;
int x;
while (val != 0)
{
cin >> val;
for (index = 1; index < 149; index++) //change to 32 eventually
{
x = val * index - index / index;
cout << x << " " << val << " " << index << endl;
cout << x % 4 << endl;
cout << x % 3 << endl;
cout << x % 2 << endl << endl;
}
} // you can repeat the input for a different starting number at end
return 0;
}
output is predictable; modulus is as input 1:
[000, 111, 220, 301, 010, 121, 200, 311, 020, 101, 211, 321] , [000, 111, 220, 301, 010...repeating. every number can be associated with an integer value and have a deriviate. Play around with the input, see if you can find a pattern :) i think I already know it as >> binary >> hexidemcimal " << " bit; i could be wrong, but there is a reason binary is the way it is not because it works. and this is why 12 x 12 array.
If you change the value of "val", the input, every point that 31 has, from all points ranging, <0, 1, 2, 3... as input, 31 is 200, 321, 010, 101, 220, 311, 000, 121, 210, 301, 020, 111, 200 starting from 13, 12, 11, 10...so the inverse would be 1, 2, 3, ...
[1]200, 111, 020, 301, 210, 121, 000, 311, 220, 101, 010, 321, 200...[13]
I found that when starting with <input: 1> and <input : 31>, putting them in rows and columns, each pair of any number will give the first and last array of mods. So, 1 starts with 000, ends with 200, each number is like that no matter what, whatever it started with the column, row, of <input 1> and <input 31>
000, 111, 220, 301, 010, 121, 200, 311, 020, 101, 211, 321.
200, 111, 020, 301, 210, 121, 000, 311, 220, 101, 010, 321.
For <input 1 -> 12> top row is what will start,
bottom is the end of that range of pattern.
Also,
5, 11, 17, 23, 29 are the only numbers usually associated within themselves that provide 200, or 000.
is this a structure complex? from when you combine logarithms such as, [g] as log (2 log x^log (n)) = log (n) + log (x) = 2? (log(x) * x^2 is just X because this is pertaining to square roots because [index::25] on any input gives me the row >input1<
anything by >input> index = 36 is always 321.
301, 311, 321 is repeat for 100, 10^2;
144 is always 321;
16 is always 301, 311, 321;
2^4 is 311, 301, 321;
5^3 = [->010, 101, 220, 311, 000, 121, 210, 301, 020, 111, 200], 321, 010; twelve for pattern. This is the second row, backwards - 1 from 321.
200, 111, 020, 301, 210, 121, 000, 311, 220, 101, [<- 010, 321].