Computer Programming

Storing global data.

these are difference in between c and c++: a) C is a SPL and C++ is a OOP. b) C has not concept of object but C++ has this feature. c) C has not 'class' name data type but C++ has.

When you turn it off, all memory is lost. You usually end up with pseudo-random patters.

To actively clear all mem would require a machine language program ... which would be wiped in the process.

Period is 101110

Assembly language is easier to produce as output of compiler and it is easier to debug assembly language.

The declaration of an array of 3 int pointers will be:

int *p[3];

The declaration of a function that receive an array of int pointers will be:

int my_func(int **p);

or

int my_func(int *p[]);

and you can pass it to other function simply by passing p.

#include <stdio.h>

int main()

{

int i;

for(i = 51; i <= 100; i+=2)

printf("%d\n", i);

return 0;

}

Syntax Error: error due to missing colon, semicolon, parenthesis, etc. Syntax is the way in which we construct sentences by following principles and rules.

Example: In C++, it would be a syntax error to say

int x = "five";

This will not compile because it does not follow the syntax of the language and does not make any sense to the compiler.

Semantic Error: it is a logical error. it is due to wrong logical statements. Semantics is the interpretations of and meanings derived from the sentence transmission and understanding of the message. Semantics errors are Logical, while Syntax errors are code errors.

Example: A semantic error would compile, but be incorrect logically:

const int pi = 12345;

Your program will likely compile and run without error but your results will be incorrect. (Note that these types of errors are usually much harder to debug)

Three type of languages

High level

Mid level

Low level

Arrays allow similar types of data to be stored within a contiguous block of memory such that every data element is accessible in constant time, regardless of its physical location within the array. This is achieved through simple pointer arithmetic treating each element as a memory offset from the start of the array. Since every element is the same length (in bytes), locating any element is simply a matter of calculating its offset from its index. Indices are zero-based thus the third element can be found at index 2. The memory offset for that element is therefore the product of the element size and 2. However, C permits indices to be specified directly, while the pointer arithmetic is done in the background. Thus array_name[2] automatically returns a reference to the third element.

Arrays with large and complex variable length data elements need to store those elements separately from the array, usually non-contiguously. This is achieved by using a pointer array. Pointer arrays are particularly useful when sorting extremely large data lists as it is much easier and more efficient to implement a sorting algorithm with an array than it is with a linked list, particularly when constant-time random-access is essential to the algorithm. The time and effort in building the array is generally more than compensated for by the efficiency of the algorithm.

Arrays can also be divided and subdivided to better model the data they represent. For instance, a chessboard might be implemented as a one-dimensional array of 64 elements, however it makes more sense to model the chessboard in a two-dimensional array of 8x8 elements. Although the array is still allocated contiguously and can be thought of as being 8 rows and 8 columns, it's actually better to think of this two-dimensional array as being a one-dimensional array of 8 elements, where each element is another one-dimensional array of 8 elements.

By thinking this way it makes it possible to allocate extremely large arrays in non-contiguous memory (as completely separate one-dimensional arrays) and also makes comprehension of a four-dimensional array in a three-dimensional world that much easier (unless you actually want to model time and space of course).

A four-dimensional array can be thought of in a variety of ways: as being a one dimensional array of three-dimensional arrays, or as a two-dimensional array of two-dimensional arrays, or as a three-dimensional array of one-dimensional arrays, or even as a one-dimensional array of one-dimensional arrays of one-dimensional arrays of one-dimensional arrays. Whichever method you use to imagine your array is immaterial, so long as it makes sense to you that's all that really matters.

A recursive function is one that calls upon itself until a given result in the original call is met.

Take a look at this example.

Program Recursion;

Uses

crt;

Var

number:longint;

Function Factorial(number:longint):longint;

Begin

if number > 0 then

factorial:=number*factorial(number-1)

else

factorial:=1;

End;

Begin

clrscr;

readln(number);

writeln(factorial(number));

readln;

End.

Note how the function factorial calls itself.

You really don't have to, the vast majority of computer users will never need to know any. Just like the vast majority of car drivers don't need to study auto mechanics. People that will never use a computer certainly have no need. However if you want to program computers, either for your own casual entertainment or for a job, that's why!

Raw data becomes information once it is organized and sorted. Raw data that is collected, is useless until it becomes information.

Negative integers are typically encoded using two's complement notation. That is, to convert the sign of any given integer, the bits are flipped (as per ones' complement) and 1 is added. Thus to convert the value +1 to -1 using 8-bit notation:

00000001 = 11111110 + 1 = 11111111

And reversing the process (-1 to +1):

11111111 = 00000000 + 1 = 00000001

In hexadecimal notation, the value 0x80 is the largest negative integer (-128) and 0x7F is the largest positive integer (+127). That is, 10000000 and 01111111 respectively.

Note that ones' complement was used in the past and while some systems still use it they are few and far between today. One of the problems with ones' complement is that +0 and -0 (00000000 and 11111111 respectively) would be treated as being two separate values, when the value 0 is neither positive nor negative. In twos complement, flipping the sign of zero becomes:

00000000 = 11111111 + 1 = 00000000

Note that the actual value is 100000000, but the most-significant bit (the overflow) is ignored because there can only be 8-bits in an 8-bit value. The same is true of 16-bit values, 24-bit values, etc. When all bits are filled with 1s, adding 1 wraps the value back to 0 again.

Bare metal coding a.k.a. coding or programming "on the metal" refers to writing computer programs in machine language, the only set of instructions that a CPU understands. Most would also include Assembly language in this category, as the resulting code runs natively (doesn't need to be compiled). All other computer languages must be translated by a compiler or interpreter into this native machine language.

we can measure the expansion of the world by matrices cause in magnetic fields vectors can be streched up to a certain limit which are the eigen values.

The Delphi programming language was named after the Oracle of Delphi, the common name for the Pythia, the priestess of the Temple of Apollo at Delphi in Greece. The Oracle database was a popular DBMS and, given that Delphi is based upon the Pascal programming language which focuses on database development, this tied in nicely with the phrase; "If you want to talk to the Oracle, go to Delphi."

okay i figured it out...its the 19th amandment! which gave women the right to vote. the 19th amendment is also known as the susan b Anthony amendment! thanks. you can Google the question and scroll down a little bit and it will tell you the same answer if you want to check and be sure

Best in what way? Best for the computer to learn? Well, that is determined by two things...the algorithm that the computer processor(s) run through to achieve the "machine learning", and the speed/efficiency of that algorithm - since it could be an algorithm that will work but perhaps will take so much time to arrive at a good result that it is ineffective in a practical sense.

Now, if you want to ask instead what is the best computer language in which to program algorithms...it is a controversial subject, but overall I would say programming it in a language that is translated well into the machine language which will be running the algorithm, since it must be the best that it can be -- for speed and efficiency. Then, the computer processor(s) speed is/are not hampered by the inefficiency of the choice of code generator or compiler/intrepreter (i.e., in general, the programming language).

However, I also suspect that you are asking from a personal point of view, namely, which language should you learn if you wanted to get into this machine learning field...I think majority of people working in the field like Prolog, Lisp, C++, and Java. Also, there are some people programming in Natural Language Programming (NLP) parsing and lexical analysis that prefer computer languages devoted specifically to NLP.

NLP and Machine Learning algorithms are often working hand in hand to sift through human language texts of all kinds to glean and summarize information and find relevant correlations that exist between all of the ideas and stories in those texts - some factual info, some opinions. Businesses like this stuff for data mining and finding patterns amongst people's likes and dislikes so that they can market to those preferences.

Also, many people like to discover correlations, for instance, that say when certain words are used in a financial article, the chances are that these certain types of stocks will rise in price. Thus data mining is a large reason for the popularity of machine learning.

NLP has been around for many years and is the effort behind what many people have sought -- to build a computer helper that they can talk with in a natural way - so much easier than all that typing and thinking of how to pose the question just so.

It is the next step in the evolution of an internet search engine -- one that learns the best answers and filters out all the extra stuff and does not present the "irrelevant".

My guess is that the programming language choice for machine learning algorithms will become less important than the design of the machine learning algorithms themselves. As time goes forward, the "programming" is being done with visual tools and automatic code generators, and implementing a design of a new machine learning learning algorithm is done with those high level tools where the designers don't necessarily know how it looks in the programming language or in the machine language.

An argument can be made that the "programmers" should know the efficiency of their designs of the machine learning algorithms on that hardware - but that is usually left to the people who are specifically designing the code generators - which is something far removed from the fun of designing the machine learning algorithms. Specialization is the nature of these fields. So, some designers will arrive on the scene that don't know anything about programming languages, they just know the algorithms of the specific domain and are constantly improving them using the Algorithm Studio software.