corrora & //apploc.dek
CRYOGEN: Class, Method, Function, Type and Boolean
MECHANICS.
Every mathematical expression will be explained, that said this will be a no-experience necessary. The basic math will be covered in Mechanics. (If you already know the basic math, please proceed to the sub page located in the header. It will be password protected, please read the end of the document to gain the password to the next page.)
Starting with Fractions and will introduce a linear equation (don't get fancy with me) all variables such as x, y, a, b, u, n, and R will be understood as we go along and will be covered when entering that stage, each expression will be evaluated. Lets get started.
fraction: 1 and 6/12, is also the same as 1 and 1/2, because 6 is half of 12. We will not need to get deeper into this.
Here's a harder one: 1 and 1/2 is also 3/2 because the remaining digits from 2/2 is 1, is 1/2 so it wil be 1 and 1/2 or 1 and 6/12. Easy right?
Example: 2 and 3/4, you take the 2 and multiply the denominator or the bottom number by the full digit: 2*4 = 8, but you keep the denominator the same. Then you add the top number of the fraction or the numerator, to the value you made by the full digit and bottom number together with the top number. 11/4. Which is 4/4 + 4/4 = 2. The remaining value is 3, just use the same denominator and you have 2 and 3/4 = 11/4.
Example 2: 11/7 is?
7/7 + 4/7 is 11/7.
The next variables are syntax for now, or caled passive kinetic to do a specific action when it is present with the sum of the expression. All variables will be named if they aren't, then they will be put into a float. Usually floats don't carry anything but decimals, but in cases it can be used in a function to carry a variable's sum. This is not a standard float, since a float is usually only used for decimals (yes I know, but it has to be said twice). They can be used to label pi signs, and geometric angles.
A quick lesson, that all programming is usually object-orientated or functional orientation. There is no real difference, but the style (Python vs Haskell, haskell being functional orientation). When you connect an object it takes the values and stores them in memory. So when you create an object it can be a shape and use the reference to order a program or do something differently. This is usually a boolean or a variable that you need to use for examining a result. All the true programming is a result of a functioning stable number system that keeps the coder in an engagement. For instance, if you have a formula for example, Area of a rectangle and the Area of a polygon any shape, they may hold integers that are ery simiar broken down.
If A = LW and A is 45 = LW can be (9 * 5) = A, but which is 9 or 5, Length or Width? This is where object programming excels, you can find that out by pre-programming a method to do the work for you so that the equation is broken down into simpe forms and the reality the object could be a Circle and have nothing to do with a Circle unless you want it to do a geometric system. It's handy, but simply the method is to web or connect the math to a type that is mathematically correct.
In the object Circle, I can save the information of a volume formula or an area variable that the circle had nothing to do with. When you see math in programming its usually to edit a structure to do a different answer. Since the input is the expression and the output is the answer it usually is a number or a calculation that an object wanted to prepare or edit even make mechanics different (Not the standard math, like a plus sign could actually really be a minus sign).
Quick Throwback: X + 2X + 2X^2 + 10 = Y
Add like terms, the exponent 2X^2 cannot be combined with the regular X's.
3X + 2X^2 + 10 = Y
Now there lies a problem we don't know the answer but you can always bypass the object expression with a fault, that we can input any system of numbers in place such as X = 1, X = 2, X = 3, X = 4, X = 5... ("..." means on-going). Same with Y = 1, Y = 2... Or we can put the variable subsitution and solve for the variable and put the last expression in a true or false statement called a: BOOLEAN.
Given: X = 3,
3X + 2X^2 + 10 = Y
2(3) + 2(3^2) + 10 = Y
(6) + (18) + 10 = Y
34 = Y.
If you had both input variables X = 3, Y = 24, this solution would be incorrect, but if it is you can do a true or false statement called a Boolean, and can change the outcome even if it doesn't add up. This one didn't need to be put in a float because it had no decimals or had no real answer we just know there will be a pattern if we data mine into the equation. This allows us to program a "CLASS" that does a specific job and is personally named and usually you can resurrect these names in so called "graveyard" or "discard pile". That means you can use it once you create it, this can be modified or even changed completely in the same program, if you give the permission (revelance to sums of equations). Remember the more a variable appears the easier it is to control.
What you need to know:
BOOLEAN: True or False Statement.
METHOD: In which a program is controlled.
CLASS: A defintion in the overview of a program, usually can be resurrected from the "graveyard".
FUNCTION: It's undecidied whether FUNCTION can be simply a syntax word to do anything that is in detailed expression or edit/modify. Otherwise is a FUNCTION in mathematics.
INT: Integer, any number above or below zero including zero, leading into inequalities. Greater than (>), Less than (<) X > (is greater than) Y, X > Y.
Variables: X, Y, A, B, U, n, R; variables that will be categorized based on math that shows a specific pattern.
Defining the variables in controls:
X is defined by a continuing control called "sum is", therefore when we do a program X is always going to be uppercase, the lowercase does something different. It is case sensitive. X is used for patterns, always a static number like "INT" (INTEGER), there is a separate case where "small x" could also be "big X" when they are ordered such as: 90 = X + 21, which is wrong because the X needs to be on the left side, and the 90 on the right side, because 90 is the sum, hence "sum is". X + 21 = 90.
- 21 = -21
X = 69. X sum is 69.
Lets try this out, the formula taken from Python Tab, above in the header:
((int * (int + 1)) + (5(i) - int * (int + 1) / 2) * (5 * 2)i) = X
Order of Operations is, Parenthesis, Exponent, Multiplication, Division, Addition and Subtraction. Called PEMDAS, order from left to right when solving.
(5 * 2)i) is same as, i(5 * 2), this is called the Distributive Property, you do this:
5i * 2i so the above formula would be:
INT = 6, I = 4.
((6 * (6 + 1)) + 5(4) - 6 * (6 + 1) / 2) * 5(4) * 2(4) = X
6 * 7 + 20 - 6 * 7 / 2) * (20 * 8) = X -- line below the minus sign
42 + 20 -( 6 * 7) / 2) * (160) = X
42 + 20 - 42 / 2) * (160) = X
- 42/2
42 + 20 -21 * 160 = X
62 -3360 = X
3300 = X
Is this correct, did we follow the order of operations?
((6 * (6 + 1)) + 5(4) - 6 * (6 + 1) / 2) * (5(4) * 2(4)) = X
(6 * 7) + 20 - 6 * 7 / 2) * (20 * 8)
42 + 20 -42/2 (160)
-21
62 -21 * (160) = 6560
Now that we have two answers, which one is correct?
I believe that the divide by 2 is a little confusing. So I'll edit the formula.
((int * (int + 1)) + 5(i) - int * (int + 1) / ((2) * (5i * 2i)) = X
We get 41/320 as a fraction or 0.128125, this can be put into a float!
Now is there a way to make this happen?
100 42 + 20 - 42 / 2 * 5 * 4 * 4 * 2 = 1600 --notice this is a multiply sign instead of addition
101 (20 / 2 = 10) * (4 * 5) + (4 * 2) = 280 --notice there are two equal signs
102 10 * 5 * 4 + 2 * 4 = 208 --notice the equal sign turned into just 10, because 20/2
I would say for 208, ((INT * INT + 1 + (5(4)) -(INT * (INT + 1)) / (2)) * (5 * 4 + 2 * 4)... check?
((6 * 6 + 1) + (20) - 42) / 2) * 20 + 8 = ?
((42 + 20 - 42) / 2) * (20 + 8) = 208!
So instead of writing this whole formula out, you can basically write it in code dynamically, because there are so many outcomes that could happen when the computer doesn't read the parenthesis correctly or not at all so it would be hand written in regular math a code in any language uses math as basics.
Ada:
42 + 20 - 42 is newObject;
return newObject;
>> 20 / 2 * 20 is Shape;
>> 200 + 20 + 8 is newObject(1);
return newObject(1);
return Shape;
OUTPUT newObject: 20
OUTPUT newObject(1): 208
OUTPUT SHAPE: 200
Some languages are fancy and you can simply do this:
i = 4
INT - INT + 1 + INT - INT + 1 * 5i = R
R(1) + 20 + 8 = R(2)
return R(2);
output>> R(2)= 5i
R(2)/2 * 5i + 2i = _newObject
output>> R(2)/2 + 7i -- error try again;
R(2)/2 * 5(i) + 2(i) is _newObject(1);
output>> 208;
But please remember, this isn't the full code, you would have to have a constructor for R (a scope), and name everything from class to method and maybe even a boolean for run-time errors. Just touching base with a few things before we get into that.
Here's the easiest way to explain high-level
programming. The only way you will get
information out of a parent, child and grand-
child (in computer programming these are the
names of a class, method of which the code
does, and an annex to the code for
manipulation. If I have a variable in a
program that does something specific. Lets say
we are in an object of the program and we want
to annex its properties into another class,
sub-program, type or boolean; then we would
use mathematics to support the claim that was
interpreted: x is equal to 45, y is the
integer 9, a is the integer 5, R is a
inequality where R is greater than 5 but less
than 10.
Now we can use R specifically to multiply any
numbers 6, 7, 8, 9. R > 5 < 10. If we add the
variable "y" into the equation we can continue
because R is related to x is equal to 45, by
combining this you can create a parent, child
and grand-child.
Parent: Program 1 is equal to 45.
Child: R > 5 < 10;
type: class: method: boolean
Grand-child: R is 9.
function: 9 is called R;
subtype: Only when result is 45 and
completed, will R be used even if R is 6, 7,
8, 9 only return when R is 5 < R > 6 = [6, 7,
8, or 9] or just "9".
This allows the returned result capable of
triggering an event if you wish to. The
opposite way to do this, and it isn't wrong.
Is to import programs instead of doing the
pre-work. Like, determine if R is an even or
odd number, is R: 5, 9; they are both odd so
return result (then the result would look like
a graph, or list that R could be. This takes
time, but if you already created or have an
import for this procedure then it's just
turning the program on to give and read
results which I don't know how to do yet).
The way I do it is that you decide that for
one time you create a variable that does
something specific to command a procedure,
then you are able to decide the direct
constants, only edit not modify the properties
(modify when I speak about it will always be
importing properties).
A provided given that must be said over and
over, and if I didn't say it enough yet; all
programs contain different mathematical
equations, expressions and data-structures
that will always be connected somehow. If they
aren't then its protected, but not the same as
"private" in Ada programming language. It also
isn't virus proof. What this means, when
someone wants to use super-programs that can
crack a program, it will remain hidden from
their view unless they have a library similar
to yours. It's real easy to invade the
protected memory, but its a digital print on
the web and inside local memory. Almost all
your code will be in this protected memory, we
can't ghost ourselves. Those who do are easily
caught, so if you're using this website to
invade privacy then you are the problem.
Another thing on the "protected memory" or
"digital print" section is that it could
actually be more information about an object
or variable even a float. This depends on the
oddity of human error. Not all programs are
machine like where you are repeating yourself
over and over. It takes thought and can be
written efficiently or inefficient. If it
works fine, but when in the big-business area
you're going to need how to speed up the
program. And that's mostly done when you start
graphing or reverse engineering your product.
Topic Baseline:
A base-line is the format which something is
measured in programming. You must need to know
outside information first before a sensor can
be base-lined or edit or even view a base-line
this means that the base-line must be parallel
to the measurement. Meaning if my heatsink
goes off in my computer because it's over-
heating, then the sensor uses a base-line
before even used to measure heat. Therefore,
if you're into hardware programming you do the
testing in the trial and error phase of a
physical object and not virtual. If my
computer measures the CPU temperature at 90
degrees, the base-line was used to measure
heat equal to the testing phase of the sensor
and not the actual temperature it was
evaluated by trial and error of physical
heating of the sensor to set the measurement.
AKA the measurement of my CPU was based on
an experiment using heat to the actual sensor
and moderating the heat to a temperature closest
to the actual temperature. So making a sensor is
like using a micro-controller and a custom chip
to use a base-line to adjust the software in the
sensor to read the most accurate temperature.
Hardware Programming, Micro-controllers and Custom Micro-Chips.
Every now and then you will come across some codes that edit memory and are hash codes. These are specific to the properties in the computer's memory or digital print. These properties can be imported into the program and can edit or discharge an answer based on a selected action. This is like a hand-shake that happens when you connect the code into a property based outcome. Meaning that the time it takes to hand-shake the most you can do is add a micro-chip using a micro-controller and will eventually do the task itself. Rasberry Pi is a micro-controller that can program micro-chips and such. It is hardware programming but also uses Python for doing scripts. A script is a detailed expression using the existing programming to "print" or "do" and outcome that is hardware based not so much software connected. There is a sort of dynamic misconception that when you take the hardware, you cannot edit it. This is wrong. You can edit the hardware, its called kernals in software mostly on an Operating System. There is some other ways to edit the hardware, but you have to used existing code, if you're using third party imports then you are most likely a hacker or considered somewhat a hacker or crack artist. Hash codes are really hard to understand and I have yet to understand them. If you choose hardware programming or Robotics & Mechatronics, then you will have to understand them and use them fully. I believe the language "Assembly" uses these hash codes and also uses HEX codes. Hexadecimal codes are 16 bit codes that are transmitted in machine language to do a physical real-life action. Like turning on an electric stove to a certain temperature. A better example is the hard drive in a computer. It's making little dots on the disk and is read by a laser to receive data that is either off or on, called binary. Binary 1: is a positive on signal. Binary: 0 is an off signal. There may be other ways to read it, but that's the basics that I will only touch base on.
Binary is ones and zeros, would look something like this: 1001 1100 0110 0111. Now Hexidecimal would look something like this using A-F. "In mathematics and computing, hexadecimal (also base 16, or hex) is a positional numeral system with a radix, or base, of 16. It uses sixteen distinct symbols, most often the symbols 0–9 to represent values zero to nine, and A, B, C, D, E, F (or alternatively a, b, c, d, e, f) to represent values ten to fifteen". https://en.wikipedia.org/wiki/Hexadecimal
This page is not finished and will contain more mechanics. The password to the next page will be displayed when further work has been done. -- PASSWORD IS "roastdouble"
i = 4
n = 280
INT = 6
y = 48
x = 208
i**2 + i**2 - int + n -- new formula
2i**2 - int + n = 306
This is taken from PYTHON tab.
ghost render: i = 4
((int * (int + 1)) + 5(i) - int * (int + 1) / 2) * (5 + 2)i)
((6 * (6 + 1) + 5(4) - 6 * (6 + 1) / 2 * (5 + 2)4) =
((42) + (20) - (42) / 2 * (20 + 8)) = 280
+ 20 / 2 * (28)
+ 10 * (28)
+ 280 = n
y = 48
y = ((2i + 5i) + int * (int + 1)) + 5i - int * (int + 1)
((28) + 6 * (6 + 1)) + 5(4) - 6 * (6 + 1)
28 + 6 * 7 + 5(4) - 6 * 7 = 48
28 + 42 + 20 - 42 = 48
caption: y = ((8 + 20) + 6 * (6 +1)) + 5((4) - 6 * 7)
y = 28 + (6 * 7) + 20 - (6 * 7)
y = 28 + (42) + 20 - (42)
y = 48
2(4)**2 - 6 + 280 = 306
32 - 6 + 280 = 306 / 6 = 51 + y = 99 / 11 = 9 + 32 + INT = 47
u = INT + 32 + 9
u = 47 - 208 + 6 + 32 + 9 / INT = -19
47 = 47 * 6
u = 282 - 51
u = 231 - 48
u = 183 - 306
u = -123 + 9 / 6
u = -19
_______________________________________________________________________________________________________
i = 4
n = 280
INT = 6
y = 48
x = 208
u = -19
i**2 + i**2 - INT + n / INT + y / 11 + i**2 + i**2 + INT - x + INT + i**2 + i**2 + 9 / INT = u
i**2 + i**2 - INT + n / INT + y / 11 + i**2 + i**2 + INT - x + INT + i**2 + i**2 + x(0.5) = u
u : 4**2 + 4**2 - 6 + 280 / INT + 48 / 11 + 4**2 + 4**2 + 6 - 208 + 6 + 4**2 + 4**2 + 9 / 6 = -19
u(2) : 4**2 + 4**2 - 6 + 280 / INT + 48 / 11 + 4**2 + 4**2 + 6 - 208 + 6 + 4**2 + 4**2 + 208(0.5) = -19
u /= u(2) -- because it is a different formula but same answer...re-inventing a formula from existing simulations.
(i**2 + i**2) + (i**2 + i**2) + (i**2 + i**2) / INT = Sqrt(4**2); Sqrt(16); 4.
(i**2 + i**2) + (i**2 + i**2) + (i**2 + i**2)
32 + 32 + 32
i = 4
INT = 6
y = 48
32 * 3 / INT; 16 * 11 / i = 44 / 11 = i;
32 * 3 / INT; 16 * 11 / 4 = 44 / 11 = 4;
i.2 = 4**2 = 4 * 4 = 16
32**2 = 1024 / i = 256 / i = 64 / i = 16 / i = i;
32**2 = 1024 / 4 = 256 / 4 = 64 / 4 = 16 / 4 = 4;
32 * 3 = 96 / INT = 16; -- we can label this as a new variable undefined yet we will see.
96 / i = 24 / i = INT;
32 * 3 = 96 / INT / i / i = INT
32(7/INT) = 112/3
112 * 3 = 336 / INT = 56 / (INT + 1) is 8 or 112 * 3 = 336 / (INT + 1) = 56 / 8 = (INT + 1);
32(INT/INT + 1) = 192/(INT + 1)
32 / i = 8 / i = Sqrt(i); Sqrt(4) = 2 -- we will use this for creating a Sqrt function in programming.
(32 * INT) = 192/32 = INT
(192 / INT)= 32
128/32 = i
(192 / i) = y / INT = 8 / Sqrt(4) = i
(128 * 2) = 256 / i**2 = 16; i.2;
32**2 = 1024 / i = 256 / i = 64 / i = 16 / i = i; -- we will use this for the Sqrt formula for i...
We need to find a way to create the operator ** as a square, this is designated for squaring a number.
j = i**2
for i => j
j * i then i * i
when i == print i.j("i**2, j**2")
return i.j } else { i**2 == i*i:
Now we will define all the variables we've been using formally.
i = 4
n = 280
INT = 6
y = 48
x = 208
u = -19
i.2 = 16
j = i.j * i.j
i*i = i**2
R: Reserved
Sqrt = i.j**2 = (R: 1) / i.j = R: 1 / i.j = (R: 2) / i.j = (R: 3) / i.j = i.j;
where R equals the sum is when operators are used. i.j means any number like 3.
3**2 + 3**2 + 3**2 -- when we use a different number, we do this: if 5**2 * 5 = 125**2; 5 / 5 / 5 / 5 / 5 = 5;
For instance, we use 3**2 * 3= 27**2 / 3 / 3 / 3 / 3 / 3 = 3;
= 27**2 / 3 / 3 / 3 / 3 / 3 = 3;
We use as many divisors as needed to equal 1: This will only work for perfect squares, irrationals should be put in a float, I don't think we will need them but eventually into an object we may reference them.
R: 1 = first reserve
R: 2 = second reserve sum
R: 3 = third reserve sum
R: 4 = ...so forth
Here are some examples of Python programming language. Before you get into detail, you must know lexical analysis. It's how many spaces you put before a blocked code. For instance, a Parent has no spaces before the code, a child has four space or one tab, the grand-child has eight spaces or two tabs and so forth. This is called PEP808 but known to many as PEP-0008. It is originally four spaces, eight spaces, twelve spaces, this guide may be different. As long as you're consistent with either spaces or tab, it shouldn't be a problem. Here is a resource: https://www.python.org/dev/peps/pep-0008/
Here is some helpful examples that will get you familiar with Python. If you know already a little about Python please skip to the secondary URL.
http://www.ibiblio.org/g2swap/byteofpython/read/introduction.html
http://www.ibiblio.org/g2swap/byteofpython/read/making-modules.html